From c74257a033a8b320c7986f9af420cfe277dc30d0 Mon Sep 17 00:00:00 2001 From: Bhatu Date: Tue, 6 Apr 2021 04:22:55 +0530 Subject: [PATCH] SIRNN: A Math Library for Secure RNN Inference Code release. --- Athos/CompileSampleNetworks.py | 58 +- Athos/CompileTFGraph.py | 54 +- Athos/CompilerScripts/compile_tf.py | 26 +- .../sample_networks/run_demo_2pc.sh | 4 +- Athos/Networks/ChestXRay/setup_and_run.sh | 2 +- Athos/Networks/DenseNet/setup_and_run.sh | 4 +- Athos/Networks/ResNet/setup_and_run.sh | 4 +- Athos/SeeDot/Compiler.py | 3 + Athos/SeeDot/IR/IRBuilderCSF.py | 142 +- Athos/TFCompiler/ProcessTFGraph.py | 40 +- Athos/TFEzPCLibrary/Library32_common.ezpc | 224 + Athos/TFEzPCLibrary/Library32_cpp_pre.ezpc | 36206 +++++++++++++++ Athos/TFEzPCLibrary/Library32_sci.ezpc | 18 + Athos/TFEzPCLibrary/Library64_common.ezpc | 225 + Athos/TFEzPCLibrary/Library64_cpp_pre.ezpc | 36232 +++++++++++++++ Athos/TFEzPCLibrary/Library64_porthos.ezpc | 9 + Athos/TFEzPCLibrary/Library64_sci.ezpc | 18 + Athos/tests/conftest.py | 6 +- Athos/tests/tf/unittests/test_arith_binops.py | 7 +- Athos/tests/tf/unittests/test_non_linear.py | 21 +- Athos/tests/utils.py | 6 +- EzPC/EzPC/codegensci.ml | 169 +- README.md | 7 +- SCI/CMakeLists.txt | 38 +- SCI/README.md | 13 +- SCI/cmake/SCIConfig.cmake.in | 23 + SCI/cmake/install_EMP.cmake | 49 + SCI/cmake/install_Eigen3.cmake | 18 + SCI/networks/CMakeLists.txt | 32 +- SCI/networks/main_densenet121.cpp | 14064 ++++++ SCI/networks/main_densenet121_field64.cpp | 11069 ----- SCI/networks/main_densenet121_ring32.cpp | 11069 ----- SCI/networks/main_minionn.cpp | 2631 ++ SCI/networks/main_minionn_field64.cpp | 2170 - SCI/networks/main_minionn_ring32.cpp | 2169 - SCI/networks/main_resnet32_cifar.cpp | 5988 +++ SCI/networks/main_resnet32_cifar_field64.cpp | 4738 -- SCI/networks/main_resnet50.cpp | 7272 +++ SCI/networks/main_resnet50_field64.cpp | 5754 --- SCI/networks/main_resnet50_ring32.cpp | 5754 --- SCI/networks/main_sqnet.cpp | 3800 ++ SCI/networks/main_sqnet_field64.cpp | 3054 -- SCI/networks/main_sqnet_ring32.cpp | 3054 -- SCI/src/BuildingBlocks/CMakeLists.txt | 8 + SCI/src/BuildingBlocks/aux-protocols.cpp | 665 + SCI/src/BuildingBlocks/aux-protocols.h | 162 + SCI/src/BuildingBlocks/truncation.cpp | 311 + SCI/src/BuildingBlocks/truncation.h | 115 + SCI/src/BuildingBlocks/value-extension.cpp | 121 + SCI/src/BuildingBlocks/value-extension.h | 52 + SCI/src/CMakeLists.txt | 105 +- SCI/src/LinearHE/CMakeLists.txt | 49 +- SCI/src/LinearHE/conv-field.cpp | 1645 +- SCI/src/LinearHE/conv-field.h | 297 +- SCI/src/LinearHE/defines-HE.h | 15 +- SCI/src/LinearHE/elemwise-prod-field.cpp | 305 +- SCI/src/LinearHE/elemwise-prod-field.h | 59 +- SCI/src/LinearHE/fc-field.cpp | 625 +- SCI/src/LinearHE/fc-field.h | 141 +- SCI/src/LinearHE/utils-HE.cpp | 393 +- SCI/src/LinearHE/utils-HE.h | 73 +- SCI/src/LinearOT/CMakeLists.txt | 6 + SCI/src/LinearOT/linear-ot.cpp | 746 + SCI/src/LinearOT/linear-ot.h | 113 + SCI/src/LinearOT/linear-uniform.h | 750 + SCI/src/Math/CMakeLists.txt | 4 + SCI/src/Math/math-functions.cpp | 895 + SCI/src/Math/math-functions.h | 85 + SCI/src/Millionaire/CMakeLists.txt | 2 +- SCI/src/Millionaire/bit-triple-generator.h | 548 +- SCI/src/Millionaire/equality.h | 360 + SCI/src/Millionaire/millionaire.h | 944 +- .../Millionaire/millionaire_with_equality.h | 398 + SCI/src/NonLinear/argmax.h | 884 +- SCI/src/NonLinear/drelu-field.h | 590 +- SCI/src/NonLinear/maxpool.h | 331 +- SCI/src/NonLinear/relu-field.h | 392 +- SCI/src/NonLinear/relu-interface.h | 68 +- SCI/src/NonLinear/relu-ring.h | 444 +- SCI/src/OT/CMakeLists.txt | 4 +- SCI/src/OT/emp-ot.h | 10 +- SCI/src/OT/ideal.h | 219 +- SCI/src/OT/iknp.h | 1456 +- SCI/src/OT/kkot.h | 443 +- SCI/src/OT/np.h | 368 +- SCI/src/OT/ot-utils.h | 319 +- SCI/src/OT/ot.h | 171 +- SCI/src/OT/ot_pack.h | 218 +- SCI/src/OT/split-iknp.h | 1720 +- SCI/src/OT/split-kkot.h | 1155 +- SCI/src/OT/split-utils.h | 342 +- SCI/src/cleartext_library_fixed.cpp | 1224 + SCI/src/cleartext_library_fixed.h | 180 + SCI/src/cleartext_library_fixed_uniform.h | 3061 ++ SCI/src/defines.h | 54 + SCI/src/defines_uniform.h | 84 + SCI/src/functionalities.h | 1023 - SCI/src/functionalities_pt.h | 2312 - SCI/src/functionalities_uniform.h | 1105 + SCI/src/functionalities_wrapper.h | 1464 - SCI/src/globals.cpp | 109 + SCI/src/globals.h | 550 +- SCI/src/library_fixed.cpp | 2805 ++ SCI/src/library_fixed.h | 298 + SCI/src/library_fixed_common.h | 257 + SCI/src/library_fixed_uniform.cpp | 1943 + SCI/src/library_fixed_uniform.h | 192 + SCI/src/linear-primary.h | 685 - SCI/src/utils/ArgMapping/ArgMapping.h | 176 +- SCI/src/utils/CMakeLists.txt | 5 + SCI/src/utils/ThreadPool.h | 152 +- SCI/src/utils/aes-ni.h | 455 +- SCI/src/utils/aes.h | 153 +- SCI/src/utils/aes_opt.h | 1837 +- SCI/src/utils/block.h | 381 +- SCI/src/utils/ccrf.h | 51 +- .../utils/cmake/source_of_randomness.cmake | 1 + SCI/src/utils/constants.h | 795 +- SCI/src/utils/crh.h | 82 +- SCI/src/utils/emp-tool.h | 12 +- SCI/src/utils/group.h | 103 +- SCI/src/utils/group_openssl.h | 249 +- SCI/src/utils/hash.h | 143 +- SCI/src/utils/io_channel.h | 79 +- SCI/src/utils/net_io_channel.h | 282 +- SCI/src/utils/prg.h | 449 +- SCI/src/utils/prp.h | 138 +- SCI/src/utils/ubuntu_terminal_colors.h | 38 +- SCI/src/utils/utils.h | 60 +- SCI/src/utils/utils.hpp | 20 +- SCI/tests/CMakeLists.txt | 42 +- SCI/tests/test_HE_conv.cpp | 154 - SCI/tests/test_HE_elemwise_prod.cpp | 90 - SCI/tests/test_HE_fc.cpp | 102 - SCI/tests/test_argmax.cpp | 208 - SCI/tests/test_field_argmax.cpp | 184 + SCI/tests/test_field_conv.cpp | 141 + SCI/tests/test_field_elemwise_prod.cpp | 80 + SCI/tests/test_field_fc.cpp | 91 + SCI/tests/test_field_maxpool.cpp | 352 +- SCI/tests/test_field_relu.cpp | 433 +- SCI/tests/test_functionalities.cpp | 259 - SCI/tests/test_linear.cpp | 192 - SCI/tests/test_ring_argmax.cpp | 278 +- SCI/tests/test_ring_aux_protocols.cpp | 483 + SCI/tests/test_ring_exp.cpp | 198 + SCI/tests/test_ring_hadamard_product.cpp | 120 + SCI/tests/test_ring_library_fixed.cpp | 735 + SCI/tests/test_ring_matmul.cpp | 205 + SCI/tests/test_ring_maxpool.cpp | 364 +- SCI/tests/test_ring_relu.cpp | 397 +- SCI/tests/test_ring_sigmoid.cpp | 190 + SCI/tests/test_ring_sqrt.cpp | 212 + SCI/tests/test_ring_tanh.cpp | 190 + SCI/tests/test_ring_truncation.cpp | 177 + SCI/tests/test_ring_value_extension.cpp | 123 + SIRNN/Library_SIRNN.ezpc | 36563 ++++++++++++++++ SIRNN/README.md | 164 + SIRNN/preProcessSIRNN.py | 219 + SIRNN/secureCodegen.py | 404 + SIRNN/templates/CMakeLists.txt | 21 + SIRNN/templates/CMakeLists.txt_Dataset | 3 + SIRNN/templates/main.cpp | 187 + SIRNN/templates/predictors.h | 10 + setup_env_and_build.sh | 4 +- 165 files changed, 175204 insertions(+), 66748 deletions(-) create mode 100644 SCI/cmake/SCIConfig.cmake.in create mode 100644 SCI/cmake/install_EMP.cmake create mode 100644 SCI/cmake/install_Eigen3.cmake create mode 100644 SCI/networks/main_densenet121.cpp delete mode 100644 SCI/networks/main_densenet121_field64.cpp delete mode 100644 SCI/networks/main_densenet121_ring32.cpp create mode 100644 SCI/networks/main_minionn.cpp delete mode 100644 SCI/networks/main_minionn_field64.cpp delete mode 100644 SCI/networks/main_minionn_ring32.cpp create mode 100644 SCI/networks/main_resnet32_cifar.cpp delete mode 100644 SCI/networks/main_resnet32_cifar_field64.cpp create mode 100644 SCI/networks/main_resnet50.cpp delete mode 100644 SCI/networks/main_resnet50_field64.cpp delete mode 100644 SCI/networks/main_resnet50_ring32.cpp create mode 100644 SCI/networks/main_sqnet.cpp delete mode 100644 SCI/networks/main_sqnet_field64.cpp delete mode 100644 SCI/networks/main_sqnet_ring32.cpp create mode 100644 SCI/src/BuildingBlocks/CMakeLists.txt create mode 100644 SCI/src/BuildingBlocks/aux-protocols.cpp create mode 100644 SCI/src/BuildingBlocks/aux-protocols.h create mode 100644 SCI/src/BuildingBlocks/truncation.cpp create mode 100644 SCI/src/BuildingBlocks/truncation.h create mode 100644 SCI/src/BuildingBlocks/value-extension.cpp create mode 100644 SCI/src/BuildingBlocks/value-extension.h create mode 100644 SCI/src/LinearOT/CMakeLists.txt create mode 100644 SCI/src/LinearOT/linear-ot.cpp create mode 100644 SCI/src/LinearOT/linear-ot.h create mode 100644 SCI/src/LinearOT/linear-uniform.h create mode 100644 SCI/src/Math/CMakeLists.txt create mode 100644 SCI/src/Math/math-functions.cpp create mode 100644 SCI/src/Math/math-functions.h create mode 100644 SCI/src/Millionaire/equality.h create mode 100644 SCI/src/Millionaire/millionaire_with_equality.h create mode 100644 SCI/src/cleartext_library_fixed.cpp create mode 100644 SCI/src/cleartext_library_fixed.h create mode 100644 SCI/src/cleartext_library_fixed_uniform.h create mode 100644 SCI/src/defines.h create mode 100644 SCI/src/defines_uniform.h delete mode 100644 SCI/src/functionalities.h delete mode 100644 SCI/src/functionalities_pt.h create mode 100644 SCI/src/functionalities_uniform.h delete mode 100644 SCI/src/functionalities_wrapper.h create mode 100644 SCI/src/globals.cpp create mode 100644 SCI/src/library_fixed.cpp create mode 100644 SCI/src/library_fixed.h create mode 100644 SCI/src/library_fixed_common.h create mode 100644 SCI/src/library_fixed_uniform.cpp create mode 100644 SCI/src/library_fixed_uniform.h delete mode 100644 SCI/src/linear-primary.h delete mode 100644 SCI/tests/test_HE_conv.cpp delete mode 100644 SCI/tests/test_HE_elemwise_prod.cpp delete mode 100644 SCI/tests/test_HE_fc.cpp delete mode 100644 SCI/tests/test_argmax.cpp create mode 100644 SCI/tests/test_field_argmax.cpp create mode 100644 SCI/tests/test_field_conv.cpp create mode 100644 SCI/tests/test_field_elemwise_prod.cpp create mode 100644 SCI/tests/test_field_fc.cpp delete mode 100644 SCI/tests/test_functionalities.cpp delete mode 100644 SCI/tests/test_linear.cpp create mode 100644 SCI/tests/test_ring_aux_protocols.cpp create mode 100644 SCI/tests/test_ring_exp.cpp create mode 100644 SCI/tests/test_ring_hadamard_product.cpp create mode 100644 SCI/tests/test_ring_library_fixed.cpp create mode 100644 SCI/tests/test_ring_matmul.cpp create mode 100644 SCI/tests/test_ring_sigmoid.cpp create mode 100644 SCI/tests/test_ring_sqrt.cpp create mode 100644 SCI/tests/test_ring_tanh.cpp create mode 100644 SCI/tests/test_ring_truncation.cpp create mode 100644 SCI/tests/test_ring_value_extension.cpp create mode 100644 SIRNN/Library_SIRNN.ezpc create mode 100644 SIRNN/README.md create mode 100644 SIRNN/preProcessSIRNN.py create mode 100644 SIRNN/secureCodegen.py create mode 100644 SIRNN/templates/CMakeLists.txt create mode 100644 SIRNN/templates/CMakeLists.txt_Dataset create mode 100644 SIRNN/templates/main.cpp create mode 100644 SIRNN/templates/predictors.h diff --git a/Athos/CompileSampleNetworks.py b/Athos/CompileSampleNetworks.py index 733017cd..576f711e 100644 --- a/Athos/CompileSampleNetworks.py +++ b/Athos/CompileSampleNetworks.py @@ -82,8 +82,14 @@ def generate_code(params, debug=False): "SqueezeNetCIFAR10", ], "Network must be any of ResNet/DenseNet/SqueezeNetImgNet/SqueezeNetCIFAR10" scale = 12 if params["scale"] is None else params["scale"] - bitlength = 64 if params["bitlength"] is None else params["bitlength"] target = params["target"] + if params["bitlength"] is None: + if target == "SCI": + bitlength = 41 + else: + bitlength = 64 + else: + bitlength = params["bitlength"] disable_all_hlil_opts = ( False if params["disable_all_hlil_opts"] is None @@ -262,29 +268,43 @@ def generate_code(params, debug=False): "Not compiling generated code. Please follow the readme and build Porthos." ) elif target == "SCI": - sci = os.path.join(athos_dir, "..", "SCI") - sci_src = os.path.join(sci, "src") - sci_lib = os.path.join(sci, "build", "lib") - eigen_path = os.path.join(sci, "extern", "eigen") - seal_lib_path = os.path.join(sci, "extern", "SEAL", "native", "lib") - if os.path.exists(sci_lib): + sci_install = os.path.join(athos_dir, "..", "SCI", "build", "install") + build_dir = "build_dir" + os.system("rm -rf {build_dir}".format(build_dir=build_dir)) + os.mkdir(build_dir) + os.chdir(build_dir) + cmake_file = """ + cmake_minimum_required (VERSION 3.0) + project (BUILD_IT) + find_package(SCI REQUIRED PATHS \"{sci_install}\") + add_executable({prog_name} {src_file}) + target_link_libraries({prog_name} SCI::SCI-{backend}) + """.format( + sci_install=sci_install, + prog_name=program_name, + src_file=output_file, + backend=backend.upper(), + ) + with open("CMakeLists.txt", "w") as f: + f.write(cmake_file) + + if os.path.exists(sci_install): + ret = os.system("cmake --log-level=ERROR .") + if ret != 0: + sys.exit("Compilation of generated code failed. Exiting...") + ret = os.system("cmake --build . --parallel") + if ret != 0: + sys.exit("Compilation of generated code failed. Exiting...") os.system( - """g++ {opt_flag} -fpermissive -pthread -w -maes -msse4.1 -mavx -mavx2 -mrdseed \ - -faligned-new -std=c++17 -fopenmp -I \"{eigen}\" -I \"{sci_src}\" \"{file}\" \ - -L \"{sci_lib}\" -lSCI-LinearHE -L \"{seal}\" -lseal -lssl -lcrypto \ - -o \"{output}\"""".format( - eigen=eigen_path, - sci_src=sci_src, - file=output_file, - sci_lib=sci_lib, - seal=seal_lib_path, - output=program_path, - opt_flag=opt_flag, + "mv {tmp_prog} {prog_path}".format( + tmp_prog=program_name, prog_path=program_path ) ) + os.chdir("..") + os.system("rm -r {build_dir}".format(build_dir=build_dir)) else: print( - "Not compiling generated code. Please follow the readme and build SCI before running this script." + "Not compiling generated code. Please follow the readme and build and install SCI." ) os.chdir(cwd) diff --git a/Athos/CompileTFGraph.py b/Athos/CompileTFGraph.py index 860d937a..584c1829 100644 --- a/Athos/CompileTFGraph.py +++ b/Athos/CompileTFGraph.py @@ -101,7 +101,7 @@ def generate_code(params, role, debug=False): target = params["target"] if params["bitlength"] is None: if target == "SCI": - bitlength = 63 + bitlength = 41 else: bitlength = 64 else: @@ -281,31 +281,43 @@ def generate_code(params, role, debug=False): "Not compiling generated code. Please follow the readme and build Porthos." ) elif target == "SCI": - sci = os.path.join(athos_dir, "..", "SCI") - sci_src = os.path.join(sci, "src") - sci_lib = os.path.join(sci, "build", "lib") - eigen_path = os.path.join(sci, "extern", "eigen") - seal_lib_path = os.path.join(sci, "extern", "SEAL", "native", "lib") - seal_inc_path = os.path.join(sci, "extern", "SEAL", "native", "src") - if os.path.exists(sci_lib): + sci_install = os.path.join(athos_dir, "..", "SCI", "build", "install") + build_dir = "build_dir" + os.system("rm -r {build_dir}".format(build_dir=build_dir)) + os.mkdir(build_dir) + os.chdir(build_dir) + cmake_file = """ + cmake_minimum_required (VERSION 3.0) + project (BUILD_IT) + find_package(SCI REQUIRED PATHS \"{sci_install}\") + add_executable({prog_name} {src_file}) + target_link_libraries({prog_name} SCI::SCI-{backend}) + """.format( + sci_install=sci_install, + prog_name=program_name, + src_file=output_file, + backend=backend.upper(), + ) + with open("CMakeLists.txt", "w") as f: + f.write(cmake_file) + + if os.path.exists(sci_install): + ret = os.system("cmake --log-level=ERROR .") + if ret != 0: + sys.exit("Compilation of generated code failed. Exiting...") + ret = os.system("cmake --build . --parallel") + if ret != 0: + sys.exit("Compilation of generated code failed. Exiting...") os.system( - """g++ {opt_flag} -fpermissive -pthread -w -maes -msse4.1 -mavx -mavx2 -mrdseed \ - -faligned-new -std=c++17 -fopenmp -I \"{eigen}\" -I \"{seal_inc_path}\" -I \"{sci_src}\" \"{file}\" \ - -L \"{sci_lib}\" -lSCI-LinearHE -L \"{seal}\" -lseal -lssl -lcrypto \ - -o \"{output}\"""".format( - eigen=eigen_path, - sci_src=sci_src, - file=output_file, - sci_lib=sci_lib, - seal_inc_path=seal_inc_path, - seal=seal_lib_path, - output=program_path, - opt_flag=opt_flag, + "mv {tmp_prog} {prog_path}".format( + tmp_prog=program_name, prog_path=program_path ) ) + os.chdir("..") + os.system("rm -r {build_dir}".format(build_dir=build_dir)) else: print( - "Not compiling generated code. Please follow the readme and build SCI." + "Not compiling generated code. Please follow the readme and build and install SCI." ) os.chdir(cwd) diff --git a/Athos/CompilerScripts/compile_tf.py b/Athos/CompilerScripts/compile_tf.py index 90cc60ed..b41d028f 100644 --- a/Athos/CompilerScripts/compile_tf.py +++ b/Athos/CompilerScripts/compile_tf.py @@ -121,6 +121,25 @@ def get_unsupported_ops(graph): return unsupported_ops +def get_op_names_from_tensors(tensor_names): + op_names = [] + for name in tensor_names: + if ":" in name: + try: + op_name, out_n = name.split(":") + out_n = int(out_n) + except: + raise ValueError( + "The tensor name {} looks like a tensor name but is not a valid one".format( + name + ) + ) + op_names.append(op_name) + else: + op_names.append(name) + return op_names + + # Generates the computation graph and tensor size metadata and saves them in # the model directory. # Optionaly dumps model weights as fixedpt in specified scaling factor @@ -128,7 +147,8 @@ def compile(model_fname, input_t_info, output_t_names, scaling_factor, save_weig model_name = os.path.basename(model_fname)[:-3] print("Loading tf graph ", model_fname) graph = tf_graph_io.load_pb(model_fname) - assert tensors_exist(graph, output_t_names) + output_op_names = get_op_names_from_tensors(output_t_names) + assert tensors_exist(graph, output_op_names) unsupported_ops = get_unsupported_ops(graph) if len(unsupported_ops) != 0: @@ -145,7 +165,7 @@ def compile(model_fname, input_t_info, output_t_names, scaling_factor, save_weig tensors_exist(graph, list(input_t_info.keys())) graph = set_input_shapes(graph, input_t_info) input_t_names = list(input_t_info.keys()) - graph_def = grappler.optimize(graph, input_t_names, output_t_names) + graph_def = grappler.optimize(graph, input_t_names, output_op_names) graph_def = grappler.convert_consts_to_var(graph_def) graph = get_graph_from(graph_def) @@ -170,7 +190,7 @@ def compile(model_fname, input_t_info, output_t_names, scaling_factor, save_weig # these constants. We strip them away in a new graph def which is amenable # to codegen but leave them in the graph. optimized_graph_def = DumpTFMtData.strip_variable_init_constants( - graph_def, input_t_names, output_t_names + graph_def, input_t_names, output_op_names ) tf_graph_io.dump_graph_def_pb( diff --git a/Athos/CompilerScripts/sample_networks/run_demo_2pc.sh b/Athos/CompilerScripts/sample_networks/run_demo_2pc.sh index 0b0db262..19836a1b 100755 --- a/Athos/CompilerScripts/sample_networks/run_demo_2pc.sh +++ b/Athos/CompilerScripts/sample_networks/run_demo_2pc.sh @@ -46,8 +46,8 @@ TIME_CMD="/usr/bin/time --format \"%M %U %S %e\"" PARTY0_IP="127.0.0.1" PORT=12345 -PARTY0_RUN_CMD="${MODEL_BINARY_PATH} r=1 p=${PORT} < ${MODEL_WEIGHT_PATH}" -PARTY1_RUN_CMD="${MODEL_BINARY_PATH} r=2 ip=${PARTY0_IP} p=${PORT} < ${MODEL_INPUT_PATH}" +PARTY0_RUN_CMD="${MODEL_BINARY_PATH} r=1 port=${PORT} < ${MODEL_WEIGHT_PATH}" +PARTY1_RUN_CMD="${MODEL_BINARY_PATH} r=2 ip=${PARTY0_IP} port=${PORT} < ${MODEL_INPUT_PATH}" PARTY0_DUMP_CMD="> ${MODEL_DIR}/party0_mpc_output.out 2> ${MODEL_DIR}/party0_stats" PARTY1_DUMP_CMD="> ${MODEL_DIR}/party1_mpc_output.out 2> ${MODEL_DIR}/party1_stats" diff --git a/Athos/Networks/ChestXRay/setup_and_run.sh b/Athos/Networks/ChestXRay/setup_and_run.sh index 5bd52758..d1e5adff 100755 --- a/Athos/Networks/ChestXRay/setup_and_run.sh +++ b/Athos/Networks/ChestXRay/setup_and_run.sh @@ -49,4 +49,4 @@ echo "This will take some time" echo "--------------------------------------------------------------------------------" echo -e "\n\n" python3 ChestXRay_tf_main.py --runPrediction True --scalingFac $scale --saveImgAndWtData True -echo -e "\n\n" \ No newline at end of file +echo -e "\n\n" diff --git a/Athos/Networks/DenseNet/setup_and_run.sh b/Athos/Networks/DenseNet/setup_and_run.sh index 0ae2784b..77c3e083 100755 --- a/Athos/Networks/DenseNet/setup_and_run.sh +++ b/Athos/Networks/DenseNet/setup_and_run.sh @@ -40,7 +40,7 @@ if [[ ! -f "PreTrainedModel/tf-densenet121.ckpt.data-00000-of-00001" || ! -f tar -xvzf ${filename} cd - fi -exit +#exit echo -e "\n\n" echo "--------------------------------------------------------------------------------" echo "Running DenseNet network and dumping computation graph, inputs and model weights" @@ -48,4 +48,4 @@ echo "This will take some time" echo "--------------------------------------------------------------------------------" echo -e "\n\n" python3 DenseNet_main.py --runPrediction True --scalingFac $scale --saveImgAndWtData True -echo -e "\n\n" \ No newline at end of file +echo -e "\n\n" diff --git a/Athos/Networks/ResNet/setup_and_run.sh b/Athos/Networks/ResNet/setup_and_run.sh index d0a04851..30b059e3 100755 --- a/Athos/Networks/ResNet/setup_and_run.sh +++ b/Athos/Networks/ResNet/setup_and_run.sh @@ -37,7 +37,7 @@ if [[ ! -d "PreTrainedModel/resnet_v2_fp32_savedmodel_NHWC" ]]; then tar -xvzf ${filename} cd - fi -exit +#exit echo -e "\n\n" echo "--------------------------------------------------------------------------------" echo "Running ResNet network and dumping computation graph, inputs and model weights" @@ -45,4 +45,4 @@ echo "This will take some time" echo "--------------------------------------------------------------------------------" echo -e "\n\n" python3 ResNet_main.py --runPrediction True --scalingFac $scale --saveImgAndWtData True -echo -e "\n\n" \ No newline at end of file +echo -e "\n\n" diff --git a/Athos/SeeDot/Compiler.py b/Athos/SeeDot/Compiler.py index 0bf44138..af126898 100644 --- a/Athos/SeeDot/Compiler.py +++ b/Athos/SeeDot/Compiler.py @@ -131,6 +131,9 @@ def fixOuputScale(self, res: (IR.Prog, IR.Expr), compiler: IRBuilderCSF): argsDict[IR.Int(scale_down, 32)] = "consSF" funcCall = IR.FuncCall(funcName, argsDict) scaledown_cmd_list.append(funcCall) + # ArgMax sets scale to -1 + if output_scale == -1: + continue if output_scale < Util.Config.consSF: assert ( False diff --git a/Athos/SeeDot/IR/IRBuilderCSF.py b/Athos/SeeDot/IR/IRBuilderCSF.py index fc821585..66cca4a0 100644 --- a/Athos/SeeDot/IR/IRBuilderCSF.py +++ b/Athos/SeeDot/IR/IRBuilderCSF.py @@ -45,14 +45,14 @@ def __init__(self, intPartBitwidth=-1): self._iter_cnt = 0 # Global variables - # Used to note declarations which will go before any statements - # But since this affects memory consumption, use carefully + # Used to note declarations which will go before any statements + # But since this affects memory consumption, use carefully self.globalDecls = ( {} ) # Mapping of (identifier name (string) -> list of [type, secret/public variable, bitlen of decl]) - # The 2nd arg can be either 'secret' or 'public'. - # If public/secret unspecified, default to 'secret'. - # The 3rd arg is used to specify the bitlen of the decl. + # The 2nd arg can be either 'secret' or 'public'. + # If public/secret unspecified, default to 'secret'. + # The 3rd arg is used to specify the bitlen of the decl. # Name mapping from SeeDot names to new names is useful for debugging self.name_mapping = {} @@ -336,21 +336,21 @@ def visitReshape(self, node: AST.Reshape, args=None): (prog_1, expr_1) = self.visit(node.expr) """ - reshape(A, n, h, w) - - cmd1: t1 = t2 = t3 = 0; - loop2: for n in 0:N: - for h in 0:H: - for w in 0:W: - cmd3: B[n][h][w] = A[t1][t2][t3] - cmd4: t3++; - cmd5: if (t3 == WW) - t3 = 0; - t2++; - if (t2 == HH) - t2 = 0; - t1++; - """ + reshape(A, n, h, w) + + cmd1: t1 = t2 = t3 = 0; + loop2: for n in 0:N: + for h in 0:H: + for w in 0:W: + cmd3: B[n][h][w] = A[t1][t2][t3] + cmd4: t3++; + cmd5: if (t3 == WW) + t3 = 0; + t2++; + if (t2 == HH) + t2 = 0; + t1++; + """ typ_1 = node.expr.type typ_2 = node.type @@ -1394,6 +1394,11 @@ def visitFloorLike(self, node: AST.Func, args=None): AST.Operators.SQRT, AST.Operators.RSQRT, ]: + assert ( + self.scaleFac > 31 + ), "The program scaling factor {} is invalid. Should be lesser than 32 if network has tan/sig/sqrt as those only support 32 bitlengths".format( + self.scaleFac + ) argsList[IR.Int(self.scaleFac, 32)] = "sA" argsList[IR.Int(self.scaleFac, 32)] = "sB" else: @@ -1413,12 +1418,24 @@ def visitFloorLike(self, node: AST.Func, args=None): AST.Operators.SQRT, AST.Operators.RSQRT, ]: - # Since these class of fucntions can only handle input of 32 bitlength, we have to scale down - # inputs before calling them. 23 bit mantissa - if final_sf > 23: + # Since these class of functions can only handle input of 32 bitlength, we have to scale down + # inputs before calling them. + # 32 bit fixedpt |(+/-)| _ _ _ _ _ _ _ _ | _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ | + # 31 bits available. For small values with max precision we can do 0.31 split + # Consider fp number: 2^-25 (2.98023223876953125 × 10^-8) + # | 1 | 1 1 0 0 1 1 0 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 | + # = 1 * 1.0 * 2^(102 - 127) = 2^-25 + # If we scale by mantissa number of bits i.e. 23, we get a fixedpt val + # = floor(1 * (2 ^ (-25 + 23))) = floor(2^-2) = floor(0.025) = 0 + # We have lost the precision. It is possible to scale more than mantissa bits to get precision. + # if we had scaled by 25 bits, we wouldve got fixedpt val = 1 and we could then do a 6.25 split while + # storing it. Upper bound of scaling is not mantissa, it is fixedpt bitlen available. + if final_sf > 31: assert ( final_sf > self.scaleFac - ), "The program scaling factor is invalid. Should be lesser than 32 if network has tan/sig/sqrt" + ), "The program scaling factor {} is invalid. Should be lesser than 32 if network has tan/sig/sqrt as those only support 32 bitlengths".format( + self.scaleFac + ) assert final_sf - self.scaleFac == self.scaleFac progExtraBefore = IRUtil.prog_merge( progExtraBefore, @@ -1440,6 +1457,7 @@ def visitFloorLike(self, node: AST.Func, args=None): AST.Operators.RSQRT, ]: argsList[IR.Int(min(32, self.actualbitwidth), 32)] = "bwA" + # argsList[IR.Int(min(32, self.actualbitwidth), 32)] = "bwB" argsList[IR.Int(self.actualbitwidth, 32)] = "bwB" if node.op == AST.Operators.SQRT: argsList[IR.Bool(False)] = "inverse" @@ -1497,17 +1515,17 @@ def visitUninterpFuncCall(self, node: AST.UninterpFuncCall, args=None): curShape = curArg.type.shape # If len(shape) == 0 : that means its a float - no need to qualify - # the function name with 0 in that case, since its essentially - # become an int. + # the function name with 0 in that case, since its essentially + # become an int. if len(curShape) > 0: funcName += self.varNameDelim + str(len(curShape)) ### TODO : right now if random strings like int are passed, its being set as datatype int -- int datatype in - # unintrepreted func call is being used in a hacky way right now + # unintrepreted func call is being used in a hacky way right now # Policy : - # First output tensor sizes are inserted in args. - # Then for each input tensor, its shape is inserted in args, followed by the input tensor itself. - # If the current input tensor has the same shape as any of the previous tensors, then its shape is not inserted. + # First output tensor sizes are inserted in args. + # Then for each input tensor, its shape is inserted in args, followed by the input tensor itself. + # If the current input tensor has the same shape as any of the previous tensors, then its shape is not inserted. funcArgsList = OrderedDict() if not (Util.Config.disableTruncOpti): @@ -1638,37 +1656,37 @@ def visitReduce(self, node: AST.Reduce, args=None): # We already have the output shape so we dont need to calculate with keep_dims """ - We need to reduce across axes. - Example: Say reduction axes are specified as 0,3 and keep dim = false - output rank -> len(input_shape) - len(reduction_axes) - output is 2D. - for i1=[0:s1] - for i2=[0:s2] - sum = 0 - for i0=[0:s0] - for i3=[0:s3] - sum = sum + input[i0][i1][i2][i3] - output[i1][i2] = sum / (s0 * s3) - if keep dim == true, output rank is same as input. We generate: - output[0][i1][i2][0] = sum / (s0 * s3) - - Ideally the above loop nest is what we would want to generate. But since we have - a division, we need to make calls to the div functionality and flatten the tensors. - temp_flat[s1*s2]; - out_flat[s1*s2]; - for i1=[0:s1] - for i2=[0:s2] - sum = 0 - for i0=[0:s0] - for i3=[0:s3] - sum = sum + input[i0][i1][i2][i3] - temp_flat[i1*s2 + i2] = sum - ElemWiseVectorPublicDiv(size=s1*s2, inp=temp_flat, divisor=s0*s3, out=out_flat) - for i1=[0:s1] - for i2=[0:s2] - output[i1][i2] = out_flat[i1*s2 + i2] - - """ + We need to reduce across axes. + Example: Say reduction axes are specified as 0,3 and keep dim = false + output rank -> len(input_shape) - len(reduction_axes) + output is 2D. + for i1=[0:s1] + for i2=[0:s2] + sum = 0 + for i0=[0:s0] + for i3=[0:s3] + sum = sum + input[i0][i1][i2][i3] + output[i1][i2] = sum / (s0 * s3) + if keep dim == true, output rank is same as input. We generate: + output[0][i1][i2][0] = sum / (s0 * s3) + + Ideally the above loop nest is what we would want to generate. But since we have + a division, we need to make calls to the div functionality and flatten the tensors. + temp_flat[s1*s2]; + out_flat[s1*s2]; + for i1=[0:s1] + for i2=[0:s2] + sum = 0 + for i0=[0:s0] + for i3=[0:s3] + sum = sum + input[i0][i1][i2][i3] + temp_flat[i1*s2 + i2] = sum + ElemWiseVectorPublicDiv(size=s1*s2, inp=temp_flat, divisor=s0*s3, out=out_flat) + for i1=[0:s1] + for i2=[0:s2] + output[i1][i2] = out_flat[i1*s2 + i2] + + """ reduced_dims = node.reductionAxesList inputShape = node.expr.type.shape perm = [] @@ -1683,8 +1701,6 @@ def visitReduce(self, node: AST.Reduce, args=None): perm.append(i) # perm will now be [ 1 ,2 ] + [ 0, 3] perm.extend(reduced_dims) - print(perm) - print(reduced_dims) loop_shape = [inputShape[perm[i]] for i in range(len(inputShape))] shuffled_inputiters = [inputiters[perm[i]] for i in range(len(inputShape))] diff --git a/Athos/TFCompiler/ProcessTFGraph.py b/Athos/TFCompiler/ProcessTFGraph.py index 0c4b7461..bb5ff118 100644 --- a/Athos/TFCompiler/ProcessTFGraph.py +++ b/Athos/TFCompiler/ProcessTFGraph.py @@ -110,14 +110,44 @@ def addOutputs(program, dictNodeNameToOutVarStr, output_tensors): assert lastLetASTNode is not None if output_tensors is None: output_name = lastLetASTNode.name - print(output_name.name) + tf_node_name = lastLetASTNode.decl.metadata[AST.ASTNode.mtdKeyTFNodeName] + print( + "Output not specified, taking output of ", + tf_node_name, + " as program output.", + ) output = AST.Output(output_name, AST.Party.CLIENT) + mtdForCurAST = { + AST.ASTNode.mtdKeyTFOpName: "Output", + AST.ASTNode.mtdKeyTFNodeName: tf_node_name, + } + mtdAST.visit(output, mtdForCurAST) lastLetASTNode.expr = output else: outVarCt = 0 outVarPrefix = "O" for i in range(0, len(output_tensors)): # name, decl, expr t_name = output_tensors[i] + if t_name not in dictNodeNameToOutVarStr: + if ":" in t_name: + try: + op_name, out_n = t_name.split(":") + out_n = int(out_n) + except: + raise ValueError( + "The tensor name {} looks like a tensor name but is not a valid one".format( + name + ) + ) + if out_n == 0: + if op_name in dictNodeNameToOutVarStr: + t_name = op_name + else: + t_name = op_name + "_mpc_const_var" + else: + t_name = op_name + "_mpc_const_var" + ":" + str(out_n) + else: + t_name += "_mpc_const_var" if i == len(output_tensors) - 1: output_name = AST.ID(dictNodeNameToOutVarStr[t_name]) output = AST.Output(output_name, AST.Party.CLIENT) @@ -307,10 +337,10 @@ def process_tf_graph(filename, output_tensors=None): for i, curInput in enumerate(inputsRef): if curInput.startswith("^"): # My hypothesis from empirical observation is that inputs which have '^' ahead of the node name - # denote control flow dependency and not data dependency. - # For all purposes for this compilation, control and data dependency is considered same. - # The reasoning being that everything is serial -- and graph execution is done in a - # a topological sort. + # denote control flow dependency and not data dependency. + # For all purposes for this compilation, control and data dependency is considered same. + # The reasoning being that everything is serial -- and graph execution is done in a + # a topological sort. inputsRef[i] = curInput.split("^")[-1] # Create extra info dict diff --git a/Athos/TFEzPCLibrary/Library32_common.ezpc b/Athos/TFEzPCLibrary/Library32_common.ezpc index c30c5c46..25cacfc0 100644 --- a/Athos/TFEzPCLibrary/Library32_common.ezpc +++ b/Athos/TFEzPCLibrary/Library32_common.ezpc @@ -1596,6 +1596,11 @@ def void ArgMax3(int32_pl outs1, int32_pl outs2, int32_pl outs3, } (**************************) +def void Relu1(int32_pl s1, int32_al[s1] inArr, int32_al[s1] outArr, int32_pl sf, bool_pl doTruncation) +{ + Relu(s1, inArr, outArr, sf, doTruncation); +} + def void Relu2(int32_pl s1, int32_pl s2, int32_al[s1][s2] inArr, int32_al[s1][s2] outArr, int32_pl sf, bool_pl doTruncation) { int32_pl size = s1*s2; @@ -1937,3 +1942,222 @@ def void ScaleDown5(int32_pl s1, int32_pl s2, int32_pl s3, int32_pl s4, int32_pl ClearMemSecret1(size, reshapedArr); } + + +def void Tanh1(int32_pl s1, int32_al[s1] inp, int32_al[s1] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + TanhImpl(LUTBITS, s1, sA, sB, bwA, bwB, inp, out); +} + +def void Tanh2(int32_pl s1, int32_pl s2, int32_al[s1][s2] inp, int32_al[s1][s2] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2; + int32_al[size] inpCopy; + int32_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + inpCopy[i*s1 + j] = inp[i][j]; + }; + }; + + TanhImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + out[i][j] = outCopy[i*s2 + j]; + }; + }; +} + +def void Tanh3(int32_pl s1, int32_pl s2, int32_pl s3, int32_al[s1][s2][s3] inp, int32_al[s1][s2][s3] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3; + int32_al[size] inpCopy; + int32_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + inpCopy[i*s2*s3 + j*s3 + k] = inp[i][j][k]; + }; + }; + }; + + TanhImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + out[i][j][k] = outCopy[i*s2*s3 + j*s3 + k]; + }; + }; + }; +} + +def void Tanh4(int32_pl s1, int32_pl s2, int32_pl s3, int32_pl s4, int32_al[s1][s2][s3][s4] inp, int32_al[s1][s2][s3][s4] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3 * s4; + int32_al[size] inpCopy; + int32_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l] = inp[i][j][k][l]; + }; + }; + }; + }; + + TanhImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + out[i][j][k][l] = inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l]; + }; + }; + }; + }; +} +def void Sigmoid1(int32_pl s1, int32_al[s1] inp, int32_al[s1] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + SigmoidImpl(LUTBITS, s1, sA, sB, bwA, bwB, inp, out); +} + +def void Sigmoid2(int32_pl s1, int32_pl s2, int32_al[s1][s2] inp, int32_al[s1][s2] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2; + int32_al[size] inpCopy; + int32_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + inpCopy[i*s1 + j] = inp[i][j]; + }; + }; + + SigmoidImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + out[i][j] = outCopy[i*s2 + j]; + }; + }; +} + +def void Sigmoid3(int32_pl s1, int32_pl s2, int32_pl s3, int32_al[s1][s2][s3] inp, int32_al[s1][s2][s3] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3; + int32_al[size] inpCopy; + int32_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + inpCopy[i*s2*s3 + j*s3 + k] = inp[i][j][k]; + }; + }; + }; + + SigmoidImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + out[i][j][k] = outCopy[i*s2*s3 + j*s3 + k]; + }; + }; + }; +} + +def void Sigmoid4(int32_pl s1, int32_pl s2, int32_pl s3, int32_pl s4, int32_al[s1][s2][s3][s4] inp, int32_al[s1][s2][s3][s4] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3 * s4; + int32_al[size] inpCopy; + int32_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l] = inp[i][j][k][l]; + }; + }; + }; + }; + + SigmoidImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + out[i][j][k][l] = inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l]; + }; + }; + }; + }; +} + +def void Sqrt1(int32_pl s1, int32_al[s1] inp, int32_al[s1] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_pl LUTBITS) { + SqrtImpl(LUTBITS, s1, sA, sB, bwA, bwB, inverse, inp, out); +} + +def void Sqrt2(int32_pl s1, int32_pl s2, int32_al[s1][s2] inp, int32_al[s1][s2] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_pl LUTBITS) { + int32_pl size = s1 * s2; + int32_al[size] inpCopy; + int32_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + inpCopy[i*s1 + j] = inp[i][j]; + }; + }; + + SqrtImpl(LUTBITS, size, sA, sB, bwA, bwB, inverse, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + out[i][j] = outCopy[i*s2 + j]; + }; + }; +} + +def void Sqrt3(int32_pl s1, int32_pl s2, int32_pl s3, int32_al[s1][s2][s3] inp, int32_al[s1][s2][s3] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3; + int32_al[size] inpCopy; + int32_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + inpCopy[i*s2*s3 + j*s3 + k] = inp[i][j][k]; + }; + }; + }; + + SqrtImpl(LUTBITS, size, sA, sB, bwA, bwB, inverse, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + out[i][j][k] = outCopy[i*s2*s3 + j*s3 + k]; + }; + }; + }; +} + +def void Sqrt4(int32_pl s1, int32_pl s2, int32_pl s3, int32_pl s4, int32_al[s1][s2][s3][s4] inp, int32_al[s1][s2][s3][s4] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3 * s4; + int32_al[size] inpCopy; + int32_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l] = inp[i][j][k][l]; + }; + }; + }; + }; + + SqrtImpl(LUTBITS, size, sA, sB, bwA, bwB, inverse, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + out[i][j][k][l] = inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l]; + }; + }; + }; + }; +} diff --git a/Athos/TFEzPCLibrary/Library32_cpp_pre.ezpc b/Athos/TFEzPCLibrary/Library32_cpp_pre.ezpc index f7f8cef4..1ab5c67d 100644 --- a/Athos/TFEzPCLibrary/Library32_cpp_pre.ezpc +++ b/Athos/TFEzPCLibrary/Library32_cpp_pre.ezpc @@ -236,6 +236,36212 @@ def void ElemWiseVectorPublicDiv(int32_pl s1, int32_al[s1] arr1, int32_pl diviso } +(* <><><><><><><> Auto-generated code <><><><><><><> *) +def void fillLUTINVSQRT(int32_pl[1020] inp) +{ +inp[0] = 4; +inp[1] = 2; +inp[2] = 3; +inp[3] = 2; +inp[4] = 8; +inp[5] = 5; +inp[6] = 7; +inp[7] = 5; +inp[8] = 6; +inp[9] = 4; +inp[10] = 6; +inp[11] = 4; +inp[12] = 16; +inp[13] = 11; +inp[14] = 15; +inp[15] = 10; +inp[16] = 14; +inp[17] = 10; +inp[18] = 13; +inp[19] = 9; +inp[20] = 13; +inp[21] = 9; +inp[22] = 12; +inp[23] = 8; +inp[24] = 12; +inp[25] = 8; +inp[26] = 11; +inp[27] = 8; +inp[28] = 32; +inp[29] = 22; +inp[30] = 31; +inp[31] = 21; +inp[32] = 30; +inp[33] = 21; +inp[34] = 29; +inp[35] = 20; +inp[36] = 28; +inp[37] = 20; +inp[38] = 27; +inp[39] = 19; +inp[40] = 27; +inp[41] = 19; +inp[42] = 26; +inp[43] = 18; +inp[44] = 26; +inp[45] = 18; +inp[46] = 25; +inp[47] = 18; +inp[48] = 25; +inp[49] = 17; +inp[50] = 24; +inp[51] = 17; +inp[52] = 24; +inp[53] = 17; +inp[54] = 23; +inp[55] = 16; +inp[56] = 23; +inp[57] = 16; +inp[58] = 22; +inp[59] = 16; +inp[60] = 64; +inp[61] = 45; +inp[62] = 63; +inp[63] = 44; +inp[64] = 62; +inp[65] = 43; +inp[66] = 61; +inp[67] = 43; +inp[68] = 60; +inp[69] = 42; +inp[70] = 59; +inp[71] = 42; +inp[72] = 58; +inp[73] = 41; +inp[74] = 57; +inp[75] = 40; +inp[76] = 57; +inp[77] = 40; +inp[78] = 56; +inp[79] = 39; +inp[80] = 55; +inp[81] = 39; +inp[82] = 55; +inp[83] = 39; +inp[84] = 54; +inp[85] = 38; +inp[86] = 53; +inp[87] = 38; +inp[88] = 53; +inp[89] = 37; +inp[90] = 52; +inp[91] = 37; +inp[92] = 52; +inp[93] = 36; +inp[94] = 51; +inp[95] = 36; +inp[96] = 51; +inp[97] = 36; +inp[98] = 50; +inp[99] = 35; +inp[100] = 50; +inp[101] = 35; +inp[102] = 49; +inp[103] = 35; +inp[104] = 49; +inp[105] = 34; +inp[106] = 48; +inp[107] = 34; +inp[108] = 48; +inp[109] = 34; +inp[110] = 47; +inp[111] = 33; +inp[112] = 47; +inp[113] = 33; +inp[114] = 47; +inp[115] = 33; +inp[116] = 46; +inp[117] = 33; +inp[118] = 46; +inp[119] = 32; +inp[120] = 45; +inp[121] = 32; +inp[122] = 45; +inp[123] = 32; +inp[124] = 128; +inp[125] = 90; +inp[126] = 127; +inp[127] = 89; +inp[128] = 126; +inp[129] = 89; +inp[130] = 125; +inp[131] = 88; +inp[132] = 124; +inp[133] = 87; +inp[134] = 123; +inp[135] = 87; +inp[136] = 122; +inp[137] = 86; +inp[138] = 121; +inp[139] = 85; +inp[140] = 120; +inp[141] = 85; +inp[142] = 119; +inp[143] = 84; +inp[144] = 119; +inp[145] = 84; +inp[146] = 118; +inp[147] = 83; +inp[148] = 117; +inp[149] = 83; +inp[150] = 116; +inp[151] = 82; +inp[152] = 115; +inp[153] = 81; +inp[154] = 115; +inp[155] = 81; +inp[156] = 114; +inp[157] = 80; +inp[158] = 113; +inp[159] = 80; +inp[160] = 113; +inp[161] = 79; +inp[162] = 112; +inp[163] = 79; +inp[164] = 111; +inp[165] = 79; +inp[166] = 111; +inp[167] = 78; +inp[168] = 110; +inp[169] = 78; +inp[170] = 109; +inp[171] = 77; +inp[172] = 109; +inp[173] = 77; +inp[174] = 108; +inp[175] = 76; +inp[176] = 107; +inp[177] = 76; +inp[178] = 107; +inp[179] = 75; +inp[180] = 106; +inp[181] = 75; +inp[182] = 106; +inp[183] = 75; +inp[184] = 105; +inp[185] = 74; +inp[186] = 105; +inp[187] = 74; +inp[188] = 104; +inp[189] = 73; +inp[190] = 103; +inp[191] = 73; +inp[192] = 103; +inp[193] = 73; +inp[194] = 102; +inp[195] = 72; +inp[196] = 102; +inp[197] = 72; +inp[198] = 101; +inp[199] = 72; +inp[200] = 101; +inp[201] = 71; +inp[202] = 100; +inp[203] = 71; +inp[204] = 100; +inp[205] = 71; +inp[206] = 99; +inp[207] = 70; +inp[208] = 99; +inp[209] = 70; +inp[210] = 98; +inp[211] = 69; +inp[212] = 98; +inp[213] = 69; +inp[214] = 98; +inp[215] = 69; +inp[216] = 97; +inp[217] = 69; +inp[218] = 97; +inp[219] = 68; +inp[220] = 96; +inp[221] = 68; +inp[222] = 96; +inp[223] = 68; +inp[224] = 95; +inp[225] = 67; +inp[226] = 95; +inp[227] = 67; +inp[228] = 95; +inp[229] = 67; +inp[230] = 94; +inp[231] = 66; +inp[232] = 94; +inp[233] = 66; +inp[234] = 93; +inp[235] = 66; +inp[236] = 93; +inp[237] = 66; +inp[238] = 93; +inp[239] = 65; +inp[240] = 92; +inp[241] = 65; +inp[242] = 92; +inp[243] = 65; +inp[244] = 91; +inp[245] = 65; +inp[246] = 91; +inp[247] = 64; +inp[248] = 91; +inp[249] = 64; +inp[250] = 90; +inp[251] = 64; +inp[252] = 256; +inp[253] = 181; +inp[254] = 255; +inp[255] = 180; +inp[256] = 254; +inp[257] = 179; +inp[258] = 253; +inp[259] = 178; +inp[260] = 252; +inp[261] = 178; +inp[262] = 251; +inp[263] = 177; +inp[264] = 250; +inp[265] = 176; +inp[266] = 249; +inp[267] = 176; +inp[268] = 248; +inp[269] = 175; +inp[270] = 247; +inp[271] = 174; +inp[272] = 246; +inp[273] = 174; +inp[274] = 245; +inp[275] = 173; +inp[276] = 244; +inp[277] = 173; +inp[278] = 243; +inp[279] = 172; +inp[280] = 243; +inp[281] = 171; +inp[282] = 242; +inp[283] = 171; +inp[284] = 241; +inp[285] = 170; +inp[286] = 240; +inp[287] = 170; +inp[288] = 239; +inp[289] = 169; +inp[290] = 238; +inp[291] = 168; +inp[292] = 238; +inp[293] = 168; +inp[294] = 237; +inp[295] = 167; +inp[296] = 236; +inp[297] = 167; +inp[298] = 235; +inp[299] = 166; +inp[300] = 234; +inp[301] = 166; +inp[302] = 234; +inp[303] = 165; +inp[304] = 233; +inp[305] = 165; +inp[306] = 232; +inp[307] = 164; +inp[308] = 231; +inp[309] = 163; +inp[310] = 231; +inp[311] = 163; +inp[312] = 230; +inp[313] = 162; +inp[314] = 229; +inp[315] = 162; +inp[316] = 228; +inp[317] = 161; +inp[318] = 228; +inp[319] = 161; +inp[320] = 227; +inp[321] = 160; +inp[322] = 226; +inp[323] = 160; +inp[324] = 226; +inp[325] = 159; +inp[326] = 225; +inp[327] = 159; +inp[328] = 224; +inp[329] = 158; +inp[330] = 224; +inp[331] = 158; +inp[332] = 223; +inp[333] = 158; +inp[334] = 222; +inp[335] = 157; +inp[336] = 222; +inp[337] = 157; +inp[338] = 221; +inp[339] = 156; +inp[340] = 220; +inp[341] = 156; +inp[342] = 220; +inp[343] = 155; +inp[344] = 219; +inp[345] = 155; +inp[346] = 218; +inp[347] = 154; +inp[348] = 218; +inp[349] = 154; +inp[350] = 217; +inp[351] = 153; +inp[352] = 217; +inp[353] = 153; +inp[354] = 216; +inp[355] = 153; +inp[356] = 215; +inp[357] = 152; +inp[358] = 215; +inp[359] = 152; +inp[360] = 214; +inp[361] = 151; +inp[362] = 214; +inp[363] = 151; +inp[364] = 213; +inp[365] = 150; +inp[366] = 212; +inp[367] = 150; +inp[368] = 212; +inp[369] = 150; +inp[370] = 211; +inp[371] = 149; +inp[372] = 211; +inp[373] = 149; +inp[374] = 210; +inp[375] = 148; +inp[376] = 210; +inp[377] = 148; +inp[378] = 209; +inp[379] = 148; +inp[380] = 209; +inp[381] = 147; +inp[382] = 208; +inp[383] = 147; +inp[384] = 207; +inp[385] = 147; +inp[386] = 207; +inp[387] = 146; +inp[388] = 206; +inp[389] = 146; +inp[390] = 206; +inp[391] = 145; +inp[392] = 205; +inp[393] = 145; +inp[394] = 205; +inp[395] = 145; +inp[396] = 204; +inp[397] = 144; +inp[398] = 204; +inp[399] = 144; +inp[400] = 203; +inp[401] = 144; +inp[402] = 203; +inp[403] = 143; +inp[404] = 202; +inp[405] = 143; +inp[406] = 202; +inp[407] = 143; +inp[408] = 201; +inp[409] = 142; +inp[410] = 201; +inp[411] = 142; +inp[412] = 200; +inp[413] = 142; +inp[414] = 200; +inp[415] = 141; +inp[416] = 199; +inp[417] = 141; +inp[418] = 199; +inp[419] = 140; +inp[420] = 198; +inp[421] = 140; +inp[422] = 198; +inp[423] = 140; +inp[424] = 197; +inp[425] = 139; +inp[426] = 197; +inp[427] = 139; +inp[428] = 197; +inp[429] = 139; +inp[430] = 196; +inp[431] = 139; +inp[432] = 196; +inp[433] = 138; +inp[434] = 195; +inp[435] = 138; +inp[436] = 195; +inp[437] = 138; +inp[438] = 194; +inp[439] = 137; +inp[440] = 194; +inp[441] = 137; +inp[442] = 193; +inp[443] = 137; +inp[444] = 193; +inp[445] = 136; +inp[446] = 193; +inp[447] = 136; +inp[448] = 192; +inp[449] = 136; +inp[450] = 192; +inp[451] = 135; +inp[452] = 191; +inp[453] = 135; +inp[454] = 191; +inp[455] = 135; +inp[456] = 190; +inp[457] = 135; +inp[458] = 190; +inp[459] = 134; +inp[460] = 190; +inp[461] = 134; +inp[462] = 189; +inp[463] = 134; +inp[464] = 189; +inp[465] = 133; +inp[466] = 188; +inp[467] = 133; +inp[468] = 188; +inp[469] = 133; +inp[470] = 188; +inp[471] = 133; +inp[472] = 187; +inp[473] = 132; +inp[474] = 187; +inp[475] = 132; +inp[476] = 186; +inp[477] = 132; +inp[478] = 186; +inp[479] = 131; +inp[480] = 186; +inp[481] = 131; +inp[482] = 185; +inp[483] = 131; +inp[484] = 185; +inp[485] = 131; +inp[486] = 185; +inp[487] = 130; +inp[488] = 184; +inp[489] = 130; +inp[490] = 184; +inp[491] = 130; +inp[492] = 183; +inp[493] = 130; +inp[494] = 183; +inp[495] = 129; +inp[496] = 183; +inp[497] = 129; +inp[498] = 182; +inp[499] = 129; +inp[500] = 182; +inp[501] = 129; +inp[502] = 182; +inp[503] = 128; +inp[504] = 181; +inp[505] = 128; +inp[506] = 181; +inp[507] = 128; +inp[508] = 512; +inp[509] = 362; +inp[510] = 511; +inp[511] = 361; +inp[512] = 510; +inp[513] = 360; +inp[514] = 509; +inp[515] = 359; +inp[516] = 508; +inp[517] = 359; +inp[518] = 507; +inp[519] = 358; +inp[520] = 506; +inp[521] = 357; +inp[522] = 505; +inp[523] = 357; +inp[524] = 504; +inp[525] = 356; +inp[526] = 503; +inp[527] = 355; +inp[528] = 502; +inp[529] = 355; +inp[530] = 501; +inp[531] = 354; +inp[532] = 500; +inp[533] = 353; +inp[534] = 499; +inp[535] = 353; +inp[536] = 498; +inp[537] = 352; +inp[538] = 497; +inp[539] = 351; +inp[540] = 496; +inp[541] = 351; +inp[542] = 495; +inp[543] = 350; +inp[544] = 494; +inp[545] = 349; +inp[546] = 493; +inp[547] = 349; +inp[548] = 493; +inp[549] = 348; +inp[550] = 492; +inp[551] = 348; +inp[552] = 491; +inp[553] = 347; +inp[554] = 490; +inp[555] = 346; +inp[556] = 489; +inp[557] = 346; +inp[558] = 488; +inp[559] = 345; +inp[560] = 487; +inp[561] = 344; +inp[562] = 486; +inp[563] = 344; +inp[564] = 486; +inp[565] = 343; +inp[566] = 485; +inp[567] = 343; +inp[568] = 484; +inp[569] = 342; +inp[570] = 483; +inp[571] = 341; +inp[572] = 482; +inp[573] = 341; +inp[574] = 481; +inp[575] = 340; +inp[576] = 481; +inp[577] = 340; +inp[578] = 480; +inp[579] = 339; +inp[580] = 479; +inp[581] = 338; +inp[582] = 478; +inp[583] = 338; +inp[584] = 477; +inp[585] = 337; +inp[586] = 476; +inp[587] = 337; +inp[588] = 476; +inp[589] = 336; +inp[590] = 475; +inp[591] = 336; +inp[592] = 474; +inp[593] = 335; +inp[594] = 473; +inp[595] = 334; +inp[596] = 472; +inp[597] = 334; +inp[598] = 472; +inp[599] = 333; +inp[600] = 471; +inp[601] = 333; +inp[602] = 470; +inp[603] = 332; +inp[604] = 469; +inp[605] = 332; +inp[606] = 469; +inp[607] = 331; +inp[608] = 468; +inp[609] = 331; +inp[610] = 467; +inp[611] = 330; +inp[612] = 466; +inp[613] = 330; +inp[614] = 466; +inp[615] = 329; +inp[616] = 465; +inp[617] = 328; +inp[618] = 464; +inp[619] = 328; +inp[620] = 463; +inp[621] = 327; +inp[622] = 463; +inp[623] = 327; +inp[624] = 462; +inp[625] = 326; +inp[626] = 461; +inp[627] = 326; +inp[628] = 460; +inp[629] = 325; +inp[630] = 460; +inp[631] = 325; +inp[632] = 459; +inp[633] = 324; +inp[634] = 458; +inp[635] = 324; +inp[636] = 457; +inp[637] = 323; +inp[638] = 457; +inp[639] = 323; +inp[640] = 456; +inp[641] = 322; +inp[642] = 455; +inp[643] = 322; +inp[644] = 455; +inp[645] = 321; +inp[646] = 454; +inp[647] = 321; +inp[648] = 453; +inp[649] = 320; +inp[650] = 453; +inp[651] = 320; +inp[652] = 452; +inp[653] = 319; +inp[654] = 451; +inp[655] = 319; +inp[656] = 450; +inp[657] = 318; +inp[658] = 450; +inp[659] = 318; +inp[660] = 449; +inp[661] = 317; +inp[662] = 448; +inp[663] = 317; +inp[664] = 448; +inp[665] = 316; +inp[666] = 447; +inp[667] = 316; +inp[668] = 446; +inp[669] = 316; +inp[670] = 446; +inp[671] = 315; +inp[672] = 445; +inp[673] = 315; +inp[674] = 444; +inp[675] = 314; +inp[676] = 444; +inp[677] = 314; +inp[678] = 443; +inp[679] = 313; +inp[680] = 442; +inp[681] = 313; +inp[682] = 442; +inp[683] = 312; +inp[684] = 441; +inp[685] = 312; +inp[686] = 441; +inp[687] = 311; +inp[688] = 440; +inp[689] = 311; +inp[690] = 439; +inp[691] = 310; +inp[692] = 439; +inp[693] = 310; +inp[694] = 438; +inp[695] = 310; +inp[696] = 437; +inp[697] = 309; +inp[698] = 437; +inp[699] = 309; +inp[700] = 436; +inp[701] = 308; +inp[702] = 436; +inp[703] = 308; +inp[704] = 435; +inp[705] = 307; +inp[706] = 434; +inp[707] = 307; +inp[708] = 434; +inp[709] = 307; +inp[710] = 433; +inp[711] = 306; +inp[712] = 432; +inp[713] = 306; +inp[714] = 432; +inp[715] = 305; +inp[716] = 431; +inp[717] = 305; +inp[718] = 431; +inp[719] = 304; +inp[720] = 430; +inp[721] = 304; +inp[722] = 429; +inp[723] = 304; +inp[724] = 429; +inp[725] = 303; +inp[726] = 428; +inp[727] = 303; +inp[728] = 428; +inp[729] = 302; +inp[730] = 427; +inp[731] = 302; +inp[732] = 427; +inp[733] = 301; +inp[734] = 426; +inp[735] = 301; +inp[736] = 425; +inp[737] = 301; +inp[738] = 425; +inp[739] = 300; +inp[740] = 424; +inp[741] = 300; +inp[742] = 424; +inp[743] = 299; +inp[744] = 423; +inp[745] = 299; +inp[746] = 423; +inp[747] = 299; +inp[748] = 422; +inp[749] = 298; +inp[750] = 421; +inp[751] = 298; +inp[752] = 421; +inp[753] = 297; +inp[754] = 420; +inp[755] = 297; +inp[756] = 420; +inp[757] = 297; +inp[758] = 419; +inp[759] = 296; +inp[760] = 419; +inp[761] = 296; +inp[762] = 418; +inp[763] = 295; +inp[764] = 418; +inp[765] = 295; +inp[766] = 417; +inp[767] = 295; +inp[768] = 416; +inp[769] = 294; +inp[770] = 416; +inp[771] = 294; +inp[772] = 415; +inp[773] = 294; +inp[774] = 415; +inp[775] = 293; +inp[776] = 414; +inp[777] = 293; +inp[778] = 414; +inp[779] = 292; +inp[780] = 413; +inp[781] = 292; +inp[782] = 413; +inp[783] = 292; +inp[784] = 412; +inp[785] = 291; +inp[786] = 412; +inp[787] = 291; +inp[788] = 411; +inp[789] = 291; +inp[790] = 411; +inp[791] = 290; +inp[792] = 410; +inp[793] = 290; +inp[794] = 410; +inp[795] = 289; +inp[796] = 409; +inp[797] = 289; +inp[798] = 409; +inp[799] = 289; +inp[800] = 408; +inp[801] = 288; +inp[802] = 408; +inp[803] = 288; +inp[804] = 407; +inp[805] = 288; +inp[806] = 407; +inp[807] = 287; +inp[808] = 406; +inp[809] = 287; +inp[810] = 406; +inp[811] = 287; +inp[812] = 405; +inp[813] = 286; +inp[814] = 405; +inp[815] = 286; +inp[816] = 404; +inp[817] = 286; +inp[818] = 404; +inp[819] = 285; +inp[820] = 403; +inp[821] = 285; +inp[822] = 403; +inp[823] = 285; +inp[824] = 402; +inp[825] = 284; +inp[826] = 402; +inp[827] = 284; +inp[828] = 401; +inp[829] = 284; +inp[830] = 401; +inp[831] = 283; +inp[832] = 400; +inp[833] = 283; +inp[834] = 400; +inp[835] = 282; +inp[836] = 399; +inp[837] = 282; +inp[838] = 399; +inp[839] = 282; +inp[840] = 398; +inp[841] = 281; +inp[842] = 398; +inp[843] = 281; +inp[844] = 397; +inp[845] = 281; +inp[846] = 397; +inp[847] = 280; +inp[848] = 396; +inp[849] = 280; +inp[850] = 396; +inp[851] = 280; +inp[852] = 395; +inp[853] = 279; +inp[854] = 395; +inp[855] = 279; +inp[856] = 395; +inp[857] = 279; +inp[858] = 394; +inp[859] = 279; +inp[860] = 394; +inp[861] = 278; +inp[862] = 393; +inp[863] = 278; +inp[864] = 393; +inp[865] = 278; +inp[866] = 392; +inp[867] = 277; +inp[868] = 392; +inp[869] = 277; +inp[870] = 391; +inp[871] = 277; +inp[872] = 391; +inp[873] = 276; +inp[874] = 390; +inp[875] = 276; +inp[876] = 390; +inp[877] = 276; +inp[878] = 390; +inp[879] = 275; +inp[880] = 389; +inp[881] = 275; +inp[882] = 389; +inp[883] = 275; +inp[884] = 388; +inp[885] = 274; +inp[886] = 388; +inp[887] = 274; +inp[888] = 387; +inp[889] = 274; +inp[890] = 387; +inp[891] = 273; +inp[892] = 387; +inp[893] = 273; +inp[894] = 386; +inp[895] = 273; +inp[896] = 386; +inp[897] = 273; +inp[898] = 385; +inp[899] = 272; +inp[900] = 385; +inp[901] = 272; +inp[902] = 384; +inp[903] = 272; +inp[904] = 384; +inp[905] = 271; +inp[906] = 384; +inp[907] = 271; +inp[908] = 383; +inp[909] = 271; +inp[910] = 383; +inp[911] = 270; +inp[912] = 382; +inp[913] = 270; +inp[914] = 382; +inp[915] = 270; +inp[916] = 381; +inp[917] = 270; +inp[918] = 381; +inp[919] = 269; +inp[920] = 381; +inp[921] = 269; +inp[922] = 380; +inp[923] = 269; +inp[924] = 380; +inp[925] = 268; +inp[926] = 379; +inp[927] = 268; +inp[928] = 379; +inp[929] = 268; +inp[930] = 379; +inp[931] = 268; +inp[932] = 378; +inp[933] = 267; +inp[934] = 378; +inp[935] = 267; +inp[936] = 377; +inp[937] = 267; +inp[938] = 377; +inp[939] = 266; +inp[940] = 377; +inp[941] = 266; +inp[942] = 376; +inp[943] = 266; +inp[944] = 376; +inp[945] = 266; +inp[946] = 375; +inp[947] = 265; +inp[948] = 375; +inp[949] = 265; +inp[950] = 375; +inp[951] = 265; +inp[952] = 374; +inp[953] = 264; +inp[954] = 374; +inp[955] = 264; +inp[956] = 373; +inp[957] = 264; +inp[958] = 373; +inp[959] = 264; +inp[960] = 373; +inp[961] = 263; +inp[962] = 372; +inp[963] = 263; +inp[964] = 372; +inp[965] = 263; +inp[966] = 371; +inp[967] = 263; +inp[968] = 371; +inp[969] = 262; +inp[970] = 371; +inp[971] = 262; +inp[972] = 370; +inp[973] = 262; +inp[974] = 370; +inp[975] = 261; +inp[976] = 370; +inp[977] = 261; +inp[978] = 369; +inp[979] = 261; +inp[980] = 369; +inp[981] = 261; +inp[982] = 368; +inp[983] = 260; +inp[984] = 368; +inp[985] = 260; +inp[986] = 368; +inp[987] = 260; +inp[988] = 367; +inp[989] = 260; +inp[990] = 367; +inp[991] = 259; +inp[992] = 367; +inp[993] = 259; +inp[994] = 366; +inp[995] = 259; +inp[996] = 366; +inp[997] = 259; +inp[998] = 365; +inp[999] = 258; +inp[1000] = 365; +inp[1001] = 258; +inp[1002] = 365; +inp[1003] = 258; +inp[1004] = 364; +inp[1005] = 258; +inp[1006] = 364; +inp[1007] = 257; +inp[1008] = 364; +inp[1009] = 257; +inp[1010] = 363; +inp[1011] = 257; +inp[1012] = 363; +inp[1013] = 257; +inp[1014] = 363; +inp[1015] = 256; +inp[1016] = 362; +inp[1017] = 256; +inp[1018] = 362; +inp[1019] = 256; +} + +def void fillLUTDIV(int32_pl[1020] inp) +{ +inp[0] = 10; +inp[1] = 15; +inp[2] = 5; +inp[3] = 10; +inp[4] = 25; +inp[5] = 63; +inp[6] = 17; +inp[7] = 51; +inp[8] = 12; +inp[9] = 42; +inp[10] = 9; +inp[11] = 36; +inp[12] = 56; +inp[13] = 255; +inp[14] = 45; +inp[15] = 227; +inp[16] = 37; +inp[17] = 204; +inp[18] = 31; +inp[19] = 186; +inp[20] = 26; +inp[21] = 170; +inp[22] = 22; +inp[23] = 157; +inp[24] = 19; +inp[25] = 146; +inp[26] = 17; +inp[27] = 136; +inp[28] = 120; +inp[29] = 1023; +inp[30] = 107; +inp[31] = 963; +inp[32] = 95; +inp[33] = 909; +inp[34] = 86; +inp[35] = 862; +inp[36] = 78; +inp[37] = 818; +inp[38] = 70; +inp[39] = 779; +inp[40] = 64; +inp[41] = 744; +inp[42] = 59; +inp[43] = 712; +inp[44] = 54; +inp[45] = 682; +inp[46] = 50; +inp[47] = 655; +inp[48] = 46; +inp[49] = 630; +inp[50] = 43; +inp[51] = 606; +inp[52] = 40; +inp[53] = 585; +inp[54] = 37; +inp[55] = 564; +inp[56] = 35; +inp[57] = 546; +inp[58] = 33; +inp[59] = 528; +inp[60] = 248; +inp[61] = 4095; +inp[62] = 233; +inp[63] = 3971; +inp[64] = 220; +inp[65] = 3854; +inp[66] = 208; +inp[67] = 3744; +inp[68] = 196; +inp[69] = 3640; +inp[70] = 186; +inp[71] = 3542; +inp[72] = 176; +inp[73] = 3448; +inp[74] = 168; +inp[75] = 3360; +inp[76] = 159; +inp[77] = 3276; +inp[78] = 152; +inp[79] = 3196; +inp[80] = 145; +inp[81] = 3120; +inp[82] = 138; +inp[83] = 3047; +inp[84] = 132; +inp[85] = 2978; +inp[86] = 126; +inp[87] = 2912; +inp[88] = 121; +inp[89] = 2849; +inp[90] = 116; +inp[91] = 2788; +inp[92] = 111; +inp[93] = 2730; +inp[94] = 106; +inp[95] = 2674; +inp[96] = 102; +inp[97] = 2621; +inp[98] = 98; +inp[99] = 2569; +inp[100] = 95; +inp[101] = 2520; +inp[102] = 91; +inp[103] = 2472; +inp[104] = 88; +inp[105] = 2427; +inp[106] = 85; +inp[107] = 2383; +inp[108] = 82; +inp[109] = 2340; +inp[110] = 79; +inp[111] = 2299; +inp[112] = 76; +inp[113] = 2259; +inp[114] = 74; +inp[115] = 2221; +inp[116] = 71; +inp[117] = 2184; +inp[118] = 69; +inp[119] = 2148; +inp[120] = 67; +inp[121] = 2113; +inp[122] = 65; +inp[123] = 2080; +inp[124] = 504; +inp[125] = 16383; +inp[126] = 488; +inp[127] = 16131; +inp[128] = 474; +inp[129] = 15887; +inp[130] = 460; +inp[131] = 15649; +inp[132] = 446; +inp[133] = 15419; +inp[134] = 434; +inp[135] = 15196; +inp[136] = 421; +inp[137] = 14979; +inp[138] = 410; +inp[139] = 14768; +inp[140] = 399; +inp[141] = 14563; +inp[142] = 388; +inp[143] = 14363; +inp[144] = 377; +inp[145] = 14169; +inp[146] = 367; +inp[147] = 13980; +inp[148] = 358; +inp[149] = 13796; +inp[150] = 349; +inp[151] = 13617; +inp[152] = 340; +inp[153] = 13443; +inp[154] = 331; +inp[155] = 13272; +inp[156] = 323; +inp[157] = 13106; +inp[158] = 315; +inp[159] = 12945; +inp[160] = 308; +inp[161] = 12787; +inp[162] = 300; +inp[163] = 12633; +inp[164] = 293; +inp[165] = 12482; +inp[166] = 286; +inp[167] = 12335; +inp[168] = 280; +inp[169] = 12192; +inp[170] = 273; +inp[171] = 12052; +inp[172] = 267; +inp[173] = 11915; +inp[174] = 261; +inp[175] = 11781; +inp[176] = 256; +inp[177] = 11650; +inp[178] = 250; +inp[179] = 11522; +inp[180] = 245; +inp[181] = 11397; +inp[182] = 239; +inp[183] = 11274; +inp[184] = 234; +inp[185] = 11154; +inp[186] = 229; +inp[187] = 11037; +inp[188] = 225; +inp[189] = 10922; +inp[190] = 220; +inp[191] = 10809; +inp[192] = 216; +inp[193] = 10699; +inp[194] = 211; +inp[195] = 10591; +inp[196] = 207; +inp[197] = 10485; +inp[198] = 203; +inp[199] = 10381; +inp[200] = 199; +inp[201] = 10280; +inp[202] = 195; +inp[203] = 10180; +inp[204] = 192; +inp[205] = 10082; +inp[206] = 188; +inp[207] = 9986; +inp[208] = 184; +inp[209] = 9892; +inp[210] = 181; +inp[211] = 9799; +inp[212] = 178; +inp[213] = 9708; +inp[214] = 174; +inp[215] = 9619; +inp[216] = 171; +inp[217] = 9532; +inp[218] = 168; +inp[219] = 9446; +inp[220] = 165; +inp[221] = 9362; +inp[222] = 162; +inp[223] = 9279; +inp[224] = 159; +inp[225] = 9197; +inp[226] = 157; +inp[227] = 9117; +inp[228] = 154; +inp[229] = 9039; +inp[230] = 151; +inp[231] = 8962; +inp[232] = 149; +inp[233] = 8886; +inp[234] = 146; +inp[235] = 8811; +inp[236] = 144; +inp[237] = 8738; +inp[238] = 142; +inp[239] = 8665; +inp[240] = 139; +inp[241] = 8594; +inp[242] = 137; +inp[243] = 8524; +inp[244] = 135; +inp[245] = 8456; +inp[246] = 133; +inp[247] = 8388; +inp[248] = 131; +inp[249] = 8321; +inp[250] = 129; +inp[251] = 8256; +inp[252] = 1016; +inp[253] = 65535; +inp[254] = 1000; +inp[255] = 65027; +inp[256] = 985; +inp[257] = 64527; +inp[258] = 970; +inp[259] = 64034; +inp[260] = 955; +inp[261] = 63549; +inp[262] = 941; +inp[263] = 63071; +inp[264] = 927; +inp[265] = 62601; +inp[266] = 913; +inp[267] = 62137; +inp[268] = 900; +inp[269] = 61680; +inp[270] = 887; +inp[271] = 61230; +inp[272] = 874; +inp[273] = 60786; +inp[274] = 862; +inp[275] = 60349; +inp[276] = 849; +inp[277] = 59918; +inp[278] = 837; +inp[279] = 59493; +inp[280] = 826; +inp[281] = 59074; +inp[282] = 814; +inp[283] = 58661; +inp[284] = 803; +inp[285] = 58253; +inp[286] = 792; +inp[287] = 57852; +inp[288] = 781; +inp[289] = 57455; +inp[290] = 771; +inp[291] = 57065; +inp[292] = 760; +inp[293] = 56679; +inp[294] = 750; +inp[295] = 56299; +inp[296] = 740; +inp[297] = 55923; +inp[298] = 730; +inp[299] = 55553; +inp[300] = 721; +inp[301] = 55187; +inp[302] = 712; +inp[303] = 54827; +inp[304] = 702; +inp[305] = 54471; +inp[306] = 693; +inp[307] = 54119; +inp[308] = 685; +inp[309] = 53772; +inp[310] = 676; +inp[311] = 53430; +inp[312] = 667; +inp[313] = 53092; +inp[314] = 659; +inp[315] = 52758; +inp[316] = 651; +inp[317] = 52428; +inp[318] = 643; +inp[319] = 52102; +inp[320] = 635; +inp[321] = 51781; +inp[322] = 627; +inp[323] = 51463; +inp[324] = 620; +inp[325] = 51149; +inp[326] = 612; +inp[327] = 50839; +inp[328] = 605; +inp[329] = 50533; +inp[330] = 597; +inp[331] = 50230; +inp[332] = 590; +inp[333] = 49931; +inp[334] = 583; +inp[335] = 49636; +inp[336] = 577; +inp[337] = 49344; +inp[338] = 570; +inp[339] = 49055; +inp[340] = 563; +inp[341] = 48770; +inp[342] = 557; +inp[343] = 48488; +inp[344] = 550; +inp[345] = 48210; +inp[346] = 544; +inp[347] = 47934; +inp[348] = 538; +inp[349] = 47662; +inp[350] = 532; +inp[351] = 47393; +inp[352] = 526; +inp[353] = 47126; +inp[354] = 520; +inp[355] = 46863; +inp[356] = 514; +inp[357] = 46603; +inp[358] = 509; +inp[359] = 46345; +inp[360] = 503; +inp[361] = 46091; +inp[362] = 498; +inp[363] = 45839; +inp[364] = 492; +inp[365] = 45590; +inp[366] = 487; +inp[367] = 45343; +inp[368] = 482; +inp[369] = 45099; +inp[370] = 477; +inp[371] = 44858; +inp[372] = 472; +inp[373] = 44620; +inp[374] = 467; +inp[375] = 44384; +inp[376] = 462; +inp[377] = 44150; +inp[378] = 457; +inp[379] = 43919; +inp[380] = 452; +inp[381] = 43690; +inp[382] = 448; +inp[383] = 43464; +inp[384] = 443; +inp[385] = 43240; +inp[386] = 438; +inp[387] = 43018; +inp[388] = 434; +inp[389] = 42798; +inp[390] = 430; +inp[391] = 42581; +inp[392] = 425; +inp[393] = 42366; +inp[394] = 421; +inp[395] = 42153; +inp[396] = 417; +inp[397] = 41942; +inp[398] = 413; +inp[399] = 41734; +inp[400] = 409; +inp[401] = 41527; +inp[402] = 405; +inp[403] = 41323; +inp[404] = 401; +inp[405] = 41120; +inp[406] = 397; +inp[407] = 40919; +inp[408] = 393; +inp[409] = 40721; +inp[410] = 389; +inp[411] = 40524; +inp[412] = 385; +inp[413] = 40329; +inp[414] = 382; +inp[415] = 40136; +inp[416] = 378; +inp[417] = 39945; +inp[418] = 375; +inp[419] = 39756; +inp[420] = 371; +inp[421] = 39568; +inp[422] = 368; +inp[423] = 39383; +inp[424] = 364; +inp[425] = 39198; +inp[426] = 361; +inp[427] = 39016; +inp[428] = 357; +inp[429] = 38836; +inp[430] = 354; +inp[431] = 38657; +inp[432] = 351; +inp[433] = 38479; +inp[434] = 348; +inp[435] = 38304; +inp[436] = 345; +inp[437] = 38129; +inp[438] = 341; +inp[439] = 37957; +inp[440] = 338; +inp[441] = 37786; +inp[442] = 335; +inp[443] = 37616; +inp[444] = 332; +inp[445] = 37449; +inp[446] = 329; +inp[447] = 37282; +inp[448] = 327; +inp[449] = 37117; +inp[450] = 324; +inp[451] = 36954; +inp[452] = 321; +inp[453] = 36792; +inp[454] = 318; +inp[455] = 36631; +inp[456] = 315; +inp[457] = 36472; +inp[458] = 313; +inp[459] = 36314; +inp[460] = 310; +inp[461] = 36157; +inp[462] = 307; +inp[463] = 36002; +inp[464] = 305; +inp[465] = 35848; +inp[466] = 302; +inp[467] = 35696; +inp[468] = 299; +inp[469] = 35544; +inp[470] = 297; +inp[471] = 35394; +inp[472] = 294; +inp[473] = 35246; +inp[474] = 292; +inp[475] = 35098; +inp[476] = 290; +inp[477] = 34952; +inp[478] = 287; +inp[479] = 34807; +inp[480] = 285; +inp[481] = 34663; +inp[482] = 282; +inp[483] = 34520; +inp[484] = 280; +inp[485] = 34379; +inp[486] = 278; +inp[487] = 34239; +inp[488] = 276; +inp[489] = 34099; +inp[490] = 273; +inp[491] = 33961; +inp[492] = 271; +inp[493] = 33824; +inp[494] = 269; +inp[495] = 33689; +inp[496] = 267; +inp[497] = 33554; +inp[498] = 265; +inp[499] = 33420; +inp[500] = 263; +inp[501] = 33288; +inp[502] = 261; +inp[503] = 33156; +inp[504] = 259; +inp[505] = 33025; +inp[506] = 257; +inp[507] = 32896; +inp[508] = 2040; +inp[509] = 262143; +inp[510] = 2024; +inp[511] = 261123; +inp[512] = 2008; +inp[513] = 260111; +inp[514] = 1993; +inp[515] = 259107; +inp[516] = 1977; +inp[517] = 258110; +inp[518] = 1962; +inp[519] = 257121; +inp[520] = 1947; +inp[521] = 256140; +inp[522] = 1933; +inp[523] = 255166; +inp[524] = 1918; +inp[525] = 254199; +inp[526] = 1904; +inp[527] = 253240; +inp[528] = 1889; +inp[529] = 252288; +inp[530] = 1875; +inp[531] = 251343; +inp[532] = 1861; +inp[533] = 250405; +inp[534] = 1847; +inp[535] = 249474; +inp[536] = 1834; +inp[537] = 248550; +inp[538] = 1820; +inp[539] = 247633; +inp[540] = 1807; +inp[541] = 246723; +inp[542] = 1794; +inp[543] = 245819; +inp[544] = 1781; +inp[545] = 244922; +inp[546] = 1768; +inp[547] = 244031; +inp[548] = 1755; +inp[549] = 243147; +inp[550] = 1742; +inp[551] = 242269; +inp[552] = 1730; +inp[553] = 241398; +inp[554] = 1718; +inp[555] = 240533; +inp[556] = 1705; +inp[557] = 239674; +inp[558] = 1693; +inp[559] = 238821; +inp[560] = 1681; +inp[561] = 237974; +inp[562] = 1669; +inp[563] = 237133; +inp[564] = 1658; +inp[565] = 236298; +inp[566] = 1646; +inp[567] = 235469; +inp[568] = 1635; +inp[569] = 234646; +inp[570] = 1623; +inp[571] = 233828; +inp[572] = 1612; +inp[573] = 233016; +inp[574] = 1601; +inp[575] = 232210; +inp[576] = 1590; +inp[577] = 231409; +inp[578] = 1579; +inp[579] = 230614; +inp[580] = 1568; +inp[581] = 229824; +inp[582] = 1558; +inp[583] = 229040; +inp[584] = 1547; +inp[585] = 228261; +inp[586] = 1537; +inp[587] = 227487; +inp[588] = 1526; +inp[589] = 226718; +inp[590] = 1516; +inp[591] = 225955; +inp[592] = 1506; +inp[593] = 225197; +inp[594] = 1496; +inp[595] = 224444; +inp[596] = 1486; +inp[597] = 223695; +inp[598] = 1476; +inp[599] = 222952; +inp[600] = 1466; +inp[601] = 222214; +inp[602] = 1457; +inp[603] = 221481; +inp[604] = 1447; +inp[605] = 220752; +inp[606] = 1438; +inp[607] = 220028; +inp[608] = 1428; +inp[609] = 219309; +inp[610] = 1419; +inp[611] = 218595; +inp[612] = 1410; +inp[613] = 217885; +inp[614] = 1401; +inp[615] = 217180; +inp[616] = 1392; +inp[617] = 216479; +inp[618] = 1383; +inp[619] = 215783; +inp[620] = 1374; +inp[621] = 215092; +inp[622] = 1365; +inp[623] = 214405; +inp[624] = 1356; +inp[625] = 213722; +inp[626] = 1348; +inp[627] = 213043; +inp[628] = 1339; +inp[629] = 212369; +inp[630] = 1331; +inp[631] = 211699; +inp[632] = 1323; +inp[633] = 211033; +inp[634] = 1314; +inp[635] = 210372; +inp[636] = 1306; +inp[637] = 209714; +inp[638] = 1298; +inp[639] = 209061; +inp[640] = 1290; +inp[641] = 208412; +inp[642] = 1282; +inp[643] = 207767; +inp[644] = 1274; +inp[645] = 207125; +inp[646] = 1266; +inp[647] = 206488; +inp[648] = 1259; +inp[649] = 205855; +inp[650] = 1251; +inp[651] = 205225; +inp[652] = 1243; +inp[653] = 204599; +inp[654] = 1236; +inp[655] = 203978; +inp[656] = 1228; +inp[657] = 203359; +inp[658] = 1221; +inp[659] = 202745; +inp[660] = 1214; +inp[661] = 202134; +inp[662] = 1206; +inp[663] = 201527; +inp[664] = 1199; +inp[665] = 200924; +inp[666] = 1192; +inp[667] = 200324; +inp[668] = 1185; +inp[669] = 199728; +inp[670] = 1178; +inp[671] = 199135; +inp[672] = 1171; +inp[673] = 198546; +inp[674] = 1164; +inp[675] = 197961; +inp[676] = 1157; +inp[677] = 197378; +inp[678] = 1150; +inp[679] = 196799; +inp[680] = 1144; +inp[681] = 196224; +inp[682] = 1137; +inp[683] = 195652; +inp[684] = 1130; +inp[685] = 195083; +inp[686] = 1124; +inp[687] = 194518; +inp[688] = 1117; +inp[689] = 193956; +inp[690] = 1111; +inp[691] = 193397; +inp[692] = 1105; +inp[693] = 192841; +inp[694] = 1098; +inp[695] = 192288; +inp[696] = 1092; +inp[697] = 191739; +inp[698] = 1086; +inp[699] = 191193; +inp[700] = 1080; +inp[701] = 190649; +inp[702] = 1074; +inp[703] = 190109; +inp[704] = 1068; +inp[705] = 189572; +inp[706] = 1062; +inp[707] = 189038; +inp[708] = 1056; +inp[709] = 188507; +inp[710] = 1050; +inp[711] = 187979; +inp[712] = 1044; +inp[713] = 187454; +inp[714] = 1038; +inp[715] = 186932; +inp[716] = 1032; +inp[717] = 186413; +inp[718] = 1027; +inp[719] = 185896; +inp[720] = 1021; +inp[721] = 185383; +inp[722] = 1015; +inp[723] = 184872; +inp[724] = 1010; +inp[725] = 184364; +inp[726] = 1004; +inp[727] = 183859; +inp[728] = 999; +inp[729] = 183357; +inp[730] = 993; +inp[731] = 182857; +inp[732] = 988; +inp[733] = 182360; +inp[734] = 983; +inp[735] = 181866; +inp[736] = 977; +inp[737] = 181375; +inp[738] = 972; +inp[739] = 180886; +inp[740] = 967; +inp[741] = 180400; +inp[742] = 962; +inp[743] = 179916; +inp[744] = 956; +inp[745] = 179435; +inp[746] = 951; +inp[747] = 178956; +inp[748] = 946; +inp[749] = 178480; +inp[750] = 941; +inp[751] = 178007; +inp[752] = 936; +inp[753] = 177536; +inp[754] = 931; +inp[755] = 177068; +inp[756] = 927; +inp[757] = 176602; +inp[758] = 922; +inp[759] = 176138; +inp[760] = 917; +inp[761] = 175677; +inp[762] = 912; +inp[763] = 175218; +inp[764] = 907; +inp[765] = 174762; +inp[766] = 903; +inp[767] = 174308; +inp[768] = 898; +inp[769] = 173857; +inp[770] = 893; +inp[771] = 173407; +inp[772] = 889; +inp[773] = 172960; +inp[774] = 884; +inp[775] = 172516; +inp[776] = 880; +inp[777] = 172073; +inp[778] = 875; +inp[779] = 171633; +inp[780] = 871; +inp[781] = 171195; +inp[782] = 866; +inp[783] = 170760; +inp[784] = 862; +inp[785] = 170326; +inp[786] = 858; +inp[787] = 169895; +inp[788] = 853; +inp[789] = 169466; +inp[790] = 849; +inp[791] = 169039; +inp[792] = 845; +inp[793] = 168615; +inp[794] = 840; +inp[795] = 168192; +inp[796] = 836; +inp[797] = 167772; +inp[798] = 832; +inp[799] = 167353; +inp[800] = 828; +inp[801] = 166937; +inp[802] = 824; +inp[803] = 166523; +inp[804] = 820; +inp[805] = 166110; +inp[806] = 816; +inp[807] = 165700; +inp[808] = 812; +inp[809] = 165292; +inp[810] = 808; +inp[811] = 164886; +inp[812] = 804; +inp[813] = 164482; +inp[814] = 800; +inp[815] = 164080; +inp[816] = 796; +inp[817] = 163680; +inp[818] = 792; +inp[819] = 163281; +inp[820] = 788; +inp[821] = 162885; +inp[822] = 784; +inp[823] = 162491; +inp[824] = 781; +inp[825] = 162098; +inp[826] = 777; +inp[827] = 161707; +inp[828] = 773; +inp[829] = 161319; +inp[830] = 770; +inp[831] = 160932; +inp[832] = 766; +inp[833] = 160547; +inp[834] = 762; +inp[835] = 160164; +inp[836] = 759; +inp[837] = 159782; +inp[838] = 755; +inp[839] = 159403; +inp[840] = 751; +inp[841] = 159025; +inp[842] = 748; +inp[843] = 158649; +inp[844] = 744; +inp[845] = 158275; +inp[846] = 741; +inp[847] = 157903; +inp[848] = 737; +inp[849] = 157532; +inp[850] = 734; +inp[851] = 157163; +inp[852] = 730; +inp[853] = 156796; +inp[854] = 727; +inp[855] = 156430; +inp[856] = 724; +inp[857] = 156067; +inp[858] = 720; +inp[859] = 155704; +inp[860] = 717; +inp[861] = 155344; +inp[862] = 714; +inp[863] = 154985; +inp[864] = 710; +inp[865] = 154628; +inp[866] = 707; +inp[867] = 154273; +inp[868] = 704; +inp[869] = 153919; +inp[870] = 701; +inp[871] = 153567; +inp[872] = 698; +inp[873] = 153216; +inp[874] = 694; +inp[875] = 152867; +inp[876] = 691; +inp[877] = 152520; +inp[878] = 688; +inp[879] = 152174; +inp[880] = 685; +inp[881] = 151829; +inp[882] = 682; +inp[883] = 151487; +inp[884] = 679; +inp[885] = 151145; +inp[886] = 676; +inp[887] = 150806; +inp[888] = 673; +inp[889] = 150468; +inp[890] = 670; +inp[891] = 150131; +inp[892] = 667; +inp[893] = 149796; +inp[894] = 664; +inp[895] = 149462; +inp[896] = 661; +inp[897] = 149130; +inp[898] = 658; +inp[899] = 148800; +inp[900] = 655; +inp[901] = 148470; +inp[902] = 652; +inp[903] = 148143; +inp[904] = 649; +inp[905] = 147816; +inp[906] = 646; +inp[907] = 147491; +inp[908] = 644; +inp[909] = 147168; +inp[910] = 641; +inp[911] = 146846; +inp[912] = 638; +inp[913] = 146525; +inp[914] = 635; +inp[915] = 146206; +inp[916] = 632; +inp[917] = 145888; +inp[918] = 630; +inp[919] = 145572; +inp[920] = 627; +inp[921] = 145257; +inp[922] = 624; +inp[923] = 144943; +inp[924] = 622; +inp[925] = 144631; +inp[926] = 619; +inp[927] = 144320; +inp[928] = 616; +inp[929] = 144010; +inp[930] = 614; +inp[931] = 143701; +inp[932] = 611; +inp[933] = 143394; +inp[934] = 608; +inp[935] = 143089; +inp[936] = 606; +inp[937] = 142784; +inp[938] = 603; +inp[939] = 142481; +inp[940] = 601; +inp[941] = 142179; +inp[942] = 598; +inp[943] = 141879; +inp[944] = 596; +inp[945] = 141579; +inp[946] = 593; +inp[947] = 141281; +inp[948] = 591; +inp[949] = 140984; +inp[950] = 588; +inp[951] = 140689; +inp[952] = 586; +inp[953] = 140395; +inp[954] = 583; +inp[955] = 140101; +inp[956] = 581; +inp[957] = 139810; +inp[958] = 578; +inp[959] = 139519; +inp[960] = 576; +inp[961] = 139229; +inp[962] = 574; +inp[963] = 138941; +inp[964] = 571; +inp[965] = 138654; +inp[966] = 569; +inp[967] = 138368; +inp[968] = 567; +inp[969] = 138084; +inp[970] = 564; +inp[971] = 137800; +inp[972] = 562; +inp[973] = 137518; +inp[974] = 560; +inp[975] = 137236; +inp[976] = 557; +inp[977] = 136956; +inp[978] = 555; +inp[979] = 136677; +inp[980] = 553; +inp[981] = 136400; +inp[982] = 551; +inp[983] = 136123; +inp[984] = 548; +inp[985] = 135847; +inp[986] = 546; +inp[987] = 135573; +inp[988] = 544; +inp[989] = 135300; +inp[990] = 542; +inp[991] = 135027; +inp[992] = 540; +inp[993] = 134756; +inp[994] = 537; +inp[995] = 134486; +inp[996] = 535; +inp[997] = 134217; +inp[998] = 533; +inp[999] = 133949; +inp[1000] = 531; +inp[1001] = 133682; +inp[1002] = 529; +inp[1003] = 133417; +inp[1004] = 527; +inp[1005] = 133152; +inp[1006] = 525; +inp[1007] = 132888; +inp[1008] = 523; +inp[1009] = 132626; +inp[1010] = 521; +inp[1011] = 132364; +inp[1012] = 519; +inp[1013] = 132103; +inp[1014] = 517; +inp[1015] = 131844; +inp[1016] = 515; +inp[1017] = 131585; +inp[1018] = 513; +inp[1019] = 131328; +} + +def void fillLUTNEGEXP(int32_pl[33660] inp) +{ +inp[0] = 1073741824; +inp[1] = 1073741824; +inp[2] = 395007542; +inp[3] = 395007542; +inp[4] = 1073741824; +inp[5] = 1073741824; +inp[6] = 651257336; +inp[7] = 145315153; +inp[8] = 1073741824; +inp[9] = 1073741824; +inp[10] = 836230973; +inp[11] = 19666267; +inp[12] = 1073741824; +inp[13] = 1073741824; +inp[14] = 947573833; +inp[15] = 360200; +inp[16] = 1073741824; +inp[17] = 1073741824; +inp[18] = 1008687095; +inp[19] = 120; +inp[20] = 1073741824; +inp[21] = 1073741824; +inp[22] = 1040706261; +inp[23] = 0; +inp[24] = 1073741824; +inp[25] = 1073741824; +inp[26] = 1057094999; +inp[27] = 0; +inp[28] = 1073741824; +inp[29] = 1073741824; +inp[30] = 1065385898; +inp[31] = 0; +inp[32] = 1073741824; +inp[33] = 1073741824; +inp[34] = 1069555701; +inp[35] = 0; +inp[36] = 1073741824; +inp[37] = 1073741824; +inp[38] = 1071646718; +inp[39] = 0; +inp[40] = 1073741824; +inp[41] = 1073741824; +inp[42] = 1072693759; +inp[43] = 0; +inp[44] = 1073741824; +inp[45] = 1073741824; +inp[46] = 1073217663; +inp[47] = 0; +inp[48] = 1073741824; +inp[49] = 1073741824; +inp[50] = 1073479711; +inp[51] = 0; +inp[52] = 1073741824; +inp[53] = 1073741824; +inp[54] = 1073610759; +inp[55] = 0; +inp[56] = 1073741824; +inp[57] = 1073741824; +inp[58] = 1073676289; +inp[59] = 0; +inp[60] = 1073741824; +inp[61] = 1073741824; +inp[62] = 1073709056; +inp[63] = 0; +inp[64] = 1073741824; +inp[65] = 1073741824; +inp[66] = 1073725440; +inp[67] = 0; +inp[68] = 1073741824; +inp[69] = 1073741824; +inp[70] = 1073733632; +inp[71] = 0; +inp[72] = 1073741824; +inp[73] = 1073741824; +inp[74] = 1073737728; +inp[75] = 0; +inp[76] = 1073741824; +inp[77] = 1073741824; +inp[78] = 1073739776; +inp[79] = 0; +inp[80] = 1073741824; +inp[81] = 1073741824; +inp[82] = 1073740800; +inp[83] = 0; +inp[84] = 1073741824; +inp[85] = 1073741824; +inp[86] = 1073741312; +inp[87] = 0; +inp[88] = 1073741824; +inp[89] = 1073741824; +inp[90] = 1073741568; +inp[91] = 0; +inp[92] = 1073741824; +inp[93] = 1073741824; +inp[94] = 1073741696; +inp[95] = 0; +inp[96] = 1073741824; +inp[97] = 1073741824; +inp[98] = 1073741760; +inp[99] = 0; +inp[100] = 1073741824; +inp[101] = 1073741824; +inp[102] = 1073741792; +inp[103] = 0; +inp[104] = 1073741824; +inp[105] = 1073741824; +inp[106] = 1073741808; +inp[107] = 0; +inp[108] = 1073741824; +inp[109] = 1073741824; +inp[110] = 1073741816; +inp[111] = 0; +inp[112] = 1073741824; +inp[113] = 1073741824; +inp[114] = 1073741820; +inp[115] = 0; +inp[116] = 1073741824; +inp[117] = 1073741824; +inp[118] = 1073741822; +inp[119] = 0; +inp[120] = 1073741824; +inp[121] = 1073741824; +inp[122] = 1073741823; +inp[123] = 0; +inp[124] = 1073741824; +inp[125] = 1073741824; +inp[126] = 1073741823; +inp[127] = 0; +inp[128] = 1073741824; +inp[129] = 1073741824; +inp[130] = 1073741823; +inp[131] = 0; +inp[132] = 1073741824; +inp[133] = 1073741824; +inp[134] = 395007542; +inp[135] = 395007542; +inp[136] = 145315153; +inp[137] = 145315153; +inp[138] = 53458457; +inp[139] = 53458457; +inp[140] = 1073741824; +inp[141] = 1073741824; +inp[142] = 651257336; +inp[143] = 145315153; +inp[144] = 395007542; +inp[145] = 19666267; +inp[146] = 239584185; +inp[147] = 2661539; +inp[148] = 1073741824; +inp[149] = 1073741824; +inp[150] = 836230973; +inp[151] = 19666267; +inp[152] = 651257336; +inp[153] = 360200; +inp[154] = 507199723; +inp[155] = 6597; +inp[156] = 1073741824; +inp[157] = 1073741824; +inp[158] = 947573833; +inp[159] = 360200; +inp[160] = 836230973; +inp[161] = 120; +inp[162] = 737971243; +inp[163] = 0; +inp[164] = 1073741824; +inp[165] = 1073741824; +inp[166] = 1008687095; +inp[167] = 120; +inp[168] = 947573833; +inp[169] = 0; +inp[170] = 890163237; +inp[171] = 0; +inp[172] = 1073741824; +inp[173] = 1073741824; +inp[174] = 1040706261; +inp[175] = 0; +inp[176] = 1008687095; +inp[177] = 0; +inp[178] = 977653056; +inp[179] = 0; +inp[180] = 1073741824; +inp[181] = 1073741824; +inp[182] = 1057094999; +inp[183] = 0; +inp[184] = 1040706261; +inp[185] = 0; +inp[186] = 1024571605; +inp[187] = 0; +inp[188] = 1073741824; +inp[189] = 1073741824; +inp[190] = 1065385898; +inp[191] = 0; +inp[192] = 1057094999; +inp[193] = 0; +inp[194] = 1048868621; +inp[195] = 0; +inp[196] = 1073741824; +inp[197] = 1073741824; +inp[198] = 1069555701; +inp[199] = 0; +inp[200] = 1065385898; +inp[201] = 0; +inp[202] = 1061232352; +inp[203] = 0; +inp[204] = 1073741824; +inp[205] = 1073741824; +inp[206] = 1071646718; +inp[207] = 0; +inp[208] = 1069555701; +inp[209] = 0; +inp[210] = 1067468764; +inp[211] = 0; +inp[212] = 1073741824; +inp[213] = 1073741824; +inp[214] = 1072693759; +inp[215] = 0; +inp[216] = 1071646718; +inp[217] = 0; +inp[218] = 1070600699; +inp[219] = 0; +inp[220] = 1073741824; +inp[221] = 1073741824; +inp[222] = 1073217663; +inp[223] = 0; +inp[224] = 1072693759; +inp[225] = 0; +inp[226] = 1072170111; +inp[227] = 0; +inp[228] = 1073741824; +inp[229] = 1073741824; +inp[230] = 1073479711; +inp[231] = 0; +inp[232] = 1073217663; +inp[233] = 0; +inp[234] = 1072955679; +inp[235] = 0; +inp[236] = 1073741824; +inp[237] = 1073741824; +inp[238] = 1073610759; +inp[239] = 0; +inp[240] = 1073479711; +inp[241] = 0; +inp[242] = 1073348679; +inp[243] = 0; +inp[244] = 1073741824; +inp[245] = 1073741824; +inp[246] = 1073676289; +inp[247] = 0; +inp[248] = 1073610759; +inp[249] = 0; +inp[250] = 1073545233; +inp[251] = 0; +inp[252] = 1073741824; +inp[253] = 1073741824; +inp[254] = 1073709056; +inp[255] = 0; +inp[256] = 1073676289; +inp[257] = 0; +inp[258] = 1073643524; +inp[259] = 0; +inp[260] = 1073741824; +inp[261] = 1073741824; +inp[262] = 1073725440; +inp[263] = 0; +inp[264] = 1073709056; +inp[265] = 0; +inp[266] = 1073692673; +inp[267] = 0; +inp[268] = 1073741824; +inp[269] = 1073741824; +inp[270] = 1073733632; +inp[271] = 0; +inp[272] = 1073725440; +inp[273] = 0; +inp[274] = 1073717248; +inp[275] = 0; +inp[276] = 1073741824; +inp[277] = 1073741824; +inp[278] = 1073737728; +inp[279] = 0; +inp[280] = 1073733632; +inp[281] = 0; +inp[282] = 1073729536; +inp[283] = 0; +inp[284] = 1073741824; +inp[285] = 1073741824; +inp[286] = 1073739776; +inp[287] = 0; +inp[288] = 1073737728; +inp[289] = 0; +inp[290] = 1073735680; +inp[291] = 0; +inp[292] = 1073741824; +inp[293] = 1073741824; +inp[294] = 1073740800; +inp[295] = 0; +inp[296] = 1073739776; +inp[297] = 0; +inp[298] = 1073738752; +inp[299] = 0; +inp[300] = 1073741824; +inp[301] = 1073741824; +inp[302] = 1073741312; +inp[303] = 0; +inp[304] = 1073740800; +inp[305] = 0; +inp[306] = 1073740288; +inp[307] = 0; +inp[308] = 1073741824; +inp[309] = 1073741824; +inp[310] = 1073741568; +inp[311] = 0; +inp[312] = 1073741312; +inp[313] = 0; +inp[314] = 1073741056; +inp[315] = 0; +inp[316] = 1073741824; +inp[317] = 1073741824; +inp[318] = 1073741696; +inp[319] = 0; +inp[320] = 1073741568; +inp[321] = 0; +inp[322] = 1073741440; +inp[323] = 0; +inp[324] = 1073741824; +inp[325] = 1073741824; +inp[326] = 1073741760; +inp[327] = 0; +inp[328] = 1073741696; +inp[329] = 0; +inp[330] = 1073741632; +inp[331] = 0; +inp[332] = 1073741824; +inp[333] = 1073741824; +inp[334] = 1073741792; +inp[335] = 0; +inp[336] = 1073741760; +inp[337] = 0; +inp[338] = 1073741728; +inp[339] = 0; +inp[340] = 1073741824; +inp[341] = 1073741824; +inp[342] = 1073741808; +inp[343] = 0; +inp[344] = 1073741792; +inp[345] = 0; +inp[346] = 1073741776; +inp[347] = 0; +inp[348] = 1073741824; +inp[349] = 1073741824; +inp[350] = 1073741816; +inp[351] = 0; +inp[352] = 1073741808; +inp[353] = 0; +inp[354] = 1073741800; +inp[355] = 0; +inp[356] = 1073741824; +inp[357] = 1073741824; +inp[358] = 1073741820; +inp[359] = 0; +inp[360] = 1073741816; +inp[361] = 0; +inp[362] = 1073741812; +inp[363] = 0; +inp[364] = 1073741824; +inp[365] = 1073741824; +inp[366] = 1073741822; +inp[367] = 0; +inp[368] = 1073741820; +inp[369] = 0; +inp[370] = 1073741818; +inp[371] = 0; +inp[372] = 1073741824; +inp[373] = 1073741824; +inp[374] = 1073741823; +inp[375] = 0; +inp[376] = 1073741822; +inp[377] = 0; +inp[378] = 1073741821; +inp[379] = 0; +inp[380] = 1073741824; +inp[381] = 1073741824; +inp[382] = 1073741823; +inp[383] = 0; +inp[384] = 1073741823; +inp[385] = 0; +inp[386] = 1073741822; +inp[387] = 0; +inp[388] = 1073741824; +inp[389] = 1073741824; +inp[390] = 1073741823; +inp[391] = 0; +inp[392] = 1073741823; +inp[393] = 0; +inp[394] = 1073741823; +inp[395] = 0; +inp[396] = 1073741824; +inp[397] = 1073741824; +inp[398] = 395007542; +inp[399] = 395007542; +inp[400] = 145315153; +inp[401] = 145315153; +inp[402] = 53458457; +inp[403] = 53458457; +inp[404] = 19666267; +inp[405] = 19666267; +inp[406] = 7234815; +inp[407] = 7234815; +inp[408] = 2661539; +inp[409] = 2661539; +inp[410] = 979125; +inp[411] = 979125; +inp[412] = 1073741824; +inp[413] = 1073741824; +inp[414] = 651257336; +inp[415] = 145315153; +inp[416] = 395007542; +inp[417] = 19666267; +inp[418] = 239584185; +inp[419] = 2661539; +inp[420] = 145315153; +inp[421] = 360200; +inp[422] = 88138096; +inp[423] = 48747; +inp[424] = 53458457; +inp[425] = 6597; +inp[426] = 32424193; +inp[427] = 892; +inp[428] = 1073741824; +inp[429] = 1073741824; +inp[430] = 836230973; +inp[431] = 19666267; +inp[432] = 651257336; +inp[433] = 360200; +inp[434] = 507199723; +inp[435] = 6597; +inp[436] = 395007542; +inp[437] = 120; +inp[438] = 307632183; +inp[439] = 2; +inp[440] = 239584185; +inp[441] = 0; +inp[442] = 186588351; +inp[443] = 0; +inp[444] = 1073741824; +inp[445] = 1073741824; +inp[446] = 947573833; +inp[447] = 360200; +inp[448] = 836230973; +inp[449] = 120; +inp[450] = 737971243; +inp[451] = 0; +inp[452] = 651257336; +inp[453] = 0; +inp[454] = 574732582; +inp[455] = 0; +inp[456] = 507199723; +inp[457] = 0; +inp[458] = 447602185; +inp[459] = 0; +inp[460] = 1073741824; +inp[461] = 1073741824; +inp[462] = 1008687095; +inp[463] = 120; +inp[464] = 947573833; +inp[465] = 0; +inp[466] = 890163237; +inp[467] = 0; +inp[468] = 836230973; +inp[469] = 0; +inp[470] = 785566299; +inp[471] = 0; +inp[472] = 737971243; +inp[473] = 0; +inp[474] = 693259826; +inp[475] = 0; +inp[476] = 1073741824; +inp[477] = 1073741824; +inp[478] = 1040706261; +inp[479] = 0; +inp[480] = 1008687095; +inp[481] = 0; +inp[482] = 977653056; +inp[483] = 0; +inp[484] = 947573833; +inp[485] = 0; +inp[486] = 918420051; +inp[487] = 0; +inp[488] = 890163237; +inp[489] = 0; +inp[490] = 862775793; +inp[491] = 0; +inp[492] = 1073741824; +inp[493] = 1073741824; +inp[494] = 1057094999; +inp[495] = 0; +inp[496] = 1040706261; +inp[497] = 0; +inp[498] = 1024571605; +inp[499] = 0; +inp[500] = 1008687095; +inp[501] = 0; +inp[502] = 993048851; +inp[503] = 0; +inp[504] = 977653056; +inp[505] = 0; +inp[506] = 962495950; +inp[507] = 0; +inp[508] = 1073741824; +inp[509] = 1073741824; +inp[510] = 1065385898; +inp[511] = 0; +inp[512] = 1057094999; +inp[513] = 0; +inp[514] = 1048868621; +inp[515] = 0; +inp[516] = 1040706261; +inp[517] = 0; +inp[518] = 1032607420; +inp[519] = 0; +inp[520] = 1024571605; +inp[521] = 0; +inp[522] = 1016598326; +inp[523] = 0; +inp[524] = 1073741824; +inp[525] = 1073741824; +inp[526] = 1069555701; +inp[527] = 0; +inp[528] = 1065385898; +inp[529] = 0; +inp[530] = 1061232352; +inp[531] = 0; +inp[532] = 1057094999; +inp[533] = 0; +inp[534] = 1052973777; +inp[535] = 0; +inp[536] = 1048868621; +inp[537] = 0; +inp[538] = 1044779470; +inp[539] = 0; +inp[540] = 1073741824; +inp[541] = 1073741824; +inp[542] = 1071646718; +inp[543] = 0; +inp[544] = 1069555701; +inp[545] = 0; +inp[546] = 1067468764; +inp[547] = 0; +inp[548] = 1065385898; +inp[549] = 0; +inp[550] = 1063307097; +inp[551] = 0; +inp[552] = 1061232352; +inp[553] = 0; +inp[554] = 1059161656; +inp[555] = 0; +inp[556] = 1073741824; +inp[557] = 1073741824; +inp[558] = 1072693759; +inp[559] = 0; +inp[560] = 1071646718; +inp[561] = 0; +inp[562] = 1070600699; +inp[563] = 0; +inp[564] = 1069555701; +inp[565] = 0; +inp[566] = 1068511723; +inp[567] = 0; +inp[568] = 1067468764; +inp[569] = 0; +inp[570] = 1066426822; +inp[571] = 0; +inp[572] = 1073741824; +inp[573] = 1073741824; +inp[574] = 1073217663; +inp[575] = 0; +inp[576] = 1072693759; +inp[577] = 0; +inp[578] = 1072170111; +inp[579] = 0; +inp[580] = 1071646718; +inp[581] = 0; +inp[582] = 1071123581; +inp[583] = 0; +inp[584] = 1070600699; +inp[585] = 0; +inp[586] = 1070078072; +inp[587] = 0; +inp[588] = 1073741824; +inp[589] = 1073741824; +inp[590] = 1073479711; +inp[591] = 0; +inp[592] = 1073217663; +inp[593] = 0; +inp[594] = 1072955679; +inp[595] = 0; +inp[596] = 1072693759; +inp[597] = 0; +inp[598] = 1072431903; +inp[599] = 0; +inp[600] = 1072170111; +inp[601] = 0; +inp[602] = 1071908383; +inp[603] = 0; +inp[604] = 1073741824; +inp[605] = 1073741824; +inp[606] = 1073610759; +inp[607] = 0; +inp[608] = 1073479711; +inp[609] = 0; +inp[610] = 1073348679; +inp[611] = 0; +inp[612] = 1073217663; +inp[613] = 0; +inp[614] = 1073086663; +inp[615] = 0; +inp[616] = 1072955679; +inp[617] = 0; +inp[618] = 1072824711; +inp[619] = 0; +inp[620] = 1073741824; +inp[621] = 1073741824; +inp[622] = 1073676289; +inp[623] = 0; +inp[624] = 1073610759; +inp[625] = 0; +inp[626] = 1073545233; +inp[627] = 0; +inp[628] = 1073479711; +inp[629] = 0; +inp[630] = 1073414193; +inp[631] = 0; +inp[632] = 1073348679; +inp[633] = 0; +inp[634] = 1073283169; +inp[635] = 0; +inp[636] = 1073741824; +inp[637] = 1073741824; +inp[638] = 1073709056; +inp[639] = 0; +inp[640] = 1073676289; +inp[641] = 0; +inp[642] = 1073643524; +inp[643] = 0; +inp[644] = 1073610759; +inp[645] = 0; +inp[646] = 1073577996; +inp[647] = 0; +inp[648] = 1073545233; +inp[649] = 0; +inp[650] = 1073512472; +inp[651] = 0; +inp[652] = 1073741824; +inp[653] = 1073741824; +inp[654] = 1073725440; +inp[655] = 0; +inp[656] = 1073709056; +inp[657] = 0; +inp[658] = 1073692673; +inp[659] = 0; +inp[660] = 1073676289; +inp[661] = 0; +inp[662] = 1073659907; +inp[663] = 0; +inp[664] = 1073643524; +inp[665] = 0; +inp[666] = 1073627142; +inp[667] = 0; +inp[668] = 1073741824; +inp[669] = 1073741824; +inp[670] = 1073733632; +inp[671] = 0; +inp[672] = 1073725440; +inp[673] = 0; +inp[674] = 1073717248; +inp[675] = 0; +inp[676] = 1073709056; +inp[677] = 0; +inp[678] = 1073700864; +inp[679] = 0; +inp[680] = 1073692673; +inp[681] = 0; +inp[682] = 1073684481; +inp[683] = 0; +inp[684] = 1073741824; +inp[685] = 1073741824; +inp[686] = 1073737728; +inp[687] = 0; +inp[688] = 1073733632; +inp[689] = 0; +inp[690] = 1073729536; +inp[691] = 0; +inp[692] = 1073725440; +inp[693] = 0; +inp[694] = 1073721344; +inp[695] = 0; +inp[696] = 1073717248; +inp[697] = 0; +inp[698] = 1073713152; +inp[699] = 0; +inp[700] = 1073741824; +inp[701] = 1073741824; +inp[702] = 1073739776; +inp[703] = 0; +inp[704] = 1073737728; +inp[705] = 0; +inp[706] = 1073735680; +inp[707] = 0; +inp[708] = 1073733632; +inp[709] = 0; +inp[710] = 1073731584; +inp[711] = 0; +inp[712] = 1073729536; +inp[713] = 0; +inp[714] = 1073727488; +inp[715] = 0; +inp[716] = 1073741824; +inp[717] = 1073741824; +inp[718] = 1073740800; +inp[719] = 0; +inp[720] = 1073739776; +inp[721] = 0; +inp[722] = 1073738752; +inp[723] = 0; +inp[724] = 1073737728; +inp[725] = 0; +inp[726] = 1073736704; +inp[727] = 0; +inp[728] = 1073735680; +inp[729] = 0; +inp[730] = 1073734656; +inp[731] = 0; +inp[732] = 1073741824; +inp[733] = 1073741824; +inp[734] = 1073741312; +inp[735] = 0; +inp[736] = 1073740800; +inp[737] = 0; +inp[738] = 1073740288; +inp[739] = 0; +inp[740] = 1073739776; +inp[741] = 0; +inp[742] = 1073739264; +inp[743] = 0; +inp[744] = 1073738752; +inp[745] = 0; +inp[746] = 1073738240; +inp[747] = 0; +inp[748] = 1073741824; +inp[749] = 1073741824; +inp[750] = 1073741568; +inp[751] = 0; +inp[752] = 1073741312; +inp[753] = 0; +inp[754] = 1073741056; +inp[755] = 0; +inp[756] = 1073740800; +inp[757] = 0; +inp[758] = 1073740544; +inp[759] = 0; +inp[760] = 1073740288; +inp[761] = 0; +inp[762] = 1073740032; +inp[763] = 0; +inp[764] = 1073741824; +inp[765] = 1073741824; +inp[766] = 1073741696; +inp[767] = 0; +inp[768] = 1073741568; +inp[769] = 0; +inp[770] = 1073741440; +inp[771] = 0; +inp[772] = 1073741312; +inp[773] = 0; +inp[774] = 1073741184; +inp[775] = 0; +inp[776] = 1073741056; +inp[777] = 0; +inp[778] = 1073740928; +inp[779] = 0; +inp[780] = 1073741824; +inp[781] = 1073741824; +inp[782] = 1073741760; +inp[783] = 0; +inp[784] = 1073741696; +inp[785] = 0; +inp[786] = 1073741632; +inp[787] = 0; +inp[788] = 1073741568; +inp[789] = 0; +inp[790] = 1073741504; +inp[791] = 0; +inp[792] = 1073741440; +inp[793] = 0; +inp[794] = 1073741376; +inp[795] = 0; +inp[796] = 1073741824; +inp[797] = 1073741824; +inp[798] = 1073741792; +inp[799] = 0; +inp[800] = 1073741760; +inp[801] = 0; +inp[802] = 1073741728; +inp[803] = 0; +inp[804] = 1073741696; +inp[805] = 0; +inp[806] = 1073741664; +inp[807] = 0; +inp[808] = 1073741632; +inp[809] = 0; +inp[810] = 1073741600; +inp[811] = 0; +inp[812] = 1073741824; +inp[813] = 1073741824; +inp[814] = 1073741808; +inp[815] = 0; +inp[816] = 1073741792; +inp[817] = 0; +inp[818] = 1073741776; +inp[819] = 0; +inp[820] = 1073741760; +inp[821] = 0; +inp[822] = 1073741744; +inp[823] = 0; +inp[824] = 1073741728; +inp[825] = 0; +inp[826] = 1073741712; +inp[827] = 0; +inp[828] = 1073741824; +inp[829] = 1073741824; +inp[830] = 1073741816; +inp[831] = 0; +inp[832] = 1073741808; +inp[833] = 0; +inp[834] = 1073741800; +inp[835] = 0; +inp[836] = 1073741792; +inp[837] = 0; +inp[838] = 1073741784; +inp[839] = 0; +inp[840] = 1073741776; +inp[841] = 0; +inp[842] = 1073741768; +inp[843] = 0; +inp[844] = 1073741824; +inp[845] = 1073741824; +inp[846] = 1073741820; +inp[847] = 0; +inp[848] = 1073741816; +inp[849] = 0; +inp[850] = 1073741812; +inp[851] = 0; +inp[852] = 1073741808; +inp[853] = 0; +inp[854] = 1073741804; +inp[855] = 0; +inp[856] = 1073741800; +inp[857] = 0; +inp[858] = 1073741796; +inp[859] = 0; +inp[860] = 1073741824; +inp[861] = 1073741824; +inp[862] = 1073741822; +inp[863] = 0; +inp[864] = 1073741820; +inp[865] = 0; +inp[866] = 1073741818; +inp[867] = 0; +inp[868] = 1073741816; +inp[869] = 0; +inp[870] = 1073741814; +inp[871] = 0; +inp[872] = 1073741812; +inp[873] = 0; +inp[874] = 1073741810; +inp[875] = 0; +inp[876] = 1073741824; +inp[877] = 1073741824; +inp[878] = 1073741823; +inp[879] = 0; +inp[880] = 1073741822; +inp[881] = 0; +inp[882] = 1073741821; +inp[883] = 0; +inp[884] = 1073741820; +inp[885] = 0; +inp[886] = 1073741819; +inp[887] = 0; +inp[888] = 1073741818; +inp[889] = 0; +inp[890] = 1073741817; +inp[891] = 0; +inp[892] = 1073741824; +inp[893] = 1073741824; +inp[894] = 1073741823; +inp[895] = 0; +inp[896] = 1073741823; +inp[897] = 0; +inp[898] = 1073741822; +inp[899] = 0; +inp[900] = 1073741822; +inp[901] = 0; +inp[902] = 1073741821; +inp[903] = 0; +inp[904] = 1073741821; +inp[905] = 0; +inp[906] = 1073741820; +inp[907] = 0; +inp[908] = 1073741824; +inp[909] = 1073741824; +inp[910] = 1073741823; +inp[911] = 0; +inp[912] = 1073741823; +inp[913] = 0; +inp[914] = 1073741823; +inp[915] = 0; +inp[916] = 1073741823; +inp[917] = 0; +inp[918] = 1073741822; +inp[919] = 0; +inp[920] = 1073741822; +inp[921] = 0; +inp[922] = 1073741822; +inp[923] = 0; +inp[924] = 1073741824; +inp[925] = 1073741824; +inp[926] = 395007542; +inp[927] = 395007542; +inp[928] = 145315153; +inp[929] = 145315153; +inp[930] = 53458457; +inp[931] = 53458457; +inp[932] = 19666267; +inp[933] = 19666267; +inp[934] = 7234815; +inp[935] = 7234815; +inp[936] = 2661539; +inp[937] = 2661539; +inp[938] = 979125; +inp[939] = 979125; +inp[940] = 360200; +inp[941] = 360200; +inp[942] = 132510; +inp[943] = 132510; +inp[944] = 48747; +inp[945] = 48747; +inp[946] = 17933; +inp[947] = 17933; +inp[948] = 6597; +inp[949] = 6597; +inp[950] = 2427; +inp[951] = 2427; +inp[952] = 892; +inp[953] = 892; +inp[954] = 328; +inp[955] = 328; +inp[956] = 1073741824; +inp[957] = 1073741824; +inp[958] = 651257336; +inp[959] = 145315153; +inp[960] = 395007542; +inp[961] = 19666267; +inp[962] = 239584185; +inp[963] = 2661539; +inp[964] = 145315153; +inp[965] = 360200; +inp[966] = 88138096; +inp[967] = 48747; +inp[968] = 53458457; +inp[969] = 6597; +inp[970] = 32424193; +inp[971] = 892; +inp[972] = 19666267; +inp[973] = 120; +inp[974] = 11928194; +inp[975] = 16; +inp[976] = 7234815; +inp[977] = 2; +inp[978] = 4388137; +inp[979] = 0; +inp[980] = 2661539; +inp[981] = 0; +inp[982] = 1614305; +inp[983] = 0; +inp[984] = 979125; +inp[985] = 0; +inp[986] = 593869; +inp[987] = 0; +inp[988] = 1073741824; +inp[989] = 1073741824; +inp[990] = 836230973; +inp[991] = 19666267; +inp[992] = 651257336; +inp[993] = 360200; +inp[994] = 507199723; +inp[995] = 6597; +inp[996] = 395007542; +inp[997] = 120; +inp[998] = 307632183; +inp[999] = 2; +inp[1000] = 239584185; +inp[1001] = 0; +inp[1002] = 186588351; +inp[1003] = 0; +inp[1004] = 145315153; +inp[1005] = 0; +inp[1006] = 113171555; +inp[1007] = 0; +inp[1008] = 88138096; +inp[1009] = 0; +inp[1010] = 68642018; +inp[1011] = 0; +inp[1012] = 53458457; +inp[1013] = 0; +inp[1014] = 41633488; +inp[1015] = 0; +inp[1016] = 32424193; +inp[1017] = 0; +inp[1018] = 25251987; +inp[1019] = 0; +inp[1020] = 1073741824; +inp[1021] = 1073741824; +inp[1022] = 947573833; +inp[1023] = 360200; +inp[1024] = 836230973; +inp[1025] = 120; +inp[1026] = 737971243; +inp[1027] = 0; +inp[1028] = 651257336; +inp[1029] = 0; +inp[1030] = 574732582; +inp[1031] = 0; +inp[1032] = 507199723; +inp[1033] = 0; +inp[1034] = 447602185; +inp[1035] = 0; +inp[1036] = 395007542; +inp[1037] = 0; +inp[1038] = 348592932; +inp[1039] = 0; +inp[1040] = 307632183; +inp[1041] = 0; +inp[1042] = 271484448; +inp[1043] = 0; +inp[1044] = 239584185; +inp[1045] = 0; +inp[1046] = 211432301; +inp[1047] = 0; +inp[1048] = 186588351; +inp[1049] = 0; +inp[1050] = 164663641; +inp[1051] = 0; +inp[1052] = 1073741824; +inp[1053] = 1073741824; +inp[1054] = 1008687095; +inp[1055] = 120; +inp[1056] = 947573833; +inp[1057] = 0; +inp[1058] = 890163237; +inp[1059] = 0; +inp[1060] = 836230973; +inp[1061] = 0; +inp[1062] = 785566299; +inp[1063] = 0; +inp[1064] = 737971243; +inp[1065] = 0; +inp[1066] = 693259826; +inp[1067] = 0; +inp[1068] = 651257336; +inp[1069] = 0; +inp[1070] = 611799649; +inp[1071] = 0; +inp[1072] = 574732582; +inp[1073] = 0; +inp[1074] = 539911295; +inp[1075] = 0; +inp[1076] = 507199723; +inp[1077] = 0; +inp[1078] = 476470046; +inp[1079] = 0; +inp[1080] = 447602185; +inp[1081] = 0; +inp[1082] = 420483339; +inp[1083] = 0; +inp[1084] = 1073741824; +inp[1085] = 1073741824; +inp[1086] = 1040706261; +inp[1087] = 0; +inp[1088] = 1008687095; +inp[1089] = 0; +inp[1090] = 977653056; +inp[1091] = 0; +inp[1092] = 947573833; +inp[1093] = 0; +inp[1094] = 918420051; +inp[1095] = 0; +inp[1096] = 890163237; +inp[1097] = 0; +inp[1098] = 862775793; +inp[1099] = 0; +inp[1100] = 836230973; +inp[1101] = 0; +inp[1102] = 810502851; +inp[1103] = 0; +inp[1104] = 785566299; +inp[1105] = 0; +inp[1106] = 761396965; +inp[1107] = 0; +inp[1108] = 737971243; +inp[1109] = 0; +inp[1110] = 715266255; +inp[1111] = 0; +inp[1112] = 693259826; +inp[1113] = 0; +inp[1114] = 671930463; +inp[1115] = 0; +inp[1116] = 1073741824; +inp[1117] = 1073741824; +inp[1118] = 1057094999; +inp[1119] = 0; +inp[1120] = 1040706261; +inp[1121] = 0; +inp[1122] = 1024571605; +inp[1123] = 0; +inp[1124] = 1008687095; +inp[1125] = 0; +inp[1126] = 993048851; +inp[1127] = 0; +inp[1128] = 977653056; +inp[1129] = 0; +inp[1130] = 962495950; +inp[1131] = 0; +inp[1132] = 947573833; +inp[1133] = 0; +inp[1134] = 932883063; +inp[1135] = 0; +inp[1136] = 918420051; +inp[1137] = 0; +inp[1138] = 904181268; +inp[1139] = 0; +inp[1140] = 890163237; +inp[1141] = 0; +inp[1142] = 876362535; +inp[1143] = 0; +inp[1144] = 862775793; +inp[1145] = 0; +inp[1146] = 849399695; +inp[1147] = 0; +inp[1148] = 1073741824; +inp[1149] = 1073741824; +inp[1150] = 1065385898; +inp[1151] = 0; +inp[1152] = 1057094999; +inp[1153] = 0; +inp[1154] = 1048868621; +inp[1155] = 0; +inp[1156] = 1040706261; +inp[1157] = 0; +inp[1158] = 1032607420; +inp[1159] = 0; +inp[1160] = 1024571605; +inp[1161] = 0; +inp[1162] = 1016598326; +inp[1163] = 0; +inp[1164] = 1008687095; +inp[1165] = 0; +inp[1166] = 1000837430; +inp[1167] = 0; +inp[1168] = 993048851; +inp[1169] = 0; +inp[1170] = 985320884; +inp[1171] = 0; +inp[1172] = 977653056; +inp[1173] = 0; +inp[1174] = 970044899; +inp[1175] = 0; +inp[1176] = 962495950; +inp[1177] = 0; +inp[1178] = 955005747; +inp[1179] = 0; +inp[1180] = 1073741824; +inp[1181] = 1073741824; +inp[1182] = 1069555701; +inp[1183] = 0; +inp[1184] = 1065385898; +inp[1185] = 0; +inp[1186] = 1061232352; +inp[1187] = 0; +inp[1188] = 1057094999; +inp[1189] = 0; +inp[1190] = 1052973777; +inp[1191] = 0; +inp[1192] = 1048868621; +inp[1193] = 0; +inp[1194] = 1044779470; +inp[1195] = 0; +inp[1196] = 1040706261; +inp[1197] = 0; +inp[1198] = 1036648931; +inp[1199] = 0; +inp[1200] = 1032607420; +inp[1201] = 0; +inp[1202] = 1028581665; +inp[1203] = 0; +inp[1204] = 1024571605; +inp[1205] = 0; +inp[1206] = 1020577179; +inp[1207] = 0; +inp[1208] = 1016598326; +inp[1209] = 0; +inp[1210] = 1012634985; +inp[1211] = 0; +inp[1212] = 1073741824; +inp[1213] = 1073741824; +inp[1214] = 1071646718; +inp[1215] = 0; +inp[1216] = 1069555701; +inp[1217] = 0; +inp[1218] = 1067468764; +inp[1219] = 0; +inp[1220] = 1065385898; +inp[1221] = 0; +inp[1222] = 1063307097; +inp[1223] = 0; +inp[1224] = 1061232352; +inp[1225] = 0; +inp[1226] = 1059161656; +inp[1227] = 0; +inp[1228] = 1057094999; +inp[1229] = 0; +inp[1230] = 1055032376; +inp[1231] = 0; +inp[1232] = 1052973777; +inp[1233] = 0; +inp[1234] = 1050919194; +inp[1235] = 0; +inp[1236] = 1048868621; +inp[1237] = 0; +inp[1238] = 1046822049; +inp[1239] = 0; +inp[1240] = 1044779470; +inp[1241] = 0; +inp[1242] = 1042740876; +inp[1243] = 0; +inp[1244] = 1073741824; +inp[1245] = 1073741824; +inp[1246] = 1072693759; +inp[1247] = 0; +inp[1248] = 1071646718; +inp[1249] = 0; +inp[1250] = 1070600699; +inp[1251] = 0; +inp[1252] = 1069555701; +inp[1253] = 0; +inp[1254] = 1068511723; +inp[1255] = 0; +inp[1256] = 1067468764; +inp[1257] = 0; +inp[1258] = 1066426822; +inp[1259] = 0; +inp[1260] = 1065385898; +inp[1261] = 0; +inp[1262] = 1064345990; +inp[1263] = 0; +inp[1264] = 1063307097; +inp[1265] = 0; +inp[1266] = 1062269218; +inp[1267] = 0; +inp[1268] = 1061232352; +inp[1269] = 0; +inp[1270] = 1060196498; +inp[1271] = 0; +inp[1272] = 1059161656; +inp[1273] = 0; +inp[1274] = 1058127823; +inp[1275] = 0; +inp[1276] = 1073741824; +inp[1277] = 1073741824; +inp[1278] = 1073217663; +inp[1279] = 0; +inp[1280] = 1072693759; +inp[1281] = 0; +inp[1282] = 1072170111; +inp[1283] = 0; +inp[1284] = 1071646718; +inp[1285] = 0; +inp[1286] = 1071123581; +inp[1287] = 0; +inp[1288] = 1070600699; +inp[1289] = 0; +inp[1290] = 1070078072; +inp[1291] = 0; +inp[1292] = 1069555701; +inp[1293] = 0; +inp[1294] = 1069033584; +inp[1295] = 0; +inp[1296] = 1068511723; +inp[1297] = 0; +inp[1298] = 1067990116; +inp[1299] = 0; +inp[1300] = 1067468764; +inp[1301] = 0; +inp[1302] = 1066947666; +inp[1303] = 0; +inp[1304] = 1066426822; +inp[1305] = 0; +inp[1306] = 1065906233; +inp[1307] = 0; +inp[1308] = 1073741824; +inp[1309] = 1073741824; +inp[1310] = 1073479711; +inp[1311] = 0; +inp[1312] = 1073217663; +inp[1313] = 0; +inp[1314] = 1072955679; +inp[1315] = 0; +inp[1316] = 1072693759; +inp[1317] = 0; +inp[1318] = 1072431903; +inp[1319] = 0; +inp[1320] = 1072170111; +inp[1321] = 0; +inp[1322] = 1071908383; +inp[1323] = 0; +inp[1324] = 1071646718; +inp[1325] = 0; +inp[1326] = 1071385118; +inp[1327] = 0; +inp[1328] = 1071123581; +inp[1329] = 0; +inp[1330] = 1070862108; +inp[1331] = 0; +inp[1332] = 1070600699; +inp[1333] = 0; +inp[1334] = 1070339354; +inp[1335] = 0; +inp[1336] = 1070078072; +inp[1337] = 0; +inp[1338] = 1069816855; +inp[1339] = 0; +inp[1340] = 1073741824; +inp[1341] = 1073741824; +inp[1342] = 1073610759; +inp[1343] = 0; +inp[1344] = 1073479711; +inp[1345] = 0; +inp[1346] = 1073348679; +inp[1347] = 0; +inp[1348] = 1073217663; +inp[1349] = 0; +inp[1350] = 1073086663; +inp[1351] = 0; +inp[1352] = 1072955679; +inp[1353] = 0; +inp[1354] = 1072824711; +inp[1355] = 0; +inp[1356] = 1072693759; +inp[1357] = 0; +inp[1358] = 1072562823; +inp[1359] = 0; +inp[1360] = 1072431903; +inp[1361] = 0; +inp[1362] = 1072300999; +inp[1363] = 0; +inp[1364] = 1072170111; +inp[1365] = 0; +inp[1366] = 1072039239; +inp[1367] = 0; +inp[1368] = 1071908383; +inp[1369] = 0; +inp[1370] = 1071777542; +inp[1371] = 0; +inp[1372] = 1073741824; +inp[1373] = 1073741824; +inp[1374] = 1073676289; +inp[1375] = 0; +inp[1376] = 1073610759; +inp[1377] = 0; +inp[1378] = 1073545233; +inp[1379] = 0; +inp[1380] = 1073479711; +inp[1381] = 0; +inp[1382] = 1073414193; +inp[1383] = 0; +inp[1384] = 1073348679; +inp[1385] = 0; +inp[1386] = 1073283169; +inp[1387] = 0; +inp[1388] = 1073217663; +inp[1389] = 0; +inp[1390] = 1073152161; +inp[1391] = 0; +inp[1392] = 1073086663; +inp[1393] = 0; +inp[1394] = 1073021169; +inp[1395] = 0; +inp[1396] = 1072955679; +inp[1397] = 0; +inp[1398] = 1072890193; +inp[1399] = 0; +inp[1400] = 1072824711; +inp[1401] = 0; +inp[1402] = 1072759233; +inp[1403] = 0; +inp[1404] = 1073741824; +inp[1405] = 1073741824; +inp[1406] = 1073709056; +inp[1407] = 0; +inp[1408] = 1073676289; +inp[1409] = 0; +inp[1410] = 1073643524; +inp[1411] = 0; +inp[1412] = 1073610759; +inp[1413] = 0; +inp[1414] = 1073577996; +inp[1415] = 0; +inp[1416] = 1073545233; +inp[1417] = 0; +inp[1418] = 1073512472; +inp[1419] = 0; +inp[1420] = 1073479711; +inp[1421] = 0; +inp[1422] = 1073446952; +inp[1423] = 0; +inp[1424] = 1073414193; +inp[1425] = 0; +inp[1426] = 1073381436; +inp[1427] = 0; +inp[1428] = 1073348679; +inp[1429] = 0; +inp[1430] = 1073315924; +inp[1431] = 0; +inp[1432] = 1073283169; +inp[1433] = 0; +inp[1434] = 1073250416; +inp[1435] = 0; +inp[1436] = 1073741824; +inp[1437] = 1073741824; +inp[1438] = 1073725440; +inp[1439] = 0; +inp[1440] = 1073709056; +inp[1441] = 0; +inp[1442] = 1073692673; +inp[1443] = 0; +inp[1444] = 1073676289; +inp[1445] = 0; +inp[1446] = 1073659907; +inp[1447] = 0; +inp[1448] = 1073643524; +inp[1449] = 0; +inp[1450] = 1073627142; +inp[1451] = 0; +inp[1452] = 1073610759; +inp[1453] = 0; +inp[1454] = 1073594378; +inp[1455] = 0; +inp[1456] = 1073577996; +inp[1457] = 0; +inp[1458] = 1073561615; +inp[1459] = 0; +inp[1460] = 1073545233; +inp[1461] = 0; +inp[1462] = 1073528853; +inp[1463] = 0; +inp[1464] = 1073512472; +inp[1465] = 0; +inp[1466] = 1073496092; +inp[1467] = 0; +inp[1468] = 1073741824; +inp[1469] = 1073741824; +inp[1470] = 1073733632; +inp[1471] = 0; +inp[1472] = 1073725440; +inp[1473] = 0; +inp[1474] = 1073717248; +inp[1475] = 0; +inp[1476] = 1073709056; +inp[1477] = 0; +inp[1478] = 1073700864; +inp[1479] = 0; +inp[1480] = 1073692673; +inp[1481] = 0; +inp[1482] = 1073684481; +inp[1483] = 0; +inp[1484] = 1073676289; +inp[1485] = 0; +inp[1486] = 1073668098; +inp[1487] = 0; +inp[1488] = 1073659907; +inp[1489] = 0; +inp[1490] = 1073651715; +inp[1491] = 0; +inp[1492] = 1073643524; +inp[1493] = 0; +inp[1494] = 1073635333; +inp[1495] = 0; +inp[1496] = 1073627142; +inp[1497] = 0; +inp[1498] = 1073618951; +inp[1499] = 0; +inp[1500] = 1073741824; +inp[1501] = 1073741824; +inp[1502] = 1073737728; +inp[1503] = 0; +inp[1504] = 1073733632; +inp[1505] = 0; +inp[1506] = 1073729536; +inp[1507] = 0; +inp[1508] = 1073725440; +inp[1509] = 0; +inp[1510] = 1073721344; +inp[1511] = 0; +inp[1512] = 1073717248; +inp[1513] = 0; +inp[1514] = 1073713152; +inp[1515] = 0; +inp[1516] = 1073709056; +inp[1517] = 0; +inp[1518] = 1073704960; +inp[1519] = 0; +inp[1520] = 1073700864; +inp[1521] = 0; +inp[1522] = 1073696768; +inp[1523] = 0; +inp[1524] = 1073692673; +inp[1525] = 0; +inp[1526] = 1073688577; +inp[1527] = 0; +inp[1528] = 1073684481; +inp[1529] = 0; +inp[1530] = 1073680385; +inp[1531] = 0; +inp[1532] = 1073741824; +inp[1533] = 1073741824; +inp[1534] = 1073739776; +inp[1535] = 0; +inp[1536] = 1073737728; +inp[1537] = 0; +inp[1538] = 1073735680; +inp[1539] = 0; +inp[1540] = 1073733632; +inp[1541] = 0; +inp[1542] = 1073731584; +inp[1543] = 0; +inp[1544] = 1073729536; +inp[1545] = 0; +inp[1546] = 1073727488; +inp[1547] = 0; +inp[1548] = 1073725440; +inp[1549] = 0; +inp[1550] = 1073723392; +inp[1551] = 0; +inp[1552] = 1073721344; +inp[1553] = 0; +inp[1554] = 1073719296; +inp[1555] = 0; +inp[1556] = 1073717248; +inp[1557] = 0; +inp[1558] = 1073715200; +inp[1559] = 0; +inp[1560] = 1073713152; +inp[1561] = 0; +inp[1562] = 1073711104; +inp[1563] = 0; +inp[1564] = 1073741824; +inp[1565] = 1073741824; +inp[1566] = 1073740800; +inp[1567] = 0; +inp[1568] = 1073739776; +inp[1569] = 0; +inp[1570] = 1073738752; +inp[1571] = 0; +inp[1572] = 1073737728; +inp[1573] = 0; +inp[1574] = 1073736704; +inp[1575] = 0; +inp[1576] = 1073735680; +inp[1577] = 0; +inp[1578] = 1073734656; +inp[1579] = 0; +inp[1580] = 1073733632; +inp[1581] = 0; +inp[1582] = 1073732608; +inp[1583] = 0; +inp[1584] = 1073731584; +inp[1585] = 0; +inp[1586] = 1073730560; +inp[1587] = 0; +inp[1588] = 1073729536; +inp[1589] = 0; +inp[1590] = 1073728512; +inp[1591] = 0; +inp[1592] = 1073727488; +inp[1593] = 0; +inp[1594] = 1073726464; +inp[1595] = 0; +inp[1596] = 1073741824; +inp[1597] = 1073741824; +inp[1598] = 1073741312; +inp[1599] = 0; +inp[1600] = 1073740800; +inp[1601] = 0; +inp[1602] = 1073740288; +inp[1603] = 0; +inp[1604] = 1073739776; +inp[1605] = 0; +inp[1606] = 1073739264; +inp[1607] = 0; +inp[1608] = 1073738752; +inp[1609] = 0; +inp[1610] = 1073738240; +inp[1611] = 0; +inp[1612] = 1073737728; +inp[1613] = 0; +inp[1614] = 1073737216; +inp[1615] = 0; +inp[1616] = 1073736704; +inp[1617] = 0; +inp[1618] = 1073736192; +inp[1619] = 0; +inp[1620] = 1073735680; +inp[1621] = 0; +inp[1622] = 1073735168; +inp[1623] = 0; +inp[1624] = 1073734656; +inp[1625] = 0; +inp[1626] = 1073734144; +inp[1627] = 0; +inp[1628] = 1073741824; +inp[1629] = 1073741824; +inp[1630] = 1073741568; +inp[1631] = 0; +inp[1632] = 1073741312; +inp[1633] = 0; +inp[1634] = 1073741056; +inp[1635] = 0; +inp[1636] = 1073740800; +inp[1637] = 0; +inp[1638] = 1073740544; +inp[1639] = 0; +inp[1640] = 1073740288; +inp[1641] = 0; +inp[1642] = 1073740032; +inp[1643] = 0; +inp[1644] = 1073739776; +inp[1645] = 0; +inp[1646] = 1073739520; +inp[1647] = 0; +inp[1648] = 1073739264; +inp[1649] = 0; +inp[1650] = 1073739008; +inp[1651] = 0; +inp[1652] = 1073738752; +inp[1653] = 0; +inp[1654] = 1073738496; +inp[1655] = 0; +inp[1656] = 1073738240; +inp[1657] = 0; +inp[1658] = 1073737984; +inp[1659] = 0; +inp[1660] = 1073741824; +inp[1661] = 1073741824; +inp[1662] = 1073741696; +inp[1663] = 0; +inp[1664] = 1073741568; +inp[1665] = 0; +inp[1666] = 1073741440; +inp[1667] = 0; +inp[1668] = 1073741312; +inp[1669] = 0; +inp[1670] = 1073741184; +inp[1671] = 0; +inp[1672] = 1073741056; +inp[1673] = 0; +inp[1674] = 1073740928; +inp[1675] = 0; +inp[1676] = 1073740800; +inp[1677] = 0; +inp[1678] = 1073740672; +inp[1679] = 0; +inp[1680] = 1073740544; +inp[1681] = 0; +inp[1682] = 1073740416; +inp[1683] = 0; +inp[1684] = 1073740288; +inp[1685] = 0; +inp[1686] = 1073740160; +inp[1687] = 0; +inp[1688] = 1073740032; +inp[1689] = 0; +inp[1690] = 1073739904; +inp[1691] = 0; +inp[1692] = 1073741824; +inp[1693] = 1073741824; +inp[1694] = 1073741760; +inp[1695] = 0; +inp[1696] = 1073741696; +inp[1697] = 0; +inp[1698] = 1073741632; +inp[1699] = 0; +inp[1700] = 1073741568; +inp[1701] = 0; +inp[1702] = 1073741504; +inp[1703] = 0; +inp[1704] = 1073741440; +inp[1705] = 0; +inp[1706] = 1073741376; +inp[1707] = 0; +inp[1708] = 1073741312; +inp[1709] = 0; +inp[1710] = 1073741248; +inp[1711] = 0; +inp[1712] = 1073741184; +inp[1713] = 0; +inp[1714] = 1073741120; +inp[1715] = 0; +inp[1716] = 1073741056; +inp[1717] = 0; +inp[1718] = 1073740992; +inp[1719] = 0; +inp[1720] = 1073740928; +inp[1721] = 0; +inp[1722] = 1073740864; +inp[1723] = 0; +inp[1724] = 1073741824; +inp[1725] = 1073741824; +inp[1726] = 1073741792; +inp[1727] = 0; +inp[1728] = 1073741760; +inp[1729] = 0; +inp[1730] = 1073741728; +inp[1731] = 0; +inp[1732] = 1073741696; +inp[1733] = 0; +inp[1734] = 1073741664; +inp[1735] = 0; +inp[1736] = 1073741632; +inp[1737] = 0; +inp[1738] = 1073741600; +inp[1739] = 0; +inp[1740] = 1073741568; +inp[1741] = 0; +inp[1742] = 1073741536; +inp[1743] = 0; +inp[1744] = 1073741504; +inp[1745] = 0; +inp[1746] = 1073741472; +inp[1747] = 0; +inp[1748] = 1073741440; +inp[1749] = 0; +inp[1750] = 1073741408; +inp[1751] = 0; +inp[1752] = 1073741376; +inp[1753] = 0; +inp[1754] = 1073741344; +inp[1755] = 0; +inp[1756] = 1073741824; +inp[1757] = 1073741824; +inp[1758] = 1073741808; +inp[1759] = 0; +inp[1760] = 1073741792; +inp[1761] = 0; +inp[1762] = 1073741776; +inp[1763] = 0; +inp[1764] = 1073741760; +inp[1765] = 0; +inp[1766] = 1073741744; +inp[1767] = 0; +inp[1768] = 1073741728; +inp[1769] = 0; +inp[1770] = 1073741712; +inp[1771] = 0; +inp[1772] = 1073741696; +inp[1773] = 0; +inp[1774] = 1073741680; +inp[1775] = 0; +inp[1776] = 1073741664; +inp[1777] = 0; +inp[1778] = 1073741648; +inp[1779] = 0; +inp[1780] = 1073741632; +inp[1781] = 0; +inp[1782] = 1073741616; +inp[1783] = 0; +inp[1784] = 1073741600; +inp[1785] = 0; +inp[1786] = 1073741584; +inp[1787] = 0; +inp[1788] = 1073741824; +inp[1789] = 1073741824; +inp[1790] = 1073741816; +inp[1791] = 0; +inp[1792] = 1073741808; +inp[1793] = 0; +inp[1794] = 1073741800; +inp[1795] = 0; +inp[1796] = 1073741792; +inp[1797] = 0; +inp[1798] = 1073741784; +inp[1799] = 0; +inp[1800] = 1073741776; +inp[1801] = 0; +inp[1802] = 1073741768; +inp[1803] = 0; +inp[1804] = 1073741760; +inp[1805] = 0; +inp[1806] = 1073741752; +inp[1807] = 0; +inp[1808] = 1073741744; +inp[1809] = 0; +inp[1810] = 1073741736; +inp[1811] = 0; +inp[1812] = 1073741728; +inp[1813] = 0; +inp[1814] = 1073741720; +inp[1815] = 0; +inp[1816] = 1073741712; +inp[1817] = 0; +inp[1818] = 1073741704; +inp[1819] = 0; +inp[1820] = 1073741824; +inp[1821] = 1073741824; +inp[1822] = 1073741820; +inp[1823] = 0; +inp[1824] = 1073741816; +inp[1825] = 0; +inp[1826] = 1073741812; +inp[1827] = 0; +inp[1828] = 1073741808; +inp[1829] = 0; +inp[1830] = 1073741804; +inp[1831] = 0; +inp[1832] = 1073741800; +inp[1833] = 0; +inp[1834] = 1073741796; +inp[1835] = 0; +inp[1836] = 1073741792; +inp[1837] = 0; +inp[1838] = 1073741788; +inp[1839] = 0; +inp[1840] = 1073741784; +inp[1841] = 0; +inp[1842] = 1073741780; +inp[1843] = 0; +inp[1844] = 1073741776; +inp[1845] = 0; +inp[1846] = 1073741772; +inp[1847] = 0; +inp[1848] = 1073741768; +inp[1849] = 0; +inp[1850] = 1073741764; +inp[1851] = 0; +inp[1852] = 1073741824; +inp[1853] = 1073741824; +inp[1854] = 1073741822; +inp[1855] = 0; +inp[1856] = 1073741820; +inp[1857] = 0; +inp[1858] = 1073741818; +inp[1859] = 0; +inp[1860] = 1073741816; +inp[1861] = 0; +inp[1862] = 1073741814; +inp[1863] = 0; +inp[1864] = 1073741812; +inp[1865] = 0; +inp[1866] = 1073741810; +inp[1867] = 0; +inp[1868] = 1073741808; +inp[1869] = 0; +inp[1870] = 1073741806; +inp[1871] = 0; +inp[1872] = 1073741804; +inp[1873] = 0; +inp[1874] = 1073741802; +inp[1875] = 0; +inp[1876] = 1073741800; +inp[1877] = 0; +inp[1878] = 1073741798; +inp[1879] = 0; +inp[1880] = 1073741796; +inp[1881] = 0; +inp[1882] = 1073741794; +inp[1883] = 0; +inp[1884] = 1073741824; +inp[1885] = 1073741824; +inp[1886] = 1073741823; +inp[1887] = 0; +inp[1888] = 1073741822; +inp[1889] = 0; +inp[1890] = 1073741821; +inp[1891] = 0; +inp[1892] = 1073741820; +inp[1893] = 0; +inp[1894] = 1073741819; +inp[1895] = 0; +inp[1896] = 1073741818; +inp[1897] = 0; +inp[1898] = 1073741817; +inp[1899] = 0; +inp[1900] = 1073741816; +inp[1901] = 0; +inp[1902] = 1073741815; +inp[1903] = 0; +inp[1904] = 1073741814; +inp[1905] = 0; +inp[1906] = 1073741813; +inp[1907] = 0; +inp[1908] = 1073741812; +inp[1909] = 0; +inp[1910] = 1073741811; +inp[1911] = 0; +inp[1912] = 1073741810; +inp[1913] = 0; +inp[1914] = 1073741809; +inp[1915] = 0; +inp[1916] = 1073741824; +inp[1917] = 1073741824; +inp[1918] = 1073741823; +inp[1919] = 0; +inp[1920] = 1073741823; +inp[1921] = 0; +inp[1922] = 1073741822; +inp[1923] = 0; +inp[1924] = 1073741822; +inp[1925] = 0; +inp[1926] = 1073741821; +inp[1927] = 0; +inp[1928] = 1073741821; +inp[1929] = 0; +inp[1930] = 1073741820; +inp[1931] = 0; +inp[1932] = 1073741820; +inp[1933] = 0; +inp[1934] = 1073741819; +inp[1935] = 0; +inp[1936] = 1073741819; +inp[1937] = 0; +inp[1938] = 1073741818; +inp[1939] = 0; +inp[1940] = 1073741818; +inp[1941] = 0; +inp[1942] = 1073741817; +inp[1943] = 0; +inp[1944] = 1073741817; +inp[1945] = 0; +inp[1946] = 1073741816; +inp[1947] = 0; +inp[1948] = 1073741824; +inp[1949] = 1073741824; +inp[1950] = 1073741823; +inp[1951] = 0; +inp[1952] = 1073741823; +inp[1953] = 0; +inp[1954] = 1073741823; +inp[1955] = 0; +inp[1956] = 1073741823; +inp[1957] = 0; +inp[1958] = 1073741822; +inp[1959] = 0; +inp[1960] = 1073741822; +inp[1961] = 0; +inp[1962] = 1073741822; +inp[1963] = 0; +inp[1964] = 1073741822; +inp[1965] = 0; +inp[1966] = 1073741821; +inp[1967] = 0; +inp[1968] = 1073741821; +inp[1969] = 0; +inp[1970] = 1073741821; +inp[1971] = 0; +inp[1972] = 1073741821; +inp[1973] = 0; +inp[1974] = 1073741820; +inp[1975] = 0; +inp[1976] = 1073741820; +inp[1977] = 0; +inp[1978] = 1073741820; +inp[1979] = 0; +inp[1980] = 1073741824; +inp[1981] = 1073741824; +inp[1982] = 395007542; +inp[1983] = 395007542; +inp[1984] = 145315153; +inp[1985] = 145315153; +inp[1986] = 53458457; +inp[1987] = 53458457; +inp[1988] = 19666267; +inp[1989] = 19666267; +inp[1990] = 7234815; +inp[1991] = 7234815; +inp[1992] = 2661539; +inp[1993] = 2661539; +inp[1994] = 979125; +inp[1995] = 979125; +inp[1996] = 360200; +inp[1997] = 360200; +inp[1998] = 132510; +inp[1999] = 132510; +inp[2000] = 48747; +inp[2001] = 48747; +inp[2002] = 17933; +inp[2003] = 17933; +inp[2004] = 6597; +inp[2005] = 6597; +inp[2006] = 2427; +inp[2007] = 2427; +inp[2008] = 892; +inp[2009] = 892; +inp[2010] = 328; +inp[2011] = 328; +inp[2012] = 120; +inp[2013] = 120; +inp[2014] = 44; +inp[2015] = 44; +inp[2016] = 16; +inp[2017] = 16; +inp[2018] = 6; +inp[2019] = 6; +inp[2020] = 2; +inp[2021] = 2; +inp[2022] = 0; +inp[2023] = 0; +inp[2024] = 0; +inp[2025] = 0; +inp[2026] = 0; +inp[2027] = 0; +inp[2028] = 0; +inp[2029] = 0; +inp[2030] = 0; +inp[2031] = 0; +inp[2032] = 0; +inp[2033] = 0; +inp[2034] = 0; +inp[2035] = 0; +inp[2036] = 0; +inp[2037] = 0; +inp[2038] = 0; +inp[2039] = 0; +inp[2040] = 0; +inp[2041] = 0; +inp[2042] = 0; +inp[2043] = 0; +inp[2044] = 1073741824; +inp[2045] = 1073741824; +inp[2046] = 651257336; +inp[2047] = 145315153; +inp[2048] = 395007542; +inp[2049] = 19666267; +inp[2050] = 239584185; +inp[2051] = 2661539; +inp[2052] = 145315153; +inp[2053] = 360200; +inp[2054] = 88138096; +inp[2055] = 48747; +inp[2056] = 53458457; +inp[2057] = 6597; +inp[2058] = 32424193; +inp[2059] = 892; +inp[2060] = 19666267; +inp[2061] = 120; +inp[2062] = 11928194; +inp[2063] = 16; +inp[2064] = 7234815; +inp[2065] = 2; +inp[2066] = 4388137; +inp[2067] = 0; +inp[2068] = 2661539; +inp[2069] = 0; +inp[2070] = 1614305; +inp[2071] = 0; +inp[2072] = 979125; +inp[2073] = 0; +inp[2074] = 593869; +inp[2075] = 0; +inp[2076] = 360200; +inp[2077] = 0; +inp[2078] = 218472; +inp[2079] = 0; +inp[2080] = 132510; +inp[2081] = 0; +inp[2082] = 80371; +inp[2083] = 0; +inp[2084] = 48747; +inp[2085] = 0; +inp[2086] = 29567; +inp[2087] = 0; +inp[2088] = 17933; +inp[2089] = 0; +inp[2090] = 10877; +inp[2091] = 0; +inp[2092] = 6597; +inp[2093] = 0; +inp[2094] = 4001; +inp[2095] = 0; +inp[2096] = 2427; +inp[2097] = 0; +inp[2098] = 1472; +inp[2099] = 0; +inp[2100] = 892; +inp[2101] = 0; +inp[2102] = 541; +inp[2103] = 0; +inp[2104] = 328; +inp[2105] = 0; +inp[2106] = 199; +inp[2107] = 0; +inp[2108] = 1073741824; +inp[2109] = 1073741824; +inp[2110] = 836230973; +inp[2111] = 19666267; +inp[2112] = 651257336; +inp[2113] = 360200; +inp[2114] = 507199723; +inp[2115] = 6597; +inp[2116] = 395007542; +inp[2117] = 120; +inp[2118] = 307632183; +inp[2119] = 2; +inp[2120] = 239584185; +inp[2121] = 0; +inp[2122] = 186588351; +inp[2123] = 0; +inp[2124] = 145315153; +inp[2125] = 0; +inp[2126] = 113171555; +inp[2127] = 0; +inp[2128] = 88138096; +inp[2129] = 0; +inp[2130] = 68642018; +inp[2131] = 0; +inp[2132] = 53458457; +inp[2133] = 0; +inp[2134] = 41633488; +inp[2135] = 0; +inp[2136] = 32424193; +inp[2137] = 0; +inp[2138] = 25251987; +inp[2139] = 0; +inp[2140] = 19666267; +inp[2141] = 0; +inp[2142] = 15316104; +inp[2143] = 0; +inp[2144] = 11928194; +inp[2145] = 0; +inp[2146] = 9289686; +inp[2147] = 0; +inp[2148] = 7234815; +inp[2149] = 0; +inp[2150] = 5634479; +inp[2151] = 0; +inp[2152] = 4388137; +inp[2153] = 0; +inp[2154] = 3417484; +inp[2155] = 0; +inp[2156] = 2661539; +inp[2157] = 0; +inp[2158] = 2072809; +inp[2159] = 0; +inp[2160] = 1614305; +inp[2161] = 0; +inp[2162] = 1257222; +inp[2163] = 0; +inp[2164] = 979125; +inp[2165] = 0; +inp[2166] = 762543; +inp[2167] = 0; +inp[2168] = 593869; +inp[2169] = 0; +inp[2170] = 462506; +inp[2171] = 0; +inp[2172] = 1073741824; +inp[2173] = 1073741824; +inp[2174] = 947573833; +inp[2175] = 360200; +inp[2176] = 836230973; +inp[2177] = 120; +inp[2178] = 737971243; +inp[2179] = 0; +inp[2180] = 651257336; +inp[2181] = 0; +inp[2182] = 574732582; +inp[2183] = 0; +inp[2184] = 507199723; +inp[2185] = 0; +inp[2186] = 447602185; +inp[2187] = 0; +inp[2188] = 395007542; +inp[2189] = 0; +inp[2190] = 348592932; +inp[2191] = 0; +inp[2192] = 307632183; +inp[2193] = 0; +inp[2194] = 271484448; +inp[2195] = 0; +inp[2196] = 239584185; +inp[2197] = 0; +inp[2198] = 211432301; +inp[2199] = 0; +inp[2200] = 186588351; +inp[2201] = 0; +inp[2202] = 164663641; +inp[2203] = 0; +inp[2204] = 145315153; +inp[2205] = 0; +inp[2206] = 128240173; +inp[2207] = 0; +inp[2208] = 113171555; +inp[2209] = 0; +inp[2210] = 99873547; +inp[2211] = 0; +inp[2212] = 88138096; +inp[2213] = 0; +inp[2214] = 77781596; +inp[2215] = 0; +inp[2216] = 68642018; +inp[2217] = 0; +inp[2218] = 60576368; +inp[2219] = 0; +inp[2220] = 53458457; +inp[2221] = 0; +inp[2222] = 47176923; +inp[2223] = 0; +inp[2224] = 41633488; +inp[2225] = 0; +inp[2226] = 36741424; +inp[2227] = 0; +inp[2228] = 32424193; +inp[2229] = 0; +inp[2230] = 28614250; +inp[2231] = 0; +inp[2232] = 25251987; +inp[2233] = 0; +inp[2234] = 22284800; +inp[2235] = 0; +inp[2236] = 1073741824; +inp[2237] = 1073741824; +inp[2238] = 1008687095; +inp[2239] = 120; +inp[2240] = 947573833; +inp[2241] = 0; +inp[2242] = 890163237; +inp[2243] = 0; +inp[2244] = 836230973; +inp[2245] = 0; +inp[2246] = 785566299; +inp[2247] = 0; +inp[2248] = 737971243; +inp[2249] = 0; +inp[2250] = 693259826; +inp[2251] = 0; +inp[2252] = 651257336; +inp[2253] = 0; +inp[2254] = 611799649; +inp[2255] = 0; +inp[2256] = 574732582; +inp[2257] = 0; +inp[2258] = 539911295; +inp[2259] = 0; +inp[2260] = 507199723; +inp[2261] = 0; +inp[2262] = 476470046; +inp[2263] = 0; +inp[2264] = 447602185; +inp[2265] = 0; +inp[2266] = 420483339; +inp[2267] = 0; +inp[2268] = 395007542; +inp[2269] = 0; +inp[2270] = 371075245; +inp[2271] = 0; +inp[2272] = 348592932; +inp[2273] = 0; +inp[2274] = 327472754; +inp[2275] = 0; +inp[2276] = 307632183; +inp[2277] = 0; +inp[2278] = 288993691; +inp[2279] = 0; +inp[2280] = 271484448; +inp[2281] = 0; +inp[2282] = 255036037; +inp[2283] = 0; +inp[2284] = 239584185; +inp[2285] = 0; +inp[2286] = 225068513; +inp[2287] = 0; +inp[2288] = 211432301; +inp[2289] = 0; +inp[2290] = 198622265; +inp[2291] = 0; +inp[2292] = 186588351; +inp[2293] = 0; +inp[2294] = 175283534; +inp[2295] = 0; +inp[2296] = 164663641; +inp[2297] = 0; +inp[2298] = 154687176; +inp[2299] = 0; +inp[2300] = 1073741824; +inp[2301] = 1073741824; +inp[2302] = 1040706261; +inp[2303] = 0; +inp[2304] = 1008687095; +inp[2305] = 0; +inp[2306] = 977653056; +inp[2307] = 0; +inp[2308] = 947573833; +inp[2309] = 0; +inp[2310] = 918420051; +inp[2311] = 0; +inp[2312] = 890163237; +inp[2313] = 0; +inp[2314] = 862775793; +inp[2315] = 0; +inp[2316] = 836230973; +inp[2317] = 0; +inp[2318] = 810502851; +inp[2319] = 0; +inp[2320] = 785566299; +inp[2321] = 0; +inp[2322] = 761396965; +inp[2323] = 0; +inp[2324] = 737971243; +inp[2325] = 0; +inp[2326] = 715266255; +inp[2327] = 0; +inp[2328] = 693259826; +inp[2329] = 0; +inp[2330] = 671930463; +inp[2331] = 0; +inp[2332] = 651257336; +inp[2333] = 0; +inp[2334] = 631220255; +inp[2335] = 0; +inp[2336] = 611799649; +inp[2337] = 0; +inp[2338] = 592976553; +inp[2339] = 0; +inp[2340] = 574732582; +inp[2341] = 0; +inp[2342] = 557049919; +inp[2343] = 0; +inp[2344] = 539911295; +inp[2345] = 0; +inp[2346] = 523299971; +inp[2347] = 0; +inp[2348] = 507199723; +inp[2349] = 0; +inp[2350] = 491594828; +inp[2351] = 0; +inp[2352] = 476470046; +inp[2353] = 0; +inp[2354] = 461810603; +inp[2355] = 0; +inp[2356] = 447602185; +inp[2357] = 0; +inp[2358] = 433830913; +inp[2359] = 0; +inp[2360] = 420483339; +inp[2361] = 0; +inp[2362] = 407546427; +inp[2363] = 0; +inp[2364] = 1073741824; +inp[2365] = 1073741824; +inp[2366] = 1057094999; +inp[2367] = 0; +inp[2368] = 1040706261; +inp[2369] = 0; +inp[2370] = 1024571605; +inp[2371] = 0; +inp[2372] = 1008687095; +inp[2373] = 0; +inp[2374] = 993048851; +inp[2375] = 0; +inp[2376] = 977653056; +inp[2377] = 0; +inp[2378] = 962495950; +inp[2379] = 0; +inp[2380] = 947573833; +inp[2381] = 0; +inp[2382] = 932883063; +inp[2383] = 0; +inp[2384] = 918420051; +inp[2385] = 0; +inp[2386] = 904181268; +inp[2387] = 0; +inp[2388] = 890163237; +inp[2389] = 0; +inp[2390] = 876362535; +inp[2391] = 0; +inp[2392] = 862775793; +inp[2393] = 0; +inp[2394] = 849399695; +inp[2395] = 0; +inp[2396] = 836230973; +inp[2397] = 0; +inp[2398] = 823266413; +inp[2399] = 0; +inp[2400] = 810502851; +inp[2401] = 0; +inp[2402] = 797937169; +inp[2403] = 0; +inp[2404] = 785566299; +inp[2405] = 0; +inp[2406] = 773387223; +inp[2407] = 0; +inp[2408] = 761396965; +inp[2409] = 0; +inp[2410] = 749592599; +inp[2411] = 0; +inp[2412] = 737971243; +inp[2413] = 0; +inp[2414] = 726530060; +inp[2415] = 0; +inp[2416] = 715266255; +inp[2417] = 0; +inp[2418] = 704177080; +inp[2419] = 0; +inp[2420] = 693259826; +inp[2421] = 0; +inp[2422] = 682511829; +inp[2423] = 0; +inp[2424] = 671930463; +inp[2425] = 0; +inp[2426] = 661513147; +inp[2427] = 0; +inp[2428] = 1073741824; +inp[2429] = 1073741824; +inp[2430] = 1065385898; +inp[2431] = 0; +inp[2432] = 1057094999; +inp[2433] = 0; +inp[2434] = 1048868621; +inp[2435] = 0; +inp[2436] = 1040706261; +inp[2437] = 0; +inp[2438] = 1032607420; +inp[2439] = 0; +inp[2440] = 1024571605; +inp[2441] = 0; +inp[2442] = 1016598326; +inp[2443] = 0; +inp[2444] = 1008687095; +inp[2445] = 0; +inp[2446] = 1000837430; +inp[2447] = 0; +inp[2448] = 993048851; +inp[2449] = 0; +inp[2450] = 985320884; +inp[2451] = 0; +inp[2452] = 977653056; +inp[2453] = 0; +inp[2454] = 970044899; +inp[2455] = 0; +inp[2456] = 962495950; +inp[2457] = 0; +inp[2458] = 955005747; +inp[2459] = 0; +inp[2460] = 947573833; +inp[2461] = 0; +inp[2462] = 940199755; +inp[2463] = 0; +inp[2464] = 932883063; +inp[2465] = 0; +inp[2466] = 925623309; +inp[2467] = 0; +inp[2468] = 918420051; +inp[2469] = 0; +inp[2470] = 911272850; +inp[2471] = 0; +inp[2472] = 904181268; +inp[2473] = 0; +inp[2474] = 897144874; +inp[2475] = 0; +inp[2476] = 890163237; +inp[2477] = 0; +inp[2478] = 883235932; +inp[2479] = 0; +inp[2480] = 876362535; +inp[2481] = 0; +inp[2482] = 869542628; +inp[2483] = 0; +inp[2484] = 862775793; +inp[2485] = 0; +inp[2486] = 856061619; +inp[2487] = 0; +inp[2488] = 849399695; +inp[2489] = 0; +inp[2490] = 842789614; +inp[2491] = 0; +inp[2492] = 1073741824; +inp[2493] = 1073741824; +inp[2494] = 1069555701; +inp[2495] = 0; +inp[2496] = 1065385898; +inp[2497] = 0; +inp[2498] = 1061232352; +inp[2499] = 0; +inp[2500] = 1057094999; +inp[2501] = 0; +inp[2502] = 1052973777; +inp[2503] = 0; +inp[2504] = 1048868621; +inp[2505] = 0; +inp[2506] = 1044779470; +inp[2507] = 0; +inp[2508] = 1040706261; +inp[2509] = 0; +inp[2510] = 1036648931; +inp[2511] = 0; +inp[2512] = 1032607420; +inp[2513] = 0; +inp[2514] = 1028581665; +inp[2515] = 0; +inp[2516] = 1024571605; +inp[2517] = 0; +inp[2518] = 1020577179; +inp[2519] = 0; +inp[2520] = 1016598326; +inp[2521] = 0; +inp[2522] = 1012634985; +inp[2523] = 0; +inp[2524] = 1008687095; +inp[2525] = 0; +inp[2526] = 1004754597; +inp[2527] = 0; +inp[2528] = 1000837430; +inp[2529] = 0; +inp[2530] = 996935534; +inp[2531] = 0; +inp[2532] = 993048851; +inp[2533] = 0; +inp[2534] = 989177321; +inp[2535] = 0; +inp[2536] = 985320884; +inp[2537] = 0; +inp[2538] = 981479482; +inp[2539] = 0; +inp[2540] = 977653056; +inp[2541] = 0; +inp[2542] = 973841548; +inp[2543] = 0; +inp[2544] = 970044899; +inp[2545] = 0; +inp[2546] = 966263053; +inp[2547] = 0; +inp[2548] = 962495950; +inp[2549] = 0; +inp[2550] = 958743534; +inp[2551] = 0; +inp[2552] = 955005747; +inp[2553] = 0; +inp[2554] = 951282532; +inp[2555] = 0; +inp[2556] = 1073741824; +inp[2557] = 1073741824; +inp[2558] = 1071646718; +inp[2559] = 0; +inp[2560] = 1069555701; +inp[2561] = 0; +inp[2562] = 1067468764; +inp[2563] = 0; +inp[2564] = 1065385898; +inp[2565] = 0; +inp[2566] = 1063307097; +inp[2567] = 0; +inp[2568] = 1061232352; +inp[2569] = 0; +inp[2570] = 1059161656; +inp[2571] = 0; +inp[2572] = 1057094999; +inp[2573] = 0; +inp[2574] = 1055032376; +inp[2575] = 0; +inp[2576] = 1052973777; +inp[2577] = 0; +inp[2578] = 1050919194; +inp[2579] = 0; +inp[2580] = 1048868621; +inp[2581] = 0; +inp[2582] = 1046822049; +inp[2583] = 0; +inp[2584] = 1044779470; +inp[2585] = 0; +inp[2586] = 1042740876; +inp[2587] = 0; +inp[2588] = 1040706261; +inp[2589] = 0; +inp[2590] = 1038675615; +inp[2591] = 0; +inp[2592] = 1036648931; +inp[2593] = 0; +inp[2594] = 1034626202; +inp[2595] = 0; +inp[2596] = 1032607420; +inp[2597] = 0; +inp[2598] = 1030592577; +inp[2599] = 0; +inp[2600] = 1028581665; +inp[2601] = 0; +inp[2602] = 1026574677; +inp[2603] = 0; +inp[2604] = 1024571605; +inp[2605] = 0; +inp[2606] = 1022572442; +inp[2607] = 0; +inp[2608] = 1020577179; +inp[2609] = 0; +inp[2610] = 1018585810; +inp[2611] = 0; +inp[2612] = 1016598326; +inp[2613] = 0; +inp[2614] = 1014614720; +inp[2615] = 0; +inp[2616] = 1012634985; +inp[2617] = 0; +inp[2618] = 1010659112; +inp[2619] = 0; +inp[2620] = 1073741824; +inp[2621] = 1073741824; +inp[2622] = 1072693759; +inp[2623] = 0; +inp[2624] = 1071646718; +inp[2625] = 0; +inp[2626] = 1070600699; +inp[2627] = 0; +inp[2628] = 1069555701; +inp[2629] = 0; +inp[2630] = 1068511723; +inp[2631] = 0; +inp[2632] = 1067468764; +inp[2633] = 0; +inp[2634] = 1066426822; +inp[2635] = 0; +inp[2636] = 1065385898; +inp[2637] = 0; +inp[2638] = 1064345990; +inp[2639] = 0; +inp[2640] = 1063307097; +inp[2641] = 0; +inp[2642] = 1062269218; +inp[2643] = 0; +inp[2644] = 1061232352; +inp[2645] = 0; +inp[2646] = 1060196498; +inp[2647] = 0; +inp[2648] = 1059161656; +inp[2649] = 0; +inp[2650] = 1058127823; +inp[2651] = 0; +inp[2652] = 1057094999; +inp[2653] = 0; +inp[2654] = 1056063184; +inp[2655] = 0; +inp[2656] = 1055032376; +inp[2657] = 0; +inp[2658] = 1054002574; +inp[2659] = 0; +inp[2660] = 1052973777; +inp[2661] = 0; +inp[2662] = 1051945984; +inp[2663] = 0; +inp[2664] = 1050919194; +inp[2665] = 0; +inp[2666] = 1049893407; +inp[2667] = 0; +inp[2668] = 1048868621; +inp[2669] = 0; +inp[2670] = 1047844835; +inp[2671] = 0; +inp[2672] = 1046822049; +inp[2673] = 0; +inp[2674] = 1045800261; +inp[2675] = 0; +inp[2676] = 1044779470; +inp[2677] = 0; +inp[2678] = 1043759675; +inp[2679] = 0; +inp[2680] = 1042740876; +inp[2681] = 0; +inp[2682] = 1041723072; +inp[2683] = 0; +inp[2684] = 1073741824; +inp[2685] = 1073741824; +inp[2686] = 1073217663; +inp[2687] = 0; +inp[2688] = 1072693759; +inp[2689] = 0; +inp[2690] = 1072170111; +inp[2691] = 0; +inp[2692] = 1071646718; +inp[2693] = 0; +inp[2694] = 1071123581; +inp[2695] = 0; +inp[2696] = 1070600699; +inp[2697] = 0; +inp[2698] = 1070078072; +inp[2699] = 0; +inp[2700] = 1069555701; +inp[2701] = 0; +inp[2702] = 1069033584; +inp[2703] = 0; +inp[2704] = 1068511723; +inp[2705] = 0; +inp[2706] = 1067990116; +inp[2707] = 0; +inp[2708] = 1067468764; +inp[2709] = 0; +inp[2710] = 1066947666; +inp[2711] = 0; +inp[2712] = 1066426822; +inp[2713] = 0; +inp[2714] = 1065906233; +inp[2715] = 0; +inp[2716] = 1065385898; +inp[2717] = 0; +inp[2718] = 1064865817; +inp[2719] = 0; +inp[2720] = 1064345990; +inp[2721] = 0; +inp[2722] = 1063826417; +inp[2723] = 0; +inp[2724] = 1063307097; +inp[2725] = 0; +inp[2726] = 1062788031; +inp[2727] = 0; +inp[2728] = 1062269218; +inp[2729] = 0; +inp[2730] = 1061750659; +inp[2731] = 0; +inp[2732] = 1061232352; +inp[2733] = 0; +inp[2734] = 1060714299; +inp[2735] = 0; +inp[2736] = 1060196498; +inp[2737] = 0; +inp[2738] = 1059678951; +inp[2739] = 0; +inp[2740] = 1059161656; +inp[2741] = 0; +inp[2742] = 1058644613; +inp[2743] = 0; +inp[2744] = 1058127823; +inp[2745] = 0; +inp[2746] = 1057611285; +inp[2747] = 0; +inp[2748] = 1073741824; +inp[2749] = 1073741824; +inp[2750] = 1073479711; +inp[2751] = 0; +inp[2752] = 1073217663; +inp[2753] = 0; +inp[2754] = 1072955679; +inp[2755] = 0; +inp[2756] = 1072693759; +inp[2757] = 0; +inp[2758] = 1072431903; +inp[2759] = 0; +inp[2760] = 1072170111; +inp[2761] = 0; +inp[2762] = 1071908383; +inp[2763] = 0; +inp[2764] = 1071646718; +inp[2765] = 0; +inp[2766] = 1071385118; +inp[2767] = 0; +inp[2768] = 1071123581; +inp[2769] = 0; +inp[2770] = 1070862108; +inp[2771] = 0; +inp[2772] = 1070600699; +inp[2773] = 0; +inp[2774] = 1070339354; +inp[2775] = 0; +inp[2776] = 1070078072; +inp[2777] = 0; +inp[2778] = 1069816855; +inp[2779] = 0; +inp[2780] = 1069555701; +inp[2781] = 0; +inp[2782] = 1069294611; +inp[2783] = 0; +inp[2784] = 1069033584; +inp[2785] = 0; +inp[2786] = 1068772622; +inp[2787] = 0; +inp[2788] = 1068511723; +inp[2789] = 0; +inp[2790] = 1068250887; +inp[2791] = 0; +inp[2792] = 1067990116; +inp[2793] = 0; +inp[2794] = 1067729408; +inp[2795] = 0; +inp[2796] = 1067468764; +inp[2797] = 0; +inp[2798] = 1067208183; +inp[2799] = 0; +inp[2800] = 1066947666; +inp[2801] = 0; +inp[2802] = 1066687212; +inp[2803] = 0; +inp[2804] = 1066426822; +inp[2805] = 0; +inp[2806] = 1066166496; +inp[2807] = 0; +inp[2808] = 1065906233; +inp[2809] = 0; +inp[2810] = 1065646034; +inp[2811] = 0; +inp[2812] = 1073741824; +inp[2813] = 1073741824; +inp[2814] = 1073610759; +inp[2815] = 0; +inp[2816] = 1073479711; +inp[2817] = 0; +inp[2818] = 1073348679; +inp[2819] = 0; +inp[2820] = 1073217663; +inp[2821] = 0; +inp[2822] = 1073086663; +inp[2823] = 0; +inp[2824] = 1072955679; +inp[2825] = 0; +inp[2826] = 1072824711; +inp[2827] = 0; +inp[2828] = 1072693759; +inp[2829] = 0; +inp[2830] = 1072562823; +inp[2831] = 0; +inp[2832] = 1072431903; +inp[2833] = 0; +inp[2834] = 1072300999; +inp[2835] = 0; +inp[2836] = 1072170111; +inp[2837] = 0; +inp[2838] = 1072039239; +inp[2839] = 0; +inp[2840] = 1071908383; +inp[2841] = 0; +inp[2842] = 1071777542; +inp[2843] = 0; +inp[2844] = 1071646718; +inp[2845] = 0; +inp[2846] = 1071515910; +inp[2847] = 0; +inp[2848] = 1071385118; +inp[2849] = 0; +inp[2850] = 1071254341; +inp[2851] = 0; +inp[2852] = 1071123581; +inp[2853] = 0; +inp[2854] = 1070992836; +inp[2855] = 0; +inp[2856] = 1070862108; +inp[2857] = 0; +inp[2858] = 1070731396; +inp[2859] = 0; +inp[2860] = 1070600699; +inp[2861] = 0; +inp[2862] = 1070470018; +inp[2863] = 0; +inp[2864] = 1070339354; +inp[2865] = 0; +inp[2866] = 1070208705; +inp[2867] = 0; +inp[2868] = 1070078072; +inp[2869] = 0; +inp[2870] = 1069947456; +inp[2871] = 0; +inp[2872] = 1069816855; +inp[2873] = 0; +inp[2874] = 1069686270; +inp[2875] = 0; +inp[2876] = 1073741824; +inp[2877] = 1073741824; +inp[2878] = 1073676289; +inp[2879] = 0; +inp[2880] = 1073610759; +inp[2881] = 0; +inp[2882] = 1073545233; +inp[2883] = 0; +inp[2884] = 1073479711; +inp[2885] = 0; +inp[2886] = 1073414193; +inp[2887] = 0; +inp[2888] = 1073348679; +inp[2889] = 0; +inp[2890] = 1073283169; +inp[2891] = 0; +inp[2892] = 1073217663; +inp[2893] = 0; +inp[2894] = 1073152161; +inp[2895] = 0; +inp[2896] = 1073086663; +inp[2897] = 0; +inp[2898] = 1073021169; +inp[2899] = 0; +inp[2900] = 1072955679; +inp[2901] = 0; +inp[2902] = 1072890193; +inp[2903] = 0; +inp[2904] = 1072824711; +inp[2905] = 0; +inp[2906] = 1072759233; +inp[2907] = 0; +inp[2908] = 1072693759; +inp[2909] = 0; +inp[2910] = 1072628289; +inp[2911] = 0; +inp[2912] = 1072562823; +inp[2913] = 0; +inp[2914] = 1072497361; +inp[2915] = 0; +inp[2916] = 1072431903; +inp[2917] = 0; +inp[2918] = 1072366449; +inp[2919] = 0; +inp[2920] = 1072300999; +inp[2921] = 0; +inp[2922] = 1072235553; +inp[2923] = 0; +inp[2924] = 1072170111; +inp[2925] = 0; +inp[2926] = 1072104673; +inp[2927] = 0; +inp[2928] = 1072039239; +inp[2929] = 0; +inp[2930] = 1071973809; +inp[2931] = 0; +inp[2932] = 1071908383; +inp[2933] = 0; +inp[2934] = 1071842961; +inp[2935] = 0; +inp[2936] = 1071777542; +inp[2937] = 0; +inp[2938] = 1071712128; +inp[2939] = 0; +inp[2940] = 1073741824; +inp[2941] = 1073741824; +inp[2942] = 1073709056; +inp[2943] = 0; +inp[2944] = 1073676289; +inp[2945] = 0; +inp[2946] = 1073643524; +inp[2947] = 0; +inp[2948] = 1073610759; +inp[2949] = 0; +inp[2950] = 1073577996; +inp[2951] = 0; +inp[2952] = 1073545233; +inp[2953] = 0; +inp[2954] = 1073512472; +inp[2955] = 0; +inp[2956] = 1073479711; +inp[2957] = 0; +inp[2958] = 1073446952; +inp[2959] = 0; +inp[2960] = 1073414193; +inp[2961] = 0; +inp[2962] = 1073381436; +inp[2963] = 0; +inp[2964] = 1073348679; +inp[2965] = 0; +inp[2966] = 1073315924; +inp[2967] = 0; +inp[2968] = 1073283169; +inp[2969] = 0; +inp[2970] = 1073250416; +inp[2971] = 0; +inp[2972] = 1073217663; +inp[2973] = 0; +inp[2974] = 1073184912; +inp[2975] = 0; +inp[2976] = 1073152161; +inp[2977] = 0; +inp[2978] = 1073119412; +inp[2979] = 0; +inp[2980] = 1073086663; +inp[2981] = 0; +inp[2982] = 1073053916; +inp[2983] = 0; +inp[2984] = 1073021169; +inp[2985] = 0; +inp[2986] = 1072988424; +inp[2987] = 0; +inp[2988] = 1072955679; +inp[2989] = 0; +inp[2990] = 1072922936; +inp[2991] = 0; +inp[2992] = 1072890193; +inp[2993] = 0; +inp[2994] = 1072857452; +inp[2995] = 0; +inp[2996] = 1072824711; +inp[2997] = 0; +inp[2998] = 1072791972; +inp[2999] = 0; +inp[3000] = 1072759233; +inp[3001] = 0; +inp[3002] = 1072726496; +inp[3003] = 0; +inp[3004] = 1073741824; +inp[3005] = 1073741824; +inp[3006] = 1073725440; +inp[3007] = 0; +inp[3008] = 1073709056; +inp[3009] = 0; +inp[3010] = 1073692673; +inp[3011] = 0; +inp[3012] = 1073676289; +inp[3013] = 0; +inp[3014] = 1073659907; +inp[3015] = 0; +inp[3016] = 1073643524; +inp[3017] = 0; +inp[3018] = 1073627142; +inp[3019] = 0; +inp[3020] = 1073610759; +inp[3021] = 0; +inp[3022] = 1073594378; +inp[3023] = 0; +inp[3024] = 1073577996; +inp[3025] = 0; +inp[3026] = 1073561615; +inp[3027] = 0; +inp[3028] = 1073545233; +inp[3029] = 0; +inp[3030] = 1073528853; +inp[3031] = 0; +inp[3032] = 1073512472; +inp[3033] = 0; +inp[3034] = 1073496092; +inp[3035] = 0; +inp[3036] = 1073479711; +inp[3037] = 0; +inp[3038] = 1073463332; +inp[3039] = 0; +inp[3040] = 1073446952; +inp[3041] = 0; +inp[3042] = 1073430573; +inp[3043] = 0; +inp[3044] = 1073414193; +inp[3045] = 0; +inp[3046] = 1073397815; +inp[3047] = 0; +inp[3048] = 1073381436; +inp[3049] = 0; +inp[3050] = 1073365058; +inp[3051] = 0; +inp[3052] = 1073348679; +inp[3053] = 0; +inp[3054] = 1073332302; +inp[3055] = 0; +inp[3056] = 1073315924; +inp[3057] = 0; +inp[3058] = 1073299547; +inp[3059] = 0; +inp[3060] = 1073283169; +inp[3061] = 0; +inp[3062] = 1073266793; +inp[3063] = 0; +inp[3064] = 1073250416; +inp[3065] = 0; +inp[3066] = 1073234040; +inp[3067] = 0; +inp[3068] = 1073741824; +inp[3069] = 1073741824; +inp[3070] = 1073733632; +inp[3071] = 0; +inp[3072] = 1073725440; +inp[3073] = 0; +inp[3074] = 1073717248; +inp[3075] = 0; +inp[3076] = 1073709056; +inp[3077] = 0; +inp[3078] = 1073700864; +inp[3079] = 0; +inp[3080] = 1073692673; +inp[3081] = 0; +inp[3082] = 1073684481; +inp[3083] = 0; +inp[3084] = 1073676289; +inp[3085] = 0; +inp[3086] = 1073668098; +inp[3087] = 0; +inp[3088] = 1073659907; +inp[3089] = 0; +inp[3090] = 1073651715; +inp[3091] = 0; +inp[3092] = 1073643524; +inp[3093] = 0; +inp[3094] = 1073635333; +inp[3095] = 0; +inp[3096] = 1073627142; +inp[3097] = 0; +inp[3098] = 1073618951; +inp[3099] = 0; +inp[3100] = 1073610759; +inp[3101] = 0; +inp[3102] = 1073602569; +inp[3103] = 0; +inp[3104] = 1073594378; +inp[3105] = 0; +inp[3106] = 1073586187; +inp[3107] = 0; +inp[3108] = 1073577996; +inp[3109] = 0; +inp[3110] = 1073569805; +inp[3111] = 0; +inp[3112] = 1073561615; +inp[3113] = 0; +inp[3114] = 1073553424; +inp[3115] = 0; +inp[3116] = 1073545233; +inp[3117] = 0; +inp[3118] = 1073537043; +inp[3119] = 0; +inp[3120] = 1073528853; +inp[3121] = 0; +inp[3122] = 1073520662; +inp[3123] = 0; +inp[3124] = 1073512472; +inp[3125] = 0; +inp[3126] = 1073504282; +inp[3127] = 0; +inp[3128] = 1073496092; +inp[3129] = 0; +inp[3130] = 1073487902; +inp[3131] = 0; +inp[3132] = 1073741824; +inp[3133] = 1073741824; +inp[3134] = 1073737728; +inp[3135] = 0; +inp[3136] = 1073733632; +inp[3137] = 0; +inp[3138] = 1073729536; +inp[3139] = 0; +inp[3140] = 1073725440; +inp[3141] = 0; +inp[3142] = 1073721344; +inp[3143] = 0; +inp[3144] = 1073717248; +inp[3145] = 0; +inp[3146] = 1073713152; +inp[3147] = 0; +inp[3148] = 1073709056; +inp[3149] = 0; +inp[3150] = 1073704960; +inp[3151] = 0; +inp[3152] = 1073700864; +inp[3153] = 0; +inp[3154] = 1073696768; +inp[3155] = 0; +inp[3156] = 1073692673; +inp[3157] = 0; +inp[3158] = 1073688577; +inp[3159] = 0; +inp[3160] = 1073684481; +inp[3161] = 0; +inp[3162] = 1073680385; +inp[3163] = 0; +inp[3164] = 1073676289; +inp[3165] = 0; +inp[3166] = 1073672194; +inp[3167] = 0; +inp[3168] = 1073668098; +inp[3169] = 0; +inp[3170] = 1073664002; +inp[3171] = 0; +inp[3172] = 1073659907; +inp[3173] = 0; +inp[3174] = 1073655811; +inp[3175] = 0; +inp[3176] = 1073651715; +inp[3177] = 0; +inp[3178] = 1073647620; +inp[3179] = 0; +inp[3180] = 1073643524; +inp[3181] = 0; +inp[3182] = 1073639428; +inp[3183] = 0; +inp[3184] = 1073635333; +inp[3185] = 0; +inp[3186] = 1073631237; +inp[3187] = 0; +inp[3188] = 1073627142; +inp[3189] = 0; +inp[3190] = 1073623046; +inp[3191] = 0; +inp[3192] = 1073618951; +inp[3193] = 0; +inp[3194] = 1073614855; +inp[3195] = 0; +inp[3196] = 1073741824; +inp[3197] = 1073741824; +inp[3198] = 1073739776; +inp[3199] = 0; +inp[3200] = 1073737728; +inp[3201] = 0; +inp[3202] = 1073735680; +inp[3203] = 0; +inp[3204] = 1073733632; +inp[3205] = 0; +inp[3206] = 1073731584; +inp[3207] = 0; +inp[3208] = 1073729536; +inp[3209] = 0; +inp[3210] = 1073727488; +inp[3211] = 0; +inp[3212] = 1073725440; +inp[3213] = 0; +inp[3214] = 1073723392; +inp[3215] = 0; +inp[3216] = 1073721344; +inp[3217] = 0; +inp[3218] = 1073719296; +inp[3219] = 0; +inp[3220] = 1073717248; +inp[3221] = 0; +inp[3222] = 1073715200; +inp[3223] = 0; +inp[3224] = 1073713152; +inp[3225] = 0; +inp[3226] = 1073711104; +inp[3227] = 0; +inp[3228] = 1073709056; +inp[3229] = 0; +inp[3230] = 1073707008; +inp[3231] = 0; +inp[3232] = 1073704960; +inp[3233] = 0; +inp[3234] = 1073702912; +inp[3235] = 0; +inp[3236] = 1073700864; +inp[3237] = 0; +inp[3238] = 1073698816; +inp[3239] = 0; +inp[3240] = 1073696768; +inp[3241] = 0; +inp[3242] = 1073694721; +inp[3243] = 0; +inp[3244] = 1073692673; +inp[3245] = 0; +inp[3246] = 1073690625; +inp[3247] = 0; +inp[3248] = 1073688577; +inp[3249] = 0; +inp[3250] = 1073686529; +inp[3251] = 0; +inp[3252] = 1073684481; +inp[3253] = 0; +inp[3254] = 1073682433; +inp[3255] = 0; +inp[3256] = 1073680385; +inp[3257] = 0; +inp[3258] = 1073678337; +inp[3259] = 0; +inp[3260] = 1073741824; +inp[3261] = 1073741824; +inp[3262] = 1073740800; +inp[3263] = 0; +inp[3264] = 1073739776; +inp[3265] = 0; +inp[3266] = 1073738752; +inp[3267] = 0; +inp[3268] = 1073737728; +inp[3269] = 0; +inp[3270] = 1073736704; +inp[3271] = 0; +inp[3272] = 1073735680; +inp[3273] = 0; +inp[3274] = 1073734656; +inp[3275] = 0; +inp[3276] = 1073733632; +inp[3277] = 0; +inp[3278] = 1073732608; +inp[3279] = 0; +inp[3280] = 1073731584; +inp[3281] = 0; +inp[3282] = 1073730560; +inp[3283] = 0; +inp[3284] = 1073729536; +inp[3285] = 0; +inp[3286] = 1073728512; +inp[3287] = 0; +inp[3288] = 1073727488; +inp[3289] = 0; +inp[3290] = 1073726464; +inp[3291] = 0; +inp[3292] = 1073725440; +inp[3293] = 0; +inp[3294] = 1073724416; +inp[3295] = 0; +inp[3296] = 1073723392; +inp[3297] = 0; +inp[3298] = 1073722368; +inp[3299] = 0; +inp[3300] = 1073721344; +inp[3301] = 0; +inp[3302] = 1073720320; +inp[3303] = 0; +inp[3304] = 1073719296; +inp[3305] = 0; +inp[3306] = 1073718272; +inp[3307] = 0; +inp[3308] = 1073717248; +inp[3309] = 0; +inp[3310] = 1073716224; +inp[3311] = 0; +inp[3312] = 1073715200; +inp[3313] = 0; +inp[3314] = 1073714176; +inp[3315] = 0; +inp[3316] = 1073713152; +inp[3317] = 0; +inp[3318] = 1073712128; +inp[3319] = 0; +inp[3320] = 1073711104; +inp[3321] = 0; +inp[3322] = 1073710080; +inp[3323] = 0; +inp[3324] = 1073741824; +inp[3325] = 1073741824; +inp[3326] = 1073741312; +inp[3327] = 0; +inp[3328] = 1073740800; +inp[3329] = 0; +inp[3330] = 1073740288; +inp[3331] = 0; +inp[3332] = 1073739776; +inp[3333] = 0; +inp[3334] = 1073739264; +inp[3335] = 0; +inp[3336] = 1073738752; +inp[3337] = 0; +inp[3338] = 1073738240; +inp[3339] = 0; +inp[3340] = 1073737728; +inp[3341] = 0; +inp[3342] = 1073737216; +inp[3343] = 0; +inp[3344] = 1073736704; +inp[3345] = 0; +inp[3346] = 1073736192; +inp[3347] = 0; +inp[3348] = 1073735680; +inp[3349] = 0; +inp[3350] = 1073735168; +inp[3351] = 0; +inp[3352] = 1073734656; +inp[3353] = 0; +inp[3354] = 1073734144; +inp[3355] = 0; +inp[3356] = 1073733632; +inp[3357] = 0; +inp[3358] = 1073733120; +inp[3359] = 0; +inp[3360] = 1073732608; +inp[3361] = 0; +inp[3362] = 1073732096; +inp[3363] = 0; +inp[3364] = 1073731584; +inp[3365] = 0; +inp[3366] = 1073731072; +inp[3367] = 0; +inp[3368] = 1073730560; +inp[3369] = 0; +inp[3370] = 1073730048; +inp[3371] = 0; +inp[3372] = 1073729536; +inp[3373] = 0; +inp[3374] = 1073729024; +inp[3375] = 0; +inp[3376] = 1073728512; +inp[3377] = 0; +inp[3378] = 1073728000; +inp[3379] = 0; +inp[3380] = 1073727488; +inp[3381] = 0; +inp[3382] = 1073726976; +inp[3383] = 0; +inp[3384] = 1073726464; +inp[3385] = 0; +inp[3386] = 1073725952; +inp[3387] = 0; +inp[3388] = 1073741824; +inp[3389] = 1073741824; +inp[3390] = 1073741568; +inp[3391] = 0; +inp[3392] = 1073741312; +inp[3393] = 0; +inp[3394] = 1073741056; +inp[3395] = 0; +inp[3396] = 1073740800; +inp[3397] = 0; +inp[3398] = 1073740544; +inp[3399] = 0; +inp[3400] = 1073740288; +inp[3401] = 0; +inp[3402] = 1073740032; +inp[3403] = 0; +inp[3404] = 1073739776; +inp[3405] = 0; +inp[3406] = 1073739520; +inp[3407] = 0; +inp[3408] = 1073739264; +inp[3409] = 0; +inp[3410] = 1073739008; +inp[3411] = 0; +inp[3412] = 1073738752; +inp[3413] = 0; +inp[3414] = 1073738496; +inp[3415] = 0; +inp[3416] = 1073738240; +inp[3417] = 0; +inp[3418] = 1073737984; +inp[3419] = 0; +inp[3420] = 1073737728; +inp[3421] = 0; +inp[3422] = 1073737472; +inp[3423] = 0; +inp[3424] = 1073737216; +inp[3425] = 0; +inp[3426] = 1073736960; +inp[3427] = 0; +inp[3428] = 1073736704; +inp[3429] = 0; +inp[3430] = 1073736448; +inp[3431] = 0; +inp[3432] = 1073736192; +inp[3433] = 0; +inp[3434] = 1073735936; +inp[3435] = 0; +inp[3436] = 1073735680; +inp[3437] = 0; +inp[3438] = 1073735424; +inp[3439] = 0; +inp[3440] = 1073735168; +inp[3441] = 0; +inp[3442] = 1073734912; +inp[3443] = 0; +inp[3444] = 1073734656; +inp[3445] = 0; +inp[3446] = 1073734400; +inp[3447] = 0; +inp[3448] = 1073734144; +inp[3449] = 0; +inp[3450] = 1073733888; +inp[3451] = 0; +inp[3452] = 1073741824; +inp[3453] = 1073741824; +inp[3454] = 1073741696; +inp[3455] = 0; +inp[3456] = 1073741568; +inp[3457] = 0; +inp[3458] = 1073741440; +inp[3459] = 0; +inp[3460] = 1073741312; +inp[3461] = 0; +inp[3462] = 1073741184; +inp[3463] = 0; +inp[3464] = 1073741056; +inp[3465] = 0; +inp[3466] = 1073740928; +inp[3467] = 0; +inp[3468] = 1073740800; +inp[3469] = 0; +inp[3470] = 1073740672; +inp[3471] = 0; +inp[3472] = 1073740544; +inp[3473] = 0; +inp[3474] = 1073740416; +inp[3475] = 0; +inp[3476] = 1073740288; +inp[3477] = 0; +inp[3478] = 1073740160; +inp[3479] = 0; +inp[3480] = 1073740032; +inp[3481] = 0; +inp[3482] = 1073739904; +inp[3483] = 0; +inp[3484] = 1073739776; +inp[3485] = 0; +inp[3486] = 1073739648; +inp[3487] = 0; +inp[3488] = 1073739520; +inp[3489] = 0; +inp[3490] = 1073739392; +inp[3491] = 0; +inp[3492] = 1073739264; +inp[3493] = 0; +inp[3494] = 1073739136; +inp[3495] = 0; +inp[3496] = 1073739008; +inp[3497] = 0; +inp[3498] = 1073738880; +inp[3499] = 0; +inp[3500] = 1073738752; +inp[3501] = 0; +inp[3502] = 1073738624; +inp[3503] = 0; +inp[3504] = 1073738496; +inp[3505] = 0; +inp[3506] = 1073738368; +inp[3507] = 0; +inp[3508] = 1073738240; +inp[3509] = 0; +inp[3510] = 1073738112; +inp[3511] = 0; +inp[3512] = 1073737984; +inp[3513] = 0; +inp[3514] = 1073737856; +inp[3515] = 0; +inp[3516] = 1073741824; +inp[3517] = 1073741824; +inp[3518] = 1073741760; +inp[3519] = 0; +inp[3520] = 1073741696; +inp[3521] = 0; +inp[3522] = 1073741632; +inp[3523] = 0; +inp[3524] = 1073741568; +inp[3525] = 0; +inp[3526] = 1073741504; +inp[3527] = 0; +inp[3528] = 1073741440; +inp[3529] = 0; +inp[3530] = 1073741376; +inp[3531] = 0; +inp[3532] = 1073741312; +inp[3533] = 0; +inp[3534] = 1073741248; +inp[3535] = 0; +inp[3536] = 1073741184; +inp[3537] = 0; +inp[3538] = 1073741120; +inp[3539] = 0; +inp[3540] = 1073741056; +inp[3541] = 0; +inp[3542] = 1073740992; +inp[3543] = 0; +inp[3544] = 1073740928; +inp[3545] = 0; +inp[3546] = 1073740864; +inp[3547] = 0; +inp[3548] = 1073740800; +inp[3549] = 0; +inp[3550] = 1073740736; +inp[3551] = 0; +inp[3552] = 1073740672; +inp[3553] = 0; +inp[3554] = 1073740608; +inp[3555] = 0; +inp[3556] = 1073740544; +inp[3557] = 0; +inp[3558] = 1073740480; +inp[3559] = 0; +inp[3560] = 1073740416; +inp[3561] = 0; +inp[3562] = 1073740352; +inp[3563] = 0; +inp[3564] = 1073740288; +inp[3565] = 0; +inp[3566] = 1073740224; +inp[3567] = 0; +inp[3568] = 1073740160; +inp[3569] = 0; +inp[3570] = 1073740096; +inp[3571] = 0; +inp[3572] = 1073740032; +inp[3573] = 0; +inp[3574] = 1073739968; +inp[3575] = 0; +inp[3576] = 1073739904; +inp[3577] = 0; +inp[3578] = 1073739840; +inp[3579] = 0; +inp[3580] = 1073741824; +inp[3581] = 1073741824; +inp[3582] = 1073741792; +inp[3583] = 0; +inp[3584] = 1073741760; +inp[3585] = 0; +inp[3586] = 1073741728; +inp[3587] = 0; +inp[3588] = 1073741696; +inp[3589] = 0; +inp[3590] = 1073741664; +inp[3591] = 0; +inp[3592] = 1073741632; +inp[3593] = 0; +inp[3594] = 1073741600; +inp[3595] = 0; +inp[3596] = 1073741568; +inp[3597] = 0; +inp[3598] = 1073741536; +inp[3599] = 0; +inp[3600] = 1073741504; +inp[3601] = 0; +inp[3602] = 1073741472; +inp[3603] = 0; +inp[3604] = 1073741440; +inp[3605] = 0; +inp[3606] = 1073741408; +inp[3607] = 0; +inp[3608] = 1073741376; +inp[3609] = 0; +inp[3610] = 1073741344; +inp[3611] = 0; +inp[3612] = 1073741312; +inp[3613] = 0; +inp[3614] = 1073741280; +inp[3615] = 0; +inp[3616] = 1073741248; +inp[3617] = 0; +inp[3618] = 1073741216; +inp[3619] = 0; +inp[3620] = 1073741184; +inp[3621] = 0; +inp[3622] = 1073741152; +inp[3623] = 0; +inp[3624] = 1073741120; +inp[3625] = 0; +inp[3626] = 1073741088; +inp[3627] = 0; +inp[3628] = 1073741056; +inp[3629] = 0; +inp[3630] = 1073741024; +inp[3631] = 0; +inp[3632] = 1073740992; +inp[3633] = 0; +inp[3634] = 1073740960; +inp[3635] = 0; +inp[3636] = 1073740928; +inp[3637] = 0; +inp[3638] = 1073740896; +inp[3639] = 0; +inp[3640] = 1073740864; +inp[3641] = 0; +inp[3642] = 1073740832; +inp[3643] = 0; +inp[3644] = 1073741824; +inp[3645] = 1073741824; +inp[3646] = 1073741808; +inp[3647] = 0; +inp[3648] = 1073741792; +inp[3649] = 0; +inp[3650] = 1073741776; +inp[3651] = 0; +inp[3652] = 1073741760; +inp[3653] = 0; +inp[3654] = 1073741744; +inp[3655] = 0; +inp[3656] = 1073741728; +inp[3657] = 0; +inp[3658] = 1073741712; +inp[3659] = 0; +inp[3660] = 1073741696; +inp[3661] = 0; +inp[3662] = 1073741680; +inp[3663] = 0; +inp[3664] = 1073741664; +inp[3665] = 0; +inp[3666] = 1073741648; +inp[3667] = 0; +inp[3668] = 1073741632; +inp[3669] = 0; +inp[3670] = 1073741616; +inp[3671] = 0; +inp[3672] = 1073741600; +inp[3673] = 0; +inp[3674] = 1073741584; +inp[3675] = 0; +inp[3676] = 1073741568; +inp[3677] = 0; +inp[3678] = 1073741552; +inp[3679] = 0; +inp[3680] = 1073741536; +inp[3681] = 0; +inp[3682] = 1073741520; +inp[3683] = 0; +inp[3684] = 1073741504; +inp[3685] = 0; +inp[3686] = 1073741488; +inp[3687] = 0; +inp[3688] = 1073741472; +inp[3689] = 0; +inp[3690] = 1073741456; +inp[3691] = 0; +inp[3692] = 1073741440; +inp[3693] = 0; +inp[3694] = 1073741424; +inp[3695] = 0; +inp[3696] = 1073741408; +inp[3697] = 0; +inp[3698] = 1073741392; +inp[3699] = 0; +inp[3700] = 1073741376; +inp[3701] = 0; +inp[3702] = 1073741360; +inp[3703] = 0; +inp[3704] = 1073741344; +inp[3705] = 0; +inp[3706] = 1073741328; +inp[3707] = 0; +inp[3708] = 1073741824; +inp[3709] = 1073741824; +inp[3710] = 1073741816; +inp[3711] = 0; +inp[3712] = 1073741808; +inp[3713] = 0; +inp[3714] = 1073741800; +inp[3715] = 0; +inp[3716] = 1073741792; +inp[3717] = 0; +inp[3718] = 1073741784; +inp[3719] = 0; +inp[3720] = 1073741776; +inp[3721] = 0; +inp[3722] = 1073741768; +inp[3723] = 0; +inp[3724] = 1073741760; +inp[3725] = 0; +inp[3726] = 1073741752; +inp[3727] = 0; +inp[3728] = 1073741744; +inp[3729] = 0; +inp[3730] = 1073741736; +inp[3731] = 0; +inp[3732] = 1073741728; +inp[3733] = 0; +inp[3734] = 1073741720; +inp[3735] = 0; +inp[3736] = 1073741712; +inp[3737] = 0; +inp[3738] = 1073741704; +inp[3739] = 0; +inp[3740] = 1073741696; +inp[3741] = 0; +inp[3742] = 1073741688; +inp[3743] = 0; +inp[3744] = 1073741680; +inp[3745] = 0; +inp[3746] = 1073741672; +inp[3747] = 0; +inp[3748] = 1073741664; +inp[3749] = 0; +inp[3750] = 1073741656; +inp[3751] = 0; +inp[3752] = 1073741648; +inp[3753] = 0; +inp[3754] = 1073741640; +inp[3755] = 0; +inp[3756] = 1073741632; +inp[3757] = 0; +inp[3758] = 1073741624; +inp[3759] = 0; +inp[3760] = 1073741616; +inp[3761] = 0; +inp[3762] = 1073741608; +inp[3763] = 0; +inp[3764] = 1073741600; +inp[3765] = 0; +inp[3766] = 1073741592; +inp[3767] = 0; +inp[3768] = 1073741584; +inp[3769] = 0; +inp[3770] = 1073741576; +inp[3771] = 0; +inp[3772] = 1073741824; +inp[3773] = 1073741824; +inp[3774] = 1073741820; +inp[3775] = 0; +inp[3776] = 1073741816; +inp[3777] = 0; +inp[3778] = 1073741812; +inp[3779] = 0; +inp[3780] = 1073741808; +inp[3781] = 0; +inp[3782] = 1073741804; +inp[3783] = 0; +inp[3784] = 1073741800; +inp[3785] = 0; +inp[3786] = 1073741796; +inp[3787] = 0; +inp[3788] = 1073741792; +inp[3789] = 0; +inp[3790] = 1073741788; +inp[3791] = 0; +inp[3792] = 1073741784; +inp[3793] = 0; +inp[3794] = 1073741780; +inp[3795] = 0; +inp[3796] = 1073741776; +inp[3797] = 0; +inp[3798] = 1073741772; +inp[3799] = 0; +inp[3800] = 1073741768; +inp[3801] = 0; +inp[3802] = 1073741764; +inp[3803] = 0; +inp[3804] = 1073741760; +inp[3805] = 0; +inp[3806] = 1073741756; +inp[3807] = 0; +inp[3808] = 1073741752; +inp[3809] = 0; +inp[3810] = 1073741748; +inp[3811] = 0; +inp[3812] = 1073741744; +inp[3813] = 0; +inp[3814] = 1073741740; +inp[3815] = 0; +inp[3816] = 1073741736; +inp[3817] = 0; +inp[3818] = 1073741732; +inp[3819] = 0; +inp[3820] = 1073741728; +inp[3821] = 0; +inp[3822] = 1073741724; +inp[3823] = 0; +inp[3824] = 1073741720; +inp[3825] = 0; +inp[3826] = 1073741716; +inp[3827] = 0; +inp[3828] = 1073741712; +inp[3829] = 0; +inp[3830] = 1073741708; +inp[3831] = 0; +inp[3832] = 1073741704; +inp[3833] = 0; +inp[3834] = 1073741700; +inp[3835] = 0; +inp[3836] = 1073741824; +inp[3837] = 1073741824; +inp[3838] = 1073741822; +inp[3839] = 0; +inp[3840] = 1073741820; +inp[3841] = 0; +inp[3842] = 1073741818; +inp[3843] = 0; +inp[3844] = 1073741816; +inp[3845] = 0; +inp[3846] = 1073741814; +inp[3847] = 0; +inp[3848] = 1073741812; +inp[3849] = 0; +inp[3850] = 1073741810; +inp[3851] = 0; +inp[3852] = 1073741808; +inp[3853] = 0; +inp[3854] = 1073741806; +inp[3855] = 0; +inp[3856] = 1073741804; +inp[3857] = 0; +inp[3858] = 1073741802; +inp[3859] = 0; +inp[3860] = 1073741800; +inp[3861] = 0; +inp[3862] = 1073741798; +inp[3863] = 0; +inp[3864] = 1073741796; +inp[3865] = 0; +inp[3866] = 1073741794; +inp[3867] = 0; +inp[3868] = 1073741792; +inp[3869] = 0; +inp[3870] = 1073741790; +inp[3871] = 0; +inp[3872] = 1073741788; +inp[3873] = 0; +inp[3874] = 1073741786; +inp[3875] = 0; +inp[3876] = 1073741784; +inp[3877] = 0; +inp[3878] = 1073741782; +inp[3879] = 0; +inp[3880] = 1073741780; +inp[3881] = 0; +inp[3882] = 1073741778; +inp[3883] = 0; +inp[3884] = 1073741776; +inp[3885] = 0; +inp[3886] = 1073741774; +inp[3887] = 0; +inp[3888] = 1073741772; +inp[3889] = 0; +inp[3890] = 1073741770; +inp[3891] = 0; +inp[3892] = 1073741768; +inp[3893] = 0; +inp[3894] = 1073741766; +inp[3895] = 0; +inp[3896] = 1073741764; +inp[3897] = 0; +inp[3898] = 1073741762; +inp[3899] = 0; +inp[3900] = 1073741824; +inp[3901] = 1073741824; +inp[3902] = 1073741823; +inp[3903] = 0; +inp[3904] = 1073741822; +inp[3905] = 0; +inp[3906] = 1073741821; +inp[3907] = 0; +inp[3908] = 1073741820; +inp[3909] = 0; +inp[3910] = 1073741819; +inp[3911] = 0; +inp[3912] = 1073741818; +inp[3913] = 0; +inp[3914] = 1073741817; +inp[3915] = 0; +inp[3916] = 1073741816; +inp[3917] = 0; +inp[3918] = 1073741815; +inp[3919] = 0; +inp[3920] = 1073741814; +inp[3921] = 0; +inp[3922] = 1073741813; +inp[3923] = 0; +inp[3924] = 1073741812; +inp[3925] = 0; +inp[3926] = 1073741811; +inp[3927] = 0; +inp[3928] = 1073741810; +inp[3929] = 0; +inp[3930] = 1073741809; +inp[3931] = 0; +inp[3932] = 1073741808; +inp[3933] = 0; +inp[3934] = 1073741807; +inp[3935] = 0; +inp[3936] = 1073741806; +inp[3937] = 0; +inp[3938] = 1073741805; +inp[3939] = 0; +inp[3940] = 1073741804; +inp[3941] = 0; +inp[3942] = 1073741803; +inp[3943] = 0; +inp[3944] = 1073741802; +inp[3945] = 0; +inp[3946] = 1073741801; +inp[3947] = 0; +inp[3948] = 1073741800; +inp[3949] = 0; +inp[3950] = 1073741799; +inp[3951] = 0; +inp[3952] = 1073741798; +inp[3953] = 0; +inp[3954] = 1073741797; +inp[3955] = 0; +inp[3956] = 1073741796; +inp[3957] = 0; +inp[3958] = 1073741795; +inp[3959] = 0; +inp[3960] = 1073741794; +inp[3961] = 0; +inp[3962] = 1073741793; +inp[3963] = 0; +inp[3964] = 1073741824; +inp[3965] = 1073741824; +inp[3966] = 1073741823; +inp[3967] = 0; +inp[3968] = 1073741823; +inp[3969] = 0; +inp[3970] = 1073741822; +inp[3971] = 0; +inp[3972] = 1073741822; +inp[3973] = 0; +inp[3974] = 1073741821; +inp[3975] = 0; +inp[3976] = 1073741821; +inp[3977] = 0; +inp[3978] = 1073741820; +inp[3979] = 0; +inp[3980] = 1073741820; +inp[3981] = 0; +inp[3982] = 1073741819; +inp[3983] = 0; +inp[3984] = 1073741819; +inp[3985] = 0; +inp[3986] = 1073741818; +inp[3987] = 0; +inp[3988] = 1073741818; +inp[3989] = 0; +inp[3990] = 1073741817; +inp[3991] = 0; +inp[3992] = 1073741817; +inp[3993] = 0; +inp[3994] = 1073741816; +inp[3995] = 0; +inp[3996] = 1073741816; +inp[3997] = 0; +inp[3998] = 1073741815; +inp[3999] = 0; +inp[4000] = 1073741815; +inp[4001] = 0; +inp[4002] = 1073741814; +inp[4003] = 0; +inp[4004] = 1073741814; +inp[4005] = 0; +inp[4006] = 1073741813; +inp[4007] = 0; +inp[4008] = 1073741813; +inp[4009] = 0; +inp[4010] = 1073741812; +inp[4011] = 0; +inp[4012] = 1073741812; +inp[4013] = 0; +inp[4014] = 1073741811; +inp[4015] = 0; +inp[4016] = 1073741811; +inp[4017] = 0; +inp[4018] = 1073741810; +inp[4019] = 0; +inp[4020] = 1073741810; +inp[4021] = 0; +inp[4022] = 1073741809; +inp[4023] = 0; +inp[4024] = 1073741809; +inp[4025] = 0; +inp[4026] = 1073741808; +inp[4027] = 0; +inp[4028] = 1073741824; +inp[4029] = 1073741824; +inp[4030] = 1073741823; +inp[4031] = 0; +inp[4032] = 1073741823; +inp[4033] = 0; +inp[4034] = 1073741823; +inp[4035] = 0; +inp[4036] = 1073741823; +inp[4037] = 0; +inp[4038] = 1073741822; +inp[4039] = 0; +inp[4040] = 1073741822; +inp[4041] = 0; +inp[4042] = 1073741822; +inp[4043] = 0; +inp[4044] = 1073741822; +inp[4045] = 0; +inp[4046] = 1073741821; +inp[4047] = 0; +inp[4048] = 1073741821; +inp[4049] = 0; +inp[4050] = 1073741821; +inp[4051] = 0; +inp[4052] = 1073741821; +inp[4053] = 0; +inp[4054] = 1073741820; +inp[4055] = 0; +inp[4056] = 1073741820; +inp[4057] = 0; +inp[4058] = 1073741820; +inp[4059] = 0; +inp[4060] = 1073741820; +inp[4061] = 0; +inp[4062] = 1073741819; +inp[4063] = 0; +inp[4064] = 1073741819; +inp[4065] = 0; +inp[4066] = 1073741819; +inp[4067] = 0; +inp[4068] = 1073741819; +inp[4069] = 0; +inp[4070] = 1073741818; +inp[4071] = 0; +inp[4072] = 1073741818; +inp[4073] = 0; +inp[4074] = 1073741818; +inp[4075] = 0; +inp[4076] = 1073741818; +inp[4077] = 0; +inp[4078] = 1073741817; +inp[4079] = 0; +inp[4080] = 1073741817; +inp[4081] = 0; +inp[4082] = 1073741817; +inp[4083] = 0; +inp[4084] = 1073741817; +inp[4085] = 0; +inp[4086] = 1073741816; +inp[4087] = 0; +inp[4088] = 1073741816; +inp[4089] = 0; +inp[4090] = 1073741816; +inp[4091] = 0; +inp[4092] = 1073741824; +inp[4093] = 1073741824; +inp[4094] = 395007542; +inp[4095] = 395007542; +inp[4096] = 145315153; +inp[4097] = 145315153; +inp[4098] = 53458457; +inp[4099] = 53458457; +inp[4100] = 19666267; +inp[4101] = 19666267; +inp[4102] = 7234815; +inp[4103] = 7234815; +inp[4104] = 2661539; +inp[4105] = 2661539; +inp[4106] = 979125; +inp[4107] = 979125; +inp[4108] = 360200; +inp[4109] = 360200; +inp[4110] = 132510; +inp[4111] = 132510; +inp[4112] = 48747; +inp[4113] = 48747; +inp[4114] = 17933; +inp[4115] = 17933; +inp[4116] = 6597; +inp[4117] = 6597; +inp[4118] = 2427; +inp[4119] = 2427; +inp[4120] = 892; +inp[4121] = 892; +inp[4122] = 328; +inp[4123] = 328; +inp[4124] = 120; +inp[4125] = 120; +inp[4126] = 44; +inp[4127] = 44; +inp[4128] = 16; +inp[4129] = 16; +inp[4130] = 6; +inp[4131] = 6; +inp[4132] = 2; +inp[4133] = 2; +inp[4134] = 0; +inp[4135] = 0; +inp[4136] = 0; +inp[4137] = 0; +inp[4138] = 0; +inp[4139] = 0; +inp[4140] = 0; +inp[4141] = 0; +inp[4142] = 0; +inp[4143] = 0; +inp[4144] = 0; +inp[4145] = 0; +inp[4146] = 0; +inp[4147] = 0; +inp[4148] = 0; +inp[4149] = 0; +inp[4150] = 0; +inp[4151] = 0; +inp[4152] = 0; +inp[4153] = 0; +inp[4154] = 0; +inp[4155] = 0; +inp[4156] = 0; +inp[4157] = 0; +inp[4158] = 0; +inp[4159] = 0; +inp[4160] = 0; +inp[4161] = 0; +inp[4162] = 0; +inp[4163] = 0; +inp[4164] = 0; +inp[4165] = 0; +inp[4166] = 0; +inp[4167] = 0; +inp[4168] = 0; +inp[4169] = 0; +inp[4170] = 0; +inp[4171] = 0; +inp[4172] = 0; +inp[4173] = 0; +inp[4174] = 0; +inp[4175] = 0; +inp[4176] = 0; +inp[4177] = 0; +inp[4178] = 0; +inp[4179] = 0; +inp[4180] = 0; +inp[4181] = 0; +inp[4182] = 0; +inp[4183] = 0; +inp[4184] = 0; +inp[4185] = 0; +inp[4186] = 0; +inp[4187] = 0; +inp[4188] = 0; +inp[4189] = 0; +inp[4190] = 0; +inp[4191] = 0; +inp[4192] = 0; +inp[4193] = 0; +inp[4194] = 0; +inp[4195] = 0; +inp[4196] = 0; +inp[4197] = 0; +inp[4198] = 0; +inp[4199] = 0; +inp[4200] = 0; +inp[4201] = 0; +inp[4202] = 0; +inp[4203] = 0; +inp[4204] = 0; +inp[4205] = 0; +inp[4206] = 0; +inp[4207] = 0; +inp[4208] = 0; +inp[4209] = 0; +inp[4210] = 0; +inp[4211] = 0; +inp[4212] = 0; +inp[4213] = 0; +inp[4214] = 0; +inp[4215] = 0; +inp[4216] = 0; +inp[4217] = 0; +inp[4218] = 0; +inp[4219] = 0; +inp[4220] = 1073741824; +inp[4221] = 1073741824; +inp[4222] = 651257336; +inp[4223] = 145315153; +inp[4224] = 395007542; +inp[4225] = 19666267; +inp[4226] = 239584185; +inp[4227] = 2661539; +inp[4228] = 145315153; +inp[4229] = 360200; +inp[4230] = 88138096; +inp[4231] = 48747; +inp[4232] = 53458457; +inp[4233] = 6597; +inp[4234] = 32424193; +inp[4235] = 892; +inp[4236] = 19666267; +inp[4237] = 120; +inp[4238] = 11928194; +inp[4239] = 16; +inp[4240] = 7234815; +inp[4241] = 2; +inp[4242] = 4388137; +inp[4243] = 0; +inp[4244] = 2661539; +inp[4245] = 0; +inp[4246] = 1614305; +inp[4247] = 0; +inp[4248] = 979125; +inp[4249] = 0; +inp[4250] = 593869; +inp[4251] = 0; +inp[4252] = 360200; +inp[4253] = 0; +inp[4254] = 218472; +inp[4255] = 0; +inp[4256] = 132510; +inp[4257] = 0; +inp[4258] = 80371; +inp[4259] = 0; +inp[4260] = 48747; +inp[4261] = 0; +inp[4262] = 29567; +inp[4263] = 0; +inp[4264] = 17933; +inp[4265] = 0; +inp[4266] = 10877; +inp[4267] = 0; +inp[4268] = 6597; +inp[4269] = 0; +inp[4270] = 4001; +inp[4271] = 0; +inp[4272] = 2427; +inp[4273] = 0; +inp[4274] = 1472; +inp[4275] = 0; +inp[4276] = 892; +inp[4277] = 0; +inp[4278] = 541; +inp[4279] = 0; +inp[4280] = 328; +inp[4281] = 0; +inp[4282] = 199; +inp[4283] = 0; +inp[4284] = 120; +inp[4285] = 0; +inp[4286] = 73; +inp[4287] = 0; +inp[4288] = 44; +inp[4289] = 0; +inp[4290] = 26; +inp[4291] = 0; +inp[4292] = 16; +inp[4293] = 0; +inp[4294] = 9; +inp[4295] = 0; +inp[4296] = 6; +inp[4297] = 0; +inp[4298] = 3; +inp[4299] = 0; +inp[4300] = 2; +inp[4301] = 0; +inp[4302] = 1; +inp[4303] = 0; +inp[4304] = 0; +inp[4305] = 0; +inp[4306] = 0; +inp[4307] = 0; +inp[4308] = 0; +inp[4309] = 0; +inp[4310] = 0; +inp[4311] = 0; +inp[4312] = 0; +inp[4313] = 0; +inp[4314] = 0; +inp[4315] = 0; +inp[4316] = 0; +inp[4317] = 0; +inp[4318] = 0; +inp[4319] = 0; +inp[4320] = 0; +inp[4321] = 0; +inp[4322] = 0; +inp[4323] = 0; +inp[4324] = 0; +inp[4325] = 0; +inp[4326] = 0; +inp[4327] = 0; +inp[4328] = 0; +inp[4329] = 0; +inp[4330] = 0; +inp[4331] = 0; +inp[4332] = 0; +inp[4333] = 0; +inp[4334] = 0; +inp[4335] = 0; +inp[4336] = 0; +inp[4337] = 0; +inp[4338] = 0; +inp[4339] = 0; +inp[4340] = 0; +inp[4341] = 0; +inp[4342] = 0; +inp[4343] = 0; +inp[4344] = 0; +inp[4345] = 0; +inp[4346] = 0; +inp[4347] = 0; +inp[4348] = 1073741824; +inp[4349] = 1073741824; +inp[4350] = 836230973; +inp[4351] = 19666267; +inp[4352] = 651257336; +inp[4353] = 360200; +inp[4354] = 507199723; +inp[4355] = 6597; +inp[4356] = 395007542; +inp[4357] = 120; +inp[4358] = 307632183; +inp[4359] = 2; +inp[4360] = 239584185; +inp[4361] = 0; +inp[4362] = 186588351; +inp[4363] = 0; +inp[4364] = 145315153; +inp[4365] = 0; +inp[4366] = 113171555; +inp[4367] = 0; +inp[4368] = 88138096; +inp[4369] = 0; +inp[4370] = 68642018; +inp[4371] = 0; +inp[4372] = 53458457; +inp[4373] = 0; +inp[4374] = 41633488; +inp[4375] = 0; +inp[4376] = 32424193; +inp[4377] = 0; +inp[4378] = 25251987; +inp[4379] = 0; +inp[4380] = 19666267; +inp[4381] = 0; +inp[4382] = 15316104; +inp[4383] = 0; +inp[4384] = 11928194; +inp[4385] = 0; +inp[4386] = 9289686; +inp[4387] = 0; +inp[4388] = 7234815; +inp[4389] = 0; +inp[4390] = 5634479; +inp[4391] = 0; +inp[4392] = 4388137; +inp[4393] = 0; +inp[4394] = 3417484; +inp[4395] = 0; +inp[4396] = 2661539; +inp[4397] = 0; +inp[4398] = 2072809; +inp[4399] = 0; +inp[4400] = 1614305; +inp[4401] = 0; +inp[4402] = 1257222; +inp[4403] = 0; +inp[4404] = 979125; +inp[4405] = 0; +inp[4406] = 762543; +inp[4407] = 0; +inp[4408] = 593869; +inp[4409] = 0; +inp[4410] = 462506; +inp[4411] = 0; +inp[4412] = 360200; +inp[4413] = 0; +inp[4414] = 280524; +inp[4415] = 0; +inp[4416] = 218472; +inp[4417] = 0; +inp[4418] = 170146; +inp[4419] = 0; +inp[4420] = 132510; +inp[4421] = 0; +inp[4422] = 103199; +inp[4423] = 0; +inp[4424] = 80371; +inp[4425] = 0; +inp[4426] = 62593; +inp[4427] = 0; +inp[4428] = 48747; +inp[4429] = 0; +inp[4430] = 37964; +inp[4431] = 0; +inp[4432] = 29567; +inp[4433] = 0; +inp[4434] = 23026; +inp[4435] = 0; +inp[4436] = 17933; +inp[4437] = 0; +inp[4438] = 13966; +inp[4439] = 0; +inp[4440] = 10877; +inp[4441] = 0; +inp[4442] = 8471; +inp[4443] = 0; +inp[4444] = 6597; +inp[4445] = 0; +inp[4446] = 5137; +inp[4447] = 0; +inp[4448] = 4001; +inp[4449] = 0; +inp[4450] = 3116; +inp[4451] = 0; +inp[4452] = 2427; +inp[4453] = 0; +inp[4454] = 1890; +inp[4455] = 0; +inp[4456] = 1472; +inp[4457] = 0; +inp[4458] = 1146; +inp[4459] = 0; +inp[4460] = 892; +inp[4461] = 0; +inp[4462] = 695; +inp[4463] = 0; +inp[4464] = 541; +inp[4465] = 0; +inp[4466] = 421; +inp[4467] = 0; +inp[4468] = 328; +inp[4469] = 0; +inp[4470] = 255; +inp[4471] = 0; +inp[4472] = 199; +inp[4473] = 0; +inp[4474] = 155; +inp[4475] = 0; +inp[4476] = 1073741824; +inp[4477] = 1073741824; +inp[4478] = 947573833; +inp[4479] = 360200; +inp[4480] = 836230973; +inp[4481] = 120; +inp[4482] = 737971243; +inp[4483] = 0; +inp[4484] = 651257336; +inp[4485] = 0; +inp[4486] = 574732582; +inp[4487] = 0; +inp[4488] = 507199723; +inp[4489] = 0; +inp[4490] = 447602185; +inp[4491] = 0; +inp[4492] = 395007542; +inp[4493] = 0; +inp[4494] = 348592932; +inp[4495] = 0; +inp[4496] = 307632183; +inp[4497] = 0; +inp[4498] = 271484448; +inp[4499] = 0; +inp[4500] = 239584185; +inp[4501] = 0; +inp[4502] = 211432301; +inp[4503] = 0; +inp[4504] = 186588351; +inp[4505] = 0; +inp[4506] = 164663641; +inp[4507] = 0; +inp[4508] = 145315153; +inp[4509] = 0; +inp[4510] = 128240173; +inp[4511] = 0; +inp[4512] = 113171555; +inp[4513] = 0; +inp[4514] = 99873547; +inp[4515] = 0; +inp[4516] = 88138096; +inp[4517] = 0; +inp[4518] = 77781596; +inp[4519] = 0; +inp[4520] = 68642018; +inp[4521] = 0; +inp[4522] = 60576368; +inp[4523] = 0; +inp[4524] = 53458457; +inp[4525] = 0; +inp[4526] = 47176923; +inp[4527] = 0; +inp[4528] = 41633488; +inp[4529] = 0; +inp[4530] = 36741424; +inp[4531] = 0; +inp[4532] = 32424193; +inp[4533] = 0; +inp[4534] = 28614250; +inp[4535] = 0; +inp[4536] = 25251987; +inp[4537] = 0; +inp[4538] = 22284800; +inp[4539] = 0; +inp[4540] = 19666267; +inp[4541] = 0; +inp[4542] = 17355420; +inp[4543] = 0; +inp[4544] = 15316104; +inp[4545] = 0; +inp[4546] = 13516414; +inp[4547] = 0; +inp[4548] = 11928194; +inp[4549] = 0; +inp[4550] = 10526594; +inp[4551] = 0; +inp[4552] = 9289686; +inp[4553] = 0; +inp[4554] = 8198119; +inp[4555] = 0; +inp[4556] = 7234815; +inp[4557] = 0; +inp[4558] = 6384702; +inp[4559] = 0; +inp[4560] = 5634479; +inp[4561] = 0; +inp[4562] = 4972411; +inp[4563] = 0; +inp[4564] = 4388137; +inp[4565] = 0; +inp[4566] = 3872517; +inp[4567] = 0; +inp[4568] = 3417484; +inp[4569] = 0; +inp[4570] = 3015919; +inp[4571] = 0; +inp[4572] = 2661539; +inp[4573] = 0; +inp[4574] = 2348800; +inp[4575] = 0; +inp[4576] = 2072809; +inp[4577] = 0; +inp[4578] = 1829247; +inp[4579] = 0; +inp[4580] = 1614305; +inp[4581] = 0; +inp[4582] = 1424619; +inp[4583] = 0; +inp[4584] = 1257222; +inp[4585] = 0; +inp[4586] = 1109494; +inp[4587] = 0; +inp[4588] = 979125; +inp[4589] = 0; +inp[4590] = 864075; +inp[4591] = 0; +inp[4592] = 762543; +inp[4593] = 0; +inp[4594] = 672942; +inp[4595] = 0; +inp[4596] = 593869; +inp[4597] = 0; +inp[4598] = 524088; +inp[4599] = 0; +inp[4600] = 462506; +inp[4601] = 0; +inp[4602] = 408160; +inp[4603] = 0; +inp[4604] = 1073741824; +inp[4605] = 1073741824; +inp[4606] = 1008687095; +inp[4607] = 120; +inp[4608] = 947573833; +inp[4609] = 0; +inp[4610] = 890163237; +inp[4611] = 0; +inp[4612] = 836230973; +inp[4613] = 0; +inp[4614] = 785566299; +inp[4615] = 0; +inp[4616] = 737971243; +inp[4617] = 0; +inp[4618] = 693259826; +inp[4619] = 0; +inp[4620] = 651257336; +inp[4621] = 0; +inp[4622] = 611799649; +inp[4623] = 0; +inp[4624] = 574732582; +inp[4625] = 0; +inp[4626] = 539911295; +inp[4627] = 0; +inp[4628] = 507199723; +inp[4629] = 0; +inp[4630] = 476470046; +inp[4631] = 0; +inp[4632] = 447602185; +inp[4633] = 0; +inp[4634] = 420483339; +inp[4635] = 0; +inp[4636] = 395007542; +inp[4637] = 0; +inp[4638] = 371075245; +inp[4639] = 0; +inp[4640] = 348592932; +inp[4641] = 0; +inp[4642] = 327472754; +inp[4643] = 0; +inp[4644] = 307632183; +inp[4645] = 0; +inp[4646] = 288993691; +inp[4647] = 0; +inp[4648] = 271484448; +inp[4649] = 0; +inp[4650] = 255036037; +inp[4651] = 0; +inp[4652] = 239584185; +inp[4653] = 0; +inp[4654] = 225068513; +inp[4655] = 0; +inp[4656] = 211432301; +inp[4657] = 0; +inp[4658] = 198622265; +inp[4659] = 0; +inp[4660] = 186588351; +inp[4661] = 0; +inp[4662] = 175283534; +inp[4663] = 0; +inp[4664] = 164663641; +inp[4665] = 0; +inp[4666] = 154687176; +inp[4667] = 0; +inp[4668] = 145315153; +inp[4669] = 0; +inp[4670] = 136510953; +inp[4671] = 0; +inp[4672] = 128240173; +inp[4673] = 0; +inp[4674] = 120470493; +inp[4675] = 0; +inp[4676] = 113171555; +inp[4677] = 0; +inp[4678] = 106314837; +inp[4679] = 0; +inp[4680] = 99873547; +inp[4681] = 0; +inp[4682] = 93822514; +inp[4683] = 0; +inp[4684] = 88138096; +inp[4685] = 0; +inp[4686] = 82798078; +inp[4687] = 0; +inp[4688] = 77781596; +inp[4689] = 0; +inp[4690] = 73069048; +inp[4691] = 0; +inp[4692] = 68642018; +inp[4693] = 0; +inp[4694] = 64483208; +inp[4695] = 0; +inp[4696] = 60576368; +inp[4697] = 0; +inp[4698] = 56906231; +inp[4699] = 0; +inp[4700] = 53458457; +inp[4701] = 0; +inp[4702] = 50219573; +inp[4703] = 0; +inp[4704] = 47176923; +inp[4705] = 0; +inp[4706] = 44318617; +inp[4707] = 0; +inp[4708] = 41633488; +inp[4709] = 0; +inp[4710] = 39111043; +inp[4711] = 0; +inp[4712] = 36741424; +inp[4713] = 0; +inp[4714] = 34515374; +inp[4715] = 0; +inp[4716] = 32424193; +inp[4717] = 0; +inp[4718] = 30459710; +inp[4719] = 0; +inp[4720] = 28614250; +inp[4721] = 0; +inp[4722] = 26880600; +inp[4723] = 0; +inp[4724] = 25251987; +inp[4725] = 0; +inp[4726] = 23722046; +inp[4727] = 0; +inp[4728] = 22284800; +inp[4729] = 0; +inp[4730] = 20934632; +inp[4731] = 0; +inp[4732] = 1073741824; +inp[4733] = 1073741824; +inp[4734] = 1040706261; +inp[4735] = 0; +inp[4736] = 1008687095; +inp[4737] = 0; +inp[4738] = 977653056; +inp[4739] = 0; +inp[4740] = 947573833; +inp[4741] = 0; +inp[4742] = 918420051; +inp[4743] = 0; +inp[4744] = 890163237; +inp[4745] = 0; +inp[4746] = 862775793; +inp[4747] = 0; +inp[4748] = 836230973; +inp[4749] = 0; +inp[4750] = 810502851; +inp[4751] = 0; +inp[4752] = 785566299; +inp[4753] = 0; +inp[4754] = 761396965; +inp[4755] = 0; +inp[4756] = 737971243; +inp[4757] = 0; +inp[4758] = 715266255; +inp[4759] = 0; +inp[4760] = 693259826; +inp[4761] = 0; +inp[4762] = 671930463; +inp[4763] = 0; +inp[4764] = 651257336; +inp[4765] = 0; +inp[4766] = 631220255; +inp[4767] = 0; +inp[4768] = 611799649; +inp[4769] = 0; +inp[4770] = 592976553; +inp[4771] = 0; +inp[4772] = 574732582; +inp[4773] = 0; +inp[4774] = 557049919; +inp[4775] = 0; +inp[4776] = 539911295; +inp[4777] = 0; +inp[4778] = 523299971; +inp[4779] = 0; +inp[4780] = 507199723; +inp[4781] = 0; +inp[4782] = 491594828; +inp[4783] = 0; +inp[4784] = 476470046; +inp[4785] = 0; +inp[4786] = 461810603; +inp[4787] = 0; +inp[4788] = 447602185; +inp[4789] = 0; +inp[4790] = 433830913; +inp[4791] = 0; +inp[4792] = 420483339; +inp[4793] = 0; +inp[4794] = 407546427; +inp[4795] = 0; +inp[4796] = 395007542; +inp[4797] = 0; +inp[4798] = 382854437; +inp[4799] = 0; +inp[4800] = 371075245; +inp[4801] = 0; +inp[4802] = 359658459; +inp[4803] = 0; +inp[4804] = 348592932; +inp[4805] = 0; +inp[4806] = 337867855; +inp[4807] = 0; +inp[4808] = 327472754; +inp[4809] = 0; +inp[4810] = 317397476; +inp[4811] = 0; +inp[4812] = 307632183; +inp[4813] = 0; +inp[4814] = 298167335; +inp[4815] = 0; +inp[4816] = 288993691; +inp[4817] = 0; +inp[4818] = 280102290; +inp[4819] = 0; +inp[4820] = 271484448; +inp[4821] = 0; +inp[4822] = 263131750; +inp[4823] = 0; +inp[4824] = 255036037; +inp[4825] = 0; +inp[4826] = 247189403; +inp[4827] = 0; +inp[4828] = 239584185; +inp[4829] = 0; +inp[4830] = 232212954; +inp[4831] = 0; +inp[4832] = 225068513; +inp[4833] = 0; +inp[4834] = 218143882; +inp[4835] = 0; +inp[4836] = 211432301; +inp[4837] = 0; +inp[4838] = 204927213; +inp[4839] = 0; +inp[4840] = 198622265; +inp[4841] = 0; +inp[4842] = 192511301; +inp[4843] = 0; +inp[4844] = 186588351; +inp[4845] = 0; +inp[4846] = 180847630; +inp[4847] = 0; +inp[4848] = 175283534; +inp[4849] = 0; +inp[4850] = 169890626; +inp[4851] = 0; +inp[4852] = 164663641; +inp[4853] = 0; +inp[4854] = 159597474; +inp[4855] = 0; +inp[4856] = 154687176; +inp[4857] = 0; +inp[4858] = 149927952; +inp[4859] = 0; +inp[4860] = 1073741824; +inp[4861] = 1073741824; +inp[4862] = 1057094999; +inp[4863] = 0; +inp[4864] = 1040706261; +inp[4865] = 0; +inp[4866] = 1024571605; +inp[4867] = 0; +inp[4868] = 1008687095; +inp[4869] = 0; +inp[4870] = 993048851; +inp[4871] = 0; +inp[4872] = 977653056; +inp[4873] = 0; +inp[4874] = 962495950; +inp[4875] = 0; +inp[4876] = 947573833; +inp[4877] = 0; +inp[4878] = 932883063; +inp[4879] = 0; +inp[4880] = 918420051; +inp[4881] = 0; +inp[4882] = 904181268; +inp[4883] = 0; +inp[4884] = 890163237; +inp[4885] = 0; +inp[4886] = 876362535; +inp[4887] = 0; +inp[4888] = 862775793; +inp[4889] = 0; +inp[4890] = 849399695; +inp[4891] = 0; +inp[4892] = 836230973; +inp[4893] = 0; +inp[4894] = 823266413; +inp[4895] = 0; +inp[4896] = 810502851; +inp[4897] = 0; +inp[4898] = 797937169; +inp[4899] = 0; +inp[4900] = 785566299; +inp[4901] = 0; +inp[4902] = 773387223; +inp[4903] = 0; +inp[4904] = 761396965; +inp[4905] = 0; +inp[4906] = 749592599; +inp[4907] = 0; +inp[4908] = 737971243; +inp[4909] = 0; +inp[4910] = 726530060; +inp[4911] = 0; +inp[4912] = 715266255; +inp[4913] = 0; +inp[4914] = 704177080; +inp[4915] = 0; +inp[4916] = 693259826; +inp[4917] = 0; +inp[4918] = 682511829; +inp[4919] = 0; +inp[4920] = 671930463; +inp[4921] = 0; +inp[4922] = 661513147; +inp[4923] = 0; +inp[4924] = 651257336; +inp[4925] = 0; +inp[4926] = 641160527; +inp[4927] = 0; +inp[4928] = 631220255; +inp[4929] = 0; +inp[4930] = 621434092; +inp[4931] = 0; +inp[4932] = 611799649; +inp[4933] = 0; +inp[4934] = 602314575; +inp[4935] = 0; +inp[4936] = 592976553; +inp[4937] = 0; +inp[4938] = 583783303; +inp[4939] = 0; +inp[4940] = 574732582; +inp[4941] = 0; +inp[4942] = 565822179; +inp[4943] = 0; +inp[4944] = 557049919; +inp[4945] = 0; +inp[4946] = 548413661; +inp[4947] = 0; +inp[4948] = 539911295; +inp[4949] = 0; +inp[4950] = 531540746; +inp[4951] = 0; +inp[4952] = 523299971; +inp[4953] = 0; +inp[4954] = 515186957; +inp[4955] = 0; +inp[4956] = 507199723; +inp[4957] = 0; +inp[4958] = 499336321; +inp[4959] = 0; +inp[4960] = 491594828; +inp[4961] = 0; +inp[4962] = 483973357; +inp[4963] = 0; +inp[4964] = 476470046; +inp[4965] = 0; +inp[4966] = 469083062; +inp[4967] = 0; +inp[4968] = 461810603; +inp[4969] = 0; +inp[4970] = 454650894; +inp[4971] = 0; +inp[4972] = 447602185; +inp[4973] = 0; +inp[4974] = 440662756; +inp[4975] = 0; +inp[4976] = 433830913; +inp[4977] = 0; +inp[4978] = 427104988; +inp[4979] = 0; +inp[4980] = 420483339; +inp[4981] = 0; +inp[4982] = 413964349; +inp[4983] = 0; +inp[4984] = 407546427; +inp[4985] = 0; +inp[4986] = 401228005; +inp[4987] = 0; +inp[4988] = 1073741824; +inp[4989] = 1073741824; +inp[4990] = 1065385898; +inp[4991] = 0; +inp[4992] = 1057094999; +inp[4993] = 0; +inp[4994] = 1048868621; +inp[4995] = 0; +inp[4996] = 1040706261; +inp[4997] = 0; +inp[4998] = 1032607420; +inp[4999] = 0; +inp[5000] = 1024571605; +inp[5001] = 0; +inp[5002] = 1016598326; +inp[5003] = 0; +inp[5004] = 1008687095; +inp[5005] = 0; +inp[5006] = 1000837430; +inp[5007] = 0; +inp[5008] = 993048851; +inp[5009] = 0; +inp[5010] = 985320884; +inp[5011] = 0; +inp[5012] = 977653056; +inp[5013] = 0; +inp[5014] = 970044899; +inp[5015] = 0; +inp[5016] = 962495950; +inp[5017] = 0; +inp[5018] = 955005747; +inp[5019] = 0; +inp[5020] = 947573833; +inp[5021] = 0; +inp[5022] = 940199755; +inp[5023] = 0; +inp[5024] = 932883063; +inp[5025] = 0; +inp[5026] = 925623309; +inp[5027] = 0; +inp[5028] = 918420051; +inp[5029] = 0; +inp[5030] = 911272850; +inp[5031] = 0; +inp[5032] = 904181268; +inp[5033] = 0; +inp[5034] = 897144874; +inp[5035] = 0; +inp[5036] = 890163237; +inp[5037] = 0; +inp[5038] = 883235932; +inp[5039] = 0; +inp[5040] = 876362535; +inp[5041] = 0; +inp[5042] = 869542628; +inp[5043] = 0; +inp[5044] = 862775793; +inp[5045] = 0; +inp[5046] = 856061619; +inp[5047] = 0; +inp[5048] = 849399695; +inp[5049] = 0; +inp[5050] = 842789614; +inp[5051] = 0; +inp[5052] = 836230973; +inp[5053] = 0; +inp[5054] = 829723372; +inp[5055] = 0; +inp[5056] = 823266413; +inp[5057] = 0; +inp[5058] = 816859703; +inp[5059] = 0; +inp[5060] = 810502851; +inp[5061] = 0; +inp[5062] = 804195467; +inp[5063] = 0; +inp[5064] = 797937169; +inp[5065] = 0; +inp[5066] = 791727572; +inp[5067] = 0; +inp[5068] = 785566299; +inp[5069] = 0; +inp[5070] = 779452974; +inp[5071] = 0; +inp[5072] = 773387223; +inp[5073] = 0; +inp[5074] = 767368676; +inp[5075] = 0; +inp[5076] = 761396965; +inp[5077] = 0; +inp[5078] = 755471727; +inp[5079] = 0; +inp[5080] = 749592599; +inp[5081] = 0; +inp[5082] = 743759224; +inp[5083] = 0; +inp[5084] = 737971243; +inp[5085] = 0; +inp[5086] = 732228306; +inp[5087] = 0; +inp[5088] = 726530060; +inp[5089] = 0; +inp[5090] = 720876158; +inp[5091] = 0; +inp[5092] = 715266255; +inp[5093] = 0; +inp[5094] = 709700009; +inp[5095] = 0; +inp[5096] = 704177080; +inp[5097] = 0; +inp[5098] = 698697130; +inp[5099] = 0; +inp[5100] = 693259826; +inp[5101] = 0; +inp[5102] = 687864835; +inp[5103] = 0; +inp[5104] = 682511829; +inp[5105] = 0; +inp[5106] = 677200479; +inp[5107] = 0; +inp[5108] = 671930463; +inp[5109] = 0; +inp[5110] = 666701459; +inp[5111] = 0; +inp[5112] = 661513147; +inp[5113] = 0; +inp[5114] = 656365211; +inp[5115] = 0; +inp[5116] = 1073741824; +inp[5117] = 1073741824; +inp[5118] = 1069555701; +inp[5119] = 0; +inp[5120] = 1065385898; +inp[5121] = 0; +inp[5122] = 1061232352; +inp[5123] = 0; +inp[5124] = 1057094999; +inp[5125] = 0; +inp[5126] = 1052973777; +inp[5127] = 0; +inp[5128] = 1048868621; +inp[5129] = 0; +inp[5130] = 1044779470; +inp[5131] = 0; +inp[5132] = 1040706261; +inp[5133] = 0; +inp[5134] = 1036648931; +inp[5135] = 0; +inp[5136] = 1032607420; +inp[5137] = 0; +inp[5138] = 1028581665; +inp[5139] = 0; +inp[5140] = 1024571605; +inp[5141] = 0; +inp[5142] = 1020577179; +inp[5143] = 0; +inp[5144] = 1016598326; +inp[5145] = 0; +inp[5146] = 1012634985; +inp[5147] = 0; +inp[5148] = 1008687095; +inp[5149] = 0; +inp[5150] = 1004754597; +inp[5151] = 0; +inp[5152] = 1000837430; +inp[5153] = 0; +inp[5154] = 996935534; +inp[5155] = 0; +inp[5156] = 993048851; +inp[5157] = 0; +inp[5158] = 989177321; +inp[5159] = 0; +inp[5160] = 985320884; +inp[5161] = 0; +inp[5162] = 981479482; +inp[5163] = 0; +inp[5164] = 977653056; +inp[5165] = 0; +inp[5166] = 973841548; +inp[5167] = 0; +inp[5168] = 970044899; +inp[5169] = 0; +inp[5170] = 966263053; +inp[5171] = 0; +inp[5172] = 962495950; +inp[5173] = 0; +inp[5174] = 958743534; +inp[5175] = 0; +inp[5176] = 955005747; +inp[5177] = 0; +inp[5178] = 951282532; +inp[5179] = 0; +inp[5180] = 947573833; +inp[5181] = 0; +inp[5182] = 943879593; +inp[5183] = 0; +inp[5184] = 940199755; +inp[5185] = 0; +inp[5186] = 936534264; +inp[5187] = 0; +inp[5188] = 932883063; +inp[5189] = 0; +inp[5190] = 929246096; +inp[5191] = 0; +inp[5192] = 925623309; +inp[5193] = 0; +inp[5194] = 922014646; +inp[5195] = 0; +inp[5196] = 918420051; +inp[5197] = 0; +inp[5198] = 914839471; +inp[5199] = 0; +inp[5200] = 911272850; +inp[5201] = 0; +inp[5202] = 907720134; +inp[5203] = 0; +inp[5204] = 904181268; +inp[5205] = 0; +inp[5206] = 900656200; +inp[5207] = 0; +inp[5208] = 897144874; +inp[5209] = 0; +inp[5210] = 893647237; +inp[5211] = 0; +inp[5212] = 890163237; +inp[5213] = 0; +inp[5214] = 886692819; +inp[5215] = 0; +inp[5216] = 883235932; +inp[5217] = 0; +inp[5218] = 879792521; +inp[5219] = 0; +inp[5220] = 876362535; +inp[5221] = 0; +inp[5222] = 872945921; +inp[5223] = 0; +inp[5224] = 869542628; +inp[5225] = 0; +inp[5226] = 866152602; +inp[5227] = 0; +inp[5228] = 862775793; +inp[5229] = 0; +inp[5230] = 859412149; +inp[5231] = 0; +inp[5232] = 856061619; +inp[5233] = 0; +inp[5234] = 852724151; +inp[5235] = 0; +inp[5236] = 849399695; +inp[5237] = 0; +inp[5238] = 846088199; +inp[5239] = 0; +inp[5240] = 842789614; +inp[5241] = 0; +inp[5242] = 839503888; +inp[5243] = 0; +inp[5244] = 1073741824; +inp[5245] = 1073741824; +inp[5246] = 1071646718; +inp[5247] = 0; +inp[5248] = 1069555701; +inp[5249] = 0; +inp[5250] = 1067468764; +inp[5251] = 0; +inp[5252] = 1065385898; +inp[5253] = 0; +inp[5254] = 1063307097; +inp[5255] = 0; +inp[5256] = 1061232352; +inp[5257] = 0; +inp[5258] = 1059161656; +inp[5259] = 0; +inp[5260] = 1057094999; +inp[5261] = 0; +inp[5262] = 1055032376; +inp[5263] = 0; +inp[5264] = 1052973777; +inp[5265] = 0; +inp[5266] = 1050919194; +inp[5267] = 0; +inp[5268] = 1048868621; +inp[5269] = 0; +inp[5270] = 1046822049; +inp[5271] = 0; +inp[5272] = 1044779470; +inp[5273] = 0; +inp[5274] = 1042740876; +inp[5275] = 0; +inp[5276] = 1040706261; +inp[5277] = 0; +inp[5278] = 1038675615; +inp[5279] = 0; +inp[5280] = 1036648931; +inp[5281] = 0; +inp[5282] = 1034626202; +inp[5283] = 0; +inp[5284] = 1032607420; +inp[5285] = 0; +inp[5286] = 1030592577; +inp[5287] = 0; +inp[5288] = 1028581665; +inp[5289] = 0; +inp[5290] = 1026574677; +inp[5291] = 0; +inp[5292] = 1024571605; +inp[5293] = 0; +inp[5294] = 1022572442; +inp[5295] = 0; +inp[5296] = 1020577179; +inp[5297] = 0; +inp[5298] = 1018585810; +inp[5299] = 0; +inp[5300] = 1016598326; +inp[5301] = 0; +inp[5302] = 1014614720; +inp[5303] = 0; +inp[5304] = 1012634985; +inp[5305] = 0; +inp[5306] = 1010659112; +inp[5307] = 0; +inp[5308] = 1008687095; +inp[5309] = 0; +inp[5310] = 1006718926; +inp[5311] = 0; +inp[5312] = 1004754597; +inp[5313] = 0; +inp[5314] = 1002794101; +inp[5315] = 0; +inp[5316] = 1000837430; +inp[5317] = 0; +inp[5318] = 998884577; +inp[5319] = 0; +inp[5320] = 996935534; +inp[5321] = 0; +inp[5322] = 994990295; +inp[5323] = 0; +inp[5324] = 993048851; +inp[5325] = 0; +inp[5326] = 991111195; +inp[5327] = 0; +inp[5328] = 989177321; +inp[5329] = 0; +inp[5330] = 987247219; +inp[5331] = 0; +inp[5332] = 985320884; +inp[5333] = 0; +inp[5334] = 983398307; +inp[5335] = 0; +inp[5336] = 981479482; +inp[5337] = 0; +inp[5338] = 979564400; +inp[5339] = 0; +inp[5340] = 977653056; +inp[5341] = 0; +inp[5342] = 975745441; +inp[5343] = 0; +inp[5344] = 973841548; +inp[5345] = 0; +inp[5346] = 971941370; +inp[5347] = 0; +inp[5348] = 970044899; +inp[5349] = 0; +inp[5350] = 968152129; +inp[5351] = 0; +inp[5352] = 966263053; +inp[5353] = 0; +inp[5354] = 964377662; +inp[5355] = 0; +inp[5356] = 962495950; +inp[5357] = 0; +inp[5358] = 960617910; +inp[5359] = 0; +inp[5360] = 958743534; +inp[5361] = 0; +inp[5362] = 956872815; +inp[5363] = 0; +inp[5364] = 955005747; +inp[5365] = 0; +inp[5366] = 953142322; +inp[5367] = 0; +inp[5368] = 951282532; +inp[5369] = 0; +inp[5370] = 949426372; +inp[5371] = 0; +inp[5372] = 1073741824; +inp[5373] = 1073741824; +inp[5374] = 1072693759; +inp[5375] = 0; +inp[5376] = 1071646718; +inp[5377] = 0; +inp[5378] = 1070600699; +inp[5379] = 0; +inp[5380] = 1069555701; +inp[5381] = 0; +inp[5382] = 1068511723; +inp[5383] = 0; +inp[5384] = 1067468764; +inp[5385] = 0; +inp[5386] = 1066426822; +inp[5387] = 0; +inp[5388] = 1065385898; +inp[5389] = 0; +inp[5390] = 1064345990; +inp[5391] = 0; +inp[5392] = 1063307097; +inp[5393] = 0; +inp[5394] = 1062269218; +inp[5395] = 0; +inp[5396] = 1061232352; +inp[5397] = 0; +inp[5398] = 1060196498; +inp[5399] = 0; +inp[5400] = 1059161656; +inp[5401] = 0; +inp[5402] = 1058127823; +inp[5403] = 0; +inp[5404] = 1057094999; +inp[5405] = 0; +inp[5406] = 1056063184; +inp[5407] = 0; +inp[5408] = 1055032376; +inp[5409] = 0; +inp[5410] = 1054002574; +inp[5411] = 0; +inp[5412] = 1052973777; +inp[5413] = 0; +inp[5414] = 1051945984; +inp[5415] = 0; +inp[5416] = 1050919194; +inp[5417] = 0; +inp[5418] = 1049893407; +inp[5419] = 0; +inp[5420] = 1048868621; +inp[5421] = 0; +inp[5422] = 1047844835; +inp[5423] = 0; +inp[5424] = 1046822049; +inp[5425] = 0; +inp[5426] = 1045800261; +inp[5427] = 0; +inp[5428] = 1044779470; +inp[5429] = 0; +inp[5430] = 1043759675; +inp[5431] = 0; +inp[5432] = 1042740876; +inp[5433] = 0; +inp[5434] = 1041723072; +inp[5435] = 0; +inp[5436] = 1040706261; +inp[5437] = 0; +inp[5438] = 1039690442; +inp[5439] = 0; +inp[5440] = 1038675615; +inp[5441] = 0; +inp[5442] = 1037661778; +inp[5443] = 0; +inp[5444] = 1036648931; +inp[5445] = 0; +inp[5446] = 1035637073; +inp[5447] = 0; +inp[5448] = 1034626202; +inp[5449] = 0; +inp[5450] = 1033616318; +inp[5451] = 0; +inp[5452] = 1032607420; +inp[5453] = 0; +inp[5454] = 1031599507; +inp[5455] = 0; +inp[5456] = 1030592577; +inp[5457] = 0; +inp[5458] = 1029586630; +inp[5459] = 0; +inp[5460] = 1028581665; +inp[5461] = 0; +inp[5462] = 1027577681; +inp[5463] = 0; +inp[5464] = 1026574677; +inp[5465] = 0; +inp[5466] = 1025572652; +inp[5467] = 0; +inp[5468] = 1024571605; +inp[5469] = 0; +inp[5470] = 1023571536; +inp[5471] = 0; +inp[5472] = 1022572442; +inp[5473] = 0; +inp[5474] = 1021574324; +inp[5475] = 0; +inp[5476] = 1020577179; +inp[5477] = 0; +inp[5478] = 1019581008; +inp[5479] = 0; +inp[5480] = 1018585810; +inp[5481] = 0; +inp[5482] = 1017591583; +inp[5483] = 0; +inp[5484] = 1016598326; +inp[5485] = 0; +inp[5486] = 1015606039; +inp[5487] = 0; +inp[5488] = 1014614720; +inp[5489] = 0; +inp[5490] = 1013624369; +inp[5491] = 0; +inp[5492] = 1012634985; +inp[5493] = 0; +inp[5494] = 1011646566; +inp[5495] = 0; +inp[5496] = 1010659112; +inp[5497] = 0; +inp[5498] = 1009672622; +inp[5499] = 0; +inp[5500] = 1073741824; +inp[5501] = 1073741824; +inp[5502] = 1073217663; +inp[5503] = 0; +inp[5504] = 1072693759; +inp[5505] = 0; +inp[5506] = 1072170111; +inp[5507] = 0; +inp[5508] = 1071646718; +inp[5509] = 0; +inp[5510] = 1071123581; +inp[5511] = 0; +inp[5512] = 1070600699; +inp[5513] = 0; +inp[5514] = 1070078072; +inp[5515] = 0; +inp[5516] = 1069555701; +inp[5517] = 0; +inp[5518] = 1069033584; +inp[5519] = 0; +inp[5520] = 1068511723; +inp[5521] = 0; +inp[5522] = 1067990116; +inp[5523] = 0; +inp[5524] = 1067468764; +inp[5525] = 0; +inp[5526] = 1066947666; +inp[5527] = 0; +inp[5528] = 1066426822; +inp[5529] = 0; +inp[5530] = 1065906233; +inp[5531] = 0; +inp[5532] = 1065385898; +inp[5533] = 0; +inp[5534] = 1064865817; +inp[5535] = 0; +inp[5536] = 1064345990; +inp[5537] = 0; +inp[5538] = 1063826417; +inp[5539] = 0; +inp[5540] = 1063307097; +inp[5541] = 0; +inp[5542] = 1062788031; +inp[5543] = 0; +inp[5544] = 1062269218; +inp[5545] = 0; +inp[5546] = 1061750659; +inp[5547] = 0; +inp[5548] = 1061232352; +inp[5549] = 0; +inp[5550] = 1060714299; +inp[5551] = 0; +inp[5552] = 1060196498; +inp[5553] = 0; +inp[5554] = 1059678951; +inp[5555] = 0; +inp[5556] = 1059161656; +inp[5557] = 0; +inp[5558] = 1058644613; +inp[5559] = 0; +inp[5560] = 1058127823; +inp[5561] = 0; +inp[5562] = 1057611285; +inp[5563] = 0; +inp[5564] = 1057094999; +inp[5565] = 0; +inp[5566] = 1056578966; +inp[5567] = 0; +inp[5568] = 1056063184; +inp[5569] = 0; +inp[5570] = 1055547654; +inp[5571] = 0; +inp[5572] = 1055032376; +inp[5573] = 0; +inp[5574] = 1054517349; +inp[5575] = 0; +inp[5576] = 1054002574; +inp[5577] = 0; +inp[5578] = 1053488050; +inp[5579] = 0; +inp[5580] = 1052973777; +inp[5581] = 0; +inp[5582] = 1052459755; +inp[5583] = 0; +inp[5584] = 1051945984; +inp[5585] = 0; +inp[5586] = 1051432464; +inp[5587] = 0; +inp[5588] = 1050919194; +inp[5589] = 0; +inp[5590] = 1050406175; +inp[5591] = 0; +inp[5592] = 1049893407; +inp[5593] = 0; +inp[5594] = 1049380889; +inp[5595] = 0; +inp[5596] = 1048868621; +inp[5597] = 0; +inp[5598] = 1048356603; +inp[5599] = 0; +inp[5600] = 1047844835; +inp[5601] = 0; +inp[5602] = 1047333317; +inp[5603] = 0; +inp[5604] = 1046822049; +inp[5605] = 0; +inp[5606] = 1046311030; +inp[5607] = 0; +inp[5608] = 1045800261; +inp[5609] = 0; +inp[5610] = 1045289741; +inp[5611] = 0; +inp[5612] = 1044779470; +inp[5613] = 0; +inp[5614] = 1044269448; +inp[5615] = 0; +inp[5616] = 1043759675; +inp[5617] = 0; +inp[5618] = 1043250151; +inp[5619] = 0; +inp[5620] = 1042740876; +inp[5621] = 0; +inp[5622] = 1042231850; +inp[5623] = 0; +inp[5624] = 1041723072; +inp[5625] = 0; +inp[5626] = 1041214542; +inp[5627] = 0; +inp[5628] = 1073741824; +inp[5629] = 1073741824; +inp[5630] = 1073479711; +inp[5631] = 0; +inp[5632] = 1073217663; +inp[5633] = 0; +inp[5634] = 1072955679; +inp[5635] = 0; +inp[5636] = 1072693759; +inp[5637] = 0; +inp[5638] = 1072431903; +inp[5639] = 0; +inp[5640] = 1072170111; +inp[5641] = 0; +inp[5642] = 1071908383; +inp[5643] = 0; +inp[5644] = 1071646718; +inp[5645] = 0; +inp[5646] = 1071385118; +inp[5647] = 0; +inp[5648] = 1071123581; +inp[5649] = 0; +inp[5650] = 1070862108; +inp[5651] = 0; +inp[5652] = 1070600699; +inp[5653] = 0; +inp[5654] = 1070339354; +inp[5655] = 0; +inp[5656] = 1070078072; +inp[5657] = 0; +inp[5658] = 1069816855; +inp[5659] = 0; +inp[5660] = 1069555701; +inp[5661] = 0; +inp[5662] = 1069294611; +inp[5663] = 0; +inp[5664] = 1069033584; +inp[5665] = 0; +inp[5666] = 1068772622; +inp[5667] = 0; +inp[5668] = 1068511723; +inp[5669] = 0; +inp[5670] = 1068250887; +inp[5671] = 0; +inp[5672] = 1067990116; +inp[5673] = 0; +inp[5674] = 1067729408; +inp[5675] = 0; +inp[5676] = 1067468764; +inp[5677] = 0; +inp[5678] = 1067208183; +inp[5679] = 0; +inp[5680] = 1066947666; +inp[5681] = 0; +inp[5682] = 1066687212; +inp[5683] = 0; +inp[5684] = 1066426822; +inp[5685] = 0; +inp[5686] = 1066166496; +inp[5687] = 0; +inp[5688] = 1065906233; +inp[5689] = 0; +inp[5690] = 1065646034; +inp[5691] = 0; +inp[5692] = 1065385898; +inp[5693] = 0; +inp[5694] = 1065125826; +inp[5695] = 0; +inp[5696] = 1064865817; +inp[5697] = 0; +inp[5698] = 1064605872; +inp[5699] = 0; +inp[5700] = 1064345990; +inp[5701] = 0; +inp[5702] = 1064086172; +inp[5703] = 0; +inp[5704] = 1063826417; +inp[5705] = 0; +inp[5706] = 1063566725; +inp[5707] = 0; +inp[5708] = 1063307097; +inp[5709] = 0; +inp[5710] = 1063047532; +inp[5711] = 0; +inp[5712] = 1062788031; +inp[5713] = 0; +inp[5714] = 1062528593; +inp[5715] = 0; +inp[5716] = 1062269218; +inp[5717] = 0; +inp[5718] = 1062009907; +inp[5719] = 0; +inp[5720] = 1061750659; +inp[5721] = 0; +inp[5722] = 1061491474; +inp[5723] = 0; +inp[5724] = 1061232352; +inp[5725] = 0; +inp[5726] = 1060973294; +inp[5727] = 0; +inp[5728] = 1060714299; +inp[5729] = 0; +inp[5730] = 1060455367; +inp[5731] = 0; +inp[5732] = 1060196498; +inp[5733] = 0; +inp[5734] = 1059937693; +inp[5735] = 0; +inp[5736] = 1059678951; +inp[5737] = 0; +inp[5738] = 1059420272; +inp[5739] = 0; +inp[5740] = 1059161656; +inp[5741] = 0; +inp[5742] = 1058903103; +inp[5743] = 0; +inp[5744] = 1058644613; +inp[5745] = 0; +inp[5746] = 1058386187; +inp[5747] = 0; +inp[5748] = 1058127823; +inp[5749] = 0; +inp[5750] = 1057869523; +inp[5751] = 0; +inp[5752] = 1057611285; +inp[5753] = 0; +inp[5754] = 1057353111; +inp[5755] = 0; +inp[5756] = 1073741824; +inp[5757] = 1073741824; +inp[5758] = 1073610759; +inp[5759] = 0; +inp[5760] = 1073479711; +inp[5761] = 0; +inp[5762] = 1073348679; +inp[5763] = 0; +inp[5764] = 1073217663; +inp[5765] = 0; +inp[5766] = 1073086663; +inp[5767] = 0; +inp[5768] = 1072955679; +inp[5769] = 0; +inp[5770] = 1072824711; +inp[5771] = 0; +inp[5772] = 1072693759; +inp[5773] = 0; +inp[5774] = 1072562823; +inp[5775] = 0; +inp[5776] = 1072431903; +inp[5777] = 0; +inp[5778] = 1072300999; +inp[5779] = 0; +inp[5780] = 1072170111; +inp[5781] = 0; +inp[5782] = 1072039239; +inp[5783] = 0; +inp[5784] = 1071908383; +inp[5785] = 0; +inp[5786] = 1071777542; +inp[5787] = 0; +inp[5788] = 1071646718; +inp[5789] = 0; +inp[5790] = 1071515910; +inp[5791] = 0; +inp[5792] = 1071385118; +inp[5793] = 0; +inp[5794] = 1071254341; +inp[5795] = 0; +inp[5796] = 1071123581; +inp[5797] = 0; +inp[5798] = 1070992836; +inp[5799] = 0; +inp[5800] = 1070862108; +inp[5801] = 0; +inp[5802] = 1070731396; +inp[5803] = 0; +inp[5804] = 1070600699; +inp[5805] = 0; +inp[5806] = 1070470018; +inp[5807] = 0; +inp[5808] = 1070339354; +inp[5809] = 0; +inp[5810] = 1070208705; +inp[5811] = 0; +inp[5812] = 1070078072; +inp[5813] = 0; +inp[5814] = 1069947456; +inp[5815] = 0; +inp[5816] = 1069816855; +inp[5817] = 0; +inp[5818] = 1069686270; +inp[5819] = 0; +inp[5820] = 1069555701; +inp[5821] = 0; +inp[5822] = 1069425148; +inp[5823] = 0; +inp[5824] = 1069294611; +inp[5825] = 0; +inp[5826] = 1069164090; +inp[5827] = 0; +inp[5828] = 1069033584; +inp[5829] = 0; +inp[5830] = 1068903095; +inp[5831] = 0; +inp[5832] = 1068772622; +inp[5833] = 0; +inp[5834] = 1068642164; +inp[5835] = 0; +inp[5836] = 1068511723; +inp[5837] = 0; +inp[5838] = 1068381297; +inp[5839] = 0; +inp[5840] = 1068250887; +inp[5841] = 0; +inp[5842] = 1068120494; +inp[5843] = 0; +inp[5844] = 1067990116; +inp[5845] = 0; +inp[5846] = 1067859754; +inp[5847] = 0; +inp[5848] = 1067729408; +inp[5849] = 0; +inp[5850] = 1067599078; +inp[5851] = 0; +inp[5852] = 1067468764; +inp[5853] = 0; +inp[5854] = 1067338465; +inp[5855] = 0; +inp[5856] = 1067208183; +inp[5857] = 0; +inp[5858] = 1067077916; +inp[5859] = 0; +inp[5860] = 1066947666; +inp[5861] = 0; +inp[5862] = 1066817431; +inp[5863] = 0; +inp[5864] = 1066687212; +inp[5865] = 0; +inp[5866] = 1066557009; +inp[5867] = 0; +inp[5868] = 1066426822; +inp[5869] = 0; +inp[5870] = 1066296651; +inp[5871] = 0; +inp[5872] = 1066166496; +inp[5873] = 0; +inp[5874] = 1066036357; +inp[5875] = 0; +inp[5876] = 1065906233; +inp[5877] = 0; +inp[5878] = 1065776126; +inp[5879] = 0; +inp[5880] = 1065646034; +inp[5881] = 0; +inp[5882] = 1065515958; +inp[5883] = 0; +inp[5884] = 1073741824; +inp[5885] = 1073741824; +inp[5886] = 1073676289; +inp[5887] = 0; +inp[5888] = 1073610759; +inp[5889] = 0; +inp[5890] = 1073545233; +inp[5891] = 0; +inp[5892] = 1073479711; +inp[5893] = 0; +inp[5894] = 1073414193; +inp[5895] = 0; +inp[5896] = 1073348679; +inp[5897] = 0; +inp[5898] = 1073283169; +inp[5899] = 0; +inp[5900] = 1073217663; +inp[5901] = 0; +inp[5902] = 1073152161; +inp[5903] = 0; +inp[5904] = 1073086663; +inp[5905] = 0; +inp[5906] = 1073021169; +inp[5907] = 0; +inp[5908] = 1072955679; +inp[5909] = 0; +inp[5910] = 1072890193; +inp[5911] = 0; +inp[5912] = 1072824711; +inp[5913] = 0; +inp[5914] = 1072759233; +inp[5915] = 0; +inp[5916] = 1072693759; +inp[5917] = 0; +inp[5918] = 1072628289; +inp[5919] = 0; +inp[5920] = 1072562823; +inp[5921] = 0; +inp[5922] = 1072497361; +inp[5923] = 0; +inp[5924] = 1072431903; +inp[5925] = 0; +inp[5926] = 1072366449; +inp[5927] = 0; +inp[5928] = 1072300999; +inp[5929] = 0; +inp[5930] = 1072235553; +inp[5931] = 0; +inp[5932] = 1072170111; +inp[5933] = 0; +inp[5934] = 1072104673; +inp[5935] = 0; +inp[5936] = 1072039239; +inp[5937] = 0; +inp[5938] = 1071973809; +inp[5939] = 0; +inp[5940] = 1071908383; +inp[5941] = 0; +inp[5942] = 1071842961; +inp[5943] = 0; +inp[5944] = 1071777542; +inp[5945] = 0; +inp[5946] = 1071712128; +inp[5947] = 0; +inp[5948] = 1071646718; +inp[5949] = 0; +inp[5950] = 1071581312; +inp[5951] = 0; +inp[5952] = 1071515910; +inp[5953] = 0; +inp[5954] = 1071450512; +inp[5955] = 0; +inp[5956] = 1071385118; +inp[5957] = 0; +inp[5958] = 1071319727; +inp[5959] = 0; +inp[5960] = 1071254341; +inp[5961] = 0; +inp[5962] = 1071188959; +inp[5963] = 0; +inp[5964] = 1071123581; +inp[5965] = 0; +inp[5966] = 1071058207; +inp[5967] = 0; +inp[5968] = 1070992836; +inp[5969] = 0; +inp[5970] = 1070927470; +inp[5971] = 0; +inp[5972] = 1070862108; +inp[5973] = 0; +inp[5974] = 1070796750; +inp[5975] = 0; +inp[5976] = 1070731396; +inp[5977] = 0; +inp[5978] = 1070666045; +inp[5979] = 0; +inp[5980] = 1070600699; +inp[5981] = 0; +inp[5982] = 1070535357; +inp[5983] = 0; +inp[5984] = 1070470018; +inp[5985] = 0; +inp[5986] = 1070404684; +inp[5987] = 0; +inp[5988] = 1070339354; +inp[5989] = 0; +inp[5990] = 1070274027; +inp[5991] = 0; +inp[5992] = 1070208705; +inp[5993] = 0; +inp[5994] = 1070143387; +inp[5995] = 0; +inp[5996] = 1070078072; +inp[5997] = 0; +inp[5998] = 1070012762; +inp[5999] = 0; +inp[6000] = 1069947456; +inp[6001] = 0; +inp[6002] = 1069882153; +inp[6003] = 0; +inp[6004] = 1069816855; +inp[6005] = 0; +inp[6006] = 1069751560; +inp[6007] = 0; +inp[6008] = 1069686270; +inp[6009] = 0; +inp[6010] = 1069620983; +inp[6011] = 0; +inp[6012] = 1073741824; +inp[6013] = 1073741824; +inp[6014] = 1073709056; +inp[6015] = 0; +inp[6016] = 1073676289; +inp[6017] = 0; +inp[6018] = 1073643524; +inp[6019] = 0; +inp[6020] = 1073610759; +inp[6021] = 0; +inp[6022] = 1073577996; +inp[6023] = 0; +inp[6024] = 1073545233; +inp[6025] = 0; +inp[6026] = 1073512472; +inp[6027] = 0; +inp[6028] = 1073479711; +inp[6029] = 0; +inp[6030] = 1073446952; +inp[6031] = 0; +inp[6032] = 1073414193; +inp[6033] = 0; +inp[6034] = 1073381436; +inp[6035] = 0; +inp[6036] = 1073348679; +inp[6037] = 0; +inp[6038] = 1073315924; +inp[6039] = 0; +inp[6040] = 1073283169; +inp[6041] = 0; +inp[6042] = 1073250416; +inp[6043] = 0; +inp[6044] = 1073217663; +inp[6045] = 0; +inp[6046] = 1073184912; +inp[6047] = 0; +inp[6048] = 1073152161; +inp[6049] = 0; +inp[6050] = 1073119412; +inp[6051] = 0; +inp[6052] = 1073086663; +inp[6053] = 0; +inp[6054] = 1073053916; +inp[6055] = 0; +inp[6056] = 1073021169; +inp[6057] = 0; +inp[6058] = 1072988424; +inp[6059] = 0; +inp[6060] = 1072955679; +inp[6061] = 0; +inp[6062] = 1072922936; +inp[6063] = 0; +inp[6064] = 1072890193; +inp[6065] = 0; +inp[6066] = 1072857452; +inp[6067] = 0; +inp[6068] = 1072824711; +inp[6069] = 0; +inp[6070] = 1072791972; +inp[6071] = 0; +inp[6072] = 1072759233; +inp[6073] = 0; +inp[6074] = 1072726496; +inp[6075] = 0; +inp[6076] = 1072693759; +inp[6077] = 0; +inp[6078] = 1072661024; +inp[6079] = 0; +inp[6080] = 1072628289; +inp[6081] = 0; +inp[6082] = 1072595556; +inp[6083] = 0; +inp[6084] = 1072562823; +inp[6085] = 0; +inp[6086] = 1072530092; +inp[6087] = 0; +inp[6088] = 1072497361; +inp[6089] = 0; +inp[6090] = 1072464632; +inp[6091] = 0; +inp[6092] = 1072431903; +inp[6093] = 0; +inp[6094] = 1072399176; +inp[6095] = 0; +inp[6096] = 1072366449; +inp[6097] = 0; +inp[6098] = 1072333724; +inp[6099] = 0; +inp[6100] = 1072300999; +inp[6101] = 0; +inp[6102] = 1072268276; +inp[6103] = 0; +inp[6104] = 1072235553; +inp[6105] = 0; +inp[6106] = 1072202831; +inp[6107] = 0; +inp[6108] = 1072170111; +inp[6109] = 0; +inp[6110] = 1072137391; +inp[6111] = 0; +inp[6112] = 1072104673; +inp[6113] = 0; +inp[6114] = 1072071955; +inp[6115] = 0; +inp[6116] = 1072039239; +inp[6117] = 0; +inp[6118] = 1072006523; +inp[6119] = 0; +inp[6120] = 1071973809; +inp[6121] = 0; +inp[6122] = 1071941095; +inp[6123] = 0; +inp[6124] = 1071908383; +inp[6125] = 0; +inp[6126] = 1071875671; +inp[6127] = 0; +inp[6128] = 1071842961; +inp[6129] = 0; +inp[6130] = 1071810251; +inp[6131] = 0; +inp[6132] = 1071777542; +inp[6133] = 0; +inp[6134] = 1071744835; +inp[6135] = 0; +inp[6136] = 1071712128; +inp[6137] = 0; +inp[6138] = 1071679423; +inp[6139] = 0; +inp[6140] = 1073741824; +inp[6141] = 1073741824; +inp[6142] = 1073725440; +inp[6143] = 0; +inp[6144] = 1073709056; +inp[6145] = 0; +inp[6146] = 1073692673; +inp[6147] = 0; +inp[6148] = 1073676289; +inp[6149] = 0; +inp[6150] = 1073659907; +inp[6151] = 0; +inp[6152] = 1073643524; +inp[6153] = 0; +inp[6154] = 1073627142; +inp[6155] = 0; +inp[6156] = 1073610759; +inp[6157] = 0; +inp[6158] = 1073594378; +inp[6159] = 0; +inp[6160] = 1073577996; +inp[6161] = 0; +inp[6162] = 1073561615; +inp[6163] = 0; +inp[6164] = 1073545233; +inp[6165] = 0; +inp[6166] = 1073528853; +inp[6167] = 0; +inp[6168] = 1073512472; +inp[6169] = 0; +inp[6170] = 1073496092; +inp[6171] = 0; +inp[6172] = 1073479711; +inp[6173] = 0; +inp[6174] = 1073463332; +inp[6175] = 0; +inp[6176] = 1073446952; +inp[6177] = 0; +inp[6178] = 1073430573; +inp[6179] = 0; +inp[6180] = 1073414193; +inp[6181] = 0; +inp[6182] = 1073397815; +inp[6183] = 0; +inp[6184] = 1073381436; +inp[6185] = 0; +inp[6186] = 1073365058; +inp[6187] = 0; +inp[6188] = 1073348679; +inp[6189] = 0; +inp[6190] = 1073332302; +inp[6191] = 0; +inp[6192] = 1073315924; +inp[6193] = 0; +inp[6194] = 1073299547; +inp[6195] = 0; +inp[6196] = 1073283169; +inp[6197] = 0; +inp[6198] = 1073266793; +inp[6199] = 0; +inp[6200] = 1073250416; +inp[6201] = 0; +inp[6202] = 1073234040; +inp[6203] = 0; +inp[6204] = 1073217663; +inp[6205] = 0; +inp[6206] = 1073201288; +inp[6207] = 0; +inp[6208] = 1073184912; +inp[6209] = 0; +inp[6210] = 1073168537; +inp[6211] = 0; +inp[6212] = 1073152161; +inp[6213] = 0; +inp[6214] = 1073135787; +inp[6215] = 0; +inp[6216] = 1073119412; +inp[6217] = 0; +inp[6218] = 1073103038; +inp[6219] = 0; +inp[6220] = 1073086663; +inp[6221] = 0; +inp[6222] = 1073070290; +inp[6223] = 0; +inp[6224] = 1073053916; +inp[6225] = 0; +inp[6226] = 1073037543; +inp[6227] = 0; +inp[6228] = 1073021169; +inp[6229] = 0; +inp[6230] = 1073004797; +inp[6231] = 0; +inp[6232] = 1072988424; +inp[6233] = 0; +inp[6234] = 1072972052; +inp[6235] = 0; +inp[6236] = 1072955679; +inp[6237] = 0; +inp[6238] = 1072939308; +inp[6239] = 0; +inp[6240] = 1072922936; +inp[6241] = 0; +inp[6242] = 1072906565; +inp[6243] = 0; +inp[6244] = 1072890193; +inp[6245] = 0; +inp[6246] = 1072873823; +inp[6247] = 0; +inp[6248] = 1072857452; +inp[6249] = 0; +inp[6250] = 1072841082; +inp[6251] = 0; +inp[6252] = 1072824711; +inp[6253] = 0; +inp[6254] = 1072808342; +inp[6255] = 0; +inp[6256] = 1072791972; +inp[6257] = 0; +inp[6258] = 1072775602; +inp[6259] = 0; +inp[6260] = 1072759233; +inp[6261] = 0; +inp[6262] = 1072742864; +inp[6263] = 0; +inp[6264] = 1072726496; +inp[6265] = 0; +inp[6266] = 1072710127; +inp[6267] = 0; +inp[6268] = 1073741824; +inp[6269] = 1073741824; +inp[6270] = 1073733632; +inp[6271] = 0; +inp[6272] = 1073725440; +inp[6273] = 0; +inp[6274] = 1073717248; +inp[6275] = 0; +inp[6276] = 1073709056; +inp[6277] = 0; +inp[6278] = 1073700864; +inp[6279] = 0; +inp[6280] = 1073692673; +inp[6281] = 0; +inp[6282] = 1073684481; +inp[6283] = 0; +inp[6284] = 1073676289; +inp[6285] = 0; +inp[6286] = 1073668098; +inp[6287] = 0; +inp[6288] = 1073659907; +inp[6289] = 0; +inp[6290] = 1073651715; +inp[6291] = 0; +inp[6292] = 1073643524; +inp[6293] = 0; +inp[6294] = 1073635333; +inp[6295] = 0; +inp[6296] = 1073627142; +inp[6297] = 0; +inp[6298] = 1073618951; +inp[6299] = 0; +inp[6300] = 1073610759; +inp[6301] = 0; +inp[6302] = 1073602569; +inp[6303] = 0; +inp[6304] = 1073594378; +inp[6305] = 0; +inp[6306] = 1073586187; +inp[6307] = 0; +inp[6308] = 1073577996; +inp[6309] = 0; +inp[6310] = 1073569805; +inp[6311] = 0; +inp[6312] = 1073561615; +inp[6313] = 0; +inp[6314] = 1073553424; +inp[6315] = 0; +inp[6316] = 1073545233; +inp[6317] = 0; +inp[6318] = 1073537043; +inp[6319] = 0; +inp[6320] = 1073528853; +inp[6321] = 0; +inp[6322] = 1073520662; +inp[6323] = 0; +inp[6324] = 1073512472; +inp[6325] = 0; +inp[6326] = 1073504282; +inp[6327] = 0; +inp[6328] = 1073496092; +inp[6329] = 0; +inp[6330] = 1073487902; +inp[6331] = 0; +inp[6332] = 1073479711; +inp[6333] = 0; +inp[6334] = 1073471522; +inp[6335] = 0; +inp[6336] = 1073463332; +inp[6337] = 0; +inp[6338] = 1073455142; +inp[6339] = 0; +inp[6340] = 1073446952; +inp[6341] = 0; +inp[6342] = 1073438762; +inp[6343] = 0; +inp[6344] = 1073430573; +inp[6345] = 0; +inp[6346] = 1073422383; +inp[6347] = 0; +inp[6348] = 1073414193; +inp[6349] = 0; +inp[6350] = 1073406004; +inp[6351] = 0; +inp[6352] = 1073397815; +inp[6353] = 0; +inp[6354] = 1073389625; +inp[6355] = 0; +inp[6356] = 1073381436; +inp[6357] = 0; +inp[6358] = 1073373247; +inp[6359] = 0; +inp[6360] = 1073365058; +inp[6361] = 0; +inp[6362] = 1073356869; +inp[6363] = 0; +inp[6364] = 1073348679; +inp[6365] = 0; +inp[6366] = 1073340491; +inp[6367] = 0; +inp[6368] = 1073332302; +inp[6369] = 0; +inp[6370] = 1073324113; +inp[6371] = 0; +inp[6372] = 1073315924; +inp[6373] = 0; +inp[6374] = 1073307735; +inp[6375] = 0; +inp[6376] = 1073299547; +inp[6377] = 0; +inp[6378] = 1073291358; +inp[6379] = 0; +inp[6380] = 1073283169; +inp[6381] = 0; +inp[6382] = 1073274981; +inp[6383] = 0; +inp[6384] = 1073266793; +inp[6385] = 0; +inp[6386] = 1073258604; +inp[6387] = 0; +inp[6388] = 1073250416; +inp[6389] = 0; +inp[6390] = 1073242228; +inp[6391] = 0; +inp[6392] = 1073234040; +inp[6393] = 0; +inp[6394] = 1073225852; +inp[6395] = 0; +inp[6396] = 1073741824; +inp[6397] = 1073741824; +inp[6398] = 1073737728; +inp[6399] = 0; +inp[6400] = 1073733632; +inp[6401] = 0; +inp[6402] = 1073729536; +inp[6403] = 0; +inp[6404] = 1073725440; +inp[6405] = 0; +inp[6406] = 1073721344; +inp[6407] = 0; +inp[6408] = 1073717248; +inp[6409] = 0; +inp[6410] = 1073713152; +inp[6411] = 0; +inp[6412] = 1073709056; +inp[6413] = 0; +inp[6414] = 1073704960; +inp[6415] = 0; +inp[6416] = 1073700864; +inp[6417] = 0; +inp[6418] = 1073696768; +inp[6419] = 0; +inp[6420] = 1073692673; +inp[6421] = 0; +inp[6422] = 1073688577; +inp[6423] = 0; +inp[6424] = 1073684481; +inp[6425] = 0; +inp[6426] = 1073680385; +inp[6427] = 0; +inp[6428] = 1073676289; +inp[6429] = 0; +inp[6430] = 1073672194; +inp[6431] = 0; +inp[6432] = 1073668098; +inp[6433] = 0; +inp[6434] = 1073664002; +inp[6435] = 0; +inp[6436] = 1073659907; +inp[6437] = 0; +inp[6438] = 1073655811; +inp[6439] = 0; +inp[6440] = 1073651715; +inp[6441] = 0; +inp[6442] = 1073647620; +inp[6443] = 0; +inp[6444] = 1073643524; +inp[6445] = 0; +inp[6446] = 1073639428; +inp[6447] = 0; +inp[6448] = 1073635333; +inp[6449] = 0; +inp[6450] = 1073631237; +inp[6451] = 0; +inp[6452] = 1073627142; +inp[6453] = 0; +inp[6454] = 1073623046; +inp[6455] = 0; +inp[6456] = 1073618951; +inp[6457] = 0; +inp[6458] = 1073614855; +inp[6459] = 0; +inp[6460] = 1073610759; +inp[6461] = 0; +inp[6462] = 1073606664; +inp[6463] = 0; +inp[6464] = 1073602569; +inp[6465] = 0; +inp[6466] = 1073598473; +inp[6467] = 0; +inp[6468] = 1073594378; +inp[6469] = 0; +inp[6470] = 1073590282; +inp[6471] = 0; +inp[6472] = 1073586187; +inp[6473] = 0; +inp[6474] = 1073582091; +inp[6475] = 0; +inp[6476] = 1073577996; +inp[6477] = 0; +inp[6478] = 1073573901; +inp[6479] = 0; +inp[6480] = 1073569805; +inp[6481] = 0; +inp[6482] = 1073565710; +inp[6483] = 0; +inp[6484] = 1073561615; +inp[6485] = 0; +inp[6486] = 1073557519; +inp[6487] = 0; +inp[6488] = 1073553424; +inp[6489] = 0; +inp[6490] = 1073549329; +inp[6491] = 0; +inp[6492] = 1073545233; +inp[6493] = 0; +inp[6494] = 1073541138; +inp[6495] = 0; +inp[6496] = 1073537043; +inp[6497] = 0; +inp[6498] = 1073532948; +inp[6499] = 0; +inp[6500] = 1073528853; +inp[6501] = 0; +inp[6502] = 1073524757; +inp[6503] = 0; +inp[6504] = 1073520662; +inp[6505] = 0; +inp[6506] = 1073516567; +inp[6507] = 0; +inp[6508] = 1073512472; +inp[6509] = 0; +inp[6510] = 1073508377; +inp[6511] = 0; +inp[6512] = 1073504282; +inp[6513] = 0; +inp[6514] = 1073500187; +inp[6515] = 0; +inp[6516] = 1073496092; +inp[6517] = 0; +inp[6518] = 1073491997; +inp[6519] = 0; +inp[6520] = 1073487902; +inp[6521] = 0; +inp[6522] = 1073483807; +inp[6523] = 0; +inp[6524] = 1073741824; +inp[6525] = 1073741824; +inp[6526] = 1073739776; +inp[6527] = 0; +inp[6528] = 1073737728; +inp[6529] = 0; +inp[6530] = 1073735680; +inp[6531] = 0; +inp[6532] = 1073733632; +inp[6533] = 0; +inp[6534] = 1073731584; +inp[6535] = 0; +inp[6536] = 1073729536; +inp[6537] = 0; +inp[6538] = 1073727488; +inp[6539] = 0; +inp[6540] = 1073725440; +inp[6541] = 0; +inp[6542] = 1073723392; +inp[6543] = 0; +inp[6544] = 1073721344; +inp[6545] = 0; +inp[6546] = 1073719296; +inp[6547] = 0; +inp[6548] = 1073717248; +inp[6549] = 0; +inp[6550] = 1073715200; +inp[6551] = 0; +inp[6552] = 1073713152; +inp[6553] = 0; +inp[6554] = 1073711104; +inp[6555] = 0; +inp[6556] = 1073709056; +inp[6557] = 0; +inp[6558] = 1073707008; +inp[6559] = 0; +inp[6560] = 1073704960; +inp[6561] = 0; +inp[6562] = 1073702912; +inp[6563] = 0; +inp[6564] = 1073700864; +inp[6565] = 0; +inp[6566] = 1073698816; +inp[6567] = 0; +inp[6568] = 1073696768; +inp[6569] = 0; +inp[6570] = 1073694721; +inp[6571] = 0; +inp[6572] = 1073692673; +inp[6573] = 0; +inp[6574] = 1073690625; +inp[6575] = 0; +inp[6576] = 1073688577; +inp[6577] = 0; +inp[6578] = 1073686529; +inp[6579] = 0; +inp[6580] = 1073684481; +inp[6581] = 0; +inp[6582] = 1073682433; +inp[6583] = 0; +inp[6584] = 1073680385; +inp[6585] = 0; +inp[6586] = 1073678337; +inp[6587] = 0; +inp[6588] = 1073676289; +inp[6589] = 0; +inp[6590] = 1073674242; +inp[6591] = 0; +inp[6592] = 1073672194; +inp[6593] = 0; +inp[6594] = 1073670146; +inp[6595] = 0; +inp[6596] = 1073668098; +inp[6597] = 0; +inp[6598] = 1073666050; +inp[6599] = 0; +inp[6600] = 1073664002; +inp[6601] = 0; +inp[6602] = 1073661954; +inp[6603] = 0; +inp[6604] = 1073659907; +inp[6605] = 0; +inp[6606] = 1073657859; +inp[6607] = 0; +inp[6608] = 1073655811; +inp[6609] = 0; +inp[6610] = 1073653763; +inp[6611] = 0; +inp[6612] = 1073651715; +inp[6613] = 0; +inp[6614] = 1073649667; +inp[6615] = 0; +inp[6616] = 1073647620; +inp[6617] = 0; +inp[6618] = 1073645572; +inp[6619] = 0; +inp[6620] = 1073643524; +inp[6621] = 0; +inp[6622] = 1073641476; +inp[6623] = 0; +inp[6624] = 1073639428; +inp[6625] = 0; +inp[6626] = 1073637381; +inp[6627] = 0; +inp[6628] = 1073635333; +inp[6629] = 0; +inp[6630] = 1073633285; +inp[6631] = 0; +inp[6632] = 1073631237; +inp[6633] = 0; +inp[6634] = 1073629189; +inp[6635] = 0; +inp[6636] = 1073627142; +inp[6637] = 0; +inp[6638] = 1073625094; +inp[6639] = 0; +inp[6640] = 1073623046; +inp[6641] = 0; +inp[6642] = 1073620998; +inp[6643] = 0; +inp[6644] = 1073618951; +inp[6645] = 0; +inp[6646] = 1073616903; +inp[6647] = 0; +inp[6648] = 1073614855; +inp[6649] = 0; +inp[6650] = 1073612807; +inp[6651] = 0; +inp[6652] = 1073741824; +inp[6653] = 1073741824; +inp[6654] = 1073740800; +inp[6655] = 0; +inp[6656] = 1073739776; +inp[6657] = 0; +inp[6658] = 1073738752; +inp[6659] = 0; +inp[6660] = 1073737728; +inp[6661] = 0; +inp[6662] = 1073736704; +inp[6663] = 0; +inp[6664] = 1073735680; +inp[6665] = 0; +inp[6666] = 1073734656; +inp[6667] = 0; +inp[6668] = 1073733632; +inp[6669] = 0; +inp[6670] = 1073732608; +inp[6671] = 0; +inp[6672] = 1073731584; +inp[6673] = 0; +inp[6674] = 1073730560; +inp[6675] = 0; +inp[6676] = 1073729536; +inp[6677] = 0; +inp[6678] = 1073728512; +inp[6679] = 0; +inp[6680] = 1073727488; +inp[6681] = 0; +inp[6682] = 1073726464; +inp[6683] = 0; +inp[6684] = 1073725440; +inp[6685] = 0; +inp[6686] = 1073724416; +inp[6687] = 0; +inp[6688] = 1073723392; +inp[6689] = 0; +inp[6690] = 1073722368; +inp[6691] = 0; +inp[6692] = 1073721344; +inp[6693] = 0; +inp[6694] = 1073720320; +inp[6695] = 0; +inp[6696] = 1073719296; +inp[6697] = 0; +inp[6698] = 1073718272; +inp[6699] = 0; +inp[6700] = 1073717248; +inp[6701] = 0; +inp[6702] = 1073716224; +inp[6703] = 0; +inp[6704] = 1073715200; +inp[6705] = 0; +inp[6706] = 1073714176; +inp[6707] = 0; +inp[6708] = 1073713152; +inp[6709] = 0; +inp[6710] = 1073712128; +inp[6711] = 0; +inp[6712] = 1073711104; +inp[6713] = 0; +inp[6714] = 1073710080; +inp[6715] = 0; +inp[6716] = 1073709056; +inp[6717] = 0; +inp[6718] = 1073708032; +inp[6719] = 0; +inp[6720] = 1073707008; +inp[6721] = 0; +inp[6722] = 1073705984; +inp[6723] = 0; +inp[6724] = 1073704960; +inp[6725] = 0; +inp[6726] = 1073703936; +inp[6727] = 0; +inp[6728] = 1073702912; +inp[6729] = 0; +inp[6730] = 1073701888; +inp[6731] = 0; +inp[6732] = 1073700864; +inp[6733] = 0; +inp[6734] = 1073699840; +inp[6735] = 0; +inp[6736] = 1073698816; +inp[6737] = 0; +inp[6738] = 1073697792; +inp[6739] = 0; +inp[6740] = 1073696768; +inp[6741] = 0; +inp[6742] = 1073695744; +inp[6743] = 0; +inp[6744] = 1073694721; +inp[6745] = 0; +inp[6746] = 1073693697; +inp[6747] = 0; +inp[6748] = 1073692673; +inp[6749] = 0; +inp[6750] = 1073691649; +inp[6751] = 0; +inp[6752] = 1073690625; +inp[6753] = 0; +inp[6754] = 1073689601; +inp[6755] = 0; +inp[6756] = 1073688577; +inp[6757] = 0; +inp[6758] = 1073687553; +inp[6759] = 0; +inp[6760] = 1073686529; +inp[6761] = 0; +inp[6762] = 1073685505; +inp[6763] = 0; +inp[6764] = 1073684481; +inp[6765] = 0; +inp[6766] = 1073683457; +inp[6767] = 0; +inp[6768] = 1073682433; +inp[6769] = 0; +inp[6770] = 1073681409; +inp[6771] = 0; +inp[6772] = 1073680385; +inp[6773] = 0; +inp[6774] = 1073679361; +inp[6775] = 0; +inp[6776] = 1073678337; +inp[6777] = 0; +inp[6778] = 1073677313; +inp[6779] = 0; +inp[6780] = 1073741824; +inp[6781] = 1073741824; +inp[6782] = 1073741312; +inp[6783] = 0; +inp[6784] = 1073740800; +inp[6785] = 0; +inp[6786] = 1073740288; +inp[6787] = 0; +inp[6788] = 1073739776; +inp[6789] = 0; +inp[6790] = 1073739264; +inp[6791] = 0; +inp[6792] = 1073738752; +inp[6793] = 0; +inp[6794] = 1073738240; +inp[6795] = 0; +inp[6796] = 1073737728; +inp[6797] = 0; +inp[6798] = 1073737216; +inp[6799] = 0; +inp[6800] = 1073736704; +inp[6801] = 0; +inp[6802] = 1073736192; +inp[6803] = 0; +inp[6804] = 1073735680; +inp[6805] = 0; +inp[6806] = 1073735168; +inp[6807] = 0; +inp[6808] = 1073734656; +inp[6809] = 0; +inp[6810] = 1073734144; +inp[6811] = 0; +inp[6812] = 1073733632; +inp[6813] = 0; +inp[6814] = 1073733120; +inp[6815] = 0; +inp[6816] = 1073732608; +inp[6817] = 0; +inp[6818] = 1073732096; +inp[6819] = 0; +inp[6820] = 1073731584; +inp[6821] = 0; +inp[6822] = 1073731072; +inp[6823] = 0; +inp[6824] = 1073730560; +inp[6825] = 0; +inp[6826] = 1073730048; +inp[6827] = 0; +inp[6828] = 1073729536; +inp[6829] = 0; +inp[6830] = 1073729024; +inp[6831] = 0; +inp[6832] = 1073728512; +inp[6833] = 0; +inp[6834] = 1073728000; +inp[6835] = 0; +inp[6836] = 1073727488; +inp[6837] = 0; +inp[6838] = 1073726976; +inp[6839] = 0; +inp[6840] = 1073726464; +inp[6841] = 0; +inp[6842] = 1073725952; +inp[6843] = 0; +inp[6844] = 1073725440; +inp[6845] = 0; +inp[6846] = 1073724928; +inp[6847] = 0; +inp[6848] = 1073724416; +inp[6849] = 0; +inp[6850] = 1073723904; +inp[6851] = 0; +inp[6852] = 1073723392; +inp[6853] = 0; +inp[6854] = 1073722880; +inp[6855] = 0; +inp[6856] = 1073722368; +inp[6857] = 0; +inp[6858] = 1073721856; +inp[6859] = 0; +inp[6860] = 1073721344; +inp[6861] = 0; +inp[6862] = 1073720832; +inp[6863] = 0; +inp[6864] = 1073720320; +inp[6865] = 0; +inp[6866] = 1073719808; +inp[6867] = 0; +inp[6868] = 1073719296; +inp[6869] = 0; +inp[6870] = 1073718784; +inp[6871] = 0; +inp[6872] = 1073718272; +inp[6873] = 0; +inp[6874] = 1073717760; +inp[6875] = 0; +inp[6876] = 1073717248; +inp[6877] = 0; +inp[6878] = 1073716736; +inp[6879] = 0; +inp[6880] = 1073716224; +inp[6881] = 0; +inp[6882] = 1073715712; +inp[6883] = 0; +inp[6884] = 1073715200; +inp[6885] = 0; +inp[6886] = 1073714688; +inp[6887] = 0; +inp[6888] = 1073714176; +inp[6889] = 0; +inp[6890] = 1073713664; +inp[6891] = 0; +inp[6892] = 1073713152; +inp[6893] = 0; +inp[6894] = 1073712640; +inp[6895] = 0; +inp[6896] = 1073712128; +inp[6897] = 0; +inp[6898] = 1073711616; +inp[6899] = 0; +inp[6900] = 1073711104; +inp[6901] = 0; +inp[6902] = 1073710592; +inp[6903] = 0; +inp[6904] = 1073710080; +inp[6905] = 0; +inp[6906] = 1073709568; +inp[6907] = 0; +inp[6908] = 1073741824; +inp[6909] = 1073741824; +inp[6910] = 1073741568; +inp[6911] = 0; +inp[6912] = 1073741312; +inp[6913] = 0; +inp[6914] = 1073741056; +inp[6915] = 0; +inp[6916] = 1073740800; +inp[6917] = 0; +inp[6918] = 1073740544; +inp[6919] = 0; +inp[6920] = 1073740288; +inp[6921] = 0; +inp[6922] = 1073740032; +inp[6923] = 0; +inp[6924] = 1073739776; +inp[6925] = 0; +inp[6926] = 1073739520; +inp[6927] = 0; +inp[6928] = 1073739264; +inp[6929] = 0; +inp[6930] = 1073739008; +inp[6931] = 0; +inp[6932] = 1073738752; +inp[6933] = 0; +inp[6934] = 1073738496; +inp[6935] = 0; +inp[6936] = 1073738240; +inp[6937] = 0; +inp[6938] = 1073737984; +inp[6939] = 0; +inp[6940] = 1073737728; +inp[6941] = 0; +inp[6942] = 1073737472; +inp[6943] = 0; +inp[6944] = 1073737216; +inp[6945] = 0; +inp[6946] = 1073736960; +inp[6947] = 0; +inp[6948] = 1073736704; +inp[6949] = 0; +inp[6950] = 1073736448; +inp[6951] = 0; +inp[6952] = 1073736192; +inp[6953] = 0; +inp[6954] = 1073735936; +inp[6955] = 0; +inp[6956] = 1073735680; +inp[6957] = 0; +inp[6958] = 1073735424; +inp[6959] = 0; +inp[6960] = 1073735168; +inp[6961] = 0; +inp[6962] = 1073734912; +inp[6963] = 0; +inp[6964] = 1073734656; +inp[6965] = 0; +inp[6966] = 1073734400; +inp[6967] = 0; +inp[6968] = 1073734144; +inp[6969] = 0; +inp[6970] = 1073733888; +inp[6971] = 0; +inp[6972] = 1073733632; +inp[6973] = 0; +inp[6974] = 1073733376; +inp[6975] = 0; +inp[6976] = 1073733120; +inp[6977] = 0; +inp[6978] = 1073732864; +inp[6979] = 0; +inp[6980] = 1073732608; +inp[6981] = 0; +inp[6982] = 1073732352; +inp[6983] = 0; +inp[6984] = 1073732096; +inp[6985] = 0; +inp[6986] = 1073731840; +inp[6987] = 0; +inp[6988] = 1073731584; +inp[6989] = 0; +inp[6990] = 1073731328; +inp[6991] = 0; +inp[6992] = 1073731072; +inp[6993] = 0; +inp[6994] = 1073730816; +inp[6995] = 0; +inp[6996] = 1073730560; +inp[6997] = 0; +inp[6998] = 1073730304; +inp[6999] = 0; +inp[7000] = 1073730048; +inp[7001] = 0; +inp[7002] = 1073729792; +inp[7003] = 0; +inp[7004] = 1073729536; +inp[7005] = 0; +inp[7006] = 1073729280; +inp[7007] = 0; +inp[7008] = 1073729024; +inp[7009] = 0; +inp[7010] = 1073728768; +inp[7011] = 0; +inp[7012] = 1073728512; +inp[7013] = 0; +inp[7014] = 1073728256; +inp[7015] = 0; +inp[7016] = 1073728000; +inp[7017] = 0; +inp[7018] = 1073727744; +inp[7019] = 0; +inp[7020] = 1073727488; +inp[7021] = 0; +inp[7022] = 1073727232; +inp[7023] = 0; +inp[7024] = 1073726976; +inp[7025] = 0; +inp[7026] = 1073726720; +inp[7027] = 0; +inp[7028] = 1073726464; +inp[7029] = 0; +inp[7030] = 1073726208; +inp[7031] = 0; +inp[7032] = 1073725952; +inp[7033] = 0; +inp[7034] = 1073725696; +inp[7035] = 0; +inp[7036] = 1073741824; +inp[7037] = 1073741824; +inp[7038] = 1073741696; +inp[7039] = 0; +inp[7040] = 1073741568; +inp[7041] = 0; +inp[7042] = 1073741440; +inp[7043] = 0; +inp[7044] = 1073741312; +inp[7045] = 0; +inp[7046] = 1073741184; +inp[7047] = 0; +inp[7048] = 1073741056; +inp[7049] = 0; +inp[7050] = 1073740928; +inp[7051] = 0; +inp[7052] = 1073740800; +inp[7053] = 0; +inp[7054] = 1073740672; +inp[7055] = 0; +inp[7056] = 1073740544; +inp[7057] = 0; +inp[7058] = 1073740416; +inp[7059] = 0; +inp[7060] = 1073740288; +inp[7061] = 0; +inp[7062] = 1073740160; +inp[7063] = 0; +inp[7064] = 1073740032; +inp[7065] = 0; +inp[7066] = 1073739904; +inp[7067] = 0; +inp[7068] = 1073739776; +inp[7069] = 0; +inp[7070] = 1073739648; +inp[7071] = 0; +inp[7072] = 1073739520; +inp[7073] = 0; +inp[7074] = 1073739392; +inp[7075] = 0; +inp[7076] = 1073739264; +inp[7077] = 0; +inp[7078] = 1073739136; +inp[7079] = 0; +inp[7080] = 1073739008; +inp[7081] = 0; +inp[7082] = 1073738880; +inp[7083] = 0; +inp[7084] = 1073738752; +inp[7085] = 0; +inp[7086] = 1073738624; +inp[7087] = 0; +inp[7088] = 1073738496; +inp[7089] = 0; +inp[7090] = 1073738368; +inp[7091] = 0; +inp[7092] = 1073738240; +inp[7093] = 0; +inp[7094] = 1073738112; +inp[7095] = 0; +inp[7096] = 1073737984; +inp[7097] = 0; +inp[7098] = 1073737856; +inp[7099] = 0; +inp[7100] = 1073737728; +inp[7101] = 0; +inp[7102] = 1073737600; +inp[7103] = 0; +inp[7104] = 1073737472; +inp[7105] = 0; +inp[7106] = 1073737344; +inp[7107] = 0; +inp[7108] = 1073737216; +inp[7109] = 0; +inp[7110] = 1073737088; +inp[7111] = 0; +inp[7112] = 1073736960; +inp[7113] = 0; +inp[7114] = 1073736832; +inp[7115] = 0; +inp[7116] = 1073736704; +inp[7117] = 0; +inp[7118] = 1073736576; +inp[7119] = 0; +inp[7120] = 1073736448; +inp[7121] = 0; +inp[7122] = 1073736320; +inp[7123] = 0; +inp[7124] = 1073736192; +inp[7125] = 0; +inp[7126] = 1073736064; +inp[7127] = 0; +inp[7128] = 1073735936; +inp[7129] = 0; +inp[7130] = 1073735808; +inp[7131] = 0; +inp[7132] = 1073735680; +inp[7133] = 0; +inp[7134] = 1073735552; +inp[7135] = 0; +inp[7136] = 1073735424; +inp[7137] = 0; +inp[7138] = 1073735296; +inp[7139] = 0; +inp[7140] = 1073735168; +inp[7141] = 0; +inp[7142] = 1073735040; +inp[7143] = 0; +inp[7144] = 1073734912; +inp[7145] = 0; +inp[7146] = 1073734784; +inp[7147] = 0; +inp[7148] = 1073734656; +inp[7149] = 0; +inp[7150] = 1073734528; +inp[7151] = 0; +inp[7152] = 1073734400; +inp[7153] = 0; +inp[7154] = 1073734272; +inp[7155] = 0; +inp[7156] = 1073734144; +inp[7157] = 0; +inp[7158] = 1073734016; +inp[7159] = 0; +inp[7160] = 1073733888; +inp[7161] = 0; +inp[7162] = 1073733760; +inp[7163] = 0; +inp[7164] = 1073741824; +inp[7165] = 1073741824; +inp[7166] = 1073741760; +inp[7167] = 0; +inp[7168] = 1073741696; +inp[7169] = 0; +inp[7170] = 1073741632; +inp[7171] = 0; +inp[7172] = 1073741568; +inp[7173] = 0; +inp[7174] = 1073741504; +inp[7175] = 0; +inp[7176] = 1073741440; +inp[7177] = 0; +inp[7178] = 1073741376; +inp[7179] = 0; +inp[7180] = 1073741312; +inp[7181] = 0; +inp[7182] = 1073741248; +inp[7183] = 0; +inp[7184] = 1073741184; +inp[7185] = 0; +inp[7186] = 1073741120; +inp[7187] = 0; +inp[7188] = 1073741056; +inp[7189] = 0; +inp[7190] = 1073740992; +inp[7191] = 0; +inp[7192] = 1073740928; +inp[7193] = 0; +inp[7194] = 1073740864; +inp[7195] = 0; +inp[7196] = 1073740800; +inp[7197] = 0; +inp[7198] = 1073740736; +inp[7199] = 0; +inp[7200] = 1073740672; +inp[7201] = 0; +inp[7202] = 1073740608; +inp[7203] = 0; +inp[7204] = 1073740544; +inp[7205] = 0; +inp[7206] = 1073740480; +inp[7207] = 0; +inp[7208] = 1073740416; +inp[7209] = 0; +inp[7210] = 1073740352; +inp[7211] = 0; +inp[7212] = 1073740288; +inp[7213] = 0; +inp[7214] = 1073740224; +inp[7215] = 0; +inp[7216] = 1073740160; +inp[7217] = 0; +inp[7218] = 1073740096; +inp[7219] = 0; +inp[7220] = 1073740032; +inp[7221] = 0; +inp[7222] = 1073739968; +inp[7223] = 0; +inp[7224] = 1073739904; +inp[7225] = 0; +inp[7226] = 1073739840; +inp[7227] = 0; +inp[7228] = 1073739776; +inp[7229] = 0; +inp[7230] = 1073739712; +inp[7231] = 0; +inp[7232] = 1073739648; +inp[7233] = 0; +inp[7234] = 1073739584; +inp[7235] = 0; +inp[7236] = 1073739520; +inp[7237] = 0; +inp[7238] = 1073739456; +inp[7239] = 0; +inp[7240] = 1073739392; +inp[7241] = 0; +inp[7242] = 1073739328; +inp[7243] = 0; +inp[7244] = 1073739264; +inp[7245] = 0; +inp[7246] = 1073739200; +inp[7247] = 0; +inp[7248] = 1073739136; +inp[7249] = 0; +inp[7250] = 1073739072; +inp[7251] = 0; +inp[7252] = 1073739008; +inp[7253] = 0; +inp[7254] = 1073738944; +inp[7255] = 0; +inp[7256] = 1073738880; +inp[7257] = 0; +inp[7258] = 1073738816; +inp[7259] = 0; +inp[7260] = 1073738752; +inp[7261] = 0; +inp[7262] = 1073738688; +inp[7263] = 0; +inp[7264] = 1073738624; +inp[7265] = 0; +inp[7266] = 1073738560; +inp[7267] = 0; +inp[7268] = 1073738496; +inp[7269] = 0; +inp[7270] = 1073738432; +inp[7271] = 0; +inp[7272] = 1073738368; +inp[7273] = 0; +inp[7274] = 1073738304; +inp[7275] = 0; +inp[7276] = 1073738240; +inp[7277] = 0; +inp[7278] = 1073738176; +inp[7279] = 0; +inp[7280] = 1073738112; +inp[7281] = 0; +inp[7282] = 1073738048; +inp[7283] = 0; +inp[7284] = 1073737984; +inp[7285] = 0; +inp[7286] = 1073737920; +inp[7287] = 0; +inp[7288] = 1073737856; +inp[7289] = 0; +inp[7290] = 1073737792; +inp[7291] = 0; +inp[7292] = 1073741824; +inp[7293] = 1073741824; +inp[7294] = 1073741792; +inp[7295] = 0; +inp[7296] = 1073741760; +inp[7297] = 0; +inp[7298] = 1073741728; +inp[7299] = 0; +inp[7300] = 1073741696; +inp[7301] = 0; +inp[7302] = 1073741664; +inp[7303] = 0; +inp[7304] = 1073741632; +inp[7305] = 0; +inp[7306] = 1073741600; +inp[7307] = 0; +inp[7308] = 1073741568; +inp[7309] = 0; +inp[7310] = 1073741536; +inp[7311] = 0; +inp[7312] = 1073741504; +inp[7313] = 0; +inp[7314] = 1073741472; +inp[7315] = 0; +inp[7316] = 1073741440; +inp[7317] = 0; +inp[7318] = 1073741408; +inp[7319] = 0; +inp[7320] = 1073741376; +inp[7321] = 0; +inp[7322] = 1073741344; +inp[7323] = 0; +inp[7324] = 1073741312; +inp[7325] = 0; +inp[7326] = 1073741280; +inp[7327] = 0; +inp[7328] = 1073741248; +inp[7329] = 0; +inp[7330] = 1073741216; +inp[7331] = 0; +inp[7332] = 1073741184; +inp[7333] = 0; +inp[7334] = 1073741152; +inp[7335] = 0; +inp[7336] = 1073741120; +inp[7337] = 0; +inp[7338] = 1073741088; +inp[7339] = 0; +inp[7340] = 1073741056; +inp[7341] = 0; +inp[7342] = 1073741024; +inp[7343] = 0; +inp[7344] = 1073740992; +inp[7345] = 0; +inp[7346] = 1073740960; +inp[7347] = 0; +inp[7348] = 1073740928; +inp[7349] = 0; +inp[7350] = 1073740896; +inp[7351] = 0; +inp[7352] = 1073740864; +inp[7353] = 0; +inp[7354] = 1073740832; +inp[7355] = 0; +inp[7356] = 1073740800; +inp[7357] = 0; +inp[7358] = 1073740768; +inp[7359] = 0; +inp[7360] = 1073740736; +inp[7361] = 0; +inp[7362] = 1073740704; +inp[7363] = 0; +inp[7364] = 1073740672; +inp[7365] = 0; +inp[7366] = 1073740640; +inp[7367] = 0; +inp[7368] = 1073740608; +inp[7369] = 0; +inp[7370] = 1073740576; +inp[7371] = 0; +inp[7372] = 1073740544; +inp[7373] = 0; +inp[7374] = 1073740512; +inp[7375] = 0; +inp[7376] = 1073740480; +inp[7377] = 0; +inp[7378] = 1073740448; +inp[7379] = 0; +inp[7380] = 1073740416; +inp[7381] = 0; +inp[7382] = 1073740384; +inp[7383] = 0; +inp[7384] = 1073740352; +inp[7385] = 0; +inp[7386] = 1073740320; +inp[7387] = 0; +inp[7388] = 1073740288; +inp[7389] = 0; +inp[7390] = 1073740256; +inp[7391] = 0; +inp[7392] = 1073740224; +inp[7393] = 0; +inp[7394] = 1073740192; +inp[7395] = 0; +inp[7396] = 1073740160; +inp[7397] = 0; +inp[7398] = 1073740128; +inp[7399] = 0; +inp[7400] = 1073740096; +inp[7401] = 0; +inp[7402] = 1073740064; +inp[7403] = 0; +inp[7404] = 1073740032; +inp[7405] = 0; +inp[7406] = 1073740000; +inp[7407] = 0; +inp[7408] = 1073739968; +inp[7409] = 0; +inp[7410] = 1073739936; +inp[7411] = 0; +inp[7412] = 1073739904; +inp[7413] = 0; +inp[7414] = 1073739872; +inp[7415] = 0; +inp[7416] = 1073739840; +inp[7417] = 0; +inp[7418] = 1073739808; +inp[7419] = 0; +inp[7420] = 1073741824; +inp[7421] = 1073741824; +inp[7422] = 1073741808; +inp[7423] = 0; +inp[7424] = 1073741792; +inp[7425] = 0; +inp[7426] = 1073741776; +inp[7427] = 0; +inp[7428] = 1073741760; +inp[7429] = 0; +inp[7430] = 1073741744; +inp[7431] = 0; +inp[7432] = 1073741728; +inp[7433] = 0; +inp[7434] = 1073741712; +inp[7435] = 0; +inp[7436] = 1073741696; +inp[7437] = 0; +inp[7438] = 1073741680; +inp[7439] = 0; +inp[7440] = 1073741664; +inp[7441] = 0; +inp[7442] = 1073741648; +inp[7443] = 0; +inp[7444] = 1073741632; +inp[7445] = 0; +inp[7446] = 1073741616; +inp[7447] = 0; +inp[7448] = 1073741600; +inp[7449] = 0; +inp[7450] = 1073741584; +inp[7451] = 0; +inp[7452] = 1073741568; +inp[7453] = 0; +inp[7454] = 1073741552; +inp[7455] = 0; +inp[7456] = 1073741536; +inp[7457] = 0; +inp[7458] = 1073741520; +inp[7459] = 0; +inp[7460] = 1073741504; +inp[7461] = 0; +inp[7462] = 1073741488; +inp[7463] = 0; +inp[7464] = 1073741472; +inp[7465] = 0; +inp[7466] = 1073741456; +inp[7467] = 0; +inp[7468] = 1073741440; +inp[7469] = 0; +inp[7470] = 1073741424; +inp[7471] = 0; +inp[7472] = 1073741408; +inp[7473] = 0; +inp[7474] = 1073741392; +inp[7475] = 0; +inp[7476] = 1073741376; +inp[7477] = 0; +inp[7478] = 1073741360; +inp[7479] = 0; +inp[7480] = 1073741344; +inp[7481] = 0; +inp[7482] = 1073741328; +inp[7483] = 0; +inp[7484] = 1073741312; +inp[7485] = 0; +inp[7486] = 1073741296; +inp[7487] = 0; +inp[7488] = 1073741280; +inp[7489] = 0; +inp[7490] = 1073741264; +inp[7491] = 0; +inp[7492] = 1073741248; +inp[7493] = 0; +inp[7494] = 1073741232; +inp[7495] = 0; +inp[7496] = 1073741216; +inp[7497] = 0; +inp[7498] = 1073741200; +inp[7499] = 0; +inp[7500] = 1073741184; +inp[7501] = 0; +inp[7502] = 1073741168; +inp[7503] = 0; +inp[7504] = 1073741152; +inp[7505] = 0; +inp[7506] = 1073741136; +inp[7507] = 0; +inp[7508] = 1073741120; +inp[7509] = 0; +inp[7510] = 1073741104; +inp[7511] = 0; +inp[7512] = 1073741088; +inp[7513] = 0; +inp[7514] = 1073741072; +inp[7515] = 0; +inp[7516] = 1073741056; +inp[7517] = 0; +inp[7518] = 1073741040; +inp[7519] = 0; +inp[7520] = 1073741024; +inp[7521] = 0; +inp[7522] = 1073741008; +inp[7523] = 0; +inp[7524] = 1073740992; +inp[7525] = 0; +inp[7526] = 1073740976; +inp[7527] = 0; +inp[7528] = 1073740960; +inp[7529] = 0; +inp[7530] = 1073740944; +inp[7531] = 0; +inp[7532] = 1073740928; +inp[7533] = 0; +inp[7534] = 1073740912; +inp[7535] = 0; +inp[7536] = 1073740896; +inp[7537] = 0; +inp[7538] = 1073740880; +inp[7539] = 0; +inp[7540] = 1073740864; +inp[7541] = 0; +inp[7542] = 1073740848; +inp[7543] = 0; +inp[7544] = 1073740832; +inp[7545] = 0; +inp[7546] = 1073740816; +inp[7547] = 0; +inp[7548] = 1073741824; +inp[7549] = 1073741824; +inp[7550] = 1073741816; +inp[7551] = 0; +inp[7552] = 1073741808; +inp[7553] = 0; +inp[7554] = 1073741800; +inp[7555] = 0; +inp[7556] = 1073741792; +inp[7557] = 0; +inp[7558] = 1073741784; +inp[7559] = 0; +inp[7560] = 1073741776; +inp[7561] = 0; +inp[7562] = 1073741768; +inp[7563] = 0; +inp[7564] = 1073741760; +inp[7565] = 0; +inp[7566] = 1073741752; +inp[7567] = 0; +inp[7568] = 1073741744; +inp[7569] = 0; +inp[7570] = 1073741736; +inp[7571] = 0; +inp[7572] = 1073741728; +inp[7573] = 0; +inp[7574] = 1073741720; +inp[7575] = 0; +inp[7576] = 1073741712; +inp[7577] = 0; +inp[7578] = 1073741704; +inp[7579] = 0; +inp[7580] = 1073741696; +inp[7581] = 0; +inp[7582] = 1073741688; +inp[7583] = 0; +inp[7584] = 1073741680; +inp[7585] = 0; +inp[7586] = 1073741672; +inp[7587] = 0; +inp[7588] = 1073741664; +inp[7589] = 0; +inp[7590] = 1073741656; +inp[7591] = 0; +inp[7592] = 1073741648; +inp[7593] = 0; +inp[7594] = 1073741640; +inp[7595] = 0; +inp[7596] = 1073741632; +inp[7597] = 0; +inp[7598] = 1073741624; +inp[7599] = 0; +inp[7600] = 1073741616; +inp[7601] = 0; +inp[7602] = 1073741608; +inp[7603] = 0; +inp[7604] = 1073741600; +inp[7605] = 0; +inp[7606] = 1073741592; +inp[7607] = 0; +inp[7608] = 1073741584; +inp[7609] = 0; +inp[7610] = 1073741576; +inp[7611] = 0; +inp[7612] = 1073741568; +inp[7613] = 0; +inp[7614] = 1073741560; +inp[7615] = 0; +inp[7616] = 1073741552; +inp[7617] = 0; +inp[7618] = 1073741544; +inp[7619] = 0; +inp[7620] = 1073741536; +inp[7621] = 0; +inp[7622] = 1073741528; +inp[7623] = 0; +inp[7624] = 1073741520; +inp[7625] = 0; +inp[7626] = 1073741512; +inp[7627] = 0; +inp[7628] = 1073741504; +inp[7629] = 0; +inp[7630] = 1073741496; +inp[7631] = 0; +inp[7632] = 1073741488; +inp[7633] = 0; +inp[7634] = 1073741480; +inp[7635] = 0; +inp[7636] = 1073741472; +inp[7637] = 0; +inp[7638] = 1073741464; +inp[7639] = 0; +inp[7640] = 1073741456; +inp[7641] = 0; +inp[7642] = 1073741448; +inp[7643] = 0; +inp[7644] = 1073741440; +inp[7645] = 0; +inp[7646] = 1073741432; +inp[7647] = 0; +inp[7648] = 1073741424; +inp[7649] = 0; +inp[7650] = 1073741416; +inp[7651] = 0; +inp[7652] = 1073741408; +inp[7653] = 0; +inp[7654] = 1073741400; +inp[7655] = 0; +inp[7656] = 1073741392; +inp[7657] = 0; +inp[7658] = 1073741384; +inp[7659] = 0; +inp[7660] = 1073741376; +inp[7661] = 0; +inp[7662] = 1073741368; +inp[7663] = 0; +inp[7664] = 1073741360; +inp[7665] = 0; +inp[7666] = 1073741352; +inp[7667] = 0; +inp[7668] = 1073741344; +inp[7669] = 0; +inp[7670] = 1073741336; +inp[7671] = 0; +inp[7672] = 1073741328; +inp[7673] = 0; +inp[7674] = 1073741320; +inp[7675] = 0; +inp[7676] = 1073741824; +inp[7677] = 1073741824; +inp[7678] = 1073741820; +inp[7679] = 0; +inp[7680] = 1073741816; +inp[7681] = 0; +inp[7682] = 1073741812; +inp[7683] = 0; +inp[7684] = 1073741808; +inp[7685] = 0; +inp[7686] = 1073741804; +inp[7687] = 0; +inp[7688] = 1073741800; +inp[7689] = 0; +inp[7690] = 1073741796; +inp[7691] = 0; +inp[7692] = 1073741792; +inp[7693] = 0; +inp[7694] = 1073741788; +inp[7695] = 0; +inp[7696] = 1073741784; +inp[7697] = 0; +inp[7698] = 1073741780; +inp[7699] = 0; +inp[7700] = 1073741776; +inp[7701] = 0; +inp[7702] = 1073741772; +inp[7703] = 0; +inp[7704] = 1073741768; +inp[7705] = 0; +inp[7706] = 1073741764; +inp[7707] = 0; +inp[7708] = 1073741760; +inp[7709] = 0; +inp[7710] = 1073741756; +inp[7711] = 0; +inp[7712] = 1073741752; +inp[7713] = 0; +inp[7714] = 1073741748; +inp[7715] = 0; +inp[7716] = 1073741744; +inp[7717] = 0; +inp[7718] = 1073741740; +inp[7719] = 0; +inp[7720] = 1073741736; +inp[7721] = 0; +inp[7722] = 1073741732; +inp[7723] = 0; +inp[7724] = 1073741728; +inp[7725] = 0; +inp[7726] = 1073741724; +inp[7727] = 0; +inp[7728] = 1073741720; +inp[7729] = 0; +inp[7730] = 1073741716; +inp[7731] = 0; +inp[7732] = 1073741712; +inp[7733] = 0; +inp[7734] = 1073741708; +inp[7735] = 0; +inp[7736] = 1073741704; +inp[7737] = 0; +inp[7738] = 1073741700; +inp[7739] = 0; +inp[7740] = 1073741696; +inp[7741] = 0; +inp[7742] = 1073741692; +inp[7743] = 0; +inp[7744] = 1073741688; +inp[7745] = 0; +inp[7746] = 1073741684; +inp[7747] = 0; +inp[7748] = 1073741680; +inp[7749] = 0; +inp[7750] = 1073741676; +inp[7751] = 0; +inp[7752] = 1073741672; +inp[7753] = 0; +inp[7754] = 1073741668; +inp[7755] = 0; +inp[7756] = 1073741664; +inp[7757] = 0; +inp[7758] = 1073741660; +inp[7759] = 0; +inp[7760] = 1073741656; +inp[7761] = 0; +inp[7762] = 1073741652; +inp[7763] = 0; +inp[7764] = 1073741648; +inp[7765] = 0; +inp[7766] = 1073741644; +inp[7767] = 0; +inp[7768] = 1073741640; +inp[7769] = 0; +inp[7770] = 1073741636; +inp[7771] = 0; +inp[7772] = 1073741632; +inp[7773] = 0; +inp[7774] = 1073741628; +inp[7775] = 0; +inp[7776] = 1073741624; +inp[7777] = 0; +inp[7778] = 1073741620; +inp[7779] = 0; +inp[7780] = 1073741616; +inp[7781] = 0; +inp[7782] = 1073741612; +inp[7783] = 0; +inp[7784] = 1073741608; +inp[7785] = 0; +inp[7786] = 1073741604; +inp[7787] = 0; +inp[7788] = 1073741600; +inp[7789] = 0; +inp[7790] = 1073741596; +inp[7791] = 0; +inp[7792] = 1073741592; +inp[7793] = 0; +inp[7794] = 1073741588; +inp[7795] = 0; +inp[7796] = 1073741584; +inp[7797] = 0; +inp[7798] = 1073741580; +inp[7799] = 0; +inp[7800] = 1073741576; +inp[7801] = 0; +inp[7802] = 1073741572; +inp[7803] = 0; +inp[7804] = 1073741824; +inp[7805] = 1073741824; +inp[7806] = 1073741822; +inp[7807] = 0; +inp[7808] = 1073741820; +inp[7809] = 0; +inp[7810] = 1073741818; +inp[7811] = 0; +inp[7812] = 1073741816; +inp[7813] = 0; +inp[7814] = 1073741814; +inp[7815] = 0; +inp[7816] = 1073741812; +inp[7817] = 0; +inp[7818] = 1073741810; +inp[7819] = 0; +inp[7820] = 1073741808; +inp[7821] = 0; +inp[7822] = 1073741806; +inp[7823] = 0; +inp[7824] = 1073741804; +inp[7825] = 0; +inp[7826] = 1073741802; +inp[7827] = 0; +inp[7828] = 1073741800; +inp[7829] = 0; +inp[7830] = 1073741798; +inp[7831] = 0; +inp[7832] = 1073741796; +inp[7833] = 0; +inp[7834] = 1073741794; +inp[7835] = 0; +inp[7836] = 1073741792; +inp[7837] = 0; +inp[7838] = 1073741790; +inp[7839] = 0; +inp[7840] = 1073741788; +inp[7841] = 0; +inp[7842] = 1073741786; +inp[7843] = 0; +inp[7844] = 1073741784; +inp[7845] = 0; +inp[7846] = 1073741782; +inp[7847] = 0; +inp[7848] = 1073741780; +inp[7849] = 0; +inp[7850] = 1073741778; +inp[7851] = 0; +inp[7852] = 1073741776; +inp[7853] = 0; +inp[7854] = 1073741774; +inp[7855] = 0; +inp[7856] = 1073741772; +inp[7857] = 0; +inp[7858] = 1073741770; +inp[7859] = 0; +inp[7860] = 1073741768; +inp[7861] = 0; +inp[7862] = 1073741766; +inp[7863] = 0; +inp[7864] = 1073741764; +inp[7865] = 0; +inp[7866] = 1073741762; +inp[7867] = 0; +inp[7868] = 1073741760; +inp[7869] = 0; +inp[7870] = 1073741758; +inp[7871] = 0; +inp[7872] = 1073741756; +inp[7873] = 0; +inp[7874] = 1073741754; +inp[7875] = 0; +inp[7876] = 1073741752; +inp[7877] = 0; +inp[7878] = 1073741750; +inp[7879] = 0; +inp[7880] = 1073741748; +inp[7881] = 0; +inp[7882] = 1073741746; +inp[7883] = 0; +inp[7884] = 1073741744; +inp[7885] = 0; +inp[7886] = 1073741742; +inp[7887] = 0; +inp[7888] = 1073741740; +inp[7889] = 0; +inp[7890] = 1073741738; +inp[7891] = 0; +inp[7892] = 1073741736; +inp[7893] = 0; +inp[7894] = 1073741734; +inp[7895] = 0; +inp[7896] = 1073741732; +inp[7897] = 0; +inp[7898] = 1073741730; +inp[7899] = 0; +inp[7900] = 1073741728; +inp[7901] = 0; +inp[7902] = 1073741726; +inp[7903] = 0; +inp[7904] = 1073741724; +inp[7905] = 0; +inp[7906] = 1073741722; +inp[7907] = 0; +inp[7908] = 1073741720; +inp[7909] = 0; +inp[7910] = 1073741718; +inp[7911] = 0; +inp[7912] = 1073741716; +inp[7913] = 0; +inp[7914] = 1073741714; +inp[7915] = 0; +inp[7916] = 1073741712; +inp[7917] = 0; +inp[7918] = 1073741710; +inp[7919] = 0; +inp[7920] = 1073741708; +inp[7921] = 0; +inp[7922] = 1073741706; +inp[7923] = 0; +inp[7924] = 1073741704; +inp[7925] = 0; +inp[7926] = 1073741702; +inp[7927] = 0; +inp[7928] = 1073741700; +inp[7929] = 0; +inp[7930] = 1073741698; +inp[7931] = 0; +inp[7932] = 1073741824; +inp[7933] = 1073741824; +inp[7934] = 1073741823; +inp[7935] = 0; +inp[7936] = 1073741822; +inp[7937] = 0; +inp[7938] = 1073741821; +inp[7939] = 0; +inp[7940] = 1073741820; +inp[7941] = 0; +inp[7942] = 1073741819; +inp[7943] = 0; +inp[7944] = 1073741818; +inp[7945] = 0; +inp[7946] = 1073741817; +inp[7947] = 0; +inp[7948] = 1073741816; +inp[7949] = 0; +inp[7950] = 1073741815; +inp[7951] = 0; +inp[7952] = 1073741814; +inp[7953] = 0; +inp[7954] = 1073741813; +inp[7955] = 0; +inp[7956] = 1073741812; +inp[7957] = 0; +inp[7958] = 1073741811; +inp[7959] = 0; +inp[7960] = 1073741810; +inp[7961] = 0; +inp[7962] = 1073741809; +inp[7963] = 0; +inp[7964] = 1073741808; +inp[7965] = 0; +inp[7966] = 1073741807; +inp[7967] = 0; +inp[7968] = 1073741806; +inp[7969] = 0; +inp[7970] = 1073741805; +inp[7971] = 0; +inp[7972] = 1073741804; +inp[7973] = 0; +inp[7974] = 1073741803; +inp[7975] = 0; +inp[7976] = 1073741802; +inp[7977] = 0; +inp[7978] = 1073741801; +inp[7979] = 0; +inp[7980] = 1073741800; +inp[7981] = 0; +inp[7982] = 1073741799; +inp[7983] = 0; +inp[7984] = 1073741798; +inp[7985] = 0; +inp[7986] = 1073741797; +inp[7987] = 0; +inp[7988] = 1073741796; +inp[7989] = 0; +inp[7990] = 1073741795; +inp[7991] = 0; +inp[7992] = 1073741794; +inp[7993] = 0; +inp[7994] = 1073741793; +inp[7995] = 0; +inp[7996] = 1073741792; +inp[7997] = 0; +inp[7998] = 1073741791; +inp[7999] = 0; +inp[8000] = 1073741790; +inp[8001] = 0; +inp[8002] = 1073741789; +inp[8003] = 0; +inp[8004] = 1073741788; +inp[8005] = 0; +inp[8006] = 1073741787; +inp[8007] = 0; +inp[8008] = 1073741786; +inp[8009] = 0; +inp[8010] = 1073741785; +inp[8011] = 0; +inp[8012] = 1073741784; +inp[8013] = 0; +inp[8014] = 1073741783; +inp[8015] = 0; +inp[8016] = 1073741782; +inp[8017] = 0; +inp[8018] = 1073741781; +inp[8019] = 0; +inp[8020] = 1073741780; +inp[8021] = 0; +inp[8022] = 1073741779; +inp[8023] = 0; +inp[8024] = 1073741778; +inp[8025] = 0; +inp[8026] = 1073741777; +inp[8027] = 0; +inp[8028] = 1073741776; +inp[8029] = 0; +inp[8030] = 1073741775; +inp[8031] = 0; +inp[8032] = 1073741774; +inp[8033] = 0; +inp[8034] = 1073741773; +inp[8035] = 0; +inp[8036] = 1073741772; +inp[8037] = 0; +inp[8038] = 1073741771; +inp[8039] = 0; +inp[8040] = 1073741770; +inp[8041] = 0; +inp[8042] = 1073741769; +inp[8043] = 0; +inp[8044] = 1073741768; +inp[8045] = 0; +inp[8046] = 1073741767; +inp[8047] = 0; +inp[8048] = 1073741766; +inp[8049] = 0; +inp[8050] = 1073741765; +inp[8051] = 0; +inp[8052] = 1073741764; +inp[8053] = 0; +inp[8054] = 1073741763; +inp[8055] = 0; +inp[8056] = 1073741762; +inp[8057] = 0; +inp[8058] = 1073741761; +inp[8059] = 0; +inp[8060] = 1073741824; +inp[8061] = 1073741824; +inp[8062] = 1073741823; +inp[8063] = 0; +inp[8064] = 1073741823; +inp[8065] = 0; +inp[8066] = 1073741822; +inp[8067] = 0; +inp[8068] = 1073741822; +inp[8069] = 0; +inp[8070] = 1073741821; +inp[8071] = 0; +inp[8072] = 1073741821; +inp[8073] = 0; +inp[8074] = 1073741820; +inp[8075] = 0; +inp[8076] = 1073741820; +inp[8077] = 0; +inp[8078] = 1073741819; +inp[8079] = 0; +inp[8080] = 1073741819; +inp[8081] = 0; +inp[8082] = 1073741818; +inp[8083] = 0; +inp[8084] = 1073741818; +inp[8085] = 0; +inp[8086] = 1073741817; +inp[8087] = 0; +inp[8088] = 1073741817; +inp[8089] = 0; +inp[8090] = 1073741816; +inp[8091] = 0; +inp[8092] = 1073741816; +inp[8093] = 0; +inp[8094] = 1073741815; +inp[8095] = 0; +inp[8096] = 1073741815; +inp[8097] = 0; +inp[8098] = 1073741814; +inp[8099] = 0; +inp[8100] = 1073741814; +inp[8101] = 0; +inp[8102] = 1073741813; +inp[8103] = 0; +inp[8104] = 1073741813; +inp[8105] = 0; +inp[8106] = 1073741812; +inp[8107] = 0; +inp[8108] = 1073741812; +inp[8109] = 0; +inp[8110] = 1073741811; +inp[8111] = 0; +inp[8112] = 1073741811; +inp[8113] = 0; +inp[8114] = 1073741810; +inp[8115] = 0; +inp[8116] = 1073741810; +inp[8117] = 0; +inp[8118] = 1073741809; +inp[8119] = 0; +inp[8120] = 1073741809; +inp[8121] = 0; +inp[8122] = 1073741808; +inp[8123] = 0; +inp[8124] = 1073741808; +inp[8125] = 0; +inp[8126] = 1073741807; +inp[8127] = 0; +inp[8128] = 1073741807; +inp[8129] = 0; +inp[8130] = 1073741806; +inp[8131] = 0; +inp[8132] = 1073741806; +inp[8133] = 0; +inp[8134] = 1073741805; +inp[8135] = 0; +inp[8136] = 1073741805; +inp[8137] = 0; +inp[8138] = 1073741804; +inp[8139] = 0; +inp[8140] = 1073741804; +inp[8141] = 0; +inp[8142] = 1073741803; +inp[8143] = 0; +inp[8144] = 1073741803; +inp[8145] = 0; +inp[8146] = 1073741802; +inp[8147] = 0; +inp[8148] = 1073741802; +inp[8149] = 0; +inp[8150] = 1073741801; +inp[8151] = 0; +inp[8152] = 1073741801; +inp[8153] = 0; +inp[8154] = 1073741800; +inp[8155] = 0; +inp[8156] = 1073741800; +inp[8157] = 0; +inp[8158] = 1073741799; +inp[8159] = 0; +inp[8160] = 1073741799; +inp[8161] = 0; +inp[8162] = 1073741798; +inp[8163] = 0; +inp[8164] = 1073741798; +inp[8165] = 0; +inp[8166] = 1073741797; +inp[8167] = 0; +inp[8168] = 1073741797; +inp[8169] = 0; +inp[8170] = 1073741796; +inp[8171] = 0; +inp[8172] = 1073741796; +inp[8173] = 0; +inp[8174] = 1073741795; +inp[8175] = 0; +inp[8176] = 1073741795; +inp[8177] = 0; +inp[8178] = 1073741794; +inp[8179] = 0; +inp[8180] = 1073741794; +inp[8181] = 0; +inp[8182] = 1073741793; +inp[8183] = 0; +inp[8184] = 1073741793; +inp[8185] = 0; +inp[8186] = 1073741792; +inp[8187] = 0; +inp[8188] = 1073741824; +inp[8189] = 1073741824; +inp[8190] = 1073741823; +inp[8191] = 0; +inp[8192] = 1073741823; +inp[8193] = 0; +inp[8194] = 1073741823; +inp[8195] = 0; +inp[8196] = 1073741823; +inp[8197] = 0; +inp[8198] = 1073741822; +inp[8199] = 0; +inp[8200] = 1073741822; +inp[8201] = 0; +inp[8202] = 1073741822; +inp[8203] = 0; +inp[8204] = 1073741822; +inp[8205] = 0; +inp[8206] = 1073741821; +inp[8207] = 0; +inp[8208] = 1073741821; +inp[8209] = 0; +inp[8210] = 1073741821; +inp[8211] = 0; +inp[8212] = 1073741821; +inp[8213] = 0; +inp[8214] = 1073741820; +inp[8215] = 0; +inp[8216] = 1073741820; +inp[8217] = 0; +inp[8218] = 1073741820; +inp[8219] = 0; +inp[8220] = 1073741820; +inp[8221] = 0; +inp[8222] = 1073741819; +inp[8223] = 0; +inp[8224] = 1073741819; +inp[8225] = 0; +inp[8226] = 1073741819; +inp[8227] = 0; +inp[8228] = 1073741819; +inp[8229] = 0; +inp[8230] = 1073741818; +inp[8231] = 0; +inp[8232] = 1073741818; +inp[8233] = 0; +inp[8234] = 1073741818; +inp[8235] = 0; +inp[8236] = 1073741818; +inp[8237] = 0; +inp[8238] = 1073741817; +inp[8239] = 0; +inp[8240] = 1073741817; +inp[8241] = 0; +inp[8242] = 1073741817; +inp[8243] = 0; +inp[8244] = 1073741817; +inp[8245] = 0; +inp[8246] = 1073741816; +inp[8247] = 0; +inp[8248] = 1073741816; +inp[8249] = 0; +inp[8250] = 1073741816; +inp[8251] = 0; +inp[8252] = 1073741816; +inp[8253] = 0; +inp[8254] = 1073741815; +inp[8255] = 0; +inp[8256] = 1073741815; +inp[8257] = 0; +inp[8258] = 1073741815; +inp[8259] = 0; +inp[8260] = 1073741815; +inp[8261] = 0; +inp[8262] = 1073741814; +inp[8263] = 0; +inp[8264] = 1073741814; +inp[8265] = 0; +inp[8266] = 1073741814; +inp[8267] = 0; +inp[8268] = 1073741814; +inp[8269] = 0; +inp[8270] = 1073741813; +inp[8271] = 0; +inp[8272] = 1073741813; +inp[8273] = 0; +inp[8274] = 1073741813; +inp[8275] = 0; +inp[8276] = 1073741813; +inp[8277] = 0; +inp[8278] = 1073741812; +inp[8279] = 0; +inp[8280] = 1073741812; +inp[8281] = 0; +inp[8282] = 1073741812; +inp[8283] = 0; +inp[8284] = 1073741812; +inp[8285] = 0; +inp[8286] = 1073741811; +inp[8287] = 0; +inp[8288] = 1073741811; +inp[8289] = 0; +inp[8290] = 1073741811; +inp[8291] = 0; +inp[8292] = 1073741811; +inp[8293] = 0; +inp[8294] = 1073741810; +inp[8295] = 0; +inp[8296] = 1073741810; +inp[8297] = 0; +inp[8298] = 1073741810; +inp[8299] = 0; +inp[8300] = 1073741810; +inp[8301] = 0; +inp[8302] = 1073741809; +inp[8303] = 0; +inp[8304] = 1073741809; +inp[8305] = 0; +inp[8306] = 1073741809; +inp[8307] = 0; +inp[8308] = 1073741809; +inp[8309] = 0; +inp[8310] = 1073741808; +inp[8311] = 0; +inp[8312] = 1073741808; +inp[8313] = 0; +inp[8314] = 1073741808; +inp[8315] = 0; +inp[8316] = 1073741824; +inp[8317] = 1073741824; +inp[8318] = 395007542; +inp[8319] = 395007542; +inp[8320] = 145315153; +inp[8321] = 145315153; +inp[8322] = 53458457; +inp[8323] = 53458457; +inp[8324] = 19666267; +inp[8325] = 19666267; +inp[8326] = 7234815; +inp[8327] = 7234815; +inp[8328] = 2661539; +inp[8329] = 2661539; +inp[8330] = 979125; +inp[8331] = 979125; +inp[8332] = 360200; +inp[8333] = 360200; +inp[8334] = 132510; +inp[8335] = 132510; +inp[8336] = 48747; +inp[8337] = 48747; +inp[8338] = 17933; +inp[8339] = 17933; +inp[8340] = 6597; +inp[8341] = 6597; +inp[8342] = 2427; +inp[8343] = 2427; +inp[8344] = 892; +inp[8345] = 892; +inp[8346] = 328; +inp[8347] = 328; +inp[8348] = 120; +inp[8349] = 120; +inp[8350] = 44; +inp[8351] = 44; +inp[8352] = 16; +inp[8353] = 16; +inp[8354] = 6; +inp[8355] = 6; +inp[8356] = 2; +inp[8357] = 2; +inp[8358] = 0; +inp[8359] = 0; +inp[8360] = 0; +inp[8361] = 0; +inp[8362] = 0; +inp[8363] = 0; +inp[8364] = 0; +inp[8365] = 0; +inp[8366] = 0; +inp[8367] = 0; +inp[8368] = 0; +inp[8369] = 0; +inp[8370] = 0; +inp[8371] = 0; +inp[8372] = 0; +inp[8373] = 0; +inp[8374] = 0; +inp[8375] = 0; +inp[8376] = 0; +inp[8377] = 0; +inp[8378] = 0; +inp[8379] = 0; +inp[8380] = 0; +inp[8381] = 0; +inp[8382] = 0; +inp[8383] = 0; +inp[8384] = 0; +inp[8385] = 0; +inp[8386] = 0; +inp[8387] = 0; +inp[8388] = 0; +inp[8389] = 0; +inp[8390] = 0; +inp[8391] = 0; +inp[8392] = 0; +inp[8393] = 0; +inp[8394] = 0; +inp[8395] = 0; +inp[8396] = 0; +inp[8397] = 0; +inp[8398] = 0; +inp[8399] = 0; +inp[8400] = 0; +inp[8401] = 0; +inp[8402] = 0; +inp[8403] = 0; +inp[8404] = 0; +inp[8405] = 0; +inp[8406] = 0; +inp[8407] = 0; +inp[8408] = 0; +inp[8409] = 0; +inp[8410] = 0; +inp[8411] = 0; +inp[8412] = 0; +inp[8413] = 0; +inp[8414] = 0; +inp[8415] = 0; +inp[8416] = 0; +inp[8417] = 0; +inp[8418] = 0; +inp[8419] = 0; +inp[8420] = 0; +inp[8421] = 0; +inp[8422] = 0; +inp[8423] = 0; +inp[8424] = 0; +inp[8425] = 0; +inp[8426] = 0; +inp[8427] = 0; +inp[8428] = 0; +inp[8429] = 0; +inp[8430] = 0; +inp[8431] = 0; +inp[8432] = 0; +inp[8433] = 0; +inp[8434] = 0; +inp[8435] = 0; +inp[8436] = 0; +inp[8437] = 0; +inp[8438] = 0; +inp[8439] = 0; +inp[8440] = 0; +inp[8441] = 0; +inp[8442] = 0; +inp[8443] = 0; +inp[8444] = 0; +inp[8445] = 0; +inp[8446] = 0; +inp[8447] = 0; +inp[8448] = 0; +inp[8449] = 0; +inp[8450] = 0; +inp[8451] = 0; +inp[8452] = 0; +inp[8453] = 0; +inp[8454] = 0; +inp[8455] = 0; +inp[8456] = 0; +inp[8457] = 0; +inp[8458] = 0; +inp[8459] = 0; +inp[8460] = 0; +inp[8461] = 0; +inp[8462] = 0; +inp[8463] = 0; +inp[8464] = 0; +inp[8465] = 0; +inp[8466] = 0; +inp[8467] = 0; +inp[8468] = 0; +inp[8469] = 0; +inp[8470] = 0; +inp[8471] = 0; +inp[8472] = 0; +inp[8473] = 0; +inp[8474] = 0; +inp[8475] = 0; +inp[8476] = 0; +inp[8477] = 0; +inp[8478] = 0; +inp[8479] = 0; +inp[8480] = 0; +inp[8481] = 0; +inp[8482] = 0; +inp[8483] = 0; +inp[8484] = 0; +inp[8485] = 0; +inp[8486] = 0; +inp[8487] = 0; +inp[8488] = 0; +inp[8489] = 0; +inp[8490] = 0; +inp[8491] = 0; +inp[8492] = 0; +inp[8493] = 0; +inp[8494] = 0; +inp[8495] = 0; +inp[8496] = 0; +inp[8497] = 0; +inp[8498] = 0; +inp[8499] = 0; +inp[8500] = 0; +inp[8501] = 0; +inp[8502] = 0; +inp[8503] = 0; +inp[8504] = 0; +inp[8505] = 0; +inp[8506] = 0; +inp[8507] = 0; +inp[8508] = 0; +inp[8509] = 0; +inp[8510] = 0; +inp[8511] = 0; +inp[8512] = 0; +inp[8513] = 0; +inp[8514] = 0; +inp[8515] = 0; +inp[8516] = 0; +inp[8517] = 0; +inp[8518] = 0; +inp[8519] = 0; +inp[8520] = 0; +inp[8521] = 0; +inp[8522] = 0; +inp[8523] = 0; +inp[8524] = 0; +inp[8525] = 0; +inp[8526] = 0; +inp[8527] = 0; +inp[8528] = 0; +inp[8529] = 0; +inp[8530] = 0; +inp[8531] = 0; +inp[8532] = 0; +inp[8533] = 0; +inp[8534] = 0; +inp[8535] = 0; +inp[8536] = 0; +inp[8537] = 0; +inp[8538] = 0; +inp[8539] = 0; +inp[8540] = 0; +inp[8541] = 0; +inp[8542] = 0; +inp[8543] = 0; +inp[8544] = 0; +inp[8545] = 0; +inp[8546] = 0; +inp[8547] = 0; +inp[8548] = 0; +inp[8549] = 0; +inp[8550] = 0; +inp[8551] = 0; +inp[8552] = 0; +inp[8553] = 0; +inp[8554] = 0; +inp[8555] = 0; +inp[8556] = 0; +inp[8557] = 0; +inp[8558] = 0; +inp[8559] = 0; +inp[8560] = 0; +inp[8561] = 0; +inp[8562] = 0; +inp[8563] = 0; +inp[8564] = 0; +inp[8565] = 0; +inp[8566] = 0; +inp[8567] = 0; +inp[8568] = 0; +inp[8569] = 0; +inp[8570] = 0; +inp[8571] = 0; +inp[8572] = 1073741824; +inp[8573] = 1073741824; +inp[8574] = 651257336; +inp[8575] = 145315153; +inp[8576] = 395007542; +inp[8577] = 19666267; +inp[8578] = 239584185; +inp[8579] = 2661539; +inp[8580] = 145315153; +inp[8581] = 360200; +inp[8582] = 88138096; +inp[8583] = 48747; +inp[8584] = 53458457; +inp[8585] = 6597; +inp[8586] = 32424193; +inp[8587] = 892; +inp[8588] = 19666267; +inp[8589] = 120; +inp[8590] = 11928194; +inp[8591] = 16; +inp[8592] = 7234815; +inp[8593] = 2; +inp[8594] = 4388137; +inp[8595] = 0; +inp[8596] = 2661539; +inp[8597] = 0; +inp[8598] = 1614305; +inp[8599] = 0; +inp[8600] = 979125; +inp[8601] = 0; +inp[8602] = 593869; +inp[8603] = 0; +inp[8604] = 360200; +inp[8605] = 0; +inp[8606] = 218472; +inp[8607] = 0; +inp[8608] = 132510; +inp[8609] = 0; +inp[8610] = 80371; +inp[8611] = 0; +inp[8612] = 48747; +inp[8613] = 0; +inp[8614] = 29567; +inp[8615] = 0; +inp[8616] = 17933; +inp[8617] = 0; +inp[8618] = 10877; +inp[8619] = 0; +inp[8620] = 6597; +inp[8621] = 0; +inp[8622] = 4001; +inp[8623] = 0; +inp[8624] = 2427; +inp[8625] = 0; +inp[8626] = 1472; +inp[8627] = 0; +inp[8628] = 892; +inp[8629] = 0; +inp[8630] = 541; +inp[8631] = 0; +inp[8632] = 328; +inp[8633] = 0; +inp[8634] = 199; +inp[8635] = 0; +inp[8636] = 120; +inp[8637] = 0; +inp[8638] = 73; +inp[8639] = 0; +inp[8640] = 44; +inp[8641] = 0; +inp[8642] = 26; +inp[8643] = 0; +inp[8644] = 16; +inp[8645] = 0; +inp[8646] = 9; +inp[8647] = 0; +inp[8648] = 6; +inp[8649] = 0; +inp[8650] = 3; +inp[8651] = 0; +inp[8652] = 2; +inp[8653] = 0; +inp[8654] = 1; +inp[8655] = 0; +inp[8656] = 0; +inp[8657] = 0; +inp[8658] = 0; +inp[8659] = 0; +inp[8660] = 0; +inp[8661] = 0; +inp[8662] = 0; +inp[8663] = 0; +inp[8664] = 0; +inp[8665] = 0; +inp[8666] = 0; +inp[8667] = 0; +inp[8668] = 0; +inp[8669] = 0; +inp[8670] = 0; +inp[8671] = 0; +inp[8672] = 0; +inp[8673] = 0; +inp[8674] = 0; +inp[8675] = 0; +inp[8676] = 0; +inp[8677] = 0; +inp[8678] = 0; +inp[8679] = 0; +inp[8680] = 0; +inp[8681] = 0; +inp[8682] = 0; +inp[8683] = 0; +inp[8684] = 0; +inp[8685] = 0; +inp[8686] = 0; +inp[8687] = 0; +inp[8688] = 0; +inp[8689] = 0; +inp[8690] = 0; +inp[8691] = 0; +inp[8692] = 0; +inp[8693] = 0; +inp[8694] = 0; +inp[8695] = 0; +inp[8696] = 0; +inp[8697] = 0; +inp[8698] = 0; +inp[8699] = 0; +inp[8700] = 0; +inp[8701] = 0; +inp[8702] = 0; +inp[8703] = 0; +inp[8704] = 0; +inp[8705] = 0; +inp[8706] = 0; +inp[8707] = 0; +inp[8708] = 0; +inp[8709] = 0; +inp[8710] = 0; +inp[8711] = 0; +inp[8712] = 0; +inp[8713] = 0; +inp[8714] = 0; +inp[8715] = 0; +inp[8716] = 0; +inp[8717] = 0; +inp[8718] = 0; +inp[8719] = 0; +inp[8720] = 0; +inp[8721] = 0; +inp[8722] = 0; +inp[8723] = 0; +inp[8724] = 0; +inp[8725] = 0; +inp[8726] = 0; +inp[8727] = 0; +inp[8728] = 0; +inp[8729] = 0; +inp[8730] = 0; +inp[8731] = 0; +inp[8732] = 0; +inp[8733] = 0; +inp[8734] = 0; +inp[8735] = 0; +inp[8736] = 0; +inp[8737] = 0; +inp[8738] = 0; +inp[8739] = 0; +inp[8740] = 0; +inp[8741] = 0; +inp[8742] = 0; +inp[8743] = 0; +inp[8744] = 0; +inp[8745] = 0; +inp[8746] = 0; +inp[8747] = 0; +inp[8748] = 0; +inp[8749] = 0; +inp[8750] = 0; +inp[8751] = 0; +inp[8752] = 0; +inp[8753] = 0; +inp[8754] = 0; +inp[8755] = 0; +inp[8756] = 0; +inp[8757] = 0; +inp[8758] = 0; +inp[8759] = 0; +inp[8760] = 0; +inp[8761] = 0; +inp[8762] = 0; +inp[8763] = 0; +inp[8764] = 0; +inp[8765] = 0; +inp[8766] = 0; +inp[8767] = 0; +inp[8768] = 0; +inp[8769] = 0; +inp[8770] = 0; +inp[8771] = 0; +inp[8772] = 0; +inp[8773] = 0; +inp[8774] = 0; +inp[8775] = 0; +inp[8776] = 0; +inp[8777] = 0; +inp[8778] = 0; +inp[8779] = 0; +inp[8780] = 0; +inp[8781] = 0; +inp[8782] = 0; +inp[8783] = 0; +inp[8784] = 0; +inp[8785] = 0; +inp[8786] = 0; +inp[8787] = 0; +inp[8788] = 0; +inp[8789] = 0; +inp[8790] = 0; +inp[8791] = 0; +inp[8792] = 0; +inp[8793] = 0; +inp[8794] = 0; +inp[8795] = 0; +inp[8796] = 0; +inp[8797] = 0; +inp[8798] = 0; +inp[8799] = 0; +inp[8800] = 0; +inp[8801] = 0; +inp[8802] = 0; +inp[8803] = 0; +inp[8804] = 0; +inp[8805] = 0; +inp[8806] = 0; +inp[8807] = 0; +inp[8808] = 0; +inp[8809] = 0; +inp[8810] = 0; +inp[8811] = 0; +inp[8812] = 0; +inp[8813] = 0; +inp[8814] = 0; +inp[8815] = 0; +inp[8816] = 0; +inp[8817] = 0; +inp[8818] = 0; +inp[8819] = 0; +inp[8820] = 0; +inp[8821] = 0; +inp[8822] = 0; +inp[8823] = 0; +inp[8824] = 0; +inp[8825] = 0; +inp[8826] = 0; +inp[8827] = 0; +inp[8828] = 1073741824; +inp[8829] = 1073741824; +inp[8830] = 836230973; +inp[8831] = 19666267; +inp[8832] = 651257336; +inp[8833] = 360200; +inp[8834] = 507199723; +inp[8835] = 6597; +inp[8836] = 395007542; +inp[8837] = 120; +inp[8838] = 307632183; +inp[8839] = 2; +inp[8840] = 239584185; +inp[8841] = 0; +inp[8842] = 186588351; +inp[8843] = 0; +inp[8844] = 145315153; +inp[8845] = 0; +inp[8846] = 113171555; +inp[8847] = 0; +inp[8848] = 88138096; +inp[8849] = 0; +inp[8850] = 68642018; +inp[8851] = 0; +inp[8852] = 53458457; +inp[8853] = 0; +inp[8854] = 41633488; +inp[8855] = 0; +inp[8856] = 32424193; +inp[8857] = 0; +inp[8858] = 25251987; +inp[8859] = 0; +inp[8860] = 19666267; +inp[8861] = 0; +inp[8862] = 15316104; +inp[8863] = 0; +inp[8864] = 11928194; +inp[8865] = 0; +inp[8866] = 9289686; +inp[8867] = 0; +inp[8868] = 7234815; +inp[8869] = 0; +inp[8870] = 5634479; +inp[8871] = 0; +inp[8872] = 4388137; +inp[8873] = 0; +inp[8874] = 3417484; +inp[8875] = 0; +inp[8876] = 2661539; +inp[8877] = 0; +inp[8878] = 2072809; +inp[8879] = 0; +inp[8880] = 1614305; +inp[8881] = 0; +inp[8882] = 1257222; +inp[8883] = 0; +inp[8884] = 979125; +inp[8885] = 0; +inp[8886] = 762543; +inp[8887] = 0; +inp[8888] = 593869; +inp[8889] = 0; +inp[8890] = 462506; +inp[8891] = 0; +inp[8892] = 360200; +inp[8893] = 0; +inp[8894] = 280524; +inp[8895] = 0; +inp[8896] = 218472; +inp[8897] = 0; +inp[8898] = 170146; +inp[8899] = 0; +inp[8900] = 132510; +inp[8901] = 0; +inp[8902] = 103199; +inp[8903] = 0; +inp[8904] = 80371; +inp[8905] = 0; +inp[8906] = 62593; +inp[8907] = 0; +inp[8908] = 48747; +inp[8909] = 0; +inp[8910] = 37964; +inp[8911] = 0; +inp[8912] = 29567; +inp[8913] = 0; +inp[8914] = 23026; +inp[8915] = 0; +inp[8916] = 17933; +inp[8917] = 0; +inp[8918] = 13966; +inp[8919] = 0; +inp[8920] = 10877; +inp[8921] = 0; +inp[8922] = 8471; +inp[8923] = 0; +inp[8924] = 6597; +inp[8925] = 0; +inp[8926] = 5137; +inp[8927] = 0; +inp[8928] = 4001; +inp[8929] = 0; +inp[8930] = 3116; +inp[8931] = 0; +inp[8932] = 2427; +inp[8933] = 0; +inp[8934] = 1890; +inp[8935] = 0; +inp[8936] = 1472; +inp[8937] = 0; +inp[8938] = 1146; +inp[8939] = 0; +inp[8940] = 892; +inp[8941] = 0; +inp[8942] = 695; +inp[8943] = 0; +inp[8944] = 541; +inp[8945] = 0; +inp[8946] = 421; +inp[8947] = 0; +inp[8948] = 328; +inp[8949] = 0; +inp[8950] = 255; +inp[8951] = 0; +inp[8952] = 199; +inp[8953] = 0; +inp[8954] = 155; +inp[8955] = 0; +inp[8956] = 120; +inp[8957] = 0; +inp[8958] = 94; +inp[8959] = 0; +inp[8960] = 73; +inp[8961] = 0; +inp[8962] = 57; +inp[8963] = 0; +inp[8964] = 44; +inp[8965] = 0; +inp[8966] = 34; +inp[8967] = 0; +inp[8968] = 26; +inp[8969] = 0; +inp[8970] = 20; +inp[8971] = 0; +inp[8972] = 16; +inp[8973] = 0; +inp[8974] = 12; +inp[8975] = 0; +inp[8976] = 9; +inp[8977] = 0; +inp[8978] = 7; +inp[8979] = 0; +inp[8980] = 6; +inp[8981] = 0; +inp[8982] = 4; +inp[8983] = 0; +inp[8984] = 3; +inp[8985] = 0; +inp[8986] = 2; +inp[8987] = 0; +inp[8988] = 2; +inp[8989] = 0; +inp[8990] = 1; +inp[8991] = 0; +inp[8992] = 1; +inp[8993] = 0; +inp[8994] = 1; +inp[8995] = 0; +inp[8996] = 0; +inp[8997] = 0; +inp[8998] = 0; +inp[8999] = 0; +inp[9000] = 0; +inp[9001] = 0; +inp[9002] = 0; +inp[9003] = 0; +inp[9004] = 0; +inp[9005] = 0; +inp[9006] = 0; +inp[9007] = 0; +inp[9008] = 0; +inp[9009] = 0; +inp[9010] = 0; +inp[9011] = 0; +inp[9012] = 0; +inp[9013] = 0; +inp[9014] = 0; +inp[9015] = 0; +inp[9016] = 0; +inp[9017] = 0; +inp[9018] = 0; +inp[9019] = 0; +inp[9020] = 0; +inp[9021] = 0; +inp[9022] = 0; +inp[9023] = 0; +inp[9024] = 0; +inp[9025] = 0; +inp[9026] = 0; +inp[9027] = 0; +inp[9028] = 0; +inp[9029] = 0; +inp[9030] = 0; +inp[9031] = 0; +inp[9032] = 0; +inp[9033] = 0; +inp[9034] = 0; +inp[9035] = 0; +inp[9036] = 0; +inp[9037] = 0; +inp[9038] = 0; +inp[9039] = 0; +inp[9040] = 0; +inp[9041] = 0; +inp[9042] = 0; +inp[9043] = 0; +inp[9044] = 0; +inp[9045] = 0; +inp[9046] = 0; +inp[9047] = 0; +inp[9048] = 0; +inp[9049] = 0; +inp[9050] = 0; +inp[9051] = 0; +inp[9052] = 0; +inp[9053] = 0; +inp[9054] = 0; +inp[9055] = 0; +inp[9056] = 0; +inp[9057] = 0; +inp[9058] = 0; +inp[9059] = 0; +inp[9060] = 0; +inp[9061] = 0; +inp[9062] = 0; +inp[9063] = 0; +inp[9064] = 0; +inp[9065] = 0; +inp[9066] = 0; +inp[9067] = 0; +inp[9068] = 0; +inp[9069] = 0; +inp[9070] = 0; +inp[9071] = 0; +inp[9072] = 0; +inp[9073] = 0; +inp[9074] = 0; +inp[9075] = 0; +inp[9076] = 0; +inp[9077] = 0; +inp[9078] = 0; +inp[9079] = 0; +inp[9080] = 0; +inp[9081] = 0; +inp[9082] = 0; +inp[9083] = 0; +inp[9084] = 1073741824; +inp[9085] = 1073741824; +inp[9086] = 947573833; +inp[9087] = 360200; +inp[9088] = 836230973; +inp[9089] = 120; +inp[9090] = 737971243; +inp[9091] = 0; +inp[9092] = 651257336; +inp[9093] = 0; +inp[9094] = 574732582; +inp[9095] = 0; +inp[9096] = 507199723; +inp[9097] = 0; +inp[9098] = 447602185; +inp[9099] = 0; +inp[9100] = 395007542; +inp[9101] = 0; +inp[9102] = 348592932; +inp[9103] = 0; +inp[9104] = 307632183; +inp[9105] = 0; +inp[9106] = 271484448; +inp[9107] = 0; +inp[9108] = 239584185; +inp[9109] = 0; +inp[9110] = 211432301; +inp[9111] = 0; +inp[9112] = 186588351; +inp[9113] = 0; +inp[9114] = 164663641; +inp[9115] = 0; +inp[9116] = 145315153; +inp[9117] = 0; +inp[9118] = 128240173; +inp[9119] = 0; +inp[9120] = 113171555; +inp[9121] = 0; +inp[9122] = 99873547; +inp[9123] = 0; +inp[9124] = 88138096; +inp[9125] = 0; +inp[9126] = 77781596; +inp[9127] = 0; +inp[9128] = 68642018; +inp[9129] = 0; +inp[9130] = 60576368; +inp[9131] = 0; +inp[9132] = 53458457; +inp[9133] = 0; +inp[9134] = 47176923; +inp[9135] = 0; +inp[9136] = 41633488; +inp[9137] = 0; +inp[9138] = 36741424; +inp[9139] = 0; +inp[9140] = 32424193; +inp[9141] = 0; +inp[9142] = 28614250; +inp[9143] = 0; +inp[9144] = 25251987; +inp[9145] = 0; +inp[9146] = 22284800; +inp[9147] = 0; +inp[9148] = 19666267; +inp[9149] = 0; +inp[9150] = 17355420; +inp[9151] = 0; +inp[9152] = 15316104; +inp[9153] = 0; +inp[9154] = 13516414; +inp[9155] = 0; +inp[9156] = 11928194; +inp[9157] = 0; +inp[9158] = 10526594; +inp[9159] = 0; +inp[9160] = 9289686; +inp[9161] = 0; +inp[9162] = 8198119; +inp[9163] = 0; +inp[9164] = 7234815; +inp[9165] = 0; +inp[9166] = 6384702; +inp[9167] = 0; +inp[9168] = 5634479; +inp[9169] = 0; +inp[9170] = 4972411; +inp[9171] = 0; +inp[9172] = 4388137; +inp[9173] = 0; +inp[9174] = 3872517; +inp[9175] = 0; +inp[9176] = 3417484; +inp[9177] = 0; +inp[9178] = 3015919; +inp[9179] = 0; +inp[9180] = 2661539; +inp[9181] = 0; +inp[9182] = 2348800; +inp[9183] = 0; +inp[9184] = 2072809; +inp[9185] = 0; +inp[9186] = 1829247; +inp[9187] = 0; +inp[9188] = 1614305; +inp[9189] = 0; +inp[9190] = 1424619; +inp[9191] = 0; +inp[9192] = 1257222; +inp[9193] = 0; +inp[9194] = 1109494; +inp[9195] = 0; +inp[9196] = 979125; +inp[9197] = 0; +inp[9198] = 864075; +inp[9199] = 0; +inp[9200] = 762543; +inp[9201] = 0; +inp[9202] = 672942; +inp[9203] = 0; +inp[9204] = 593869; +inp[9205] = 0; +inp[9206] = 524088; +inp[9207] = 0; +inp[9208] = 462506; +inp[9209] = 0; +inp[9210] = 408160; +inp[9211] = 0; +inp[9212] = 360200; +inp[9213] = 0; +inp[9214] = 317875; +inp[9215] = 0; +inp[9216] = 280524; +inp[9217] = 0; +inp[9218] = 247561; +inp[9219] = 0; +inp[9220] = 218472; +inp[9221] = 0; +inp[9222] = 192801; +inp[9223] = 0; +inp[9224] = 170146; +inp[9225] = 0; +inp[9226] = 150153; +inp[9227] = 0; +inp[9228] = 132510; +inp[9229] = 0; +inp[9230] = 116939; +inp[9231] = 0; +inp[9232] = 103199; +inp[9233] = 0; +inp[9234] = 91072; +inp[9235] = 0; +inp[9236] = 80371; +inp[9237] = 0; +inp[9238] = 70927; +inp[9239] = 0; +inp[9240] = 62593; +inp[9241] = 0; +inp[9242] = 55238; +inp[9243] = 0; +inp[9244] = 48747; +inp[9245] = 0; +inp[9246] = 43019; +inp[9247] = 0; +inp[9248] = 37964; +inp[9249] = 0; +inp[9250] = 33503; +inp[9251] = 0; +inp[9252] = 29567; +inp[9253] = 0; +inp[9254] = 26092; +inp[9255] = 0; +inp[9256] = 23026; +inp[9257] = 0; +inp[9258] = 20321; +inp[9259] = 0; +inp[9260] = 17933; +inp[9261] = 0; +inp[9262] = 15826; +inp[9263] = 0; +inp[9264] = 13966; +inp[9265] = 0; +inp[9266] = 12325; +inp[9267] = 0; +inp[9268] = 10877; +inp[9269] = 0; +inp[9270] = 9599; +inp[9271] = 0; +inp[9272] = 8471; +inp[9273] = 0; +inp[9274] = 7475; +inp[9275] = 0; +inp[9276] = 6597; +inp[9277] = 0; +inp[9278] = 5822; +inp[9279] = 0; +inp[9280] = 5137; +inp[9281] = 0; +inp[9282] = 4534; +inp[9283] = 0; +inp[9284] = 4001; +inp[9285] = 0; +inp[9286] = 3531; +inp[9287] = 0; +inp[9288] = 3116; +inp[9289] = 0; +inp[9290] = 2750; +inp[9291] = 0; +inp[9292] = 2427; +inp[9293] = 0; +inp[9294] = 2141; +inp[9295] = 0; +inp[9296] = 1890; +inp[9297] = 0; +inp[9298] = 1668; +inp[9299] = 0; +inp[9300] = 1472; +inp[9301] = 0; +inp[9302] = 1299; +inp[9303] = 0; +inp[9304] = 1146; +inp[9305] = 0; +inp[9306] = 1011; +inp[9307] = 0; +inp[9308] = 892; +inp[9309] = 0; +inp[9310] = 787; +inp[9311] = 0; +inp[9312] = 695; +inp[9313] = 0; +inp[9314] = 613; +inp[9315] = 0; +inp[9316] = 541; +inp[9317] = 0; +inp[9318] = 477; +inp[9319] = 0; +inp[9320] = 421; +inp[9321] = 0; +inp[9322] = 372; +inp[9323] = 0; +inp[9324] = 328; +inp[9325] = 0; +inp[9326] = 289; +inp[9327] = 0; +inp[9328] = 255; +inp[9329] = 0; +inp[9330] = 225; +inp[9331] = 0; +inp[9332] = 199; +inp[9333] = 0; +inp[9334] = 175; +inp[9335] = 0; +inp[9336] = 155; +inp[9337] = 0; +inp[9338] = 136; +inp[9339] = 0; +inp[9340] = 1073741824; +inp[9341] = 1073741824; +inp[9342] = 1008687095; +inp[9343] = 120; +inp[9344] = 947573833; +inp[9345] = 0; +inp[9346] = 890163237; +inp[9347] = 0; +inp[9348] = 836230973; +inp[9349] = 0; +inp[9350] = 785566299; +inp[9351] = 0; +inp[9352] = 737971243; +inp[9353] = 0; +inp[9354] = 693259826; +inp[9355] = 0; +inp[9356] = 651257336; +inp[9357] = 0; +inp[9358] = 611799649; +inp[9359] = 0; +inp[9360] = 574732582; +inp[9361] = 0; +inp[9362] = 539911295; +inp[9363] = 0; +inp[9364] = 507199723; +inp[9365] = 0; +inp[9366] = 476470046; +inp[9367] = 0; +inp[9368] = 447602185; +inp[9369] = 0; +inp[9370] = 420483339; +inp[9371] = 0; +inp[9372] = 395007542; +inp[9373] = 0; +inp[9374] = 371075245; +inp[9375] = 0; +inp[9376] = 348592932; +inp[9377] = 0; +inp[9378] = 327472754; +inp[9379] = 0; +inp[9380] = 307632183; +inp[9381] = 0; +inp[9382] = 288993691; +inp[9383] = 0; +inp[9384] = 271484448; +inp[9385] = 0; +inp[9386] = 255036037; +inp[9387] = 0; +inp[9388] = 239584185; +inp[9389] = 0; +inp[9390] = 225068513; +inp[9391] = 0; +inp[9392] = 211432301; +inp[9393] = 0; +inp[9394] = 198622265; +inp[9395] = 0; +inp[9396] = 186588351; +inp[9397] = 0; +inp[9398] = 175283534; +inp[9399] = 0; +inp[9400] = 164663641; +inp[9401] = 0; +inp[9402] = 154687176; +inp[9403] = 0; +inp[9404] = 145315153; +inp[9405] = 0; +inp[9406] = 136510953; +inp[9407] = 0; +inp[9408] = 128240173; +inp[9409] = 0; +inp[9410] = 120470493; +inp[9411] = 0; +inp[9412] = 113171555; +inp[9413] = 0; +inp[9414] = 106314837; +inp[9415] = 0; +inp[9416] = 99873547; +inp[9417] = 0; +inp[9418] = 93822514; +inp[9419] = 0; +inp[9420] = 88138096; +inp[9421] = 0; +inp[9422] = 82798078; +inp[9423] = 0; +inp[9424] = 77781596; +inp[9425] = 0; +inp[9426] = 73069048; +inp[9427] = 0; +inp[9428] = 68642018; +inp[9429] = 0; +inp[9430] = 64483208; +inp[9431] = 0; +inp[9432] = 60576368; +inp[9433] = 0; +inp[9434] = 56906231; +inp[9435] = 0; +inp[9436] = 53458457; +inp[9437] = 0; +inp[9438] = 50219573; +inp[9439] = 0; +inp[9440] = 47176923; +inp[9441] = 0; +inp[9442] = 44318617; +inp[9443] = 0; +inp[9444] = 41633488; +inp[9445] = 0; +inp[9446] = 39111043; +inp[9447] = 0; +inp[9448] = 36741424; +inp[9449] = 0; +inp[9450] = 34515374; +inp[9451] = 0; +inp[9452] = 32424193; +inp[9453] = 0; +inp[9454] = 30459710; +inp[9455] = 0; +inp[9456] = 28614250; +inp[9457] = 0; +inp[9458] = 26880600; +inp[9459] = 0; +inp[9460] = 25251987; +inp[9461] = 0; +inp[9462] = 23722046; +inp[9463] = 0; +inp[9464] = 22284800; +inp[9465] = 0; +inp[9466] = 20934632; +inp[9467] = 0; +inp[9468] = 19666267; +inp[9469] = 0; +inp[9470] = 18474748; +inp[9471] = 0; +inp[9472] = 17355420; +inp[9473] = 0; +inp[9474] = 16303908; +inp[9475] = 0; +inp[9476] = 15316104; +inp[9477] = 0; +inp[9478] = 14388148; +inp[9479] = 0; +inp[9480] = 13516414; +inp[9481] = 0; +inp[9482] = 12697496; +inp[9483] = 0; +inp[9484] = 11928194; +inp[9485] = 0; +inp[9486] = 11205501; +inp[9487] = 0; +inp[9488] = 10526594; +inp[9489] = 0; +inp[9490] = 9888820; +inp[9491] = 0; +inp[9492] = 9289686; +inp[9493] = 0; +inp[9494] = 8726853; +inp[9495] = 0; +inp[9496] = 8198119; +inp[9497] = 0; +inp[9498] = 7701421; +inp[9499] = 0; +inp[9500] = 7234815; +inp[9501] = 0; +inp[9502] = 6796480; +inp[9503] = 0; +inp[9504] = 6384702; +inp[9505] = 0; +inp[9506] = 5997872; +inp[9507] = 0; +inp[9508] = 5634479; +inp[9509] = 0; +inp[9510] = 5293104; +inp[9511] = 0; +inp[9512] = 4972411; +inp[9513] = 0; +inp[9514] = 4671147; +inp[9515] = 0; +inp[9516] = 4388137; +inp[9517] = 0; +inp[9518] = 4122273; +inp[9519] = 0; +inp[9520] = 3872517; +inp[9521] = 0; +inp[9522] = 3637893; +inp[9523] = 0; +inp[9524] = 3417484; +inp[9525] = 0; +inp[9526] = 3210429; +inp[9527] = 0; +inp[9528] = 3015919; +inp[9529] = 0; +inp[9530] = 2833194; +inp[9531] = 0; +inp[9532] = 2661539; +inp[9533] = 0; +inp[9534] = 2500285; +inp[9535] = 0; +inp[9536] = 2348800; +inp[9537] = 0; +inp[9538] = 2206494; +inp[9539] = 0; +inp[9540] = 2072809; +inp[9541] = 0; +inp[9542] = 1947224; +inp[9543] = 0; +inp[9544] = 1829247; +inp[9545] = 0; +inp[9546] = 1718419; +inp[9547] = 0; +inp[9548] = 1614305; +inp[9549] = 0; +inp[9550] = 1516499; +inp[9551] = 0; +inp[9552] = 1424619; +inp[9553] = 0; +inp[9554] = 1338306; +inp[9555] = 0; +inp[9556] = 1257222; +inp[9557] = 0; +inp[9558] = 1181051; +inp[9559] = 0; +inp[9560] = 1109494; +inp[9561] = 0; +inp[9562] = 1042273; +inp[9563] = 0; +inp[9564] = 979125; +inp[9565] = 0; +inp[9566] = 919803; +inp[9567] = 0; +inp[9568] = 864075; +inp[9569] = 0; +inp[9570] = 811723; +inp[9571] = 0; +inp[9572] = 762543; +inp[9573] = 0; +inp[9574] = 716343; +inp[9575] = 0; +inp[9576] = 672942; +inp[9577] = 0; +inp[9578] = 632171; +inp[9579] = 0; +inp[9580] = 593869; +inp[9581] = 0; +inp[9582] = 557889; +inp[9583] = 0; +inp[9584] = 524088; +inp[9585] = 0; +inp[9586] = 492335; +inp[9587] = 0; +inp[9588] = 462506; +inp[9589] = 0; +inp[9590] = 434484; +inp[9591] = 0; +inp[9592] = 408160; +inp[9593] = 0; +inp[9594] = 383431; +inp[9595] = 0; +inp[9596] = 1073741824; +inp[9597] = 1073741824; +inp[9598] = 1040706261; +inp[9599] = 0; +inp[9600] = 1008687095; +inp[9601] = 0; +inp[9602] = 977653056; +inp[9603] = 0; +inp[9604] = 947573833; +inp[9605] = 0; +inp[9606] = 918420051; +inp[9607] = 0; +inp[9608] = 890163237; +inp[9609] = 0; +inp[9610] = 862775793; +inp[9611] = 0; +inp[9612] = 836230973; +inp[9613] = 0; +inp[9614] = 810502851; +inp[9615] = 0; +inp[9616] = 785566299; +inp[9617] = 0; +inp[9618] = 761396965; +inp[9619] = 0; +inp[9620] = 737971243; +inp[9621] = 0; +inp[9622] = 715266255; +inp[9623] = 0; +inp[9624] = 693259826; +inp[9625] = 0; +inp[9626] = 671930463; +inp[9627] = 0; +inp[9628] = 651257336; +inp[9629] = 0; +inp[9630] = 631220255; +inp[9631] = 0; +inp[9632] = 611799649; +inp[9633] = 0; +inp[9634] = 592976553; +inp[9635] = 0; +inp[9636] = 574732582; +inp[9637] = 0; +inp[9638] = 557049919; +inp[9639] = 0; +inp[9640] = 539911295; +inp[9641] = 0; +inp[9642] = 523299971; +inp[9643] = 0; +inp[9644] = 507199723; +inp[9645] = 0; +inp[9646] = 491594828; +inp[9647] = 0; +inp[9648] = 476470046; +inp[9649] = 0; +inp[9650] = 461810603; +inp[9651] = 0; +inp[9652] = 447602185; +inp[9653] = 0; +inp[9654] = 433830913; +inp[9655] = 0; +inp[9656] = 420483339; +inp[9657] = 0; +inp[9658] = 407546427; +inp[9659] = 0; +inp[9660] = 395007542; +inp[9661] = 0; +inp[9662] = 382854437; +inp[9663] = 0; +inp[9664] = 371075245; +inp[9665] = 0; +inp[9666] = 359658459; +inp[9667] = 0; +inp[9668] = 348592932; +inp[9669] = 0; +inp[9670] = 337867855; +inp[9671] = 0; +inp[9672] = 327472754; +inp[9673] = 0; +inp[9674] = 317397476; +inp[9675] = 0; +inp[9676] = 307632183; +inp[9677] = 0; +inp[9678] = 298167335; +inp[9679] = 0; +inp[9680] = 288993691; +inp[9681] = 0; +inp[9682] = 280102290; +inp[9683] = 0; +inp[9684] = 271484448; +inp[9685] = 0; +inp[9686] = 263131750; +inp[9687] = 0; +inp[9688] = 255036037; +inp[9689] = 0; +inp[9690] = 247189403; +inp[9691] = 0; +inp[9692] = 239584185; +inp[9693] = 0; +inp[9694] = 232212954; +inp[9695] = 0; +inp[9696] = 225068513; +inp[9697] = 0; +inp[9698] = 218143882; +inp[9699] = 0; +inp[9700] = 211432301; +inp[9701] = 0; +inp[9702] = 204927213; +inp[9703] = 0; +inp[9704] = 198622265; +inp[9705] = 0; +inp[9706] = 192511301; +inp[9707] = 0; +inp[9708] = 186588351; +inp[9709] = 0; +inp[9710] = 180847630; +inp[9711] = 0; +inp[9712] = 175283534; +inp[9713] = 0; +inp[9714] = 169890626; +inp[9715] = 0; +inp[9716] = 164663641; +inp[9717] = 0; +inp[9718] = 159597474; +inp[9719] = 0; +inp[9720] = 154687176; +inp[9721] = 0; +inp[9722] = 149927952; +inp[9723] = 0; +inp[9724] = 145315153; +inp[9725] = 0; +inp[9726] = 140844276; +inp[9727] = 0; +inp[9728] = 136510953; +inp[9729] = 0; +inp[9730] = 132310953; +inp[9731] = 0; +inp[9732] = 128240173; +inp[9733] = 0; +inp[9734] = 124294637; +inp[9735] = 0; +inp[9736] = 120470493; +inp[9737] = 0; +inp[9738] = 116764006; +inp[9739] = 0; +inp[9740] = 113171555; +inp[9741] = 0; +inp[9742] = 109689632; +inp[9743] = 0; +inp[9744] = 106314837; +inp[9745] = 0; +inp[9746] = 103043874; +inp[9747] = 0; +inp[9748] = 99873547; +inp[9749] = 0; +inp[9750] = 96800761; +inp[9751] = 0; +inp[9752] = 93822514; +inp[9753] = 0; +inp[9754] = 90935899; +inp[9755] = 0; +inp[9756] = 88138096; +inp[9757] = 0; +inp[9758] = 85426372; +inp[9759] = 0; +inp[9760] = 82798078; +inp[9761] = 0; +inp[9762] = 80250649; +inp[9763] = 0; +inp[9764] = 77781596; +inp[9765] = 0; +inp[9766] = 75388508; +inp[9767] = 0; +inp[9768] = 73069048; +inp[9769] = 0; +inp[9770] = 70820949; +inp[9771] = 0; +inp[9772] = 68642018; +inp[9773] = 0; +inp[9774] = 66530125; +inp[9775] = 0; +inp[9776] = 64483208; +inp[9777] = 0; +inp[9778] = 62499268; +inp[9779] = 0; +inp[9780] = 60576368; +inp[9781] = 0; +inp[9782] = 58712629; +inp[9783] = 0; +inp[9784] = 56906231; +inp[9785] = 0; +inp[9786] = 55155411; +inp[9787] = 0; +inp[9788] = 53458457; +inp[9789] = 0; +inp[9790] = 51813713; +inp[9791] = 0; +inp[9792] = 50219573; +inp[9793] = 0; +inp[9794] = 48674479; +inp[9795] = 0; +inp[9796] = 47176923; +inp[9797] = 0; +inp[9798] = 45725441; +inp[9799] = 0; +inp[9800] = 44318617; +inp[9801] = 0; +inp[9802] = 42955077; +inp[9803] = 0; +inp[9804] = 41633488; +inp[9805] = 0; +inp[9806] = 40352560; +inp[9807] = 0; +inp[9808] = 39111043; +inp[9809] = 0; +inp[9810] = 37907722; +inp[9811] = 0; +inp[9812] = 36741424; +inp[9813] = 0; +inp[9814] = 35611009; +inp[9815] = 0; +inp[9816] = 34515374; +inp[9817] = 0; +inp[9818] = 33453447; +inp[9819] = 0; +inp[9820] = 32424193; +inp[9821] = 0; +inp[9822] = 31426605; +inp[9823] = 0; +inp[9824] = 30459710; +inp[9825] = 0; +inp[9826] = 29522564; +inp[9827] = 0; +inp[9828] = 28614250; +inp[9829] = 0; +inp[9830] = 27733882; +inp[9831] = 0; +inp[9832] = 26880600; +inp[9833] = 0; +inp[9834] = 26053571; +inp[9835] = 0; +inp[9836] = 25251987; +inp[9837] = 0; +inp[9838] = 24475065; +inp[9839] = 0; +inp[9840] = 23722046; +inp[9841] = 0; +inp[9842] = 22992196; +inp[9843] = 0; +inp[9844] = 22284800; +inp[9845] = 0; +inp[9846] = 21599169; +inp[9847] = 0; +inp[9848] = 20934632; +inp[9849] = 0; +inp[9850] = 20290541; +inp[9851] = 0; +inp[9852] = 1073741824; +inp[9853] = 1073741824; +inp[9854] = 1057094999; +inp[9855] = 0; +inp[9856] = 1040706261; +inp[9857] = 0; +inp[9858] = 1024571605; +inp[9859] = 0; +inp[9860] = 1008687095; +inp[9861] = 0; +inp[9862] = 993048851; +inp[9863] = 0; +inp[9864] = 977653056; +inp[9865] = 0; +inp[9866] = 962495950; +inp[9867] = 0; +inp[9868] = 947573833; +inp[9869] = 0; +inp[9870] = 932883063; +inp[9871] = 0; +inp[9872] = 918420051; +inp[9873] = 0; +inp[9874] = 904181268; +inp[9875] = 0; +inp[9876] = 890163237; +inp[9877] = 0; +inp[9878] = 876362535; +inp[9879] = 0; +inp[9880] = 862775793; +inp[9881] = 0; +inp[9882] = 849399695; +inp[9883] = 0; +inp[9884] = 836230973; +inp[9885] = 0; +inp[9886] = 823266413; +inp[9887] = 0; +inp[9888] = 810502851; +inp[9889] = 0; +inp[9890] = 797937169; +inp[9891] = 0; +inp[9892] = 785566299; +inp[9893] = 0; +inp[9894] = 773387223; +inp[9895] = 0; +inp[9896] = 761396965; +inp[9897] = 0; +inp[9898] = 749592599; +inp[9899] = 0; +inp[9900] = 737971243; +inp[9901] = 0; +inp[9902] = 726530060; +inp[9903] = 0; +inp[9904] = 715266255; +inp[9905] = 0; +inp[9906] = 704177080; +inp[9907] = 0; +inp[9908] = 693259826; +inp[9909] = 0; +inp[9910] = 682511829; +inp[9911] = 0; +inp[9912] = 671930463; +inp[9913] = 0; +inp[9914] = 661513147; +inp[9915] = 0; +inp[9916] = 651257336; +inp[9917] = 0; +inp[9918] = 641160527; +inp[9919] = 0; +inp[9920] = 631220255; +inp[9921] = 0; +inp[9922] = 621434092; +inp[9923] = 0; +inp[9924] = 611799649; +inp[9925] = 0; +inp[9926] = 602314575; +inp[9927] = 0; +inp[9928] = 592976553; +inp[9929] = 0; +inp[9930] = 583783303; +inp[9931] = 0; +inp[9932] = 574732582; +inp[9933] = 0; +inp[9934] = 565822179; +inp[9935] = 0; +inp[9936] = 557049919; +inp[9937] = 0; +inp[9938] = 548413661; +inp[9939] = 0; +inp[9940] = 539911295; +inp[9941] = 0; +inp[9942] = 531540746; +inp[9943] = 0; +inp[9944] = 523299971; +inp[9945] = 0; +inp[9946] = 515186957; +inp[9947] = 0; +inp[9948] = 507199723; +inp[9949] = 0; +inp[9950] = 499336321; +inp[9951] = 0; +inp[9952] = 491594828; +inp[9953] = 0; +inp[9954] = 483973357; +inp[9955] = 0; +inp[9956] = 476470046; +inp[9957] = 0; +inp[9958] = 469083062; +inp[9959] = 0; +inp[9960] = 461810603; +inp[9961] = 0; +inp[9962] = 454650894; +inp[9963] = 0; +inp[9964] = 447602185; +inp[9965] = 0; +inp[9966] = 440662756; +inp[9967] = 0; +inp[9968] = 433830913; +inp[9969] = 0; +inp[9970] = 427104988; +inp[9971] = 0; +inp[9972] = 420483339; +inp[9973] = 0; +inp[9974] = 413964349; +inp[9975] = 0; +inp[9976] = 407546427; +inp[9977] = 0; +inp[9978] = 401228005; +inp[9979] = 0; +inp[9980] = 395007542; +inp[9981] = 0; +inp[9982] = 388883517; +inp[9983] = 0; +inp[9984] = 382854437; +inp[9985] = 0; +inp[9986] = 376918829; +inp[9987] = 0; +inp[9988] = 371075245; +inp[9989] = 0; +inp[9990] = 365322256; +inp[9991] = 0; +inp[9992] = 359658459; +inp[9993] = 0; +inp[9994] = 354082472; +inp[9995] = 0; +inp[9996] = 348592932; +inp[9997] = 0; +inp[9998] = 343188499; +inp[9999] = 0; +inp[10000] = 337867855; +inp[10001] = 0; +inp[10002] = 332629699; +inp[10003] = 0; +inp[10004] = 327472754; +inp[10005] = 0; +inp[10006] = 322395759; +inp[10007] = 0; +inp[10008] = 317397476; +inp[10009] = 0; +inp[10010] = 312476685; +inp[10011] = 0; +inp[10012] = 307632183; +inp[10013] = 0; +inp[10014] = 302862788; +inp[10015] = 0; +inp[10016] = 298167335; +inp[10017] = 0; +inp[10018] = 293544679; +inp[10019] = 0; +inp[10020] = 288993691; +inp[10021] = 0; +inp[10022] = 284513259; +inp[10023] = 0; +inp[10024] = 280102290; +inp[10025] = 0; +inp[10026] = 275759706; +inp[10027] = 0; +inp[10028] = 271484448; +inp[10029] = 0; +inp[10030] = 267275472; +inp[10031] = 0; +inp[10032] = 263131750; +inp[10033] = 0; +inp[10034] = 259052270; +inp[10035] = 0; +inp[10036] = 255036037; +inp[10037] = 0; +inp[10038] = 251082070; +inp[10039] = 0; +inp[10040] = 247189403; +inp[10041] = 0; +inp[10042] = 243357087; +inp[10043] = 0; +inp[10044] = 239584185; +inp[10045] = 0; +inp[10046] = 235869776; +inp[10047] = 0; +inp[10048] = 232212954; +inp[10049] = 0; +inp[10050] = 228612826; +inp[10051] = 0; +inp[10052] = 225068513; +inp[10053] = 0; +inp[10054] = 221579149; +inp[10055] = 0; +inp[10056] = 218143882; +inp[10057] = 0; +inp[10058] = 214761875; +inp[10059] = 0; +inp[10060] = 211432301; +inp[10061] = 0; +inp[10062] = 208154347; +inp[10063] = 0; +inp[10064] = 204927213; +inp[10065] = 0; +inp[10066] = 201750111; +inp[10067] = 0; +inp[10068] = 198622265; +inp[10069] = 0; +inp[10070] = 195542912; +inp[10071] = 0; +inp[10072] = 192511301; +inp[10073] = 0; +inp[10074] = 189526689; +inp[10075] = 0; +inp[10076] = 186588351; +inp[10077] = 0; +inp[10078] = 183695566; +inp[10079] = 0; +inp[10080] = 180847630; +inp[10081] = 0; +inp[10082] = 178043848; +inp[10083] = 0; +inp[10084] = 175283534; +inp[10085] = 0; +inp[10086] = 172566014; +inp[10087] = 0; +inp[10088] = 169890626; +inp[10089] = 0; +inp[10090] = 167256716; +inp[10091] = 0; +inp[10092] = 164663641; +inp[10093] = 0; +inp[10094] = 162110768; +inp[10095] = 0; +inp[10096] = 159597474; +inp[10097] = 0; +inp[10098] = 157123144; +inp[10099] = 0; +inp[10100] = 154687176; +inp[10101] = 0; +inp[10102] = 152288973; +inp[10103] = 0; +inp[10104] = 149927952; +inp[10105] = 0; +inp[10106] = 147603534; +inp[10107] = 0; +inp[10108] = 1073741824; +inp[10109] = 1073741824; +inp[10110] = 1065385898; +inp[10111] = 0; +inp[10112] = 1057094999; +inp[10113] = 0; +inp[10114] = 1048868621; +inp[10115] = 0; +inp[10116] = 1040706261; +inp[10117] = 0; +inp[10118] = 1032607420; +inp[10119] = 0; +inp[10120] = 1024571605; +inp[10121] = 0; +inp[10122] = 1016598326; +inp[10123] = 0; +inp[10124] = 1008687095; +inp[10125] = 0; +inp[10126] = 1000837430; +inp[10127] = 0; +inp[10128] = 993048851; +inp[10129] = 0; +inp[10130] = 985320884; +inp[10131] = 0; +inp[10132] = 977653056; +inp[10133] = 0; +inp[10134] = 970044899; +inp[10135] = 0; +inp[10136] = 962495950; +inp[10137] = 0; +inp[10138] = 955005747; +inp[10139] = 0; +inp[10140] = 947573833; +inp[10141] = 0; +inp[10142] = 940199755; +inp[10143] = 0; +inp[10144] = 932883063; +inp[10145] = 0; +inp[10146] = 925623309; +inp[10147] = 0; +inp[10148] = 918420051; +inp[10149] = 0; +inp[10150] = 911272850; +inp[10151] = 0; +inp[10152] = 904181268; +inp[10153] = 0; +inp[10154] = 897144874; +inp[10155] = 0; +inp[10156] = 890163237; +inp[10157] = 0; +inp[10158] = 883235932; +inp[10159] = 0; +inp[10160] = 876362535; +inp[10161] = 0; +inp[10162] = 869542628; +inp[10163] = 0; +inp[10164] = 862775793; +inp[10165] = 0; +inp[10166] = 856061619; +inp[10167] = 0; +inp[10168] = 849399695; +inp[10169] = 0; +inp[10170] = 842789614; +inp[10171] = 0; +inp[10172] = 836230973; +inp[10173] = 0; +inp[10174] = 829723372; +inp[10175] = 0; +inp[10176] = 823266413; +inp[10177] = 0; +inp[10178] = 816859703; +inp[10179] = 0; +inp[10180] = 810502851; +inp[10181] = 0; +inp[10182] = 804195467; +inp[10183] = 0; +inp[10184] = 797937169; +inp[10185] = 0; +inp[10186] = 791727572; +inp[10187] = 0; +inp[10188] = 785566299; +inp[10189] = 0; +inp[10190] = 779452974; +inp[10191] = 0; +inp[10192] = 773387223; +inp[10193] = 0; +inp[10194] = 767368676; +inp[10195] = 0; +inp[10196] = 761396965; +inp[10197] = 0; +inp[10198] = 755471727; +inp[10199] = 0; +inp[10200] = 749592599; +inp[10201] = 0; +inp[10202] = 743759224; +inp[10203] = 0; +inp[10204] = 737971243; +inp[10205] = 0; +inp[10206] = 732228306; +inp[10207] = 0; +inp[10208] = 726530060; +inp[10209] = 0; +inp[10210] = 720876158; +inp[10211] = 0; +inp[10212] = 715266255; +inp[10213] = 0; +inp[10214] = 709700009; +inp[10215] = 0; +inp[10216] = 704177080; +inp[10217] = 0; +inp[10218] = 698697130; +inp[10219] = 0; +inp[10220] = 693259826; +inp[10221] = 0; +inp[10222] = 687864835; +inp[10223] = 0; +inp[10224] = 682511829; +inp[10225] = 0; +inp[10226] = 677200479; +inp[10227] = 0; +inp[10228] = 671930463; +inp[10229] = 0; +inp[10230] = 666701459; +inp[10231] = 0; +inp[10232] = 661513147; +inp[10233] = 0; +inp[10234] = 656365211; +inp[10235] = 0; +inp[10236] = 651257336; +inp[10237] = 0; +inp[10238] = 646189212; +inp[10239] = 0; +inp[10240] = 641160527; +inp[10241] = 0; +inp[10242] = 636170976; +inp[10243] = 0; +inp[10244] = 631220255; +inp[10245] = 0; +inp[10246] = 626308060; +inp[10247] = 0; +inp[10248] = 621434092; +inp[10249] = 0; +inp[10250] = 616598053; +inp[10251] = 0; +inp[10252] = 611799649; +inp[10253] = 0; +inp[10254] = 607038586; +inp[10255] = 0; +inp[10256] = 602314575; +inp[10257] = 0; +inp[10258] = 597627325; +inp[10259] = 0; +inp[10260] = 592976553; +inp[10261] = 0; +inp[10262] = 588361972; +inp[10263] = 0; +inp[10264] = 583783303; +inp[10265] = 0; +inp[10266] = 579240266; +inp[10267] = 0; +inp[10268] = 574732582; +inp[10269] = 0; +inp[10270] = 570259978; +inp[10271] = 0; +inp[10272] = 565822179; +inp[10273] = 0; +inp[10274] = 561418916; +inp[10275] = 0; +inp[10276] = 557049919; +inp[10277] = 0; +inp[10278] = 552714923; +inp[10279] = 0; +inp[10280] = 548413661; +inp[10281] = 0; +inp[10282] = 544145872; +inp[10283] = 0; +inp[10284] = 539911295; +inp[10285] = 0; +inp[10286] = 535709672; +inp[10287] = 0; +inp[10288] = 531540746; +inp[10289] = 0; +inp[10290] = 527404264; +inp[10291] = 0; +inp[10292] = 523299971; +inp[10293] = 0; +inp[10294] = 519227618; +inp[10295] = 0; +inp[10296] = 515186957; +inp[10297] = 0; +inp[10298] = 511177740; +inp[10299] = 0; +inp[10300] = 507199723; +inp[10301] = 0; +inp[10302] = 503252664; +inp[10303] = 0; +inp[10304] = 499336321; +inp[10305] = 0; +inp[10306] = 495450454; +inp[10307] = 0; +inp[10308] = 491594828; +inp[10309] = 0; +inp[10310] = 487769207; +inp[10311] = 0; +inp[10312] = 483973357; +inp[10313] = 0; +inp[10314] = 480207047; +inp[10315] = 0; +inp[10316] = 476470046; +inp[10317] = 0; +inp[10318] = 472762126; +inp[10319] = 0; +inp[10320] = 469083062; +inp[10321] = 0; +inp[10322] = 465432629; +inp[10323] = 0; +inp[10324] = 461810603; +inp[10325] = 0; +inp[10326] = 458216765; +inp[10327] = 0; +inp[10328] = 454650894; +inp[10329] = 0; +inp[10330] = 451112772; +inp[10331] = 0; +inp[10332] = 447602185; +inp[10333] = 0; +inp[10334] = 444118917; +inp[10335] = 0; +inp[10336] = 440662756; +inp[10337] = 0; +inp[10338] = 437233491; +inp[10339] = 0; +inp[10340] = 433830913; +inp[10341] = 0; +inp[10342] = 430454814; +inp[10343] = 0; +inp[10344] = 427104988; +inp[10345] = 0; +inp[10346] = 423781231; +inp[10347] = 0; +inp[10348] = 420483339; +inp[10349] = 0; +inp[10350] = 417211112; +inp[10351] = 0; +inp[10352] = 413964349; +inp[10353] = 0; +inp[10354] = 410742853; +inp[10355] = 0; +inp[10356] = 407546427; +inp[10357] = 0; +inp[10358] = 404374876; +inp[10359] = 0; +inp[10360] = 401228005; +inp[10361] = 0; +inp[10362] = 398105624; +inp[10363] = 0; +inp[10364] = 1073741824; +inp[10365] = 1073741824; +inp[10366] = 1069555701; +inp[10367] = 0; +inp[10368] = 1065385898; +inp[10369] = 0; +inp[10370] = 1061232352; +inp[10371] = 0; +inp[10372] = 1057094999; +inp[10373] = 0; +inp[10374] = 1052973777; +inp[10375] = 0; +inp[10376] = 1048868621; +inp[10377] = 0; +inp[10378] = 1044779470; +inp[10379] = 0; +inp[10380] = 1040706261; +inp[10381] = 0; +inp[10382] = 1036648931; +inp[10383] = 0; +inp[10384] = 1032607420; +inp[10385] = 0; +inp[10386] = 1028581665; +inp[10387] = 0; +inp[10388] = 1024571605; +inp[10389] = 0; +inp[10390] = 1020577179; +inp[10391] = 0; +inp[10392] = 1016598326; +inp[10393] = 0; +inp[10394] = 1012634985; +inp[10395] = 0; +inp[10396] = 1008687095; +inp[10397] = 0; +inp[10398] = 1004754597; +inp[10399] = 0; +inp[10400] = 1000837430; +inp[10401] = 0; +inp[10402] = 996935534; +inp[10403] = 0; +inp[10404] = 993048851; +inp[10405] = 0; +inp[10406] = 989177321; +inp[10407] = 0; +inp[10408] = 985320884; +inp[10409] = 0; +inp[10410] = 981479482; +inp[10411] = 0; +inp[10412] = 977653056; +inp[10413] = 0; +inp[10414] = 973841548; +inp[10415] = 0; +inp[10416] = 970044899; +inp[10417] = 0; +inp[10418] = 966263053; +inp[10419] = 0; +inp[10420] = 962495950; +inp[10421] = 0; +inp[10422] = 958743534; +inp[10423] = 0; +inp[10424] = 955005747; +inp[10425] = 0; +inp[10426] = 951282532; +inp[10427] = 0; +inp[10428] = 947573833; +inp[10429] = 0; +inp[10430] = 943879593; +inp[10431] = 0; +inp[10432] = 940199755; +inp[10433] = 0; +inp[10434] = 936534264; +inp[10435] = 0; +inp[10436] = 932883063; +inp[10437] = 0; +inp[10438] = 929246096; +inp[10439] = 0; +inp[10440] = 925623309; +inp[10441] = 0; +inp[10442] = 922014646; +inp[10443] = 0; +inp[10444] = 918420051; +inp[10445] = 0; +inp[10446] = 914839471; +inp[10447] = 0; +inp[10448] = 911272850; +inp[10449] = 0; +inp[10450] = 907720134; +inp[10451] = 0; +inp[10452] = 904181268; +inp[10453] = 0; +inp[10454] = 900656200; +inp[10455] = 0; +inp[10456] = 897144874; +inp[10457] = 0; +inp[10458] = 893647237; +inp[10459] = 0; +inp[10460] = 890163237; +inp[10461] = 0; +inp[10462] = 886692819; +inp[10463] = 0; +inp[10464] = 883235932; +inp[10465] = 0; +inp[10466] = 879792521; +inp[10467] = 0; +inp[10468] = 876362535; +inp[10469] = 0; +inp[10470] = 872945921; +inp[10471] = 0; +inp[10472] = 869542628; +inp[10473] = 0; +inp[10474] = 866152602; +inp[10475] = 0; +inp[10476] = 862775793; +inp[10477] = 0; +inp[10478] = 859412149; +inp[10479] = 0; +inp[10480] = 856061619; +inp[10481] = 0; +inp[10482] = 852724151; +inp[10483] = 0; +inp[10484] = 849399695; +inp[10485] = 0; +inp[10486] = 846088199; +inp[10487] = 0; +inp[10488] = 842789614; +inp[10489] = 0; +inp[10490] = 839503888; +inp[10491] = 0; +inp[10492] = 836230973; +inp[10493] = 0; +inp[10494] = 832970817; +inp[10495] = 0; +inp[10496] = 829723372; +inp[10497] = 0; +inp[10498] = 826488587; +inp[10499] = 0; +inp[10500] = 823266413; +inp[10501] = 0; +inp[10502] = 820056802; +inp[10503] = 0; +inp[10504] = 816859703; +inp[10505] = 0; +inp[10506] = 813675069; +inp[10507] = 0; +inp[10508] = 810502851; +inp[10509] = 0; +inp[10510] = 807342999; +inp[10511] = 0; +inp[10512] = 804195467; +inp[10513] = 0; +inp[10514] = 801060206; +inp[10515] = 0; +inp[10516] = 797937169; +inp[10517] = 0; +inp[10518] = 794826306; +inp[10519] = 0; +inp[10520] = 791727572; +inp[10521] = 0; +inp[10522] = 788640919; +inp[10523] = 0; +inp[10524] = 785566299; +inp[10525] = 0; +inp[10526] = 782503667; +inp[10527] = 0; +inp[10528] = 779452974; +inp[10529] = 0; +inp[10530] = 776414175; +inp[10531] = 0; +inp[10532] = 773387223; +inp[10533] = 0; +inp[10534] = 770372072; +inp[10535] = 0; +inp[10536] = 767368676; +inp[10537] = 0; +inp[10538] = 764376989; +inp[10539] = 0; +inp[10540] = 761396965; +inp[10541] = 0; +inp[10542] = 758428560; +inp[10543] = 0; +inp[10544] = 755471727; +inp[10545] = 0; +inp[10546] = 752526422; +inp[10547] = 0; +inp[10548] = 749592599; +inp[10549] = 0; +inp[10550] = 746670215; +inp[10551] = 0; +inp[10552] = 743759224; +inp[10553] = 0; +inp[10554] = 740859581; +inp[10555] = 0; +inp[10556] = 737971243; +inp[10557] = 0; +inp[10558] = 735094166; +inp[10559] = 0; +inp[10560] = 732228306; +inp[10561] = 0; +inp[10562] = 729373618; +inp[10563] = 0; +inp[10564] = 726530060; +inp[10565] = 0; +inp[10566] = 723697587; +inp[10567] = 0; +inp[10568] = 720876158; +inp[10569] = 0; +inp[10570] = 718065728; +inp[10571] = 0; +inp[10572] = 715266255; +inp[10573] = 0; +inp[10574] = 712477696; +inp[10575] = 0; +inp[10576] = 709700009; +inp[10577] = 0; +inp[10578] = 706933151; +inp[10579] = 0; +inp[10580] = 704177080; +inp[10581] = 0; +inp[10582] = 701431753; +inp[10583] = 0; +inp[10584] = 698697130; +inp[10585] = 0; +inp[10586] = 695973168; +inp[10587] = 0; +inp[10588] = 693259826; +inp[10589] = 0; +inp[10590] = 690557062; +inp[10591] = 0; +inp[10592] = 687864835; +inp[10593] = 0; +inp[10594] = 685183104; +inp[10595] = 0; +inp[10596] = 682511829; +inp[10597] = 0; +inp[10598] = 679850967; +inp[10599] = 0; +inp[10600] = 677200479; +inp[10601] = 0; +inp[10602] = 674560325; +inp[10603] = 0; +inp[10604] = 671930463; +inp[10605] = 0; +inp[10606] = 669310855; +inp[10607] = 0; +inp[10608] = 666701459; +inp[10609] = 0; +inp[10610] = 664102236; +inp[10611] = 0; +inp[10612] = 661513147; +inp[10613] = 0; +inp[10614] = 658934152; +inp[10615] = 0; +inp[10616] = 656365211; +inp[10617] = 0; +inp[10618] = 653806286; +inp[10619] = 0; +inp[10620] = 1073741824; +inp[10621] = 1073741824; +inp[10622] = 1071646718; +inp[10623] = 0; +inp[10624] = 1069555701; +inp[10625] = 0; +inp[10626] = 1067468764; +inp[10627] = 0; +inp[10628] = 1065385898; +inp[10629] = 0; +inp[10630] = 1063307097; +inp[10631] = 0; +inp[10632] = 1061232352; +inp[10633] = 0; +inp[10634] = 1059161656; +inp[10635] = 0; +inp[10636] = 1057094999; +inp[10637] = 0; +inp[10638] = 1055032376; +inp[10639] = 0; +inp[10640] = 1052973777; +inp[10641] = 0; +inp[10642] = 1050919194; +inp[10643] = 0; +inp[10644] = 1048868621; +inp[10645] = 0; +inp[10646] = 1046822049; +inp[10647] = 0; +inp[10648] = 1044779470; +inp[10649] = 0; +inp[10650] = 1042740876; +inp[10651] = 0; +inp[10652] = 1040706261; +inp[10653] = 0; +inp[10654] = 1038675615; +inp[10655] = 0; +inp[10656] = 1036648931; +inp[10657] = 0; +inp[10658] = 1034626202; +inp[10659] = 0; +inp[10660] = 1032607420; +inp[10661] = 0; +inp[10662] = 1030592577; +inp[10663] = 0; +inp[10664] = 1028581665; +inp[10665] = 0; +inp[10666] = 1026574677; +inp[10667] = 0; +inp[10668] = 1024571605; +inp[10669] = 0; +inp[10670] = 1022572442; +inp[10671] = 0; +inp[10672] = 1020577179; +inp[10673] = 0; +inp[10674] = 1018585810; +inp[10675] = 0; +inp[10676] = 1016598326; +inp[10677] = 0; +inp[10678] = 1014614720; +inp[10679] = 0; +inp[10680] = 1012634985; +inp[10681] = 0; +inp[10682] = 1010659112; +inp[10683] = 0; +inp[10684] = 1008687095; +inp[10685] = 0; +inp[10686] = 1006718926; +inp[10687] = 0; +inp[10688] = 1004754597; +inp[10689] = 0; +inp[10690] = 1002794101; +inp[10691] = 0; +inp[10692] = 1000837430; +inp[10693] = 0; +inp[10694] = 998884577; +inp[10695] = 0; +inp[10696] = 996935534; +inp[10697] = 0; +inp[10698] = 994990295; +inp[10699] = 0; +inp[10700] = 993048851; +inp[10701] = 0; +inp[10702] = 991111195; +inp[10703] = 0; +inp[10704] = 989177321; +inp[10705] = 0; +inp[10706] = 987247219; +inp[10707] = 0; +inp[10708] = 985320884; +inp[10709] = 0; +inp[10710] = 983398307; +inp[10711] = 0; +inp[10712] = 981479482; +inp[10713] = 0; +inp[10714] = 979564400; +inp[10715] = 0; +inp[10716] = 977653056; +inp[10717] = 0; +inp[10718] = 975745441; +inp[10719] = 0; +inp[10720] = 973841548; +inp[10721] = 0; +inp[10722] = 971941370; +inp[10723] = 0; +inp[10724] = 970044899; +inp[10725] = 0; +inp[10726] = 968152129; +inp[10727] = 0; +inp[10728] = 966263053; +inp[10729] = 0; +inp[10730] = 964377662; +inp[10731] = 0; +inp[10732] = 962495950; +inp[10733] = 0; +inp[10734] = 960617910; +inp[10735] = 0; +inp[10736] = 958743534; +inp[10737] = 0; +inp[10738] = 956872815; +inp[10739] = 0; +inp[10740] = 955005747; +inp[10741] = 0; +inp[10742] = 953142322; +inp[10743] = 0; +inp[10744] = 951282532; +inp[10745] = 0; +inp[10746] = 949426372; +inp[10747] = 0; +inp[10748] = 947573833; +inp[10749] = 0; +inp[10750] = 945724909; +inp[10751] = 0; +inp[10752] = 943879593; +inp[10753] = 0; +inp[10754] = 942037877; +inp[10755] = 0; +inp[10756] = 940199755; +inp[10757] = 0; +inp[10758] = 938365220; +inp[10759] = 0; +inp[10760] = 936534264; +inp[10761] = 0; +inp[10762] = 934706880; +inp[10763] = 0; +inp[10764] = 932883063; +inp[10765] = 0; +inp[10766] = 931062804; +inp[10767] = 0; +inp[10768] = 929246096; +inp[10769] = 0; +inp[10770] = 927432934; +inp[10771] = 0; +inp[10772] = 925623309; +inp[10773] = 0; +inp[10774] = 923817215; +inp[10775] = 0; +inp[10776] = 922014646; +inp[10777] = 0; +inp[10778] = 920215593; +inp[10779] = 0; +inp[10780] = 918420051; +inp[10781] = 0; +inp[10782] = 916628013; +inp[10783] = 0; +inp[10784] = 914839471; +inp[10785] = 0; +inp[10786] = 913054419; +inp[10787] = 0; +inp[10788] = 911272850; +inp[10789] = 0; +inp[10790] = 909494757; +inp[10791] = 0; +inp[10792] = 907720134; +inp[10793] = 0; +inp[10794] = 905948973; +inp[10795] = 0; +inp[10796] = 904181268; +inp[10797] = 0; +inp[10798] = 902417013; +inp[10799] = 0; +inp[10800] = 900656200; +inp[10801] = 0; +inp[10802] = 898898822; +inp[10803] = 0; +inp[10804] = 897144874; +inp[10805] = 0; +inp[10806] = 895394348; +inp[10807] = 0; +inp[10808] = 893647237; +inp[10809] = 0; +inp[10810] = 891903536; +inp[10811] = 0; +inp[10812] = 890163237; +inp[10813] = 0; +inp[10814] = 888426334; +inp[10815] = 0; +inp[10816] = 886692819; +inp[10817] = 0; +inp[10818] = 884962688; +inp[10819] = 0; +inp[10820] = 883235932; +inp[10821] = 0; +inp[10822] = 881512545; +inp[10823] = 0; +inp[10824] = 879792521; +inp[10825] = 0; +inp[10826] = 878075853; +inp[10827] = 0; +inp[10828] = 876362535; +inp[10829] = 0; +inp[10830] = 874652560; +inp[10831] = 0; +inp[10832] = 872945921; +inp[10833] = 0; +inp[10834] = 871242613; +inp[10835] = 0; +inp[10836] = 869542628; +inp[10837] = 0; +inp[10838] = 867845960; +inp[10839] = 0; +inp[10840] = 866152602; +inp[10841] = 0; +inp[10842] = 864462549; +inp[10843] = 0; +inp[10844] = 862775793; +inp[10845] = 0; +inp[10846] = 861092329; +inp[10847] = 0; +inp[10848] = 859412149; +inp[10849] = 0; +inp[10850] = 857735248; +inp[10851] = 0; +inp[10852] = 856061619; +inp[10853] = 0; +inp[10854] = 854391255; +inp[10855] = 0; +inp[10856] = 852724151; +inp[10857] = 0; +inp[10858] = 851060299; +inp[10859] = 0; +inp[10860] = 849399695; +inp[10861] = 0; +inp[10862] = 847742330; +inp[10863] = 0; +inp[10864] = 846088199; +inp[10865] = 0; +inp[10866] = 844437296; +inp[10867] = 0; +inp[10868] = 842789614; +inp[10869] = 0; +inp[10870] = 841145147; +inp[10871] = 0; +inp[10872] = 839503888; +inp[10873] = 0; +inp[10874] = 837865832; +inp[10875] = 0; +inp[10876] = 1073741824; +inp[10877] = 1073741824; +inp[10878] = 1072693759; +inp[10879] = 0; +inp[10880] = 1071646718; +inp[10881] = 0; +inp[10882] = 1070600699; +inp[10883] = 0; +inp[10884] = 1069555701; +inp[10885] = 0; +inp[10886] = 1068511723; +inp[10887] = 0; +inp[10888] = 1067468764; +inp[10889] = 0; +inp[10890] = 1066426822; +inp[10891] = 0; +inp[10892] = 1065385898; +inp[10893] = 0; +inp[10894] = 1064345990; +inp[10895] = 0; +inp[10896] = 1063307097; +inp[10897] = 0; +inp[10898] = 1062269218; +inp[10899] = 0; +inp[10900] = 1061232352; +inp[10901] = 0; +inp[10902] = 1060196498; +inp[10903] = 0; +inp[10904] = 1059161656; +inp[10905] = 0; +inp[10906] = 1058127823; +inp[10907] = 0; +inp[10908] = 1057094999; +inp[10909] = 0; +inp[10910] = 1056063184; +inp[10911] = 0; +inp[10912] = 1055032376; +inp[10913] = 0; +inp[10914] = 1054002574; +inp[10915] = 0; +inp[10916] = 1052973777; +inp[10917] = 0; +inp[10918] = 1051945984; +inp[10919] = 0; +inp[10920] = 1050919194; +inp[10921] = 0; +inp[10922] = 1049893407; +inp[10923] = 0; +inp[10924] = 1048868621; +inp[10925] = 0; +inp[10926] = 1047844835; +inp[10927] = 0; +inp[10928] = 1046822049; +inp[10929] = 0; +inp[10930] = 1045800261; +inp[10931] = 0; +inp[10932] = 1044779470; +inp[10933] = 0; +inp[10934] = 1043759675; +inp[10935] = 0; +inp[10936] = 1042740876; +inp[10937] = 0; +inp[10938] = 1041723072; +inp[10939] = 0; +inp[10940] = 1040706261; +inp[10941] = 0; +inp[10942] = 1039690442; +inp[10943] = 0; +inp[10944] = 1038675615; +inp[10945] = 0; +inp[10946] = 1037661778; +inp[10947] = 0; +inp[10948] = 1036648931; +inp[10949] = 0; +inp[10950] = 1035637073; +inp[10951] = 0; +inp[10952] = 1034626202; +inp[10953] = 0; +inp[10954] = 1033616318; +inp[10955] = 0; +inp[10956] = 1032607420; +inp[10957] = 0; +inp[10958] = 1031599507; +inp[10959] = 0; +inp[10960] = 1030592577; +inp[10961] = 0; +inp[10962] = 1029586630; +inp[10963] = 0; +inp[10964] = 1028581665; +inp[10965] = 0; +inp[10966] = 1027577681; +inp[10967] = 0; +inp[10968] = 1026574677; +inp[10969] = 0; +inp[10970] = 1025572652; +inp[10971] = 0; +inp[10972] = 1024571605; +inp[10973] = 0; +inp[10974] = 1023571536; +inp[10975] = 0; +inp[10976] = 1022572442; +inp[10977] = 0; +inp[10978] = 1021574324; +inp[10979] = 0; +inp[10980] = 1020577179; +inp[10981] = 0; +inp[10982] = 1019581008; +inp[10983] = 0; +inp[10984] = 1018585810; +inp[10985] = 0; +inp[10986] = 1017591583; +inp[10987] = 0; +inp[10988] = 1016598326; +inp[10989] = 0; +inp[10990] = 1015606039; +inp[10991] = 0; +inp[10992] = 1014614720; +inp[10993] = 0; +inp[10994] = 1013624369; +inp[10995] = 0; +inp[10996] = 1012634985; +inp[10997] = 0; +inp[10998] = 1011646566; +inp[10999] = 0; +inp[11000] = 1010659112; +inp[11001] = 0; +inp[11002] = 1009672622; +inp[11003] = 0; +inp[11004] = 1008687095; +inp[11005] = 0; +inp[11006] = 1007702530; +inp[11007] = 0; +inp[11008] = 1006718926; +inp[11009] = 0; +inp[11010] = 1005736282; +inp[11011] = 0; +inp[11012] = 1004754597; +inp[11013] = 0; +inp[11014] = 1003773870; +inp[11015] = 0; +inp[11016] = 1002794101; +inp[11017] = 0; +inp[11018] = 1001815287; +inp[11019] = 0; +inp[11020] = 1000837430; +inp[11021] = 0; +inp[11022] = 999860527; +inp[11023] = 0; +inp[11024] = 998884577; +inp[11025] = 0; +inp[11026] = 997909580; +inp[11027] = 0; +inp[11028] = 996935534; +inp[11029] = 0; +inp[11030] = 995962440; +inp[11031] = 0; +inp[11032] = 994990295; +inp[11033] = 0; +inp[11034] = 994019099; +inp[11035] = 0; +inp[11036] = 993048851; +inp[11037] = 0; +inp[11038] = 992079550; +inp[11039] = 0; +inp[11040] = 991111195; +inp[11041] = 0; +inp[11042] = 990143786; +inp[11043] = 0; +inp[11044] = 989177321; +inp[11045] = 0; +inp[11046] = 988211799; +inp[11047] = 0; +inp[11048] = 987247219; +inp[11049] = 0; +inp[11050] = 986283581; +inp[11051] = 0; +inp[11052] = 985320884; +inp[11053] = 0; +inp[11054] = 984359126; +inp[11055] = 0; +inp[11056] = 983398307; +inp[11057] = 0; +inp[11058] = 982438426; +inp[11059] = 0; +inp[11060] = 981479482; +inp[11061] = 0; +inp[11062] = 980521473; +inp[11063] = 0; +inp[11064] = 979564400; +inp[11065] = 0; +inp[11066] = 978608261; +inp[11067] = 0; +inp[11068] = 977653056; +inp[11069] = 0; +inp[11070] = 976698782; +inp[11071] = 0; +inp[11072] = 975745441; +inp[11073] = 0; +inp[11074] = 974793029; +inp[11075] = 0; +inp[11076] = 973841548; +inp[11077] = 0; +inp[11078] = 972890995; +inp[11079] = 0; +inp[11080] = 971941370; +inp[11081] = 0; +inp[11082] = 970992671; +inp[11083] = 0; +inp[11084] = 970044899; +inp[11085] = 0; +inp[11086] = 969098052; +inp[11087] = 0; +inp[11088] = 968152129; +inp[11089] = 0; +inp[11090] = 967207130; +inp[11091] = 0; +inp[11092] = 966263053; +inp[11093] = 0; +inp[11094] = 965319897; +inp[11095] = 0; +inp[11096] = 964377662; +inp[11097] = 0; +inp[11098] = 963436347; +inp[11099] = 0; +inp[11100] = 962495950; +inp[11101] = 0; +inp[11102] = 961556471; +inp[11103] = 0; +inp[11104] = 960617910; +inp[11105] = 0; +inp[11106] = 959680264; +inp[11107] = 0; +inp[11108] = 958743534; +inp[11109] = 0; +inp[11110] = 957807718; +inp[11111] = 0; +inp[11112] = 956872815; +inp[11113] = 0; +inp[11114] = 955938825; +inp[11115] = 0; +inp[11116] = 955005747; +inp[11117] = 0; +inp[11118] = 954073579; +inp[11119] = 0; +inp[11120] = 953142322; +inp[11121] = 0; +inp[11122] = 952211973; +inp[11123] = 0; +inp[11124] = 951282532; +inp[11125] = 0; +inp[11126] = 950353999; +inp[11127] = 0; +inp[11128] = 949426372; +inp[11129] = 0; +inp[11130] = 948499650; +inp[11131] = 0; +inp[11132] = 1073741824; +inp[11133] = 1073741824; +inp[11134] = 1073217663; +inp[11135] = 0; +inp[11136] = 1072693759; +inp[11137] = 0; +inp[11138] = 1072170111; +inp[11139] = 0; +inp[11140] = 1071646718; +inp[11141] = 0; +inp[11142] = 1071123581; +inp[11143] = 0; +inp[11144] = 1070600699; +inp[11145] = 0; +inp[11146] = 1070078072; +inp[11147] = 0; +inp[11148] = 1069555701; +inp[11149] = 0; +inp[11150] = 1069033584; +inp[11151] = 0; +inp[11152] = 1068511723; +inp[11153] = 0; +inp[11154] = 1067990116; +inp[11155] = 0; +inp[11156] = 1067468764; +inp[11157] = 0; +inp[11158] = 1066947666; +inp[11159] = 0; +inp[11160] = 1066426822; +inp[11161] = 0; +inp[11162] = 1065906233; +inp[11163] = 0; +inp[11164] = 1065385898; +inp[11165] = 0; +inp[11166] = 1064865817; +inp[11167] = 0; +inp[11168] = 1064345990; +inp[11169] = 0; +inp[11170] = 1063826417; +inp[11171] = 0; +inp[11172] = 1063307097; +inp[11173] = 0; +inp[11174] = 1062788031; +inp[11175] = 0; +inp[11176] = 1062269218; +inp[11177] = 0; +inp[11178] = 1061750659; +inp[11179] = 0; +inp[11180] = 1061232352; +inp[11181] = 0; +inp[11182] = 1060714299; +inp[11183] = 0; +inp[11184] = 1060196498; +inp[11185] = 0; +inp[11186] = 1059678951; +inp[11187] = 0; +inp[11188] = 1059161656; +inp[11189] = 0; +inp[11190] = 1058644613; +inp[11191] = 0; +inp[11192] = 1058127823; +inp[11193] = 0; +inp[11194] = 1057611285; +inp[11195] = 0; +inp[11196] = 1057094999; +inp[11197] = 0; +inp[11198] = 1056578966; +inp[11199] = 0; +inp[11200] = 1056063184; +inp[11201] = 0; +inp[11202] = 1055547654; +inp[11203] = 0; +inp[11204] = 1055032376; +inp[11205] = 0; +inp[11206] = 1054517349; +inp[11207] = 0; +inp[11208] = 1054002574; +inp[11209] = 0; +inp[11210] = 1053488050; +inp[11211] = 0; +inp[11212] = 1052973777; +inp[11213] = 0; +inp[11214] = 1052459755; +inp[11215] = 0; +inp[11216] = 1051945984; +inp[11217] = 0; +inp[11218] = 1051432464; +inp[11219] = 0; +inp[11220] = 1050919194; +inp[11221] = 0; +inp[11222] = 1050406175; +inp[11223] = 0; +inp[11224] = 1049893407; +inp[11225] = 0; +inp[11226] = 1049380889; +inp[11227] = 0; +inp[11228] = 1048868621; +inp[11229] = 0; +inp[11230] = 1048356603; +inp[11231] = 0; +inp[11232] = 1047844835; +inp[11233] = 0; +inp[11234] = 1047333317; +inp[11235] = 0; +inp[11236] = 1046822049; +inp[11237] = 0; +inp[11238] = 1046311030; +inp[11239] = 0; +inp[11240] = 1045800261; +inp[11241] = 0; +inp[11242] = 1045289741; +inp[11243] = 0; +inp[11244] = 1044779470; +inp[11245] = 0; +inp[11246] = 1044269448; +inp[11247] = 0; +inp[11248] = 1043759675; +inp[11249] = 0; +inp[11250] = 1043250151; +inp[11251] = 0; +inp[11252] = 1042740876; +inp[11253] = 0; +inp[11254] = 1042231850; +inp[11255] = 0; +inp[11256] = 1041723072; +inp[11257] = 0; +inp[11258] = 1041214542; +inp[11259] = 0; +inp[11260] = 1040706261; +inp[11261] = 0; +inp[11262] = 1040198227; +inp[11263] = 0; +inp[11264] = 1039690442; +inp[11265] = 0; +inp[11266] = 1039182905; +inp[11267] = 0; +inp[11268] = 1038675615; +inp[11269] = 0; +inp[11270] = 1038168573; +inp[11271] = 0; +inp[11272] = 1037661778; +inp[11273] = 0; +inp[11274] = 1037155231; +inp[11275] = 0; +inp[11276] = 1036648931; +inp[11277] = 0; +inp[11278] = 1036142879; +inp[11279] = 0; +inp[11280] = 1035637073; +inp[11281] = 0; +inp[11282] = 1035131514; +inp[11283] = 0; +inp[11284] = 1034626202; +inp[11285] = 0; +inp[11286] = 1034121137; +inp[11287] = 0; +inp[11288] = 1033616318; +inp[11289] = 0; +inp[11290] = 1033111746; +inp[11291] = 0; +inp[11292] = 1032607420; +inp[11293] = 0; +inp[11294] = 1032103340; +inp[11295] = 0; +inp[11296] = 1031599507; +inp[11297] = 0; +inp[11298] = 1031095919; +inp[11299] = 0; +inp[11300] = 1030592577; +inp[11301] = 0; +inp[11302] = 1030089481; +inp[11303] = 0; +inp[11304] = 1029586630; +inp[11305] = 0; +inp[11306] = 1029084025; +inp[11307] = 0; +inp[11308] = 1028581665; +inp[11309] = 0; +inp[11310] = 1028079551; +inp[11311] = 0; +inp[11312] = 1027577681; +inp[11313] = 0; +inp[11314] = 1027076057; +inp[11315] = 0; +inp[11316] = 1026574677; +inp[11317] = 0; +inp[11318] = 1026073543; +inp[11319] = 0; +inp[11320] = 1025572652; +inp[11321] = 0; +inp[11322] = 1025072007; +inp[11323] = 0; +inp[11324] = 1024571605; +inp[11325] = 0; +inp[11326] = 1024071449; +inp[11327] = 0; +inp[11328] = 1023571536; +inp[11329] = 0; +inp[11330] = 1023071867; +inp[11331] = 0; +inp[11332] = 1022572442; +inp[11333] = 0; +inp[11334] = 1022073261; +inp[11335] = 0; +inp[11336] = 1021574324; +inp[11337] = 0; +inp[11338] = 1021075630; +inp[11339] = 0; +inp[11340] = 1020577179; +inp[11341] = 0; +inp[11342] = 1020078972; +inp[11343] = 0; +inp[11344] = 1019581008; +inp[11345] = 0; +inp[11346] = 1019083288; +inp[11347] = 0; +inp[11348] = 1018585810; +inp[11349] = 0; +inp[11350] = 1018088575; +inp[11351] = 0; +inp[11352] = 1017591583; +inp[11353] = 0; +inp[11354] = 1017094833; +inp[11355] = 0; +inp[11356] = 1016598326; +inp[11357] = 0; +inp[11358] = 1016102061; +inp[11359] = 0; +inp[11360] = 1015606039; +inp[11361] = 0; +inp[11362] = 1015110258; +inp[11363] = 0; +inp[11364] = 1014614720; +inp[11365] = 0; +inp[11366] = 1014119424; +inp[11367] = 0; +inp[11368] = 1013624369; +inp[11369] = 0; +inp[11370] = 1013129556; +inp[11371] = 0; +inp[11372] = 1012634985; +inp[11373] = 0; +inp[11374] = 1012140655; +inp[11375] = 0; +inp[11376] = 1011646566; +inp[11377] = 0; +inp[11378] = 1011152719; +inp[11379] = 0; +inp[11380] = 1010659112; +inp[11381] = 0; +inp[11382] = 1010165747; +inp[11383] = 0; +inp[11384] = 1009672622; +inp[11385] = 0; +inp[11386] = 1009179738; +inp[11387] = 0; +inp[11388] = 1073741824; +inp[11389] = 1073741824; +inp[11390] = 1073479711; +inp[11391] = 0; +inp[11392] = 1073217663; +inp[11393] = 0; +inp[11394] = 1072955679; +inp[11395] = 0; +inp[11396] = 1072693759; +inp[11397] = 0; +inp[11398] = 1072431903; +inp[11399] = 0; +inp[11400] = 1072170111; +inp[11401] = 0; +inp[11402] = 1071908383; +inp[11403] = 0; +inp[11404] = 1071646718; +inp[11405] = 0; +inp[11406] = 1071385118; +inp[11407] = 0; +inp[11408] = 1071123581; +inp[11409] = 0; +inp[11410] = 1070862108; +inp[11411] = 0; +inp[11412] = 1070600699; +inp[11413] = 0; +inp[11414] = 1070339354; +inp[11415] = 0; +inp[11416] = 1070078072; +inp[11417] = 0; +inp[11418] = 1069816855; +inp[11419] = 0; +inp[11420] = 1069555701; +inp[11421] = 0; +inp[11422] = 1069294611; +inp[11423] = 0; +inp[11424] = 1069033584; +inp[11425] = 0; +inp[11426] = 1068772622; +inp[11427] = 0; +inp[11428] = 1068511723; +inp[11429] = 0; +inp[11430] = 1068250887; +inp[11431] = 0; +inp[11432] = 1067990116; +inp[11433] = 0; +inp[11434] = 1067729408; +inp[11435] = 0; +inp[11436] = 1067468764; +inp[11437] = 0; +inp[11438] = 1067208183; +inp[11439] = 0; +inp[11440] = 1066947666; +inp[11441] = 0; +inp[11442] = 1066687212; +inp[11443] = 0; +inp[11444] = 1066426822; +inp[11445] = 0; +inp[11446] = 1066166496; +inp[11447] = 0; +inp[11448] = 1065906233; +inp[11449] = 0; +inp[11450] = 1065646034; +inp[11451] = 0; +inp[11452] = 1065385898; +inp[11453] = 0; +inp[11454] = 1065125826; +inp[11455] = 0; +inp[11456] = 1064865817; +inp[11457] = 0; +inp[11458] = 1064605872; +inp[11459] = 0; +inp[11460] = 1064345990; +inp[11461] = 0; +inp[11462] = 1064086172; +inp[11463] = 0; +inp[11464] = 1063826417; +inp[11465] = 0; +inp[11466] = 1063566725; +inp[11467] = 0; +inp[11468] = 1063307097; +inp[11469] = 0; +inp[11470] = 1063047532; +inp[11471] = 0; +inp[11472] = 1062788031; +inp[11473] = 0; +inp[11474] = 1062528593; +inp[11475] = 0; +inp[11476] = 1062269218; +inp[11477] = 0; +inp[11478] = 1062009907; +inp[11479] = 0; +inp[11480] = 1061750659; +inp[11481] = 0; +inp[11482] = 1061491474; +inp[11483] = 0; +inp[11484] = 1061232352; +inp[11485] = 0; +inp[11486] = 1060973294; +inp[11487] = 0; +inp[11488] = 1060714299; +inp[11489] = 0; +inp[11490] = 1060455367; +inp[11491] = 0; +inp[11492] = 1060196498; +inp[11493] = 0; +inp[11494] = 1059937693; +inp[11495] = 0; +inp[11496] = 1059678951; +inp[11497] = 0; +inp[11498] = 1059420272; +inp[11499] = 0; +inp[11500] = 1059161656; +inp[11501] = 0; +inp[11502] = 1058903103; +inp[11503] = 0; +inp[11504] = 1058644613; +inp[11505] = 0; +inp[11506] = 1058386187; +inp[11507] = 0; +inp[11508] = 1058127823; +inp[11509] = 0; +inp[11510] = 1057869523; +inp[11511] = 0; +inp[11512] = 1057611285; +inp[11513] = 0; +inp[11514] = 1057353111; +inp[11515] = 0; +inp[11516] = 1057094999; +inp[11517] = 0; +inp[11518] = 1056836951; +inp[11519] = 0; +inp[11520] = 1056578966; +inp[11521] = 0; +inp[11522] = 1056321043; +inp[11523] = 0; +inp[11524] = 1056063184; +inp[11525] = 0; +inp[11526] = 1055805388; +inp[11527] = 0; +inp[11528] = 1055547654; +inp[11529] = 0; +inp[11530] = 1055289983; +inp[11531] = 0; +inp[11532] = 1055032376; +inp[11533] = 0; +inp[11534] = 1054774831; +inp[11535] = 0; +inp[11536] = 1054517349; +inp[11537] = 0; +inp[11538] = 1054259930; +inp[11539] = 0; +inp[11540] = 1054002574; +inp[11541] = 0; +inp[11542] = 1053745280; +inp[11543] = 0; +inp[11544] = 1053488050; +inp[11545] = 0; +inp[11546] = 1053230882; +inp[11547] = 0; +inp[11548] = 1052973777; +inp[11549] = 0; +inp[11550] = 1052716734; +inp[11551] = 0; +inp[11552] = 1052459755; +inp[11553] = 0; +inp[11554] = 1052202838; +inp[11555] = 0; +inp[11556] = 1051945984; +inp[11557] = 0; +inp[11558] = 1051689192; +inp[11559] = 0; +inp[11560] = 1051432464; +inp[11561] = 0; +inp[11562] = 1051175798; +inp[11563] = 0; +inp[11564] = 1050919194; +inp[11565] = 0; +inp[11566] = 1050662654; +inp[11567] = 0; +inp[11568] = 1050406175; +inp[11569] = 0; +inp[11570] = 1050149760; +inp[11571] = 0; +inp[11572] = 1049893407; +inp[11573] = 0; +inp[11574] = 1049637117; +inp[11575] = 0; +inp[11576] = 1049380889; +inp[11577] = 0; +inp[11578] = 1049124724; +inp[11579] = 0; +inp[11580] = 1048868621; +inp[11581] = 0; +inp[11582] = 1048612581; +inp[11583] = 0; +inp[11584] = 1048356603; +inp[11585] = 0; +inp[11586] = 1048100688; +inp[11587] = 0; +inp[11588] = 1047844835; +inp[11589] = 0; +inp[11590] = 1047589045; +inp[11591] = 0; +inp[11592] = 1047333317; +inp[11593] = 0; +inp[11594] = 1047077652; +inp[11595] = 0; +inp[11596] = 1046822049; +inp[11597] = 0; +inp[11598] = 1046566508; +inp[11599] = 0; +inp[11600] = 1046311030; +inp[11601] = 0; +inp[11602] = 1046055614; +inp[11603] = 0; +inp[11604] = 1045800261; +inp[11605] = 0; +inp[11606] = 1045544969; +inp[11607] = 0; +inp[11608] = 1045289741; +inp[11609] = 0; +inp[11610] = 1045034574; +inp[11611] = 0; +inp[11612] = 1044779470; +inp[11613] = 0; +inp[11614] = 1044524428; +inp[11615] = 0; +inp[11616] = 1044269448; +inp[11617] = 0; +inp[11618] = 1044014531; +inp[11619] = 0; +inp[11620] = 1043759675; +inp[11621] = 0; +inp[11622] = 1043504882; +inp[11623] = 0; +inp[11624] = 1043250151; +inp[11625] = 0; +inp[11626] = 1042995483; +inp[11627] = 0; +inp[11628] = 1042740876; +inp[11629] = 0; +inp[11630] = 1042486332; +inp[11631] = 0; +inp[11632] = 1042231850; +inp[11633] = 0; +inp[11634] = 1041977430; +inp[11635] = 0; +inp[11636] = 1041723072; +inp[11637] = 0; +inp[11638] = 1041468776; +inp[11639] = 0; +inp[11640] = 1041214542; +inp[11641] = 0; +inp[11642] = 1040960370; +inp[11643] = 0; +inp[11644] = 1073741824; +inp[11645] = 1073741824; +inp[11646] = 1073610759; +inp[11647] = 0; +inp[11648] = 1073479711; +inp[11649] = 0; +inp[11650] = 1073348679; +inp[11651] = 0; +inp[11652] = 1073217663; +inp[11653] = 0; +inp[11654] = 1073086663; +inp[11655] = 0; +inp[11656] = 1072955679; +inp[11657] = 0; +inp[11658] = 1072824711; +inp[11659] = 0; +inp[11660] = 1072693759; +inp[11661] = 0; +inp[11662] = 1072562823; +inp[11663] = 0; +inp[11664] = 1072431903; +inp[11665] = 0; +inp[11666] = 1072300999; +inp[11667] = 0; +inp[11668] = 1072170111; +inp[11669] = 0; +inp[11670] = 1072039239; +inp[11671] = 0; +inp[11672] = 1071908383; +inp[11673] = 0; +inp[11674] = 1071777542; +inp[11675] = 0; +inp[11676] = 1071646718; +inp[11677] = 0; +inp[11678] = 1071515910; +inp[11679] = 0; +inp[11680] = 1071385118; +inp[11681] = 0; +inp[11682] = 1071254341; +inp[11683] = 0; +inp[11684] = 1071123581; +inp[11685] = 0; +inp[11686] = 1070992836; +inp[11687] = 0; +inp[11688] = 1070862108; +inp[11689] = 0; +inp[11690] = 1070731396; +inp[11691] = 0; +inp[11692] = 1070600699; +inp[11693] = 0; +inp[11694] = 1070470018; +inp[11695] = 0; +inp[11696] = 1070339354; +inp[11697] = 0; +inp[11698] = 1070208705; +inp[11699] = 0; +inp[11700] = 1070078072; +inp[11701] = 0; +inp[11702] = 1069947456; +inp[11703] = 0; +inp[11704] = 1069816855; +inp[11705] = 0; +inp[11706] = 1069686270; +inp[11707] = 0; +inp[11708] = 1069555701; +inp[11709] = 0; +inp[11710] = 1069425148; +inp[11711] = 0; +inp[11712] = 1069294611; +inp[11713] = 0; +inp[11714] = 1069164090; +inp[11715] = 0; +inp[11716] = 1069033584; +inp[11717] = 0; +inp[11718] = 1068903095; +inp[11719] = 0; +inp[11720] = 1068772622; +inp[11721] = 0; +inp[11722] = 1068642164; +inp[11723] = 0; +inp[11724] = 1068511723; +inp[11725] = 0; +inp[11726] = 1068381297; +inp[11727] = 0; +inp[11728] = 1068250887; +inp[11729] = 0; +inp[11730] = 1068120494; +inp[11731] = 0; +inp[11732] = 1067990116; +inp[11733] = 0; +inp[11734] = 1067859754; +inp[11735] = 0; +inp[11736] = 1067729408; +inp[11737] = 0; +inp[11738] = 1067599078; +inp[11739] = 0; +inp[11740] = 1067468764; +inp[11741] = 0; +inp[11742] = 1067338465; +inp[11743] = 0; +inp[11744] = 1067208183; +inp[11745] = 0; +inp[11746] = 1067077916; +inp[11747] = 0; +inp[11748] = 1066947666; +inp[11749] = 0; +inp[11750] = 1066817431; +inp[11751] = 0; +inp[11752] = 1066687212; +inp[11753] = 0; +inp[11754] = 1066557009; +inp[11755] = 0; +inp[11756] = 1066426822; +inp[11757] = 0; +inp[11758] = 1066296651; +inp[11759] = 0; +inp[11760] = 1066166496; +inp[11761] = 0; +inp[11762] = 1066036357; +inp[11763] = 0; +inp[11764] = 1065906233; +inp[11765] = 0; +inp[11766] = 1065776126; +inp[11767] = 0; +inp[11768] = 1065646034; +inp[11769] = 0; +inp[11770] = 1065515958; +inp[11771] = 0; +inp[11772] = 1065385898; +inp[11773] = 0; +inp[11774] = 1065255854; +inp[11775] = 0; +inp[11776] = 1065125826; +inp[11777] = 0; +inp[11778] = 1064995814; +inp[11779] = 0; +inp[11780] = 1064865817; +inp[11781] = 0; +inp[11782] = 1064735837; +inp[11783] = 0; +inp[11784] = 1064605872; +inp[11785] = 0; +inp[11786] = 1064475923; +inp[11787] = 0; +inp[11788] = 1064345990; +inp[11789] = 0; +inp[11790] = 1064216073; +inp[11791] = 0; +inp[11792] = 1064086172; +inp[11793] = 0; +inp[11794] = 1063956286; +inp[11795] = 0; +inp[11796] = 1063826417; +inp[11797] = 0; +inp[11798] = 1063696563; +inp[11799] = 0; +inp[11800] = 1063566725; +inp[11801] = 0; +inp[11802] = 1063436903; +inp[11803] = 0; +inp[11804] = 1063307097; +inp[11805] = 0; +inp[11806] = 1063177307; +inp[11807] = 0; +inp[11808] = 1063047532; +inp[11809] = 0; +inp[11810] = 1062917774; +inp[11811] = 0; +inp[11812] = 1062788031; +inp[11813] = 0; +inp[11814] = 1062658304; +inp[11815] = 0; +inp[11816] = 1062528593; +inp[11817] = 0; +inp[11818] = 1062398898; +inp[11819] = 0; +inp[11820] = 1062269218; +inp[11821] = 0; +inp[11822] = 1062139555; +inp[11823] = 0; +inp[11824] = 1062009907; +inp[11825] = 0; +inp[11826] = 1061880275; +inp[11827] = 0; +inp[11828] = 1061750659; +inp[11829] = 0; +inp[11830] = 1061621058; +inp[11831] = 0; +inp[11832] = 1061491474; +inp[11833] = 0; +inp[11834] = 1061361905; +inp[11835] = 0; +inp[11836] = 1061232352; +inp[11837] = 0; +inp[11838] = 1061102815; +inp[11839] = 0; +inp[11840] = 1060973294; +inp[11841] = 0; +inp[11842] = 1060843789; +inp[11843] = 0; +inp[11844] = 1060714299; +inp[11845] = 0; +inp[11846] = 1060584825; +inp[11847] = 0; +inp[11848] = 1060455367; +inp[11849] = 0; +inp[11850] = 1060325925; +inp[11851] = 0; +inp[11852] = 1060196498; +inp[11853] = 0; +inp[11854] = 1060067088; +inp[11855] = 0; +inp[11856] = 1059937693; +inp[11857] = 0; +inp[11858] = 1059808314; +inp[11859] = 0; +inp[11860] = 1059678951; +inp[11861] = 0; +inp[11862] = 1059549603; +inp[11863] = 0; +inp[11864] = 1059420272; +inp[11865] = 0; +inp[11866] = 1059290956; +inp[11867] = 0; +inp[11868] = 1059161656; +inp[11869] = 0; +inp[11870] = 1059032371; +inp[11871] = 0; +inp[11872] = 1058903103; +inp[11873] = 0; +inp[11874] = 1058773850; +inp[11875] = 0; +inp[11876] = 1058644613; +inp[11877] = 0; +inp[11878] = 1058515392; +inp[11879] = 0; +inp[11880] = 1058386187; +inp[11881] = 0; +inp[11882] = 1058256997; +inp[11883] = 0; +inp[11884] = 1058127823; +inp[11885] = 0; +inp[11886] = 1057998665; +inp[11887] = 0; +inp[11888] = 1057869523; +inp[11889] = 0; +inp[11890] = 1057740396; +inp[11891] = 0; +inp[11892] = 1057611285; +inp[11893] = 0; +inp[11894] = 1057482190; +inp[11895] = 0; +inp[11896] = 1057353111; +inp[11897] = 0; +inp[11898] = 1057224047; +inp[11899] = 0; +inp[11900] = 1073741824; +inp[11901] = 1073741824; +inp[11902] = 1073676289; +inp[11903] = 0; +inp[11904] = 1073610759; +inp[11905] = 0; +inp[11906] = 1073545233; +inp[11907] = 0; +inp[11908] = 1073479711; +inp[11909] = 0; +inp[11910] = 1073414193; +inp[11911] = 0; +inp[11912] = 1073348679; +inp[11913] = 0; +inp[11914] = 1073283169; +inp[11915] = 0; +inp[11916] = 1073217663; +inp[11917] = 0; +inp[11918] = 1073152161; +inp[11919] = 0; +inp[11920] = 1073086663; +inp[11921] = 0; +inp[11922] = 1073021169; +inp[11923] = 0; +inp[11924] = 1072955679; +inp[11925] = 0; +inp[11926] = 1072890193; +inp[11927] = 0; +inp[11928] = 1072824711; +inp[11929] = 0; +inp[11930] = 1072759233; +inp[11931] = 0; +inp[11932] = 1072693759; +inp[11933] = 0; +inp[11934] = 1072628289; +inp[11935] = 0; +inp[11936] = 1072562823; +inp[11937] = 0; +inp[11938] = 1072497361; +inp[11939] = 0; +inp[11940] = 1072431903; +inp[11941] = 0; +inp[11942] = 1072366449; +inp[11943] = 0; +inp[11944] = 1072300999; +inp[11945] = 0; +inp[11946] = 1072235553; +inp[11947] = 0; +inp[11948] = 1072170111; +inp[11949] = 0; +inp[11950] = 1072104673; +inp[11951] = 0; +inp[11952] = 1072039239; +inp[11953] = 0; +inp[11954] = 1071973809; +inp[11955] = 0; +inp[11956] = 1071908383; +inp[11957] = 0; +inp[11958] = 1071842961; +inp[11959] = 0; +inp[11960] = 1071777542; +inp[11961] = 0; +inp[11962] = 1071712128; +inp[11963] = 0; +inp[11964] = 1071646718; +inp[11965] = 0; +inp[11966] = 1071581312; +inp[11967] = 0; +inp[11968] = 1071515910; +inp[11969] = 0; +inp[11970] = 1071450512; +inp[11971] = 0; +inp[11972] = 1071385118; +inp[11973] = 0; +inp[11974] = 1071319727; +inp[11975] = 0; +inp[11976] = 1071254341; +inp[11977] = 0; +inp[11978] = 1071188959; +inp[11979] = 0; +inp[11980] = 1071123581; +inp[11981] = 0; +inp[11982] = 1071058207; +inp[11983] = 0; +inp[11984] = 1070992836; +inp[11985] = 0; +inp[11986] = 1070927470; +inp[11987] = 0; +inp[11988] = 1070862108; +inp[11989] = 0; +inp[11990] = 1070796750; +inp[11991] = 0; +inp[11992] = 1070731396; +inp[11993] = 0; +inp[11994] = 1070666045; +inp[11995] = 0; +inp[11996] = 1070600699; +inp[11997] = 0; +inp[11998] = 1070535357; +inp[11999] = 0; +inp[12000] = 1070470018; +inp[12001] = 0; +inp[12002] = 1070404684; +inp[12003] = 0; +inp[12004] = 1070339354; +inp[12005] = 0; +inp[12006] = 1070274027; +inp[12007] = 0; +inp[12008] = 1070208705; +inp[12009] = 0; +inp[12010] = 1070143387; +inp[12011] = 0; +inp[12012] = 1070078072; +inp[12013] = 0; +inp[12014] = 1070012762; +inp[12015] = 0; +inp[12016] = 1069947456; +inp[12017] = 0; +inp[12018] = 1069882153; +inp[12019] = 0; +inp[12020] = 1069816855; +inp[12021] = 0; +inp[12022] = 1069751560; +inp[12023] = 0; +inp[12024] = 1069686270; +inp[12025] = 0; +inp[12026] = 1069620983; +inp[12027] = 0; +inp[12028] = 1069555701; +inp[12029] = 0; +inp[12030] = 1069490422; +inp[12031] = 0; +inp[12032] = 1069425148; +inp[12033] = 0; +inp[12034] = 1069359877; +inp[12035] = 0; +inp[12036] = 1069294611; +inp[12037] = 0; +inp[12038] = 1069229348; +inp[12039] = 0; +inp[12040] = 1069164090; +inp[12041] = 0; +inp[12042] = 1069098835; +inp[12043] = 0; +inp[12044] = 1069033584; +inp[12045] = 0; +inp[12046] = 1068968338; +inp[12047] = 0; +inp[12048] = 1068903095; +inp[12049] = 0; +inp[12050] = 1068837856; +inp[12051] = 0; +inp[12052] = 1068772622; +inp[12053] = 0; +inp[12054] = 1068707391; +inp[12055] = 0; +inp[12056] = 1068642164; +inp[12057] = 0; +inp[12058] = 1068576941; +inp[12059] = 0; +inp[12060] = 1068511723; +inp[12061] = 0; +inp[12062] = 1068446508; +inp[12063] = 0; +inp[12064] = 1068381297; +inp[12065] = 0; +inp[12066] = 1068316090; +inp[12067] = 0; +inp[12068] = 1068250887; +inp[12069] = 0; +inp[12070] = 1068185689; +inp[12071] = 0; +inp[12072] = 1068120494; +inp[12073] = 0; +inp[12074] = 1068055303; +inp[12075] = 0; +inp[12076] = 1067990116; +inp[12077] = 0; +inp[12078] = 1067924933; +inp[12079] = 0; +inp[12080] = 1067859754; +inp[12081] = 0; +inp[12082] = 1067794579; +inp[12083] = 0; +inp[12084] = 1067729408; +inp[12085] = 0; +inp[12086] = 1067664241; +inp[12087] = 0; +inp[12088] = 1067599078; +inp[12089] = 0; +inp[12090] = 1067533919; +inp[12091] = 0; +inp[12092] = 1067468764; +inp[12093] = 0; +inp[12094] = 1067403612; +inp[12095] = 0; +inp[12096] = 1067338465; +inp[12097] = 0; +inp[12098] = 1067273322; +inp[12099] = 0; +inp[12100] = 1067208183; +inp[12101] = 0; +inp[12102] = 1067143048; +inp[12103] = 0; +inp[12104] = 1067077916; +inp[12105] = 0; +inp[12106] = 1067012789; +inp[12107] = 0; +inp[12108] = 1066947666; +inp[12109] = 0; +inp[12110] = 1066882546; +inp[12111] = 0; +inp[12112] = 1066817431; +inp[12113] = 0; +inp[12114] = 1066752320; +inp[12115] = 0; +inp[12116] = 1066687212; +inp[12117] = 0; +inp[12118] = 1066622109; +inp[12119] = 0; +inp[12120] = 1066557009; +inp[12121] = 0; +inp[12122] = 1066491914; +inp[12123] = 0; +inp[12124] = 1066426822; +inp[12125] = 0; +inp[12126] = 1066361735; +inp[12127] = 0; +inp[12128] = 1066296651; +inp[12129] = 0; +inp[12130] = 1066231572; +inp[12131] = 0; +inp[12132] = 1066166496; +inp[12133] = 0; +inp[12134] = 1066101424; +inp[12135] = 0; +inp[12136] = 1066036357; +inp[12137] = 0; +inp[12138] = 1065971293; +inp[12139] = 0; +inp[12140] = 1065906233; +inp[12141] = 0; +inp[12142] = 1065841178; +inp[12143] = 0; +inp[12144] = 1065776126; +inp[12145] = 0; +inp[12146] = 1065711078; +inp[12147] = 0; +inp[12148] = 1065646034; +inp[12149] = 0; +inp[12150] = 1065580994; +inp[12151] = 0; +inp[12152] = 1065515958; +inp[12153] = 0; +inp[12154] = 1065450926; +inp[12155] = 0; +inp[12156] = 1073741824; +inp[12157] = 1073741824; +inp[12158] = 1073709056; +inp[12159] = 0; +inp[12160] = 1073676289; +inp[12161] = 0; +inp[12162] = 1073643524; +inp[12163] = 0; +inp[12164] = 1073610759; +inp[12165] = 0; +inp[12166] = 1073577996; +inp[12167] = 0; +inp[12168] = 1073545233; +inp[12169] = 0; +inp[12170] = 1073512472; +inp[12171] = 0; +inp[12172] = 1073479711; +inp[12173] = 0; +inp[12174] = 1073446952; +inp[12175] = 0; +inp[12176] = 1073414193; +inp[12177] = 0; +inp[12178] = 1073381436; +inp[12179] = 0; +inp[12180] = 1073348679; +inp[12181] = 0; +inp[12182] = 1073315924; +inp[12183] = 0; +inp[12184] = 1073283169; +inp[12185] = 0; +inp[12186] = 1073250416; +inp[12187] = 0; +inp[12188] = 1073217663; +inp[12189] = 0; +inp[12190] = 1073184912; +inp[12191] = 0; +inp[12192] = 1073152161; +inp[12193] = 0; +inp[12194] = 1073119412; +inp[12195] = 0; +inp[12196] = 1073086663; +inp[12197] = 0; +inp[12198] = 1073053916; +inp[12199] = 0; +inp[12200] = 1073021169; +inp[12201] = 0; +inp[12202] = 1072988424; +inp[12203] = 0; +inp[12204] = 1072955679; +inp[12205] = 0; +inp[12206] = 1072922936; +inp[12207] = 0; +inp[12208] = 1072890193; +inp[12209] = 0; +inp[12210] = 1072857452; +inp[12211] = 0; +inp[12212] = 1072824711; +inp[12213] = 0; +inp[12214] = 1072791972; +inp[12215] = 0; +inp[12216] = 1072759233; +inp[12217] = 0; +inp[12218] = 1072726496; +inp[12219] = 0; +inp[12220] = 1072693759; +inp[12221] = 0; +inp[12222] = 1072661024; +inp[12223] = 0; +inp[12224] = 1072628289; +inp[12225] = 0; +inp[12226] = 1072595556; +inp[12227] = 0; +inp[12228] = 1072562823; +inp[12229] = 0; +inp[12230] = 1072530092; +inp[12231] = 0; +inp[12232] = 1072497361; +inp[12233] = 0; +inp[12234] = 1072464632; +inp[12235] = 0; +inp[12236] = 1072431903; +inp[12237] = 0; +inp[12238] = 1072399176; +inp[12239] = 0; +inp[12240] = 1072366449; +inp[12241] = 0; +inp[12242] = 1072333724; +inp[12243] = 0; +inp[12244] = 1072300999; +inp[12245] = 0; +inp[12246] = 1072268276; +inp[12247] = 0; +inp[12248] = 1072235553; +inp[12249] = 0; +inp[12250] = 1072202831; +inp[12251] = 0; +inp[12252] = 1072170111; +inp[12253] = 0; +inp[12254] = 1072137391; +inp[12255] = 0; +inp[12256] = 1072104673; +inp[12257] = 0; +inp[12258] = 1072071955; +inp[12259] = 0; +inp[12260] = 1072039239; +inp[12261] = 0; +inp[12262] = 1072006523; +inp[12263] = 0; +inp[12264] = 1071973809; +inp[12265] = 0; +inp[12266] = 1071941095; +inp[12267] = 0; +inp[12268] = 1071908383; +inp[12269] = 0; +inp[12270] = 1071875671; +inp[12271] = 0; +inp[12272] = 1071842961; +inp[12273] = 0; +inp[12274] = 1071810251; +inp[12275] = 0; +inp[12276] = 1071777542; +inp[12277] = 0; +inp[12278] = 1071744835; +inp[12279] = 0; +inp[12280] = 1071712128; +inp[12281] = 0; +inp[12282] = 1071679423; +inp[12283] = 0; +inp[12284] = 1071646718; +inp[12285] = 0; +inp[12286] = 1071614015; +inp[12287] = 0; +inp[12288] = 1071581312; +inp[12289] = 0; +inp[12290] = 1071548610; +inp[12291] = 0; +inp[12292] = 1071515910; +inp[12293] = 0; +inp[12294] = 1071483210; +inp[12295] = 0; +inp[12296] = 1071450512; +inp[12297] = 0; +inp[12298] = 1071417814; +inp[12299] = 0; +inp[12300] = 1071385118; +inp[12301] = 0; +inp[12302] = 1071352422; +inp[12303] = 0; +inp[12304] = 1071319727; +inp[12305] = 0; +inp[12306] = 1071287034; +inp[12307] = 0; +inp[12308] = 1071254341; +inp[12309] = 0; +inp[12310] = 1071221650; +inp[12311] = 0; +inp[12312] = 1071188959; +inp[12313] = 0; +inp[12314] = 1071156269; +inp[12315] = 0; +inp[12316] = 1071123581; +inp[12317] = 0; +inp[12318] = 1071090893; +inp[12319] = 0; +inp[12320] = 1071058207; +inp[12321] = 0; +inp[12322] = 1071025521; +inp[12323] = 0; +inp[12324] = 1070992836; +inp[12325] = 0; +inp[12326] = 1070960153; +inp[12327] = 0; +inp[12328] = 1070927470; +inp[12329] = 0; +inp[12330] = 1070894789; +inp[12331] = 0; +inp[12332] = 1070862108; +inp[12333] = 0; +inp[12334] = 1070829428; +inp[12335] = 0; +inp[12336] = 1070796750; +inp[12337] = 0; +inp[12338] = 1070764072; +inp[12339] = 0; +inp[12340] = 1070731396; +inp[12341] = 0; +inp[12342] = 1070698720; +inp[12343] = 0; +inp[12344] = 1070666045; +inp[12345] = 0; +inp[12346] = 1070633372; +inp[12347] = 0; +inp[12348] = 1070600699; +inp[12349] = 0; +inp[12350] = 1070568027; +inp[12351] = 0; +inp[12352] = 1070535357; +inp[12353] = 0; +inp[12354] = 1070502687; +inp[12355] = 0; +inp[12356] = 1070470018; +inp[12357] = 0; +inp[12358] = 1070437351; +inp[12359] = 0; +inp[12360] = 1070404684; +inp[12361] = 0; +inp[12362] = 1070372018; +inp[12363] = 0; +inp[12364] = 1070339354; +inp[12365] = 0; +inp[12366] = 1070306690; +inp[12367] = 0; +inp[12368] = 1070274027; +inp[12369] = 0; +inp[12370] = 1070241366; +inp[12371] = 0; +inp[12372] = 1070208705; +inp[12373] = 0; +inp[12374] = 1070176045; +inp[12375] = 0; +inp[12376] = 1070143387; +inp[12377] = 0; +inp[12378] = 1070110729; +inp[12379] = 0; +inp[12380] = 1070078072; +inp[12381] = 0; +inp[12382] = 1070045417; +inp[12383] = 0; +inp[12384] = 1070012762; +inp[12385] = 0; +inp[12386] = 1069980108; +inp[12387] = 0; +inp[12388] = 1069947456; +inp[12389] = 0; +inp[12390] = 1069914804; +inp[12391] = 0; +inp[12392] = 1069882153; +inp[12393] = 0; +inp[12394] = 1069849503; +inp[12395] = 0; +inp[12396] = 1069816855; +inp[12397] = 0; +inp[12398] = 1069784207; +inp[12399] = 0; +inp[12400] = 1069751560; +inp[12401] = 0; +inp[12402] = 1069718915; +inp[12403] = 0; +inp[12404] = 1069686270; +inp[12405] = 0; +inp[12406] = 1069653626; +inp[12407] = 0; +inp[12408] = 1069620983; +inp[12409] = 0; +inp[12410] = 1069588342; +inp[12411] = 0; +inp[12412] = 1073741824; +inp[12413] = 1073741824; +inp[12414] = 1073725440; +inp[12415] = 0; +inp[12416] = 1073709056; +inp[12417] = 0; +inp[12418] = 1073692673; +inp[12419] = 0; +inp[12420] = 1073676289; +inp[12421] = 0; +inp[12422] = 1073659907; +inp[12423] = 0; +inp[12424] = 1073643524; +inp[12425] = 0; +inp[12426] = 1073627142; +inp[12427] = 0; +inp[12428] = 1073610759; +inp[12429] = 0; +inp[12430] = 1073594378; +inp[12431] = 0; +inp[12432] = 1073577996; +inp[12433] = 0; +inp[12434] = 1073561615; +inp[12435] = 0; +inp[12436] = 1073545233; +inp[12437] = 0; +inp[12438] = 1073528853; +inp[12439] = 0; +inp[12440] = 1073512472; +inp[12441] = 0; +inp[12442] = 1073496092; +inp[12443] = 0; +inp[12444] = 1073479711; +inp[12445] = 0; +inp[12446] = 1073463332; +inp[12447] = 0; +inp[12448] = 1073446952; +inp[12449] = 0; +inp[12450] = 1073430573; +inp[12451] = 0; +inp[12452] = 1073414193; +inp[12453] = 0; +inp[12454] = 1073397815; +inp[12455] = 0; +inp[12456] = 1073381436; +inp[12457] = 0; +inp[12458] = 1073365058; +inp[12459] = 0; +inp[12460] = 1073348679; +inp[12461] = 0; +inp[12462] = 1073332302; +inp[12463] = 0; +inp[12464] = 1073315924; +inp[12465] = 0; +inp[12466] = 1073299547; +inp[12467] = 0; +inp[12468] = 1073283169; +inp[12469] = 0; +inp[12470] = 1073266793; +inp[12471] = 0; +inp[12472] = 1073250416; +inp[12473] = 0; +inp[12474] = 1073234040; +inp[12475] = 0; +inp[12476] = 1073217663; +inp[12477] = 0; +inp[12478] = 1073201288; +inp[12479] = 0; +inp[12480] = 1073184912; +inp[12481] = 0; +inp[12482] = 1073168537; +inp[12483] = 0; +inp[12484] = 1073152161; +inp[12485] = 0; +inp[12486] = 1073135787; +inp[12487] = 0; +inp[12488] = 1073119412; +inp[12489] = 0; +inp[12490] = 1073103038; +inp[12491] = 0; +inp[12492] = 1073086663; +inp[12493] = 0; +inp[12494] = 1073070290; +inp[12495] = 0; +inp[12496] = 1073053916; +inp[12497] = 0; +inp[12498] = 1073037543; +inp[12499] = 0; +inp[12500] = 1073021169; +inp[12501] = 0; +inp[12502] = 1073004797; +inp[12503] = 0; +inp[12504] = 1072988424; +inp[12505] = 0; +inp[12506] = 1072972052; +inp[12507] = 0; +inp[12508] = 1072955679; +inp[12509] = 0; +inp[12510] = 1072939308; +inp[12511] = 0; +inp[12512] = 1072922936; +inp[12513] = 0; +inp[12514] = 1072906565; +inp[12515] = 0; +inp[12516] = 1072890193; +inp[12517] = 0; +inp[12518] = 1072873823; +inp[12519] = 0; +inp[12520] = 1072857452; +inp[12521] = 0; +inp[12522] = 1072841082; +inp[12523] = 0; +inp[12524] = 1072824711; +inp[12525] = 0; +inp[12526] = 1072808342; +inp[12527] = 0; +inp[12528] = 1072791972; +inp[12529] = 0; +inp[12530] = 1072775602; +inp[12531] = 0; +inp[12532] = 1072759233; +inp[12533] = 0; +inp[12534] = 1072742864; +inp[12535] = 0; +inp[12536] = 1072726496; +inp[12537] = 0; +inp[12538] = 1072710127; +inp[12539] = 0; +inp[12540] = 1072693759; +inp[12541] = 0; +inp[12542] = 1072677391; +inp[12543] = 0; +inp[12544] = 1072661024; +inp[12545] = 0; +inp[12546] = 1072644656; +inp[12547] = 0; +inp[12548] = 1072628289; +inp[12549] = 0; +inp[12550] = 1072611922; +inp[12551] = 0; +inp[12552] = 1072595556; +inp[12553] = 0; +inp[12554] = 1072579189; +inp[12555] = 0; +inp[12556] = 1072562823; +inp[12557] = 0; +inp[12558] = 1072546457; +inp[12559] = 0; +inp[12560] = 1072530092; +inp[12561] = 0; +inp[12562] = 1072513726; +inp[12563] = 0; +inp[12564] = 1072497361; +inp[12565] = 0; +inp[12566] = 1072480996; +inp[12567] = 0; +inp[12568] = 1072464632; +inp[12569] = 0; +inp[12570] = 1072448267; +inp[12571] = 0; +inp[12572] = 1072431903; +inp[12573] = 0; +inp[12574] = 1072415539; +inp[12575] = 0; +inp[12576] = 1072399176; +inp[12577] = 0; +inp[12578] = 1072382812; +inp[12579] = 0; +inp[12580] = 1072366449; +inp[12581] = 0; +inp[12582] = 1072350086; +inp[12583] = 0; +inp[12584] = 1072333724; +inp[12585] = 0; +inp[12586] = 1072317361; +inp[12587] = 0; +inp[12588] = 1072300999; +inp[12589] = 0; +inp[12590] = 1072284637; +inp[12591] = 0; +inp[12592] = 1072268276; +inp[12593] = 0; +inp[12594] = 1072251914; +inp[12595] = 0; +inp[12596] = 1072235553; +inp[12597] = 0; +inp[12598] = 1072219192; +inp[12599] = 0; +inp[12600] = 1072202831; +inp[12601] = 0; +inp[12602] = 1072186471; +inp[12603] = 0; +inp[12604] = 1072170111; +inp[12605] = 0; +inp[12606] = 1072153751; +inp[12607] = 0; +inp[12608] = 1072137391; +inp[12609] = 0; +inp[12610] = 1072121032; +inp[12611] = 0; +inp[12612] = 1072104673; +inp[12613] = 0; +inp[12614] = 1072088314; +inp[12615] = 0; +inp[12616] = 1072071955; +inp[12617] = 0; +inp[12618] = 1072055597; +inp[12619] = 0; +inp[12620] = 1072039239; +inp[12621] = 0; +inp[12622] = 1072022881; +inp[12623] = 0; +inp[12624] = 1072006523; +inp[12625] = 0; +inp[12626] = 1071990166; +inp[12627] = 0; +inp[12628] = 1071973809; +inp[12629] = 0; +inp[12630] = 1071957452; +inp[12631] = 0; +inp[12632] = 1071941095; +inp[12633] = 0; +inp[12634] = 1071924739; +inp[12635] = 0; +inp[12636] = 1071908383; +inp[12637] = 0; +inp[12638] = 1071892027; +inp[12639] = 0; +inp[12640] = 1071875671; +inp[12641] = 0; +inp[12642] = 1071859316; +inp[12643] = 0; +inp[12644] = 1071842961; +inp[12645] = 0; +inp[12646] = 1071826606; +inp[12647] = 0; +inp[12648] = 1071810251; +inp[12649] = 0; +inp[12650] = 1071793897; +inp[12651] = 0; +inp[12652] = 1071777542; +inp[12653] = 0; +inp[12654] = 1071761188; +inp[12655] = 0; +inp[12656] = 1071744835; +inp[12657] = 0; +inp[12658] = 1071728481; +inp[12659] = 0; +inp[12660] = 1071712128; +inp[12661] = 0; +inp[12662] = 1071695775; +inp[12663] = 0; +inp[12664] = 1071679423; +inp[12665] = 0; +inp[12666] = 1071663070; +inp[12667] = 0; +inp[12668] = 1073741824; +inp[12669] = 1073741824; +inp[12670] = 1073733632; +inp[12671] = 0; +inp[12672] = 1073725440; +inp[12673] = 0; +inp[12674] = 1073717248; +inp[12675] = 0; +inp[12676] = 1073709056; +inp[12677] = 0; +inp[12678] = 1073700864; +inp[12679] = 0; +inp[12680] = 1073692673; +inp[12681] = 0; +inp[12682] = 1073684481; +inp[12683] = 0; +inp[12684] = 1073676289; +inp[12685] = 0; +inp[12686] = 1073668098; +inp[12687] = 0; +inp[12688] = 1073659907; +inp[12689] = 0; +inp[12690] = 1073651715; +inp[12691] = 0; +inp[12692] = 1073643524; +inp[12693] = 0; +inp[12694] = 1073635333; +inp[12695] = 0; +inp[12696] = 1073627142; +inp[12697] = 0; +inp[12698] = 1073618951; +inp[12699] = 0; +inp[12700] = 1073610759; +inp[12701] = 0; +inp[12702] = 1073602569; +inp[12703] = 0; +inp[12704] = 1073594378; +inp[12705] = 0; +inp[12706] = 1073586187; +inp[12707] = 0; +inp[12708] = 1073577996; +inp[12709] = 0; +inp[12710] = 1073569805; +inp[12711] = 0; +inp[12712] = 1073561615; +inp[12713] = 0; +inp[12714] = 1073553424; +inp[12715] = 0; +inp[12716] = 1073545233; +inp[12717] = 0; +inp[12718] = 1073537043; +inp[12719] = 0; +inp[12720] = 1073528853; +inp[12721] = 0; +inp[12722] = 1073520662; +inp[12723] = 0; +inp[12724] = 1073512472; +inp[12725] = 0; +inp[12726] = 1073504282; +inp[12727] = 0; +inp[12728] = 1073496092; +inp[12729] = 0; +inp[12730] = 1073487902; +inp[12731] = 0; +inp[12732] = 1073479711; +inp[12733] = 0; +inp[12734] = 1073471522; +inp[12735] = 0; +inp[12736] = 1073463332; +inp[12737] = 0; +inp[12738] = 1073455142; +inp[12739] = 0; +inp[12740] = 1073446952; +inp[12741] = 0; +inp[12742] = 1073438762; +inp[12743] = 0; +inp[12744] = 1073430573; +inp[12745] = 0; +inp[12746] = 1073422383; +inp[12747] = 0; +inp[12748] = 1073414193; +inp[12749] = 0; +inp[12750] = 1073406004; +inp[12751] = 0; +inp[12752] = 1073397815; +inp[12753] = 0; +inp[12754] = 1073389625; +inp[12755] = 0; +inp[12756] = 1073381436; +inp[12757] = 0; +inp[12758] = 1073373247; +inp[12759] = 0; +inp[12760] = 1073365058; +inp[12761] = 0; +inp[12762] = 1073356869; +inp[12763] = 0; +inp[12764] = 1073348679; +inp[12765] = 0; +inp[12766] = 1073340491; +inp[12767] = 0; +inp[12768] = 1073332302; +inp[12769] = 0; +inp[12770] = 1073324113; +inp[12771] = 0; +inp[12772] = 1073315924; +inp[12773] = 0; +inp[12774] = 1073307735; +inp[12775] = 0; +inp[12776] = 1073299547; +inp[12777] = 0; +inp[12778] = 1073291358; +inp[12779] = 0; +inp[12780] = 1073283169; +inp[12781] = 0; +inp[12782] = 1073274981; +inp[12783] = 0; +inp[12784] = 1073266793; +inp[12785] = 0; +inp[12786] = 1073258604; +inp[12787] = 0; +inp[12788] = 1073250416; +inp[12789] = 0; +inp[12790] = 1073242228; +inp[12791] = 0; +inp[12792] = 1073234040; +inp[12793] = 0; +inp[12794] = 1073225852; +inp[12795] = 0; +inp[12796] = 1073217663; +inp[12797] = 0; +inp[12798] = 1073209476; +inp[12799] = 0; +inp[12800] = 1073201288; +inp[12801] = 0; +inp[12802] = 1073193100; +inp[12803] = 0; +inp[12804] = 1073184912; +inp[12805] = 0; +inp[12806] = 1073176724; +inp[12807] = 0; +inp[12808] = 1073168537; +inp[12809] = 0; +inp[12810] = 1073160349; +inp[12811] = 0; +inp[12812] = 1073152161; +inp[12813] = 0; +inp[12814] = 1073143974; +inp[12815] = 0; +inp[12816] = 1073135787; +inp[12817] = 0; +inp[12818] = 1073127599; +inp[12819] = 0; +inp[12820] = 1073119412; +inp[12821] = 0; +inp[12822] = 1073111225; +inp[12823] = 0; +inp[12824] = 1073103038; +inp[12825] = 0; +inp[12826] = 1073094850; +inp[12827] = 0; +inp[12828] = 1073086663; +inp[12829] = 0; +inp[12830] = 1073078476; +inp[12831] = 0; +inp[12832] = 1073070290; +inp[12833] = 0; +inp[12834] = 1073062103; +inp[12835] = 0; +inp[12836] = 1073053916; +inp[12837] = 0; +inp[12838] = 1073045729; +inp[12839] = 0; +inp[12840] = 1073037543; +inp[12841] = 0; +inp[12842] = 1073029356; +inp[12843] = 0; +inp[12844] = 1073021169; +inp[12845] = 0; +inp[12846] = 1073012983; +inp[12847] = 0; +inp[12848] = 1073004797; +inp[12849] = 0; +inp[12850] = 1072996610; +inp[12851] = 0; +inp[12852] = 1072988424; +inp[12853] = 0; +inp[12854] = 1072980238; +inp[12855] = 0; +inp[12856] = 1072972052; +inp[12857] = 0; +inp[12858] = 1072963865; +inp[12859] = 0; +inp[12860] = 1072955679; +inp[12861] = 0; +inp[12862] = 1072947493; +inp[12863] = 0; +inp[12864] = 1072939308; +inp[12865] = 0; +inp[12866] = 1072931122; +inp[12867] = 0; +inp[12868] = 1072922936; +inp[12869] = 0; +inp[12870] = 1072914750; +inp[12871] = 0; +inp[12872] = 1072906565; +inp[12873] = 0; +inp[12874] = 1072898379; +inp[12875] = 0; +inp[12876] = 1072890193; +inp[12877] = 0; +inp[12878] = 1072882008; +inp[12879] = 0; +inp[12880] = 1072873823; +inp[12881] = 0; +inp[12882] = 1072865637; +inp[12883] = 0; +inp[12884] = 1072857452; +inp[12885] = 0; +inp[12886] = 1072849267; +inp[12887] = 0; +inp[12888] = 1072841082; +inp[12889] = 0; +inp[12890] = 1072832896; +inp[12891] = 0; +inp[12892] = 1072824711; +inp[12893] = 0; +inp[12894] = 1072816526; +inp[12895] = 0; +inp[12896] = 1072808342; +inp[12897] = 0; +inp[12898] = 1072800157; +inp[12899] = 0; +inp[12900] = 1072791972; +inp[12901] = 0; +inp[12902] = 1072783787; +inp[12903] = 0; +inp[12904] = 1072775602; +inp[12905] = 0; +inp[12906] = 1072767418; +inp[12907] = 0; +inp[12908] = 1072759233; +inp[12909] = 0; +inp[12910] = 1072751049; +inp[12911] = 0; +inp[12912] = 1072742864; +inp[12913] = 0; +inp[12914] = 1072734680; +inp[12915] = 0; +inp[12916] = 1072726496; +inp[12917] = 0; +inp[12918] = 1072718312; +inp[12919] = 0; +inp[12920] = 1072710127; +inp[12921] = 0; +inp[12922] = 1072701943; +inp[12923] = 0; +inp[12924] = 1073741824; +inp[12925] = 1073741824; +inp[12926] = 1073737728; +inp[12927] = 0; +inp[12928] = 1073733632; +inp[12929] = 0; +inp[12930] = 1073729536; +inp[12931] = 0; +inp[12932] = 1073725440; +inp[12933] = 0; +inp[12934] = 1073721344; +inp[12935] = 0; +inp[12936] = 1073717248; +inp[12937] = 0; +inp[12938] = 1073713152; +inp[12939] = 0; +inp[12940] = 1073709056; +inp[12941] = 0; +inp[12942] = 1073704960; +inp[12943] = 0; +inp[12944] = 1073700864; +inp[12945] = 0; +inp[12946] = 1073696768; +inp[12947] = 0; +inp[12948] = 1073692673; +inp[12949] = 0; +inp[12950] = 1073688577; +inp[12951] = 0; +inp[12952] = 1073684481; +inp[12953] = 0; +inp[12954] = 1073680385; +inp[12955] = 0; +inp[12956] = 1073676289; +inp[12957] = 0; +inp[12958] = 1073672194; +inp[12959] = 0; +inp[12960] = 1073668098; +inp[12961] = 0; +inp[12962] = 1073664002; +inp[12963] = 0; +inp[12964] = 1073659907; +inp[12965] = 0; +inp[12966] = 1073655811; +inp[12967] = 0; +inp[12968] = 1073651715; +inp[12969] = 0; +inp[12970] = 1073647620; +inp[12971] = 0; +inp[12972] = 1073643524; +inp[12973] = 0; +inp[12974] = 1073639428; +inp[12975] = 0; +inp[12976] = 1073635333; +inp[12977] = 0; +inp[12978] = 1073631237; +inp[12979] = 0; +inp[12980] = 1073627142; +inp[12981] = 0; +inp[12982] = 1073623046; +inp[12983] = 0; +inp[12984] = 1073618951; +inp[12985] = 0; +inp[12986] = 1073614855; +inp[12987] = 0; +inp[12988] = 1073610759; +inp[12989] = 0; +inp[12990] = 1073606664; +inp[12991] = 0; +inp[12992] = 1073602569; +inp[12993] = 0; +inp[12994] = 1073598473; +inp[12995] = 0; +inp[12996] = 1073594378; +inp[12997] = 0; +inp[12998] = 1073590282; +inp[12999] = 0; +inp[13000] = 1073586187; +inp[13001] = 0; +inp[13002] = 1073582091; +inp[13003] = 0; +inp[13004] = 1073577996; +inp[13005] = 0; +inp[13006] = 1073573901; +inp[13007] = 0; +inp[13008] = 1073569805; +inp[13009] = 0; +inp[13010] = 1073565710; +inp[13011] = 0; +inp[13012] = 1073561615; +inp[13013] = 0; +inp[13014] = 1073557519; +inp[13015] = 0; +inp[13016] = 1073553424; +inp[13017] = 0; +inp[13018] = 1073549329; +inp[13019] = 0; +inp[13020] = 1073545233; +inp[13021] = 0; +inp[13022] = 1073541138; +inp[13023] = 0; +inp[13024] = 1073537043; +inp[13025] = 0; +inp[13026] = 1073532948; +inp[13027] = 0; +inp[13028] = 1073528853; +inp[13029] = 0; +inp[13030] = 1073524757; +inp[13031] = 0; +inp[13032] = 1073520662; +inp[13033] = 0; +inp[13034] = 1073516567; +inp[13035] = 0; +inp[13036] = 1073512472; +inp[13037] = 0; +inp[13038] = 1073508377; +inp[13039] = 0; +inp[13040] = 1073504282; +inp[13041] = 0; +inp[13042] = 1073500187; +inp[13043] = 0; +inp[13044] = 1073496092; +inp[13045] = 0; +inp[13046] = 1073491997; +inp[13047] = 0; +inp[13048] = 1073487902; +inp[13049] = 0; +inp[13050] = 1073483807; +inp[13051] = 0; +inp[13052] = 1073479711; +inp[13053] = 0; +inp[13054] = 1073475617; +inp[13055] = 0; +inp[13056] = 1073471522; +inp[13057] = 0; +inp[13058] = 1073467427; +inp[13059] = 0; +inp[13060] = 1073463332; +inp[13061] = 0; +inp[13062] = 1073459237; +inp[13063] = 0; +inp[13064] = 1073455142; +inp[13065] = 0; +inp[13066] = 1073451047; +inp[13067] = 0; +inp[13068] = 1073446952; +inp[13069] = 0; +inp[13070] = 1073442857; +inp[13071] = 0; +inp[13072] = 1073438762; +inp[13073] = 0; +inp[13074] = 1073434667; +inp[13075] = 0; +inp[13076] = 1073430573; +inp[13077] = 0; +inp[13078] = 1073426478; +inp[13079] = 0; +inp[13080] = 1073422383; +inp[13081] = 0; +inp[13082] = 1073418288; +inp[13083] = 0; +inp[13084] = 1073414193; +inp[13085] = 0; +inp[13086] = 1073410099; +inp[13087] = 0; +inp[13088] = 1073406004; +inp[13089] = 0; +inp[13090] = 1073401909; +inp[13091] = 0; +inp[13092] = 1073397815; +inp[13093] = 0; +inp[13094] = 1073393720; +inp[13095] = 0; +inp[13096] = 1073389625; +inp[13097] = 0; +inp[13098] = 1073385531; +inp[13099] = 0; +inp[13100] = 1073381436; +inp[13101] = 0; +inp[13102] = 1073377341; +inp[13103] = 0; +inp[13104] = 1073373247; +inp[13105] = 0; +inp[13106] = 1073369152; +inp[13107] = 0; +inp[13108] = 1073365058; +inp[13109] = 0; +inp[13110] = 1073360963; +inp[13111] = 0; +inp[13112] = 1073356869; +inp[13113] = 0; +inp[13114] = 1073352774; +inp[13115] = 0; +inp[13116] = 1073348679; +inp[13117] = 0; +inp[13118] = 1073344585; +inp[13119] = 0; +inp[13120] = 1073340491; +inp[13121] = 0; +inp[13122] = 1073336396; +inp[13123] = 0; +inp[13124] = 1073332302; +inp[13125] = 0; +inp[13126] = 1073328207; +inp[13127] = 0; +inp[13128] = 1073324113; +inp[13129] = 0; +inp[13130] = 1073320018; +inp[13131] = 0; +inp[13132] = 1073315924; +inp[13133] = 0; +inp[13134] = 1073311830; +inp[13135] = 0; +inp[13136] = 1073307735; +inp[13137] = 0; +inp[13138] = 1073303641; +inp[13139] = 0; +inp[13140] = 1073299547; +inp[13141] = 0; +inp[13142] = 1073295452; +inp[13143] = 0; +inp[13144] = 1073291358; +inp[13145] = 0; +inp[13146] = 1073287264; +inp[13147] = 0; +inp[13148] = 1073283169; +inp[13149] = 0; +inp[13150] = 1073279075; +inp[13151] = 0; +inp[13152] = 1073274981; +inp[13153] = 0; +inp[13154] = 1073270887; +inp[13155] = 0; +inp[13156] = 1073266793; +inp[13157] = 0; +inp[13158] = 1073262698; +inp[13159] = 0; +inp[13160] = 1073258604; +inp[13161] = 0; +inp[13162] = 1073254510; +inp[13163] = 0; +inp[13164] = 1073250416; +inp[13165] = 0; +inp[13166] = 1073246322; +inp[13167] = 0; +inp[13168] = 1073242228; +inp[13169] = 0; +inp[13170] = 1073238134; +inp[13171] = 0; +inp[13172] = 1073234040; +inp[13173] = 0; +inp[13174] = 1073229946; +inp[13175] = 0; +inp[13176] = 1073225852; +inp[13177] = 0; +inp[13178] = 1073221757; +inp[13179] = 0; +inp[13180] = 1073741824; +inp[13181] = 1073741824; +inp[13182] = 1073739776; +inp[13183] = 0; +inp[13184] = 1073737728; +inp[13185] = 0; +inp[13186] = 1073735680; +inp[13187] = 0; +inp[13188] = 1073733632; +inp[13189] = 0; +inp[13190] = 1073731584; +inp[13191] = 0; +inp[13192] = 1073729536; +inp[13193] = 0; +inp[13194] = 1073727488; +inp[13195] = 0; +inp[13196] = 1073725440; +inp[13197] = 0; +inp[13198] = 1073723392; +inp[13199] = 0; +inp[13200] = 1073721344; +inp[13201] = 0; +inp[13202] = 1073719296; +inp[13203] = 0; +inp[13204] = 1073717248; +inp[13205] = 0; +inp[13206] = 1073715200; +inp[13207] = 0; +inp[13208] = 1073713152; +inp[13209] = 0; +inp[13210] = 1073711104; +inp[13211] = 0; +inp[13212] = 1073709056; +inp[13213] = 0; +inp[13214] = 1073707008; +inp[13215] = 0; +inp[13216] = 1073704960; +inp[13217] = 0; +inp[13218] = 1073702912; +inp[13219] = 0; +inp[13220] = 1073700864; +inp[13221] = 0; +inp[13222] = 1073698816; +inp[13223] = 0; +inp[13224] = 1073696768; +inp[13225] = 0; +inp[13226] = 1073694721; +inp[13227] = 0; +inp[13228] = 1073692673; +inp[13229] = 0; +inp[13230] = 1073690625; +inp[13231] = 0; +inp[13232] = 1073688577; +inp[13233] = 0; +inp[13234] = 1073686529; +inp[13235] = 0; +inp[13236] = 1073684481; +inp[13237] = 0; +inp[13238] = 1073682433; +inp[13239] = 0; +inp[13240] = 1073680385; +inp[13241] = 0; +inp[13242] = 1073678337; +inp[13243] = 0; +inp[13244] = 1073676289; +inp[13245] = 0; +inp[13246] = 1073674242; +inp[13247] = 0; +inp[13248] = 1073672194; +inp[13249] = 0; +inp[13250] = 1073670146; +inp[13251] = 0; +inp[13252] = 1073668098; +inp[13253] = 0; +inp[13254] = 1073666050; +inp[13255] = 0; +inp[13256] = 1073664002; +inp[13257] = 0; +inp[13258] = 1073661954; +inp[13259] = 0; +inp[13260] = 1073659907; +inp[13261] = 0; +inp[13262] = 1073657859; +inp[13263] = 0; +inp[13264] = 1073655811; +inp[13265] = 0; +inp[13266] = 1073653763; +inp[13267] = 0; +inp[13268] = 1073651715; +inp[13269] = 0; +inp[13270] = 1073649667; +inp[13271] = 0; +inp[13272] = 1073647620; +inp[13273] = 0; +inp[13274] = 1073645572; +inp[13275] = 0; +inp[13276] = 1073643524; +inp[13277] = 0; +inp[13278] = 1073641476; +inp[13279] = 0; +inp[13280] = 1073639428; +inp[13281] = 0; +inp[13282] = 1073637381; +inp[13283] = 0; +inp[13284] = 1073635333; +inp[13285] = 0; +inp[13286] = 1073633285; +inp[13287] = 0; +inp[13288] = 1073631237; +inp[13289] = 0; +inp[13290] = 1073629189; +inp[13291] = 0; +inp[13292] = 1073627142; +inp[13293] = 0; +inp[13294] = 1073625094; +inp[13295] = 0; +inp[13296] = 1073623046; +inp[13297] = 0; +inp[13298] = 1073620998; +inp[13299] = 0; +inp[13300] = 1073618951; +inp[13301] = 0; +inp[13302] = 1073616903; +inp[13303] = 0; +inp[13304] = 1073614855; +inp[13305] = 0; +inp[13306] = 1073612807; +inp[13307] = 0; +inp[13308] = 1073610759; +inp[13309] = 0; +inp[13310] = 1073608712; +inp[13311] = 0; +inp[13312] = 1073606664; +inp[13313] = 0; +inp[13314] = 1073604616; +inp[13315] = 0; +inp[13316] = 1073602569; +inp[13317] = 0; +inp[13318] = 1073600521; +inp[13319] = 0; +inp[13320] = 1073598473; +inp[13321] = 0; +inp[13322] = 1073596425; +inp[13323] = 0; +inp[13324] = 1073594378; +inp[13325] = 0; +inp[13326] = 1073592330; +inp[13327] = 0; +inp[13328] = 1073590282; +inp[13329] = 0; +inp[13330] = 1073588234; +inp[13331] = 0; +inp[13332] = 1073586187; +inp[13333] = 0; +inp[13334] = 1073584139; +inp[13335] = 0; +inp[13336] = 1073582091; +inp[13337] = 0; +inp[13338] = 1073580044; +inp[13339] = 0; +inp[13340] = 1073577996; +inp[13341] = 0; +inp[13342] = 1073575948; +inp[13343] = 0; +inp[13344] = 1073573901; +inp[13345] = 0; +inp[13346] = 1073571853; +inp[13347] = 0; +inp[13348] = 1073569805; +inp[13349] = 0; +inp[13350] = 1073567758; +inp[13351] = 0; +inp[13352] = 1073565710; +inp[13353] = 0; +inp[13354] = 1073563662; +inp[13355] = 0; +inp[13356] = 1073561615; +inp[13357] = 0; +inp[13358] = 1073559567; +inp[13359] = 0; +inp[13360] = 1073557519; +inp[13361] = 0; +inp[13362] = 1073555472; +inp[13363] = 0; +inp[13364] = 1073553424; +inp[13365] = 0; +inp[13366] = 1073551376; +inp[13367] = 0; +inp[13368] = 1073549329; +inp[13369] = 0; +inp[13370] = 1073547281; +inp[13371] = 0; +inp[13372] = 1073545233; +inp[13373] = 0; +inp[13374] = 1073543186; +inp[13375] = 0; +inp[13376] = 1073541138; +inp[13377] = 0; +inp[13378] = 1073539091; +inp[13379] = 0; +inp[13380] = 1073537043; +inp[13381] = 0; +inp[13382] = 1073534995; +inp[13383] = 0; +inp[13384] = 1073532948; +inp[13385] = 0; +inp[13386] = 1073530900; +inp[13387] = 0; +inp[13388] = 1073528853; +inp[13389] = 0; +inp[13390] = 1073526805; +inp[13391] = 0; +inp[13392] = 1073524757; +inp[13393] = 0; +inp[13394] = 1073522710; +inp[13395] = 0; +inp[13396] = 1073520662; +inp[13397] = 0; +inp[13398] = 1073518615; +inp[13399] = 0; +inp[13400] = 1073516567; +inp[13401] = 0; +inp[13402] = 1073514520; +inp[13403] = 0; +inp[13404] = 1073512472; +inp[13405] = 0; +inp[13406] = 1073510424; +inp[13407] = 0; +inp[13408] = 1073508377; +inp[13409] = 0; +inp[13410] = 1073506329; +inp[13411] = 0; +inp[13412] = 1073504282; +inp[13413] = 0; +inp[13414] = 1073502234; +inp[13415] = 0; +inp[13416] = 1073500187; +inp[13417] = 0; +inp[13418] = 1073498139; +inp[13419] = 0; +inp[13420] = 1073496092; +inp[13421] = 0; +inp[13422] = 1073494044; +inp[13423] = 0; +inp[13424] = 1073491997; +inp[13425] = 0; +inp[13426] = 1073489949; +inp[13427] = 0; +inp[13428] = 1073487902; +inp[13429] = 0; +inp[13430] = 1073485854; +inp[13431] = 0; +inp[13432] = 1073483807; +inp[13433] = 0; +inp[13434] = 1073481759; +inp[13435] = 0; +inp[13436] = 1073741824; +inp[13437] = 1073741824; +inp[13438] = 1073740800; +inp[13439] = 0; +inp[13440] = 1073739776; +inp[13441] = 0; +inp[13442] = 1073738752; +inp[13443] = 0; +inp[13444] = 1073737728; +inp[13445] = 0; +inp[13446] = 1073736704; +inp[13447] = 0; +inp[13448] = 1073735680; +inp[13449] = 0; +inp[13450] = 1073734656; +inp[13451] = 0; +inp[13452] = 1073733632; +inp[13453] = 0; +inp[13454] = 1073732608; +inp[13455] = 0; +inp[13456] = 1073731584; +inp[13457] = 0; +inp[13458] = 1073730560; +inp[13459] = 0; +inp[13460] = 1073729536; +inp[13461] = 0; +inp[13462] = 1073728512; +inp[13463] = 0; +inp[13464] = 1073727488; +inp[13465] = 0; +inp[13466] = 1073726464; +inp[13467] = 0; +inp[13468] = 1073725440; +inp[13469] = 0; +inp[13470] = 1073724416; +inp[13471] = 0; +inp[13472] = 1073723392; +inp[13473] = 0; +inp[13474] = 1073722368; +inp[13475] = 0; +inp[13476] = 1073721344; +inp[13477] = 0; +inp[13478] = 1073720320; +inp[13479] = 0; +inp[13480] = 1073719296; +inp[13481] = 0; +inp[13482] = 1073718272; +inp[13483] = 0; +inp[13484] = 1073717248; +inp[13485] = 0; +inp[13486] = 1073716224; +inp[13487] = 0; +inp[13488] = 1073715200; +inp[13489] = 0; +inp[13490] = 1073714176; +inp[13491] = 0; +inp[13492] = 1073713152; +inp[13493] = 0; +inp[13494] = 1073712128; +inp[13495] = 0; +inp[13496] = 1073711104; +inp[13497] = 0; +inp[13498] = 1073710080; +inp[13499] = 0; +inp[13500] = 1073709056; +inp[13501] = 0; +inp[13502] = 1073708032; +inp[13503] = 0; +inp[13504] = 1073707008; +inp[13505] = 0; +inp[13506] = 1073705984; +inp[13507] = 0; +inp[13508] = 1073704960; +inp[13509] = 0; +inp[13510] = 1073703936; +inp[13511] = 0; +inp[13512] = 1073702912; +inp[13513] = 0; +inp[13514] = 1073701888; +inp[13515] = 0; +inp[13516] = 1073700864; +inp[13517] = 0; +inp[13518] = 1073699840; +inp[13519] = 0; +inp[13520] = 1073698816; +inp[13521] = 0; +inp[13522] = 1073697792; +inp[13523] = 0; +inp[13524] = 1073696768; +inp[13525] = 0; +inp[13526] = 1073695744; +inp[13527] = 0; +inp[13528] = 1073694721; +inp[13529] = 0; +inp[13530] = 1073693697; +inp[13531] = 0; +inp[13532] = 1073692673; +inp[13533] = 0; +inp[13534] = 1073691649; +inp[13535] = 0; +inp[13536] = 1073690625; +inp[13537] = 0; +inp[13538] = 1073689601; +inp[13539] = 0; +inp[13540] = 1073688577; +inp[13541] = 0; +inp[13542] = 1073687553; +inp[13543] = 0; +inp[13544] = 1073686529; +inp[13545] = 0; +inp[13546] = 1073685505; +inp[13547] = 0; +inp[13548] = 1073684481; +inp[13549] = 0; +inp[13550] = 1073683457; +inp[13551] = 0; +inp[13552] = 1073682433; +inp[13553] = 0; +inp[13554] = 1073681409; +inp[13555] = 0; +inp[13556] = 1073680385; +inp[13557] = 0; +inp[13558] = 1073679361; +inp[13559] = 0; +inp[13560] = 1073678337; +inp[13561] = 0; +inp[13562] = 1073677313; +inp[13563] = 0; +inp[13564] = 1073676289; +inp[13565] = 0; +inp[13566] = 1073675266; +inp[13567] = 0; +inp[13568] = 1073674242; +inp[13569] = 0; +inp[13570] = 1073673218; +inp[13571] = 0; +inp[13572] = 1073672194; +inp[13573] = 0; +inp[13574] = 1073671170; +inp[13575] = 0; +inp[13576] = 1073670146; +inp[13577] = 0; +inp[13578] = 1073669122; +inp[13579] = 0; +inp[13580] = 1073668098; +inp[13581] = 0; +inp[13582] = 1073667074; +inp[13583] = 0; +inp[13584] = 1073666050; +inp[13585] = 0; +inp[13586] = 1073665026; +inp[13587] = 0; +inp[13588] = 1073664002; +inp[13589] = 0; +inp[13590] = 1073662978; +inp[13591] = 0; +inp[13592] = 1073661954; +inp[13593] = 0; +inp[13594] = 1073660931; +inp[13595] = 0; +inp[13596] = 1073659907; +inp[13597] = 0; +inp[13598] = 1073658883; +inp[13599] = 0; +inp[13600] = 1073657859; +inp[13601] = 0; +inp[13602] = 1073656835; +inp[13603] = 0; +inp[13604] = 1073655811; +inp[13605] = 0; +inp[13606] = 1073654787; +inp[13607] = 0; +inp[13608] = 1073653763; +inp[13609] = 0; +inp[13610] = 1073652739; +inp[13611] = 0; +inp[13612] = 1073651715; +inp[13613] = 0; +inp[13614] = 1073650691; +inp[13615] = 0; +inp[13616] = 1073649667; +inp[13617] = 0; +inp[13618] = 1073648644; +inp[13619] = 0; +inp[13620] = 1073647620; +inp[13621] = 0; +inp[13622] = 1073646596; +inp[13623] = 0; +inp[13624] = 1073645572; +inp[13625] = 0; +inp[13626] = 1073644548; +inp[13627] = 0; +inp[13628] = 1073643524; +inp[13629] = 0; +inp[13630] = 1073642500; +inp[13631] = 0; +inp[13632] = 1073641476; +inp[13633] = 0; +inp[13634] = 1073640452; +inp[13635] = 0; +inp[13636] = 1073639428; +inp[13637] = 0; +inp[13638] = 1073638404; +inp[13639] = 0; +inp[13640] = 1073637381; +inp[13641] = 0; +inp[13642] = 1073636357; +inp[13643] = 0; +inp[13644] = 1073635333; +inp[13645] = 0; +inp[13646] = 1073634309; +inp[13647] = 0; +inp[13648] = 1073633285; +inp[13649] = 0; +inp[13650] = 1073632261; +inp[13651] = 0; +inp[13652] = 1073631237; +inp[13653] = 0; +inp[13654] = 1073630213; +inp[13655] = 0; +inp[13656] = 1073629189; +inp[13657] = 0; +inp[13658] = 1073628166; +inp[13659] = 0; +inp[13660] = 1073627142; +inp[13661] = 0; +inp[13662] = 1073626118; +inp[13663] = 0; +inp[13664] = 1073625094; +inp[13665] = 0; +inp[13666] = 1073624070; +inp[13667] = 0; +inp[13668] = 1073623046; +inp[13669] = 0; +inp[13670] = 1073622022; +inp[13671] = 0; +inp[13672] = 1073620998; +inp[13673] = 0; +inp[13674] = 1073619974; +inp[13675] = 0; +inp[13676] = 1073618951; +inp[13677] = 0; +inp[13678] = 1073617927; +inp[13679] = 0; +inp[13680] = 1073616903; +inp[13681] = 0; +inp[13682] = 1073615879; +inp[13683] = 0; +inp[13684] = 1073614855; +inp[13685] = 0; +inp[13686] = 1073613831; +inp[13687] = 0; +inp[13688] = 1073612807; +inp[13689] = 0; +inp[13690] = 1073611783; +inp[13691] = 0; +inp[13692] = 1073741824; +inp[13693] = 1073741824; +inp[13694] = 1073741312; +inp[13695] = 0; +inp[13696] = 1073740800; +inp[13697] = 0; +inp[13698] = 1073740288; +inp[13699] = 0; +inp[13700] = 1073739776; +inp[13701] = 0; +inp[13702] = 1073739264; +inp[13703] = 0; +inp[13704] = 1073738752; +inp[13705] = 0; +inp[13706] = 1073738240; +inp[13707] = 0; +inp[13708] = 1073737728; +inp[13709] = 0; +inp[13710] = 1073737216; +inp[13711] = 0; +inp[13712] = 1073736704; +inp[13713] = 0; +inp[13714] = 1073736192; +inp[13715] = 0; +inp[13716] = 1073735680; +inp[13717] = 0; +inp[13718] = 1073735168; +inp[13719] = 0; +inp[13720] = 1073734656; +inp[13721] = 0; +inp[13722] = 1073734144; +inp[13723] = 0; +inp[13724] = 1073733632; +inp[13725] = 0; +inp[13726] = 1073733120; +inp[13727] = 0; +inp[13728] = 1073732608; +inp[13729] = 0; +inp[13730] = 1073732096; +inp[13731] = 0; +inp[13732] = 1073731584; +inp[13733] = 0; +inp[13734] = 1073731072; +inp[13735] = 0; +inp[13736] = 1073730560; +inp[13737] = 0; +inp[13738] = 1073730048; +inp[13739] = 0; +inp[13740] = 1073729536; +inp[13741] = 0; +inp[13742] = 1073729024; +inp[13743] = 0; +inp[13744] = 1073728512; +inp[13745] = 0; +inp[13746] = 1073728000; +inp[13747] = 0; +inp[13748] = 1073727488; +inp[13749] = 0; +inp[13750] = 1073726976; +inp[13751] = 0; +inp[13752] = 1073726464; +inp[13753] = 0; +inp[13754] = 1073725952; +inp[13755] = 0; +inp[13756] = 1073725440; +inp[13757] = 0; +inp[13758] = 1073724928; +inp[13759] = 0; +inp[13760] = 1073724416; +inp[13761] = 0; +inp[13762] = 1073723904; +inp[13763] = 0; +inp[13764] = 1073723392; +inp[13765] = 0; +inp[13766] = 1073722880; +inp[13767] = 0; +inp[13768] = 1073722368; +inp[13769] = 0; +inp[13770] = 1073721856; +inp[13771] = 0; +inp[13772] = 1073721344; +inp[13773] = 0; +inp[13774] = 1073720832; +inp[13775] = 0; +inp[13776] = 1073720320; +inp[13777] = 0; +inp[13778] = 1073719808; +inp[13779] = 0; +inp[13780] = 1073719296; +inp[13781] = 0; +inp[13782] = 1073718784; +inp[13783] = 0; +inp[13784] = 1073718272; +inp[13785] = 0; +inp[13786] = 1073717760; +inp[13787] = 0; +inp[13788] = 1073717248; +inp[13789] = 0; +inp[13790] = 1073716736; +inp[13791] = 0; +inp[13792] = 1073716224; +inp[13793] = 0; +inp[13794] = 1073715712; +inp[13795] = 0; +inp[13796] = 1073715200; +inp[13797] = 0; +inp[13798] = 1073714688; +inp[13799] = 0; +inp[13800] = 1073714176; +inp[13801] = 0; +inp[13802] = 1073713664; +inp[13803] = 0; +inp[13804] = 1073713152; +inp[13805] = 0; +inp[13806] = 1073712640; +inp[13807] = 0; +inp[13808] = 1073712128; +inp[13809] = 0; +inp[13810] = 1073711616; +inp[13811] = 0; +inp[13812] = 1073711104; +inp[13813] = 0; +inp[13814] = 1073710592; +inp[13815] = 0; +inp[13816] = 1073710080; +inp[13817] = 0; +inp[13818] = 1073709568; +inp[13819] = 0; +inp[13820] = 1073709056; +inp[13821] = 0; +inp[13822] = 1073708544; +inp[13823] = 0; +inp[13824] = 1073708032; +inp[13825] = 0; +inp[13826] = 1073707520; +inp[13827] = 0; +inp[13828] = 1073707008; +inp[13829] = 0; +inp[13830] = 1073706496; +inp[13831] = 0; +inp[13832] = 1073705984; +inp[13833] = 0; +inp[13834] = 1073705472; +inp[13835] = 0; +inp[13836] = 1073704960; +inp[13837] = 0; +inp[13838] = 1073704448; +inp[13839] = 0; +inp[13840] = 1073703936; +inp[13841] = 0; +inp[13842] = 1073703424; +inp[13843] = 0; +inp[13844] = 1073702912; +inp[13845] = 0; +inp[13846] = 1073702400; +inp[13847] = 0; +inp[13848] = 1073701888; +inp[13849] = 0; +inp[13850] = 1073701376; +inp[13851] = 0; +inp[13852] = 1073700864; +inp[13853] = 0; +inp[13854] = 1073700352; +inp[13855] = 0; +inp[13856] = 1073699840; +inp[13857] = 0; +inp[13858] = 1073699328; +inp[13859] = 0; +inp[13860] = 1073698816; +inp[13861] = 0; +inp[13862] = 1073698304; +inp[13863] = 0; +inp[13864] = 1073697792; +inp[13865] = 0; +inp[13866] = 1073697280; +inp[13867] = 0; +inp[13868] = 1073696768; +inp[13869] = 0; +inp[13870] = 1073696256; +inp[13871] = 0; +inp[13872] = 1073695744; +inp[13873] = 0; +inp[13874] = 1073695233; +inp[13875] = 0; +inp[13876] = 1073694721; +inp[13877] = 0; +inp[13878] = 1073694209; +inp[13879] = 0; +inp[13880] = 1073693697; +inp[13881] = 0; +inp[13882] = 1073693185; +inp[13883] = 0; +inp[13884] = 1073692673; +inp[13885] = 0; +inp[13886] = 1073692161; +inp[13887] = 0; +inp[13888] = 1073691649; +inp[13889] = 0; +inp[13890] = 1073691137; +inp[13891] = 0; +inp[13892] = 1073690625; +inp[13893] = 0; +inp[13894] = 1073690113; +inp[13895] = 0; +inp[13896] = 1073689601; +inp[13897] = 0; +inp[13898] = 1073689089; +inp[13899] = 0; +inp[13900] = 1073688577; +inp[13901] = 0; +inp[13902] = 1073688065; +inp[13903] = 0; +inp[13904] = 1073687553; +inp[13905] = 0; +inp[13906] = 1073687041; +inp[13907] = 0; +inp[13908] = 1073686529; +inp[13909] = 0; +inp[13910] = 1073686017; +inp[13911] = 0; +inp[13912] = 1073685505; +inp[13913] = 0; +inp[13914] = 1073684993; +inp[13915] = 0; +inp[13916] = 1073684481; +inp[13917] = 0; +inp[13918] = 1073683969; +inp[13919] = 0; +inp[13920] = 1073683457; +inp[13921] = 0; +inp[13922] = 1073682945; +inp[13923] = 0; +inp[13924] = 1073682433; +inp[13925] = 0; +inp[13926] = 1073681921; +inp[13927] = 0; +inp[13928] = 1073681409; +inp[13929] = 0; +inp[13930] = 1073680897; +inp[13931] = 0; +inp[13932] = 1073680385; +inp[13933] = 0; +inp[13934] = 1073679873; +inp[13935] = 0; +inp[13936] = 1073679361; +inp[13937] = 0; +inp[13938] = 1073678849; +inp[13939] = 0; +inp[13940] = 1073678337; +inp[13941] = 0; +inp[13942] = 1073677825; +inp[13943] = 0; +inp[13944] = 1073677313; +inp[13945] = 0; +inp[13946] = 1073676801; +inp[13947] = 0; +inp[13948] = 1073741824; +inp[13949] = 1073741824; +inp[13950] = 1073741568; +inp[13951] = 0; +inp[13952] = 1073741312; +inp[13953] = 0; +inp[13954] = 1073741056; +inp[13955] = 0; +inp[13956] = 1073740800; +inp[13957] = 0; +inp[13958] = 1073740544; +inp[13959] = 0; +inp[13960] = 1073740288; +inp[13961] = 0; +inp[13962] = 1073740032; +inp[13963] = 0; +inp[13964] = 1073739776; +inp[13965] = 0; +inp[13966] = 1073739520; +inp[13967] = 0; +inp[13968] = 1073739264; +inp[13969] = 0; +inp[13970] = 1073739008; +inp[13971] = 0; +inp[13972] = 1073738752; +inp[13973] = 0; +inp[13974] = 1073738496; +inp[13975] = 0; +inp[13976] = 1073738240; +inp[13977] = 0; +inp[13978] = 1073737984; +inp[13979] = 0; +inp[13980] = 1073737728; +inp[13981] = 0; +inp[13982] = 1073737472; +inp[13983] = 0; +inp[13984] = 1073737216; +inp[13985] = 0; +inp[13986] = 1073736960; +inp[13987] = 0; +inp[13988] = 1073736704; +inp[13989] = 0; +inp[13990] = 1073736448; +inp[13991] = 0; +inp[13992] = 1073736192; +inp[13993] = 0; +inp[13994] = 1073735936; +inp[13995] = 0; +inp[13996] = 1073735680; +inp[13997] = 0; +inp[13998] = 1073735424; +inp[13999] = 0; +inp[14000] = 1073735168; +inp[14001] = 0; +inp[14002] = 1073734912; +inp[14003] = 0; +inp[14004] = 1073734656; +inp[14005] = 0; +inp[14006] = 1073734400; +inp[14007] = 0; +inp[14008] = 1073734144; +inp[14009] = 0; +inp[14010] = 1073733888; +inp[14011] = 0; +inp[14012] = 1073733632; +inp[14013] = 0; +inp[14014] = 1073733376; +inp[14015] = 0; +inp[14016] = 1073733120; +inp[14017] = 0; +inp[14018] = 1073732864; +inp[14019] = 0; +inp[14020] = 1073732608; +inp[14021] = 0; +inp[14022] = 1073732352; +inp[14023] = 0; +inp[14024] = 1073732096; +inp[14025] = 0; +inp[14026] = 1073731840; +inp[14027] = 0; +inp[14028] = 1073731584; +inp[14029] = 0; +inp[14030] = 1073731328; +inp[14031] = 0; +inp[14032] = 1073731072; +inp[14033] = 0; +inp[14034] = 1073730816; +inp[14035] = 0; +inp[14036] = 1073730560; +inp[14037] = 0; +inp[14038] = 1073730304; +inp[14039] = 0; +inp[14040] = 1073730048; +inp[14041] = 0; +inp[14042] = 1073729792; +inp[14043] = 0; +inp[14044] = 1073729536; +inp[14045] = 0; +inp[14046] = 1073729280; +inp[14047] = 0; +inp[14048] = 1073729024; +inp[14049] = 0; +inp[14050] = 1073728768; +inp[14051] = 0; +inp[14052] = 1073728512; +inp[14053] = 0; +inp[14054] = 1073728256; +inp[14055] = 0; +inp[14056] = 1073728000; +inp[14057] = 0; +inp[14058] = 1073727744; +inp[14059] = 0; +inp[14060] = 1073727488; +inp[14061] = 0; +inp[14062] = 1073727232; +inp[14063] = 0; +inp[14064] = 1073726976; +inp[14065] = 0; +inp[14066] = 1073726720; +inp[14067] = 0; +inp[14068] = 1073726464; +inp[14069] = 0; +inp[14070] = 1073726208; +inp[14071] = 0; +inp[14072] = 1073725952; +inp[14073] = 0; +inp[14074] = 1073725696; +inp[14075] = 0; +inp[14076] = 1073725440; +inp[14077] = 0; +inp[14078] = 1073725184; +inp[14079] = 0; +inp[14080] = 1073724928; +inp[14081] = 0; +inp[14082] = 1073724672; +inp[14083] = 0; +inp[14084] = 1073724416; +inp[14085] = 0; +inp[14086] = 1073724160; +inp[14087] = 0; +inp[14088] = 1073723904; +inp[14089] = 0; +inp[14090] = 1073723648; +inp[14091] = 0; +inp[14092] = 1073723392; +inp[14093] = 0; +inp[14094] = 1073723136; +inp[14095] = 0; +inp[14096] = 1073722880; +inp[14097] = 0; +inp[14098] = 1073722624; +inp[14099] = 0; +inp[14100] = 1073722368; +inp[14101] = 0; +inp[14102] = 1073722112; +inp[14103] = 0; +inp[14104] = 1073721856; +inp[14105] = 0; +inp[14106] = 1073721600; +inp[14107] = 0; +inp[14108] = 1073721344; +inp[14109] = 0; +inp[14110] = 1073721088; +inp[14111] = 0; +inp[14112] = 1073720832; +inp[14113] = 0; +inp[14114] = 1073720576; +inp[14115] = 0; +inp[14116] = 1073720320; +inp[14117] = 0; +inp[14118] = 1073720064; +inp[14119] = 0; +inp[14120] = 1073719808; +inp[14121] = 0; +inp[14122] = 1073719552; +inp[14123] = 0; +inp[14124] = 1073719296; +inp[14125] = 0; +inp[14126] = 1073719040; +inp[14127] = 0; +inp[14128] = 1073718784; +inp[14129] = 0; +inp[14130] = 1073718528; +inp[14131] = 0; +inp[14132] = 1073718272; +inp[14133] = 0; +inp[14134] = 1073718016; +inp[14135] = 0; +inp[14136] = 1073717760; +inp[14137] = 0; +inp[14138] = 1073717504; +inp[14139] = 0; +inp[14140] = 1073717248; +inp[14141] = 0; +inp[14142] = 1073716992; +inp[14143] = 0; +inp[14144] = 1073716736; +inp[14145] = 0; +inp[14146] = 1073716480; +inp[14147] = 0; +inp[14148] = 1073716224; +inp[14149] = 0; +inp[14150] = 1073715968; +inp[14151] = 0; +inp[14152] = 1073715712; +inp[14153] = 0; +inp[14154] = 1073715456; +inp[14155] = 0; +inp[14156] = 1073715200; +inp[14157] = 0; +inp[14158] = 1073714944; +inp[14159] = 0; +inp[14160] = 1073714688; +inp[14161] = 0; +inp[14162] = 1073714432; +inp[14163] = 0; +inp[14164] = 1073714176; +inp[14165] = 0; +inp[14166] = 1073713920; +inp[14167] = 0; +inp[14168] = 1073713664; +inp[14169] = 0; +inp[14170] = 1073713408; +inp[14171] = 0; +inp[14172] = 1073713152; +inp[14173] = 0; +inp[14174] = 1073712896; +inp[14175] = 0; +inp[14176] = 1073712640; +inp[14177] = 0; +inp[14178] = 1073712384; +inp[14179] = 0; +inp[14180] = 1073712128; +inp[14181] = 0; +inp[14182] = 1073711872; +inp[14183] = 0; +inp[14184] = 1073711616; +inp[14185] = 0; +inp[14186] = 1073711360; +inp[14187] = 0; +inp[14188] = 1073711104; +inp[14189] = 0; +inp[14190] = 1073710848; +inp[14191] = 0; +inp[14192] = 1073710592; +inp[14193] = 0; +inp[14194] = 1073710336; +inp[14195] = 0; +inp[14196] = 1073710080; +inp[14197] = 0; +inp[14198] = 1073709824; +inp[14199] = 0; +inp[14200] = 1073709568; +inp[14201] = 0; +inp[14202] = 1073709312; +inp[14203] = 0; +inp[14204] = 1073741824; +inp[14205] = 1073741824; +inp[14206] = 1073741696; +inp[14207] = 0; +inp[14208] = 1073741568; +inp[14209] = 0; +inp[14210] = 1073741440; +inp[14211] = 0; +inp[14212] = 1073741312; +inp[14213] = 0; +inp[14214] = 1073741184; +inp[14215] = 0; +inp[14216] = 1073741056; +inp[14217] = 0; +inp[14218] = 1073740928; +inp[14219] = 0; +inp[14220] = 1073740800; +inp[14221] = 0; +inp[14222] = 1073740672; +inp[14223] = 0; +inp[14224] = 1073740544; +inp[14225] = 0; +inp[14226] = 1073740416; +inp[14227] = 0; +inp[14228] = 1073740288; +inp[14229] = 0; +inp[14230] = 1073740160; +inp[14231] = 0; +inp[14232] = 1073740032; +inp[14233] = 0; +inp[14234] = 1073739904; +inp[14235] = 0; +inp[14236] = 1073739776; +inp[14237] = 0; +inp[14238] = 1073739648; +inp[14239] = 0; +inp[14240] = 1073739520; +inp[14241] = 0; +inp[14242] = 1073739392; +inp[14243] = 0; +inp[14244] = 1073739264; +inp[14245] = 0; +inp[14246] = 1073739136; +inp[14247] = 0; +inp[14248] = 1073739008; +inp[14249] = 0; +inp[14250] = 1073738880; +inp[14251] = 0; +inp[14252] = 1073738752; +inp[14253] = 0; +inp[14254] = 1073738624; +inp[14255] = 0; +inp[14256] = 1073738496; +inp[14257] = 0; +inp[14258] = 1073738368; +inp[14259] = 0; +inp[14260] = 1073738240; +inp[14261] = 0; +inp[14262] = 1073738112; +inp[14263] = 0; +inp[14264] = 1073737984; +inp[14265] = 0; +inp[14266] = 1073737856; +inp[14267] = 0; +inp[14268] = 1073737728; +inp[14269] = 0; +inp[14270] = 1073737600; +inp[14271] = 0; +inp[14272] = 1073737472; +inp[14273] = 0; +inp[14274] = 1073737344; +inp[14275] = 0; +inp[14276] = 1073737216; +inp[14277] = 0; +inp[14278] = 1073737088; +inp[14279] = 0; +inp[14280] = 1073736960; +inp[14281] = 0; +inp[14282] = 1073736832; +inp[14283] = 0; +inp[14284] = 1073736704; +inp[14285] = 0; +inp[14286] = 1073736576; +inp[14287] = 0; +inp[14288] = 1073736448; +inp[14289] = 0; +inp[14290] = 1073736320; +inp[14291] = 0; +inp[14292] = 1073736192; +inp[14293] = 0; +inp[14294] = 1073736064; +inp[14295] = 0; +inp[14296] = 1073735936; +inp[14297] = 0; +inp[14298] = 1073735808; +inp[14299] = 0; +inp[14300] = 1073735680; +inp[14301] = 0; +inp[14302] = 1073735552; +inp[14303] = 0; +inp[14304] = 1073735424; +inp[14305] = 0; +inp[14306] = 1073735296; +inp[14307] = 0; +inp[14308] = 1073735168; +inp[14309] = 0; +inp[14310] = 1073735040; +inp[14311] = 0; +inp[14312] = 1073734912; +inp[14313] = 0; +inp[14314] = 1073734784; +inp[14315] = 0; +inp[14316] = 1073734656; +inp[14317] = 0; +inp[14318] = 1073734528; +inp[14319] = 0; +inp[14320] = 1073734400; +inp[14321] = 0; +inp[14322] = 1073734272; +inp[14323] = 0; +inp[14324] = 1073734144; +inp[14325] = 0; +inp[14326] = 1073734016; +inp[14327] = 0; +inp[14328] = 1073733888; +inp[14329] = 0; +inp[14330] = 1073733760; +inp[14331] = 0; +inp[14332] = 1073733632; +inp[14333] = 0; +inp[14334] = 1073733504; +inp[14335] = 0; +inp[14336] = 1073733376; +inp[14337] = 0; +inp[14338] = 1073733248; +inp[14339] = 0; +inp[14340] = 1073733120; +inp[14341] = 0; +inp[14342] = 1073732992; +inp[14343] = 0; +inp[14344] = 1073732864; +inp[14345] = 0; +inp[14346] = 1073732736; +inp[14347] = 0; +inp[14348] = 1073732608; +inp[14349] = 0; +inp[14350] = 1073732480; +inp[14351] = 0; +inp[14352] = 1073732352; +inp[14353] = 0; +inp[14354] = 1073732224; +inp[14355] = 0; +inp[14356] = 1073732096; +inp[14357] = 0; +inp[14358] = 1073731968; +inp[14359] = 0; +inp[14360] = 1073731840; +inp[14361] = 0; +inp[14362] = 1073731712; +inp[14363] = 0; +inp[14364] = 1073731584; +inp[14365] = 0; +inp[14366] = 1073731456; +inp[14367] = 0; +inp[14368] = 1073731328; +inp[14369] = 0; +inp[14370] = 1073731200; +inp[14371] = 0; +inp[14372] = 1073731072; +inp[14373] = 0; +inp[14374] = 1073730944; +inp[14375] = 0; +inp[14376] = 1073730816; +inp[14377] = 0; +inp[14378] = 1073730688; +inp[14379] = 0; +inp[14380] = 1073730560; +inp[14381] = 0; +inp[14382] = 1073730432; +inp[14383] = 0; +inp[14384] = 1073730304; +inp[14385] = 0; +inp[14386] = 1073730176; +inp[14387] = 0; +inp[14388] = 1073730048; +inp[14389] = 0; +inp[14390] = 1073729920; +inp[14391] = 0; +inp[14392] = 1073729792; +inp[14393] = 0; +inp[14394] = 1073729664; +inp[14395] = 0; +inp[14396] = 1073729536; +inp[14397] = 0; +inp[14398] = 1073729408; +inp[14399] = 0; +inp[14400] = 1073729280; +inp[14401] = 0; +inp[14402] = 1073729152; +inp[14403] = 0; +inp[14404] = 1073729024; +inp[14405] = 0; +inp[14406] = 1073728896; +inp[14407] = 0; +inp[14408] = 1073728768; +inp[14409] = 0; +inp[14410] = 1073728640; +inp[14411] = 0; +inp[14412] = 1073728512; +inp[14413] = 0; +inp[14414] = 1073728384; +inp[14415] = 0; +inp[14416] = 1073728256; +inp[14417] = 0; +inp[14418] = 1073728128; +inp[14419] = 0; +inp[14420] = 1073728000; +inp[14421] = 0; +inp[14422] = 1073727872; +inp[14423] = 0; +inp[14424] = 1073727744; +inp[14425] = 0; +inp[14426] = 1073727616; +inp[14427] = 0; +inp[14428] = 1073727488; +inp[14429] = 0; +inp[14430] = 1073727360; +inp[14431] = 0; +inp[14432] = 1073727232; +inp[14433] = 0; +inp[14434] = 1073727104; +inp[14435] = 0; +inp[14436] = 1073726976; +inp[14437] = 0; +inp[14438] = 1073726848; +inp[14439] = 0; +inp[14440] = 1073726720; +inp[14441] = 0; +inp[14442] = 1073726592; +inp[14443] = 0; +inp[14444] = 1073726464; +inp[14445] = 0; +inp[14446] = 1073726336; +inp[14447] = 0; +inp[14448] = 1073726208; +inp[14449] = 0; +inp[14450] = 1073726080; +inp[14451] = 0; +inp[14452] = 1073725952; +inp[14453] = 0; +inp[14454] = 1073725824; +inp[14455] = 0; +inp[14456] = 1073725696; +inp[14457] = 0; +inp[14458] = 1073725568; +inp[14459] = 0; +inp[14460] = 1073741824; +inp[14461] = 1073741824; +inp[14462] = 1073741760; +inp[14463] = 0; +inp[14464] = 1073741696; +inp[14465] = 0; +inp[14466] = 1073741632; +inp[14467] = 0; +inp[14468] = 1073741568; +inp[14469] = 0; +inp[14470] = 1073741504; +inp[14471] = 0; +inp[14472] = 1073741440; +inp[14473] = 0; +inp[14474] = 1073741376; +inp[14475] = 0; +inp[14476] = 1073741312; +inp[14477] = 0; +inp[14478] = 1073741248; +inp[14479] = 0; +inp[14480] = 1073741184; +inp[14481] = 0; +inp[14482] = 1073741120; +inp[14483] = 0; +inp[14484] = 1073741056; +inp[14485] = 0; +inp[14486] = 1073740992; +inp[14487] = 0; +inp[14488] = 1073740928; +inp[14489] = 0; +inp[14490] = 1073740864; +inp[14491] = 0; +inp[14492] = 1073740800; +inp[14493] = 0; +inp[14494] = 1073740736; +inp[14495] = 0; +inp[14496] = 1073740672; +inp[14497] = 0; +inp[14498] = 1073740608; +inp[14499] = 0; +inp[14500] = 1073740544; +inp[14501] = 0; +inp[14502] = 1073740480; +inp[14503] = 0; +inp[14504] = 1073740416; +inp[14505] = 0; +inp[14506] = 1073740352; +inp[14507] = 0; +inp[14508] = 1073740288; +inp[14509] = 0; +inp[14510] = 1073740224; +inp[14511] = 0; +inp[14512] = 1073740160; +inp[14513] = 0; +inp[14514] = 1073740096; +inp[14515] = 0; +inp[14516] = 1073740032; +inp[14517] = 0; +inp[14518] = 1073739968; +inp[14519] = 0; +inp[14520] = 1073739904; +inp[14521] = 0; +inp[14522] = 1073739840; +inp[14523] = 0; +inp[14524] = 1073739776; +inp[14525] = 0; +inp[14526] = 1073739712; +inp[14527] = 0; +inp[14528] = 1073739648; +inp[14529] = 0; +inp[14530] = 1073739584; +inp[14531] = 0; +inp[14532] = 1073739520; +inp[14533] = 0; +inp[14534] = 1073739456; +inp[14535] = 0; +inp[14536] = 1073739392; +inp[14537] = 0; +inp[14538] = 1073739328; +inp[14539] = 0; +inp[14540] = 1073739264; +inp[14541] = 0; +inp[14542] = 1073739200; +inp[14543] = 0; +inp[14544] = 1073739136; +inp[14545] = 0; +inp[14546] = 1073739072; +inp[14547] = 0; +inp[14548] = 1073739008; +inp[14549] = 0; +inp[14550] = 1073738944; +inp[14551] = 0; +inp[14552] = 1073738880; +inp[14553] = 0; +inp[14554] = 1073738816; +inp[14555] = 0; +inp[14556] = 1073738752; +inp[14557] = 0; +inp[14558] = 1073738688; +inp[14559] = 0; +inp[14560] = 1073738624; +inp[14561] = 0; +inp[14562] = 1073738560; +inp[14563] = 0; +inp[14564] = 1073738496; +inp[14565] = 0; +inp[14566] = 1073738432; +inp[14567] = 0; +inp[14568] = 1073738368; +inp[14569] = 0; +inp[14570] = 1073738304; +inp[14571] = 0; +inp[14572] = 1073738240; +inp[14573] = 0; +inp[14574] = 1073738176; +inp[14575] = 0; +inp[14576] = 1073738112; +inp[14577] = 0; +inp[14578] = 1073738048; +inp[14579] = 0; +inp[14580] = 1073737984; +inp[14581] = 0; +inp[14582] = 1073737920; +inp[14583] = 0; +inp[14584] = 1073737856; +inp[14585] = 0; +inp[14586] = 1073737792; +inp[14587] = 0; +inp[14588] = 1073737728; +inp[14589] = 0; +inp[14590] = 1073737664; +inp[14591] = 0; +inp[14592] = 1073737600; +inp[14593] = 0; +inp[14594] = 1073737536; +inp[14595] = 0; +inp[14596] = 1073737472; +inp[14597] = 0; +inp[14598] = 1073737408; +inp[14599] = 0; +inp[14600] = 1073737344; +inp[14601] = 0; +inp[14602] = 1073737280; +inp[14603] = 0; +inp[14604] = 1073737216; +inp[14605] = 0; +inp[14606] = 1073737152; +inp[14607] = 0; +inp[14608] = 1073737088; +inp[14609] = 0; +inp[14610] = 1073737024; +inp[14611] = 0; +inp[14612] = 1073736960; +inp[14613] = 0; +inp[14614] = 1073736896; +inp[14615] = 0; +inp[14616] = 1073736832; +inp[14617] = 0; +inp[14618] = 1073736768; +inp[14619] = 0; +inp[14620] = 1073736704; +inp[14621] = 0; +inp[14622] = 1073736640; +inp[14623] = 0; +inp[14624] = 1073736576; +inp[14625] = 0; +inp[14626] = 1073736512; +inp[14627] = 0; +inp[14628] = 1073736448; +inp[14629] = 0; +inp[14630] = 1073736384; +inp[14631] = 0; +inp[14632] = 1073736320; +inp[14633] = 0; +inp[14634] = 1073736256; +inp[14635] = 0; +inp[14636] = 1073736192; +inp[14637] = 0; +inp[14638] = 1073736128; +inp[14639] = 0; +inp[14640] = 1073736064; +inp[14641] = 0; +inp[14642] = 1073736000; +inp[14643] = 0; +inp[14644] = 1073735936; +inp[14645] = 0; +inp[14646] = 1073735872; +inp[14647] = 0; +inp[14648] = 1073735808; +inp[14649] = 0; +inp[14650] = 1073735744; +inp[14651] = 0; +inp[14652] = 1073735680; +inp[14653] = 0; +inp[14654] = 1073735616; +inp[14655] = 0; +inp[14656] = 1073735552; +inp[14657] = 0; +inp[14658] = 1073735488; +inp[14659] = 0; +inp[14660] = 1073735424; +inp[14661] = 0; +inp[14662] = 1073735360; +inp[14663] = 0; +inp[14664] = 1073735296; +inp[14665] = 0; +inp[14666] = 1073735232; +inp[14667] = 0; +inp[14668] = 1073735168; +inp[14669] = 0; +inp[14670] = 1073735104; +inp[14671] = 0; +inp[14672] = 1073735040; +inp[14673] = 0; +inp[14674] = 1073734976; +inp[14675] = 0; +inp[14676] = 1073734912; +inp[14677] = 0; +inp[14678] = 1073734848; +inp[14679] = 0; +inp[14680] = 1073734784; +inp[14681] = 0; +inp[14682] = 1073734720; +inp[14683] = 0; +inp[14684] = 1073734656; +inp[14685] = 0; +inp[14686] = 1073734592; +inp[14687] = 0; +inp[14688] = 1073734528; +inp[14689] = 0; +inp[14690] = 1073734464; +inp[14691] = 0; +inp[14692] = 1073734400; +inp[14693] = 0; +inp[14694] = 1073734336; +inp[14695] = 0; +inp[14696] = 1073734272; +inp[14697] = 0; +inp[14698] = 1073734208; +inp[14699] = 0; +inp[14700] = 1073734144; +inp[14701] = 0; +inp[14702] = 1073734080; +inp[14703] = 0; +inp[14704] = 1073734016; +inp[14705] = 0; +inp[14706] = 1073733952; +inp[14707] = 0; +inp[14708] = 1073733888; +inp[14709] = 0; +inp[14710] = 1073733824; +inp[14711] = 0; +inp[14712] = 1073733760; +inp[14713] = 0; +inp[14714] = 1073733696; +inp[14715] = 0; +inp[14716] = 1073741824; +inp[14717] = 1073741824; +inp[14718] = 1073741792; +inp[14719] = 0; +inp[14720] = 1073741760; +inp[14721] = 0; +inp[14722] = 1073741728; +inp[14723] = 0; +inp[14724] = 1073741696; +inp[14725] = 0; +inp[14726] = 1073741664; +inp[14727] = 0; +inp[14728] = 1073741632; +inp[14729] = 0; +inp[14730] = 1073741600; +inp[14731] = 0; +inp[14732] = 1073741568; +inp[14733] = 0; +inp[14734] = 1073741536; +inp[14735] = 0; +inp[14736] = 1073741504; +inp[14737] = 0; +inp[14738] = 1073741472; +inp[14739] = 0; +inp[14740] = 1073741440; +inp[14741] = 0; +inp[14742] = 1073741408; +inp[14743] = 0; +inp[14744] = 1073741376; +inp[14745] = 0; +inp[14746] = 1073741344; +inp[14747] = 0; +inp[14748] = 1073741312; +inp[14749] = 0; +inp[14750] = 1073741280; +inp[14751] = 0; +inp[14752] = 1073741248; +inp[14753] = 0; +inp[14754] = 1073741216; +inp[14755] = 0; +inp[14756] = 1073741184; +inp[14757] = 0; +inp[14758] = 1073741152; +inp[14759] = 0; +inp[14760] = 1073741120; +inp[14761] = 0; +inp[14762] = 1073741088; +inp[14763] = 0; +inp[14764] = 1073741056; +inp[14765] = 0; +inp[14766] = 1073741024; +inp[14767] = 0; +inp[14768] = 1073740992; +inp[14769] = 0; +inp[14770] = 1073740960; +inp[14771] = 0; +inp[14772] = 1073740928; +inp[14773] = 0; +inp[14774] = 1073740896; +inp[14775] = 0; +inp[14776] = 1073740864; +inp[14777] = 0; +inp[14778] = 1073740832; +inp[14779] = 0; +inp[14780] = 1073740800; +inp[14781] = 0; +inp[14782] = 1073740768; +inp[14783] = 0; +inp[14784] = 1073740736; +inp[14785] = 0; +inp[14786] = 1073740704; +inp[14787] = 0; +inp[14788] = 1073740672; +inp[14789] = 0; +inp[14790] = 1073740640; +inp[14791] = 0; +inp[14792] = 1073740608; +inp[14793] = 0; +inp[14794] = 1073740576; +inp[14795] = 0; +inp[14796] = 1073740544; +inp[14797] = 0; +inp[14798] = 1073740512; +inp[14799] = 0; +inp[14800] = 1073740480; +inp[14801] = 0; +inp[14802] = 1073740448; +inp[14803] = 0; +inp[14804] = 1073740416; +inp[14805] = 0; +inp[14806] = 1073740384; +inp[14807] = 0; +inp[14808] = 1073740352; +inp[14809] = 0; +inp[14810] = 1073740320; +inp[14811] = 0; +inp[14812] = 1073740288; +inp[14813] = 0; +inp[14814] = 1073740256; +inp[14815] = 0; +inp[14816] = 1073740224; +inp[14817] = 0; +inp[14818] = 1073740192; +inp[14819] = 0; +inp[14820] = 1073740160; +inp[14821] = 0; +inp[14822] = 1073740128; +inp[14823] = 0; +inp[14824] = 1073740096; +inp[14825] = 0; +inp[14826] = 1073740064; +inp[14827] = 0; +inp[14828] = 1073740032; +inp[14829] = 0; +inp[14830] = 1073740000; +inp[14831] = 0; +inp[14832] = 1073739968; +inp[14833] = 0; +inp[14834] = 1073739936; +inp[14835] = 0; +inp[14836] = 1073739904; +inp[14837] = 0; +inp[14838] = 1073739872; +inp[14839] = 0; +inp[14840] = 1073739840; +inp[14841] = 0; +inp[14842] = 1073739808; +inp[14843] = 0; +inp[14844] = 1073739776; +inp[14845] = 0; +inp[14846] = 1073739744; +inp[14847] = 0; +inp[14848] = 1073739712; +inp[14849] = 0; +inp[14850] = 1073739680; +inp[14851] = 0; +inp[14852] = 1073739648; +inp[14853] = 0; +inp[14854] = 1073739616; +inp[14855] = 0; +inp[14856] = 1073739584; +inp[14857] = 0; +inp[14858] = 1073739552; +inp[14859] = 0; +inp[14860] = 1073739520; +inp[14861] = 0; +inp[14862] = 1073739488; +inp[14863] = 0; +inp[14864] = 1073739456; +inp[14865] = 0; +inp[14866] = 1073739424; +inp[14867] = 0; +inp[14868] = 1073739392; +inp[14869] = 0; +inp[14870] = 1073739360; +inp[14871] = 0; +inp[14872] = 1073739328; +inp[14873] = 0; +inp[14874] = 1073739296; +inp[14875] = 0; +inp[14876] = 1073739264; +inp[14877] = 0; +inp[14878] = 1073739232; +inp[14879] = 0; +inp[14880] = 1073739200; +inp[14881] = 0; +inp[14882] = 1073739168; +inp[14883] = 0; +inp[14884] = 1073739136; +inp[14885] = 0; +inp[14886] = 1073739104; +inp[14887] = 0; +inp[14888] = 1073739072; +inp[14889] = 0; +inp[14890] = 1073739040; +inp[14891] = 0; +inp[14892] = 1073739008; +inp[14893] = 0; +inp[14894] = 1073738976; +inp[14895] = 0; +inp[14896] = 1073738944; +inp[14897] = 0; +inp[14898] = 1073738912; +inp[14899] = 0; +inp[14900] = 1073738880; +inp[14901] = 0; +inp[14902] = 1073738848; +inp[14903] = 0; +inp[14904] = 1073738816; +inp[14905] = 0; +inp[14906] = 1073738784; +inp[14907] = 0; +inp[14908] = 1073738752; +inp[14909] = 0; +inp[14910] = 1073738720; +inp[14911] = 0; +inp[14912] = 1073738688; +inp[14913] = 0; +inp[14914] = 1073738656; +inp[14915] = 0; +inp[14916] = 1073738624; +inp[14917] = 0; +inp[14918] = 1073738592; +inp[14919] = 0; +inp[14920] = 1073738560; +inp[14921] = 0; +inp[14922] = 1073738528; +inp[14923] = 0; +inp[14924] = 1073738496; +inp[14925] = 0; +inp[14926] = 1073738464; +inp[14927] = 0; +inp[14928] = 1073738432; +inp[14929] = 0; +inp[14930] = 1073738400; +inp[14931] = 0; +inp[14932] = 1073738368; +inp[14933] = 0; +inp[14934] = 1073738336; +inp[14935] = 0; +inp[14936] = 1073738304; +inp[14937] = 0; +inp[14938] = 1073738272; +inp[14939] = 0; +inp[14940] = 1073738240; +inp[14941] = 0; +inp[14942] = 1073738208; +inp[14943] = 0; +inp[14944] = 1073738176; +inp[14945] = 0; +inp[14946] = 1073738144; +inp[14947] = 0; +inp[14948] = 1073738112; +inp[14949] = 0; +inp[14950] = 1073738080; +inp[14951] = 0; +inp[14952] = 1073738048; +inp[14953] = 0; +inp[14954] = 1073738016; +inp[14955] = 0; +inp[14956] = 1073737984; +inp[14957] = 0; +inp[14958] = 1073737952; +inp[14959] = 0; +inp[14960] = 1073737920; +inp[14961] = 0; +inp[14962] = 1073737888; +inp[14963] = 0; +inp[14964] = 1073737856; +inp[14965] = 0; +inp[14966] = 1073737824; +inp[14967] = 0; +inp[14968] = 1073737792; +inp[14969] = 0; +inp[14970] = 1073737760; +inp[14971] = 0; +inp[14972] = 1073741824; +inp[14973] = 1073741824; +inp[14974] = 1073741808; +inp[14975] = 0; +inp[14976] = 1073741792; +inp[14977] = 0; +inp[14978] = 1073741776; +inp[14979] = 0; +inp[14980] = 1073741760; +inp[14981] = 0; +inp[14982] = 1073741744; +inp[14983] = 0; +inp[14984] = 1073741728; +inp[14985] = 0; +inp[14986] = 1073741712; +inp[14987] = 0; +inp[14988] = 1073741696; +inp[14989] = 0; +inp[14990] = 1073741680; +inp[14991] = 0; +inp[14992] = 1073741664; +inp[14993] = 0; +inp[14994] = 1073741648; +inp[14995] = 0; +inp[14996] = 1073741632; +inp[14997] = 0; +inp[14998] = 1073741616; +inp[14999] = 0; +inp[15000] = 1073741600; +inp[15001] = 0; +inp[15002] = 1073741584; +inp[15003] = 0; +inp[15004] = 1073741568; +inp[15005] = 0; +inp[15006] = 1073741552; +inp[15007] = 0; +inp[15008] = 1073741536; +inp[15009] = 0; +inp[15010] = 1073741520; +inp[15011] = 0; +inp[15012] = 1073741504; +inp[15013] = 0; +inp[15014] = 1073741488; +inp[15015] = 0; +inp[15016] = 1073741472; +inp[15017] = 0; +inp[15018] = 1073741456; +inp[15019] = 0; +inp[15020] = 1073741440; +inp[15021] = 0; +inp[15022] = 1073741424; +inp[15023] = 0; +inp[15024] = 1073741408; +inp[15025] = 0; +inp[15026] = 1073741392; +inp[15027] = 0; +inp[15028] = 1073741376; +inp[15029] = 0; +inp[15030] = 1073741360; +inp[15031] = 0; +inp[15032] = 1073741344; +inp[15033] = 0; +inp[15034] = 1073741328; +inp[15035] = 0; +inp[15036] = 1073741312; +inp[15037] = 0; +inp[15038] = 1073741296; +inp[15039] = 0; +inp[15040] = 1073741280; +inp[15041] = 0; +inp[15042] = 1073741264; +inp[15043] = 0; +inp[15044] = 1073741248; +inp[15045] = 0; +inp[15046] = 1073741232; +inp[15047] = 0; +inp[15048] = 1073741216; +inp[15049] = 0; +inp[15050] = 1073741200; +inp[15051] = 0; +inp[15052] = 1073741184; +inp[15053] = 0; +inp[15054] = 1073741168; +inp[15055] = 0; +inp[15056] = 1073741152; +inp[15057] = 0; +inp[15058] = 1073741136; +inp[15059] = 0; +inp[15060] = 1073741120; +inp[15061] = 0; +inp[15062] = 1073741104; +inp[15063] = 0; +inp[15064] = 1073741088; +inp[15065] = 0; +inp[15066] = 1073741072; +inp[15067] = 0; +inp[15068] = 1073741056; +inp[15069] = 0; +inp[15070] = 1073741040; +inp[15071] = 0; +inp[15072] = 1073741024; +inp[15073] = 0; +inp[15074] = 1073741008; +inp[15075] = 0; +inp[15076] = 1073740992; +inp[15077] = 0; +inp[15078] = 1073740976; +inp[15079] = 0; +inp[15080] = 1073740960; +inp[15081] = 0; +inp[15082] = 1073740944; +inp[15083] = 0; +inp[15084] = 1073740928; +inp[15085] = 0; +inp[15086] = 1073740912; +inp[15087] = 0; +inp[15088] = 1073740896; +inp[15089] = 0; +inp[15090] = 1073740880; +inp[15091] = 0; +inp[15092] = 1073740864; +inp[15093] = 0; +inp[15094] = 1073740848; +inp[15095] = 0; +inp[15096] = 1073740832; +inp[15097] = 0; +inp[15098] = 1073740816; +inp[15099] = 0; +inp[15100] = 1073740800; +inp[15101] = 0; +inp[15102] = 1073740784; +inp[15103] = 0; +inp[15104] = 1073740768; +inp[15105] = 0; +inp[15106] = 1073740752; +inp[15107] = 0; +inp[15108] = 1073740736; +inp[15109] = 0; +inp[15110] = 1073740720; +inp[15111] = 0; +inp[15112] = 1073740704; +inp[15113] = 0; +inp[15114] = 1073740688; +inp[15115] = 0; +inp[15116] = 1073740672; +inp[15117] = 0; +inp[15118] = 1073740656; +inp[15119] = 0; +inp[15120] = 1073740640; +inp[15121] = 0; +inp[15122] = 1073740624; +inp[15123] = 0; +inp[15124] = 1073740608; +inp[15125] = 0; +inp[15126] = 1073740592; +inp[15127] = 0; +inp[15128] = 1073740576; +inp[15129] = 0; +inp[15130] = 1073740560; +inp[15131] = 0; +inp[15132] = 1073740544; +inp[15133] = 0; +inp[15134] = 1073740528; +inp[15135] = 0; +inp[15136] = 1073740512; +inp[15137] = 0; +inp[15138] = 1073740496; +inp[15139] = 0; +inp[15140] = 1073740480; +inp[15141] = 0; +inp[15142] = 1073740464; +inp[15143] = 0; +inp[15144] = 1073740448; +inp[15145] = 0; +inp[15146] = 1073740432; +inp[15147] = 0; +inp[15148] = 1073740416; +inp[15149] = 0; +inp[15150] = 1073740400; +inp[15151] = 0; +inp[15152] = 1073740384; +inp[15153] = 0; +inp[15154] = 1073740368; +inp[15155] = 0; +inp[15156] = 1073740352; +inp[15157] = 0; +inp[15158] = 1073740336; +inp[15159] = 0; +inp[15160] = 1073740320; +inp[15161] = 0; +inp[15162] = 1073740304; +inp[15163] = 0; +inp[15164] = 1073740288; +inp[15165] = 0; +inp[15166] = 1073740272; +inp[15167] = 0; +inp[15168] = 1073740256; +inp[15169] = 0; +inp[15170] = 1073740240; +inp[15171] = 0; +inp[15172] = 1073740224; +inp[15173] = 0; +inp[15174] = 1073740208; +inp[15175] = 0; +inp[15176] = 1073740192; +inp[15177] = 0; +inp[15178] = 1073740176; +inp[15179] = 0; +inp[15180] = 1073740160; +inp[15181] = 0; +inp[15182] = 1073740144; +inp[15183] = 0; +inp[15184] = 1073740128; +inp[15185] = 0; +inp[15186] = 1073740112; +inp[15187] = 0; +inp[15188] = 1073740096; +inp[15189] = 0; +inp[15190] = 1073740080; +inp[15191] = 0; +inp[15192] = 1073740064; +inp[15193] = 0; +inp[15194] = 1073740048; +inp[15195] = 0; +inp[15196] = 1073740032; +inp[15197] = 0; +inp[15198] = 1073740016; +inp[15199] = 0; +inp[15200] = 1073740000; +inp[15201] = 0; +inp[15202] = 1073739984; +inp[15203] = 0; +inp[15204] = 1073739968; +inp[15205] = 0; +inp[15206] = 1073739952; +inp[15207] = 0; +inp[15208] = 1073739936; +inp[15209] = 0; +inp[15210] = 1073739920; +inp[15211] = 0; +inp[15212] = 1073739904; +inp[15213] = 0; +inp[15214] = 1073739888; +inp[15215] = 0; +inp[15216] = 1073739872; +inp[15217] = 0; +inp[15218] = 1073739856; +inp[15219] = 0; +inp[15220] = 1073739840; +inp[15221] = 0; +inp[15222] = 1073739824; +inp[15223] = 0; +inp[15224] = 1073739808; +inp[15225] = 0; +inp[15226] = 1073739792; +inp[15227] = 0; +inp[15228] = 1073741824; +inp[15229] = 1073741824; +inp[15230] = 1073741816; +inp[15231] = 0; +inp[15232] = 1073741808; +inp[15233] = 0; +inp[15234] = 1073741800; +inp[15235] = 0; +inp[15236] = 1073741792; +inp[15237] = 0; +inp[15238] = 1073741784; +inp[15239] = 0; +inp[15240] = 1073741776; +inp[15241] = 0; +inp[15242] = 1073741768; +inp[15243] = 0; +inp[15244] = 1073741760; +inp[15245] = 0; +inp[15246] = 1073741752; +inp[15247] = 0; +inp[15248] = 1073741744; +inp[15249] = 0; +inp[15250] = 1073741736; +inp[15251] = 0; +inp[15252] = 1073741728; +inp[15253] = 0; +inp[15254] = 1073741720; +inp[15255] = 0; +inp[15256] = 1073741712; +inp[15257] = 0; +inp[15258] = 1073741704; +inp[15259] = 0; +inp[15260] = 1073741696; +inp[15261] = 0; +inp[15262] = 1073741688; +inp[15263] = 0; +inp[15264] = 1073741680; +inp[15265] = 0; +inp[15266] = 1073741672; +inp[15267] = 0; +inp[15268] = 1073741664; +inp[15269] = 0; +inp[15270] = 1073741656; +inp[15271] = 0; +inp[15272] = 1073741648; +inp[15273] = 0; +inp[15274] = 1073741640; +inp[15275] = 0; +inp[15276] = 1073741632; +inp[15277] = 0; +inp[15278] = 1073741624; +inp[15279] = 0; +inp[15280] = 1073741616; +inp[15281] = 0; +inp[15282] = 1073741608; +inp[15283] = 0; +inp[15284] = 1073741600; +inp[15285] = 0; +inp[15286] = 1073741592; +inp[15287] = 0; +inp[15288] = 1073741584; +inp[15289] = 0; +inp[15290] = 1073741576; +inp[15291] = 0; +inp[15292] = 1073741568; +inp[15293] = 0; +inp[15294] = 1073741560; +inp[15295] = 0; +inp[15296] = 1073741552; +inp[15297] = 0; +inp[15298] = 1073741544; +inp[15299] = 0; +inp[15300] = 1073741536; +inp[15301] = 0; +inp[15302] = 1073741528; +inp[15303] = 0; +inp[15304] = 1073741520; +inp[15305] = 0; +inp[15306] = 1073741512; +inp[15307] = 0; +inp[15308] = 1073741504; +inp[15309] = 0; +inp[15310] = 1073741496; +inp[15311] = 0; +inp[15312] = 1073741488; +inp[15313] = 0; +inp[15314] = 1073741480; +inp[15315] = 0; +inp[15316] = 1073741472; +inp[15317] = 0; +inp[15318] = 1073741464; +inp[15319] = 0; +inp[15320] = 1073741456; +inp[15321] = 0; +inp[15322] = 1073741448; +inp[15323] = 0; +inp[15324] = 1073741440; +inp[15325] = 0; +inp[15326] = 1073741432; +inp[15327] = 0; +inp[15328] = 1073741424; +inp[15329] = 0; +inp[15330] = 1073741416; +inp[15331] = 0; +inp[15332] = 1073741408; +inp[15333] = 0; +inp[15334] = 1073741400; +inp[15335] = 0; +inp[15336] = 1073741392; +inp[15337] = 0; +inp[15338] = 1073741384; +inp[15339] = 0; +inp[15340] = 1073741376; +inp[15341] = 0; +inp[15342] = 1073741368; +inp[15343] = 0; +inp[15344] = 1073741360; +inp[15345] = 0; +inp[15346] = 1073741352; +inp[15347] = 0; +inp[15348] = 1073741344; +inp[15349] = 0; +inp[15350] = 1073741336; +inp[15351] = 0; +inp[15352] = 1073741328; +inp[15353] = 0; +inp[15354] = 1073741320; +inp[15355] = 0; +inp[15356] = 1073741312; +inp[15357] = 0; +inp[15358] = 1073741304; +inp[15359] = 0; +inp[15360] = 1073741296; +inp[15361] = 0; +inp[15362] = 1073741288; +inp[15363] = 0; +inp[15364] = 1073741280; +inp[15365] = 0; +inp[15366] = 1073741272; +inp[15367] = 0; +inp[15368] = 1073741264; +inp[15369] = 0; +inp[15370] = 1073741256; +inp[15371] = 0; +inp[15372] = 1073741248; +inp[15373] = 0; +inp[15374] = 1073741240; +inp[15375] = 0; +inp[15376] = 1073741232; +inp[15377] = 0; +inp[15378] = 1073741224; +inp[15379] = 0; +inp[15380] = 1073741216; +inp[15381] = 0; +inp[15382] = 1073741208; +inp[15383] = 0; +inp[15384] = 1073741200; +inp[15385] = 0; +inp[15386] = 1073741192; +inp[15387] = 0; +inp[15388] = 1073741184; +inp[15389] = 0; +inp[15390] = 1073741176; +inp[15391] = 0; +inp[15392] = 1073741168; +inp[15393] = 0; +inp[15394] = 1073741160; +inp[15395] = 0; +inp[15396] = 1073741152; +inp[15397] = 0; +inp[15398] = 1073741144; +inp[15399] = 0; +inp[15400] = 1073741136; +inp[15401] = 0; +inp[15402] = 1073741128; +inp[15403] = 0; +inp[15404] = 1073741120; +inp[15405] = 0; +inp[15406] = 1073741112; +inp[15407] = 0; +inp[15408] = 1073741104; +inp[15409] = 0; +inp[15410] = 1073741096; +inp[15411] = 0; +inp[15412] = 1073741088; +inp[15413] = 0; +inp[15414] = 1073741080; +inp[15415] = 0; +inp[15416] = 1073741072; +inp[15417] = 0; +inp[15418] = 1073741064; +inp[15419] = 0; +inp[15420] = 1073741056; +inp[15421] = 0; +inp[15422] = 1073741048; +inp[15423] = 0; +inp[15424] = 1073741040; +inp[15425] = 0; +inp[15426] = 1073741032; +inp[15427] = 0; +inp[15428] = 1073741024; +inp[15429] = 0; +inp[15430] = 1073741016; +inp[15431] = 0; +inp[15432] = 1073741008; +inp[15433] = 0; +inp[15434] = 1073741000; +inp[15435] = 0; +inp[15436] = 1073740992; +inp[15437] = 0; +inp[15438] = 1073740984; +inp[15439] = 0; +inp[15440] = 1073740976; +inp[15441] = 0; +inp[15442] = 1073740968; +inp[15443] = 0; +inp[15444] = 1073740960; +inp[15445] = 0; +inp[15446] = 1073740952; +inp[15447] = 0; +inp[15448] = 1073740944; +inp[15449] = 0; +inp[15450] = 1073740936; +inp[15451] = 0; +inp[15452] = 1073740928; +inp[15453] = 0; +inp[15454] = 1073740920; +inp[15455] = 0; +inp[15456] = 1073740912; +inp[15457] = 0; +inp[15458] = 1073740904; +inp[15459] = 0; +inp[15460] = 1073740896; +inp[15461] = 0; +inp[15462] = 1073740888; +inp[15463] = 0; +inp[15464] = 1073740880; +inp[15465] = 0; +inp[15466] = 1073740872; +inp[15467] = 0; +inp[15468] = 1073740864; +inp[15469] = 0; +inp[15470] = 1073740856; +inp[15471] = 0; +inp[15472] = 1073740848; +inp[15473] = 0; +inp[15474] = 1073740840; +inp[15475] = 0; +inp[15476] = 1073740832; +inp[15477] = 0; +inp[15478] = 1073740824; +inp[15479] = 0; +inp[15480] = 1073740816; +inp[15481] = 0; +inp[15482] = 1073740808; +inp[15483] = 0; +inp[15484] = 1073741824; +inp[15485] = 1073741824; +inp[15486] = 1073741820; +inp[15487] = 0; +inp[15488] = 1073741816; +inp[15489] = 0; +inp[15490] = 1073741812; +inp[15491] = 0; +inp[15492] = 1073741808; +inp[15493] = 0; +inp[15494] = 1073741804; +inp[15495] = 0; +inp[15496] = 1073741800; +inp[15497] = 0; +inp[15498] = 1073741796; +inp[15499] = 0; +inp[15500] = 1073741792; +inp[15501] = 0; +inp[15502] = 1073741788; +inp[15503] = 0; +inp[15504] = 1073741784; +inp[15505] = 0; +inp[15506] = 1073741780; +inp[15507] = 0; +inp[15508] = 1073741776; +inp[15509] = 0; +inp[15510] = 1073741772; +inp[15511] = 0; +inp[15512] = 1073741768; +inp[15513] = 0; +inp[15514] = 1073741764; +inp[15515] = 0; +inp[15516] = 1073741760; +inp[15517] = 0; +inp[15518] = 1073741756; +inp[15519] = 0; +inp[15520] = 1073741752; +inp[15521] = 0; +inp[15522] = 1073741748; +inp[15523] = 0; +inp[15524] = 1073741744; +inp[15525] = 0; +inp[15526] = 1073741740; +inp[15527] = 0; +inp[15528] = 1073741736; +inp[15529] = 0; +inp[15530] = 1073741732; +inp[15531] = 0; +inp[15532] = 1073741728; +inp[15533] = 0; +inp[15534] = 1073741724; +inp[15535] = 0; +inp[15536] = 1073741720; +inp[15537] = 0; +inp[15538] = 1073741716; +inp[15539] = 0; +inp[15540] = 1073741712; +inp[15541] = 0; +inp[15542] = 1073741708; +inp[15543] = 0; +inp[15544] = 1073741704; +inp[15545] = 0; +inp[15546] = 1073741700; +inp[15547] = 0; +inp[15548] = 1073741696; +inp[15549] = 0; +inp[15550] = 1073741692; +inp[15551] = 0; +inp[15552] = 1073741688; +inp[15553] = 0; +inp[15554] = 1073741684; +inp[15555] = 0; +inp[15556] = 1073741680; +inp[15557] = 0; +inp[15558] = 1073741676; +inp[15559] = 0; +inp[15560] = 1073741672; +inp[15561] = 0; +inp[15562] = 1073741668; +inp[15563] = 0; +inp[15564] = 1073741664; +inp[15565] = 0; +inp[15566] = 1073741660; +inp[15567] = 0; +inp[15568] = 1073741656; +inp[15569] = 0; +inp[15570] = 1073741652; +inp[15571] = 0; +inp[15572] = 1073741648; +inp[15573] = 0; +inp[15574] = 1073741644; +inp[15575] = 0; +inp[15576] = 1073741640; +inp[15577] = 0; +inp[15578] = 1073741636; +inp[15579] = 0; +inp[15580] = 1073741632; +inp[15581] = 0; +inp[15582] = 1073741628; +inp[15583] = 0; +inp[15584] = 1073741624; +inp[15585] = 0; +inp[15586] = 1073741620; +inp[15587] = 0; +inp[15588] = 1073741616; +inp[15589] = 0; +inp[15590] = 1073741612; +inp[15591] = 0; +inp[15592] = 1073741608; +inp[15593] = 0; +inp[15594] = 1073741604; +inp[15595] = 0; +inp[15596] = 1073741600; +inp[15597] = 0; +inp[15598] = 1073741596; +inp[15599] = 0; +inp[15600] = 1073741592; +inp[15601] = 0; +inp[15602] = 1073741588; +inp[15603] = 0; +inp[15604] = 1073741584; +inp[15605] = 0; +inp[15606] = 1073741580; +inp[15607] = 0; +inp[15608] = 1073741576; +inp[15609] = 0; +inp[15610] = 1073741572; +inp[15611] = 0; +inp[15612] = 1073741568; +inp[15613] = 0; +inp[15614] = 1073741564; +inp[15615] = 0; +inp[15616] = 1073741560; +inp[15617] = 0; +inp[15618] = 1073741556; +inp[15619] = 0; +inp[15620] = 1073741552; +inp[15621] = 0; +inp[15622] = 1073741548; +inp[15623] = 0; +inp[15624] = 1073741544; +inp[15625] = 0; +inp[15626] = 1073741540; +inp[15627] = 0; +inp[15628] = 1073741536; +inp[15629] = 0; +inp[15630] = 1073741532; +inp[15631] = 0; +inp[15632] = 1073741528; +inp[15633] = 0; +inp[15634] = 1073741524; +inp[15635] = 0; +inp[15636] = 1073741520; +inp[15637] = 0; +inp[15638] = 1073741516; +inp[15639] = 0; +inp[15640] = 1073741512; +inp[15641] = 0; +inp[15642] = 1073741508; +inp[15643] = 0; +inp[15644] = 1073741504; +inp[15645] = 0; +inp[15646] = 1073741500; +inp[15647] = 0; +inp[15648] = 1073741496; +inp[15649] = 0; +inp[15650] = 1073741492; +inp[15651] = 0; +inp[15652] = 1073741488; +inp[15653] = 0; +inp[15654] = 1073741484; +inp[15655] = 0; +inp[15656] = 1073741480; +inp[15657] = 0; +inp[15658] = 1073741476; +inp[15659] = 0; +inp[15660] = 1073741472; +inp[15661] = 0; +inp[15662] = 1073741468; +inp[15663] = 0; +inp[15664] = 1073741464; +inp[15665] = 0; +inp[15666] = 1073741460; +inp[15667] = 0; +inp[15668] = 1073741456; +inp[15669] = 0; +inp[15670] = 1073741452; +inp[15671] = 0; +inp[15672] = 1073741448; +inp[15673] = 0; +inp[15674] = 1073741444; +inp[15675] = 0; +inp[15676] = 1073741440; +inp[15677] = 0; +inp[15678] = 1073741436; +inp[15679] = 0; +inp[15680] = 1073741432; +inp[15681] = 0; +inp[15682] = 1073741428; +inp[15683] = 0; +inp[15684] = 1073741424; +inp[15685] = 0; +inp[15686] = 1073741420; +inp[15687] = 0; +inp[15688] = 1073741416; +inp[15689] = 0; +inp[15690] = 1073741412; +inp[15691] = 0; +inp[15692] = 1073741408; +inp[15693] = 0; +inp[15694] = 1073741404; +inp[15695] = 0; +inp[15696] = 1073741400; +inp[15697] = 0; +inp[15698] = 1073741396; +inp[15699] = 0; +inp[15700] = 1073741392; +inp[15701] = 0; +inp[15702] = 1073741388; +inp[15703] = 0; +inp[15704] = 1073741384; +inp[15705] = 0; +inp[15706] = 1073741380; +inp[15707] = 0; +inp[15708] = 1073741376; +inp[15709] = 0; +inp[15710] = 1073741372; +inp[15711] = 0; +inp[15712] = 1073741368; +inp[15713] = 0; +inp[15714] = 1073741364; +inp[15715] = 0; +inp[15716] = 1073741360; +inp[15717] = 0; +inp[15718] = 1073741356; +inp[15719] = 0; +inp[15720] = 1073741352; +inp[15721] = 0; +inp[15722] = 1073741348; +inp[15723] = 0; +inp[15724] = 1073741344; +inp[15725] = 0; +inp[15726] = 1073741340; +inp[15727] = 0; +inp[15728] = 1073741336; +inp[15729] = 0; +inp[15730] = 1073741332; +inp[15731] = 0; +inp[15732] = 1073741328; +inp[15733] = 0; +inp[15734] = 1073741324; +inp[15735] = 0; +inp[15736] = 1073741320; +inp[15737] = 0; +inp[15738] = 1073741316; +inp[15739] = 0; +inp[15740] = 1073741824; +inp[15741] = 1073741824; +inp[15742] = 1073741822; +inp[15743] = 0; +inp[15744] = 1073741820; +inp[15745] = 0; +inp[15746] = 1073741818; +inp[15747] = 0; +inp[15748] = 1073741816; +inp[15749] = 0; +inp[15750] = 1073741814; +inp[15751] = 0; +inp[15752] = 1073741812; +inp[15753] = 0; +inp[15754] = 1073741810; +inp[15755] = 0; +inp[15756] = 1073741808; +inp[15757] = 0; +inp[15758] = 1073741806; +inp[15759] = 0; +inp[15760] = 1073741804; +inp[15761] = 0; +inp[15762] = 1073741802; +inp[15763] = 0; +inp[15764] = 1073741800; +inp[15765] = 0; +inp[15766] = 1073741798; +inp[15767] = 0; +inp[15768] = 1073741796; +inp[15769] = 0; +inp[15770] = 1073741794; +inp[15771] = 0; +inp[15772] = 1073741792; +inp[15773] = 0; +inp[15774] = 1073741790; +inp[15775] = 0; +inp[15776] = 1073741788; +inp[15777] = 0; +inp[15778] = 1073741786; +inp[15779] = 0; +inp[15780] = 1073741784; +inp[15781] = 0; +inp[15782] = 1073741782; +inp[15783] = 0; +inp[15784] = 1073741780; +inp[15785] = 0; +inp[15786] = 1073741778; +inp[15787] = 0; +inp[15788] = 1073741776; +inp[15789] = 0; +inp[15790] = 1073741774; +inp[15791] = 0; +inp[15792] = 1073741772; +inp[15793] = 0; +inp[15794] = 1073741770; +inp[15795] = 0; +inp[15796] = 1073741768; +inp[15797] = 0; +inp[15798] = 1073741766; +inp[15799] = 0; +inp[15800] = 1073741764; +inp[15801] = 0; +inp[15802] = 1073741762; +inp[15803] = 0; +inp[15804] = 1073741760; +inp[15805] = 0; +inp[15806] = 1073741758; +inp[15807] = 0; +inp[15808] = 1073741756; +inp[15809] = 0; +inp[15810] = 1073741754; +inp[15811] = 0; +inp[15812] = 1073741752; +inp[15813] = 0; +inp[15814] = 1073741750; +inp[15815] = 0; +inp[15816] = 1073741748; +inp[15817] = 0; +inp[15818] = 1073741746; +inp[15819] = 0; +inp[15820] = 1073741744; +inp[15821] = 0; +inp[15822] = 1073741742; +inp[15823] = 0; +inp[15824] = 1073741740; +inp[15825] = 0; +inp[15826] = 1073741738; +inp[15827] = 0; +inp[15828] = 1073741736; +inp[15829] = 0; +inp[15830] = 1073741734; +inp[15831] = 0; +inp[15832] = 1073741732; +inp[15833] = 0; +inp[15834] = 1073741730; +inp[15835] = 0; +inp[15836] = 1073741728; +inp[15837] = 0; +inp[15838] = 1073741726; +inp[15839] = 0; +inp[15840] = 1073741724; +inp[15841] = 0; +inp[15842] = 1073741722; +inp[15843] = 0; +inp[15844] = 1073741720; +inp[15845] = 0; +inp[15846] = 1073741718; +inp[15847] = 0; +inp[15848] = 1073741716; +inp[15849] = 0; +inp[15850] = 1073741714; +inp[15851] = 0; +inp[15852] = 1073741712; +inp[15853] = 0; +inp[15854] = 1073741710; +inp[15855] = 0; +inp[15856] = 1073741708; +inp[15857] = 0; +inp[15858] = 1073741706; +inp[15859] = 0; +inp[15860] = 1073741704; +inp[15861] = 0; +inp[15862] = 1073741702; +inp[15863] = 0; +inp[15864] = 1073741700; +inp[15865] = 0; +inp[15866] = 1073741698; +inp[15867] = 0; +inp[15868] = 1073741696; +inp[15869] = 0; +inp[15870] = 1073741694; +inp[15871] = 0; +inp[15872] = 1073741692; +inp[15873] = 0; +inp[15874] = 1073741690; +inp[15875] = 0; +inp[15876] = 1073741688; +inp[15877] = 0; +inp[15878] = 1073741686; +inp[15879] = 0; +inp[15880] = 1073741684; +inp[15881] = 0; +inp[15882] = 1073741682; +inp[15883] = 0; +inp[15884] = 1073741680; +inp[15885] = 0; +inp[15886] = 1073741678; +inp[15887] = 0; +inp[15888] = 1073741676; +inp[15889] = 0; +inp[15890] = 1073741674; +inp[15891] = 0; +inp[15892] = 1073741672; +inp[15893] = 0; +inp[15894] = 1073741670; +inp[15895] = 0; +inp[15896] = 1073741668; +inp[15897] = 0; +inp[15898] = 1073741666; +inp[15899] = 0; +inp[15900] = 1073741664; +inp[15901] = 0; +inp[15902] = 1073741662; +inp[15903] = 0; +inp[15904] = 1073741660; +inp[15905] = 0; +inp[15906] = 1073741658; +inp[15907] = 0; +inp[15908] = 1073741656; +inp[15909] = 0; +inp[15910] = 1073741654; +inp[15911] = 0; +inp[15912] = 1073741652; +inp[15913] = 0; +inp[15914] = 1073741650; +inp[15915] = 0; +inp[15916] = 1073741648; +inp[15917] = 0; +inp[15918] = 1073741646; +inp[15919] = 0; +inp[15920] = 1073741644; +inp[15921] = 0; +inp[15922] = 1073741642; +inp[15923] = 0; +inp[15924] = 1073741640; +inp[15925] = 0; +inp[15926] = 1073741638; +inp[15927] = 0; +inp[15928] = 1073741636; +inp[15929] = 0; +inp[15930] = 1073741634; +inp[15931] = 0; +inp[15932] = 1073741632; +inp[15933] = 0; +inp[15934] = 1073741630; +inp[15935] = 0; +inp[15936] = 1073741628; +inp[15937] = 0; +inp[15938] = 1073741626; +inp[15939] = 0; +inp[15940] = 1073741624; +inp[15941] = 0; +inp[15942] = 1073741622; +inp[15943] = 0; +inp[15944] = 1073741620; +inp[15945] = 0; +inp[15946] = 1073741618; +inp[15947] = 0; +inp[15948] = 1073741616; +inp[15949] = 0; +inp[15950] = 1073741614; +inp[15951] = 0; +inp[15952] = 1073741612; +inp[15953] = 0; +inp[15954] = 1073741610; +inp[15955] = 0; +inp[15956] = 1073741608; +inp[15957] = 0; +inp[15958] = 1073741606; +inp[15959] = 0; +inp[15960] = 1073741604; +inp[15961] = 0; +inp[15962] = 1073741602; +inp[15963] = 0; +inp[15964] = 1073741600; +inp[15965] = 0; +inp[15966] = 1073741598; +inp[15967] = 0; +inp[15968] = 1073741596; +inp[15969] = 0; +inp[15970] = 1073741594; +inp[15971] = 0; +inp[15972] = 1073741592; +inp[15973] = 0; +inp[15974] = 1073741590; +inp[15975] = 0; +inp[15976] = 1073741588; +inp[15977] = 0; +inp[15978] = 1073741586; +inp[15979] = 0; +inp[15980] = 1073741584; +inp[15981] = 0; +inp[15982] = 1073741582; +inp[15983] = 0; +inp[15984] = 1073741580; +inp[15985] = 0; +inp[15986] = 1073741578; +inp[15987] = 0; +inp[15988] = 1073741576; +inp[15989] = 0; +inp[15990] = 1073741574; +inp[15991] = 0; +inp[15992] = 1073741572; +inp[15993] = 0; +inp[15994] = 1073741570; +inp[15995] = 0; +inp[15996] = 1073741824; +inp[15997] = 1073741824; +inp[15998] = 1073741823; +inp[15999] = 0; +inp[16000] = 1073741822; +inp[16001] = 0; +inp[16002] = 1073741821; +inp[16003] = 0; +inp[16004] = 1073741820; +inp[16005] = 0; +inp[16006] = 1073741819; +inp[16007] = 0; +inp[16008] = 1073741818; +inp[16009] = 0; +inp[16010] = 1073741817; +inp[16011] = 0; +inp[16012] = 1073741816; +inp[16013] = 0; +inp[16014] = 1073741815; +inp[16015] = 0; +inp[16016] = 1073741814; +inp[16017] = 0; +inp[16018] = 1073741813; +inp[16019] = 0; +inp[16020] = 1073741812; +inp[16021] = 0; +inp[16022] = 1073741811; +inp[16023] = 0; +inp[16024] = 1073741810; +inp[16025] = 0; +inp[16026] = 1073741809; +inp[16027] = 0; +inp[16028] = 1073741808; +inp[16029] = 0; +inp[16030] = 1073741807; +inp[16031] = 0; +inp[16032] = 1073741806; +inp[16033] = 0; +inp[16034] = 1073741805; +inp[16035] = 0; +inp[16036] = 1073741804; +inp[16037] = 0; +inp[16038] = 1073741803; +inp[16039] = 0; +inp[16040] = 1073741802; +inp[16041] = 0; +inp[16042] = 1073741801; +inp[16043] = 0; +inp[16044] = 1073741800; +inp[16045] = 0; +inp[16046] = 1073741799; +inp[16047] = 0; +inp[16048] = 1073741798; +inp[16049] = 0; +inp[16050] = 1073741797; +inp[16051] = 0; +inp[16052] = 1073741796; +inp[16053] = 0; +inp[16054] = 1073741795; +inp[16055] = 0; +inp[16056] = 1073741794; +inp[16057] = 0; +inp[16058] = 1073741793; +inp[16059] = 0; +inp[16060] = 1073741792; +inp[16061] = 0; +inp[16062] = 1073741791; +inp[16063] = 0; +inp[16064] = 1073741790; +inp[16065] = 0; +inp[16066] = 1073741789; +inp[16067] = 0; +inp[16068] = 1073741788; +inp[16069] = 0; +inp[16070] = 1073741787; +inp[16071] = 0; +inp[16072] = 1073741786; +inp[16073] = 0; +inp[16074] = 1073741785; +inp[16075] = 0; +inp[16076] = 1073741784; +inp[16077] = 0; +inp[16078] = 1073741783; +inp[16079] = 0; +inp[16080] = 1073741782; +inp[16081] = 0; +inp[16082] = 1073741781; +inp[16083] = 0; +inp[16084] = 1073741780; +inp[16085] = 0; +inp[16086] = 1073741779; +inp[16087] = 0; +inp[16088] = 1073741778; +inp[16089] = 0; +inp[16090] = 1073741777; +inp[16091] = 0; +inp[16092] = 1073741776; +inp[16093] = 0; +inp[16094] = 1073741775; +inp[16095] = 0; +inp[16096] = 1073741774; +inp[16097] = 0; +inp[16098] = 1073741773; +inp[16099] = 0; +inp[16100] = 1073741772; +inp[16101] = 0; +inp[16102] = 1073741771; +inp[16103] = 0; +inp[16104] = 1073741770; +inp[16105] = 0; +inp[16106] = 1073741769; +inp[16107] = 0; +inp[16108] = 1073741768; +inp[16109] = 0; +inp[16110] = 1073741767; +inp[16111] = 0; +inp[16112] = 1073741766; +inp[16113] = 0; +inp[16114] = 1073741765; +inp[16115] = 0; +inp[16116] = 1073741764; +inp[16117] = 0; +inp[16118] = 1073741763; +inp[16119] = 0; +inp[16120] = 1073741762; +inp[16121] = 0; +inp[16122] = 1073741761; +inp[16123] = 0; +inp[16124] = 1073741760; +inp[16125] = 0; +inp[16126] = 1073741759; +inp[16127] = 0; +inp[16128] = 1073741758; +inp[16129] = 0; +inp[16130] = 1073741757; +inp[16131] = 0; +inp[16132] = 1073741756; +inp[16133] = 0; +inp[16134] = 1073741755; +inp[16135] = 0; +inp[16136] = 1073741754; +inp[16137] = 0; +inp[16138] = 1073741753; +inp[16139] = 0; +inp[16140] = 1073741752; +inp[16141] = 0; +inp[16142] = 1073741751; +inp[16143] = 0; +inp[16144] = 1073741750; +inp[16145] = 0; +inp[16146] = 1073741749; +inp[16147] = 0; +inp[16148] = 1073741748; +inp[16149] = 0; +inp[16150] = 1073741747; +inp[16151] = 0; +inp[16152] = 1073741746; +inp[16153] = 0; +inp[16154] = 1073741745; +inp[16155] = 0; +inp[16156] = 1073741744; +inp[16157] = 0; +inp[16158] = 1073741743; +inp[16159] = 0; +inp[16160] = 1073741742; +inp[16161] = 0; +inp[16162] = 1073741741; +inp[16163] = 0; +inp[16164] = 1073741740; +inp[16165] = 0; +inp[16166] = 1073741739; +inp[16167] = 0; +inp[16168] = 1073741738; +inp[16169] = 0; +inp[16170] = 1073741737; +inp[16171] = 0; +inp[16172] = 1073741736; +inp[16173] = 0; +inp[16174] = 1073741735; +inp[16175] = 0; +inp[16176] = 1073741734; +inp[16177] = 0; +inp[16178] = 1073741733; +inp[16179] = 0; +inp[16180] = 1073741732; +inp[16181] = 0; +inp[16182] = 1073741731; +inp[16183] = 0; +inp[16184] = 1073741730; +inp[16185] = 0; +inp[16186] = 1073741729; +inp[16187] = 0; +inp[16188] = 1073741728; +inp[16189] = 0; +inp[16190] = 1073741727; +inp[16191] = 0; +inp[16192] = 1073741726; +inp[16193] = 0; +inp[16194] = 1073741725; +inp[16195] = 0; +inp[16196] = 1073741724; +inp[16197] = 0; +inp[16198] = 1073741723; +inp[16199] = 0; +inp[16200] = 1073741722; +inp[16201] = 0; +inp[16202] = 1073741721; +inp[16203] = 0; +inp[16204] = 1073741720; +inp[16205] = 0; +inp[16206] = 1073741719; +inp[16207] = 0; +inp[16208] = 1073741718; +inp[16209] = 0; +inp[16210] = 1073741717; +inp[16211] = 0; +inp[16212] = 1073741716; +inp[16213] = 0; +inp[16214] = 1073741715; +inp[16215] = 0; +inp[16216] = 1073741714; +inp[16217] = 0; +inp[16218] = 1073741713; +inp[16219] = 0; +inp[16220] = 1073741712; +inp[16221] = 0; +inp[16222] = 1073741711; +inp[16223] = 0; +inp[16224] = 1073741710; +inp[16225] = 0; +inp[16226] = 1073741709; +inp[16227] = 0; +inp[16228] = 1073741708; +inp[16229] = 0; +inp[16230] = 1073741707; +inp[16231] = 0; +inp[16232] = 1073741706; +inp[16233] = 0; +inp[16234] = 1073741705; +inp[16235] = 0; +inp[16236] = 1073741704; +inp[16237] = 0; +inp[16238] = 1073741703; +inp[16239] = 0; +inp[16240] = 1073741702; +inp[16241] = 0; +inp[16242] = 1073741701; +inp[16243] = 0; +inp[16244] = 1073741700; +inp[16245] = 0; +inp[16246] = 1073741699; +inp[16247] = 0; +inp[16248] = 1073741698; +inp[16249] = 0; +inp[16250] = 1073741697; +inp[16251] = 0; +inp[16252] = 1073741824; +inp[16253] = 1073741824; +inp[16254] = 1073741823; +inp[16255] = 0; +inp[16256] = 1073741823; +inp[16257] = 0; +inp[16258] = 1073741822; +inp[16259] = 0; +inp[16260] = 1073741822; +inp[16261] = 0; +inp[16262] = 1073741821; +inp[16263] = 0; +inp[16264] = 1073741821; +inp[16265] = 0; +inp[16266] = 1073741820; +inp[16267] = 0; +inp[16268] = 1073741820; +inp[16269] = 0; +inp[16270] = 1073741819; +inp[16271] = 0; +inp[16272] = 1073741819; +inp[16273] = 0; +inp[16274] = 1073741818; +inp[16275] = 0; +inp[16276] = 1073741818; +inp[16277] = 0; +inp[16278] = 1073741817; +inp[16279] = 0; +inp[16280] = 1073741817; +inp[16281] = 0; +inp[16282] = 1073741816; +inp[16283] = 0; +inp[16284] = 1073741816; +inp[16285] = 0; +inp[16286] = 1073741815; +inp[16287] = 0; +inp[16288] = 1073741815; +inp[16289] = 0; +inp[16290] = 1073741814; +inp[16291] = 0; +inp[16292] = 1073741814; +inp[16293] = 0; +inp[16294] = 1073741813; +inp[16295] = 0; +inp[16296] = 1073741813; +inp[16297] = 0; +inp[16298] = 1073741812; +inp[16299] = 0; +inp[16300] = 1073741812; +inp[16301] = 0; +inp[16302] = 1073741811; +inp[16303] = 0; +inp[16304] = 1073741811; +inp[16305] = 0; +inp[16306] = 1073741810; +inp[16307] = 0; +inp[16308] = 1073741810; +inp[16309] = 0; +inp[16310] = 1073741809; +inp[16311] = 0; +inp[16312] = 1073741809; +inp[16313] = 0; +inp[16314] = 1073741808; +inp[16315] = 0; +inp[16316] = 1073741808; +inp[16317] = 0; +inp[16318] = 1073741807; +inp[16319] = 0; +inp[16320] = 1073741807; +inp[16321] = 0; +inp[16322] = 1073741806; +inp[16323] = 0; +inp[16324] = 1073741806; +inp[16325] = 0; +inp[16326] = 1073741805; +inp[16327] = 0; +inp[16328] = 1073741805; +inp[16329] = 0; +inp[16330] = 1073741804; +inp[16331] = 0; +inp[16332] = 1073741804; +inp[16333] = 0; +inp[16334] = 1073741803; +inp[16335] = 0; +inp[16336] = 1073741803; +inp[16337] = 0; +inp[16338] = 1073741802; +inp[16339] = 0; +inp[16340] = 1073741802; +inp[16341] = 0; +inp[16342] = 1073741801; +inp[16343] = 0; +inp[16344] = 1073741801; +inp[16345] = 0; +inp[16346] = 1073741800; +inp[16347] = 0; +inp[16348] = 1073741800; +inp[16349] = 0; +inp[16350] = 1073741799; +inp[16351] = 0; +inp[16352] = 1073741799; +inp[16353] = 0; +inp[16354] = 1073741798; +inp[16355] = 0; +inp[16356] = 1073741798; +inp[16357] = 0; +inp[16358] = 1073741797; +inp[16359] = 0; +inp[16360] = 1073741797; +inp[16361] = 0; +inp[16362] = 1073741796; +inp[16363] = 0; +inp[16364] = 1073741796; +inp[16365] = 0; +inp[16366] = 1073741795; +inp[16367] = 0; +inp[16368] = 1073741795; +inp[16369] = 0; +inp[16370] = 1073741794; +inp[16371] = 0; +inp[16372] = 1073741794; +inp[16373] = 0; +inp[16374] = 1073741793; +inp[16375] = 0; +inp[16376] = 1073741793; +inp[16377] = 0; +inp[16378] = 1073741792; +inp[16379] = 0; +inp[16380] = 1073741792; +inp[16381] = 0; +inp[16382] = 1073741791; +inp[16383] = 0; +inp[16384] = 1073741791; +inp[16385] = 0; +inp[16386] = 1073741790; +inp[16387] = 0; +inp[16388] = 1073741790; +inp[16389] = 0; +inp[16390] = 1073741789; +inp[16391] = 0; +inp[16392] = 1073741789; +inp[16393] = 0; +inp[16394] = 1073741788; +inp[16395] = 0; +inp[16396] = 1073741788; +inp[16397] = 0; +inp[16398] = 1073741787; +inp[16399] = 0; +inp[16400] = 1073741787; +inp[16401] = 0; +inp[16402] = 1073741786; +inp[16403] = 0; +inp[16404] = 1073741786; +inp[16405] = 0; +inp[16406] = 1073741785; +inp[16407] = 0; +inp[16408] = 1073741785; +inp[16409] = 0; +inp[16410] = 1073741784; +inp[16411] = 0; +inp[16412] = 1073741784; +inp[16413] = 0; +inp[16414] = 1073741783; +inp[16415] = 0; +inp[16416] = 1073741783; +inp[16417] = 0; +inp[16418] = 1073741782; +inp[16419] = 0; +inp[16420] = 1073741782; +inp[16421] = 0; +inp[16422] = 1073741781; +inp[16423] = 0; +inp[16424] = 1073741781; +inp[16425] = 0; +inp[16426] = 1073741780; +inp[16427] = 0; +inp[16428] = 1073741780; +inp[16429] = 0; +inp[16430] = 1073741779; +inp[16431] = 0; +inp[16432] = 1073741779; +inp[16433] = 0; +inp[16434] = 1073741778; +inp[16435] = 0; +inp[16436] = 1073741778; +inp[16437] = 0; +inp[16438] = 1073741777; +inp[16439] = 0; +inp[16440] = 1073741777; +inp[16441] = 0; +inp[16442] = 1073741776; +inp[16443] = 0; +inp[16444] = 1073741776; +inp[16445] = 0; +inp[16446] = 1073741775; +inp[16447] = 0; +inp[16448] = 1073741775; +inp[16449] = 0; +inp[16450] = 1073741774; +inp[16451] = 0; +inp[16452] = 1073741774; +inp[16453] = 0; +inp[16454] = 1073741773; +inp[16455] = 0; +inp[16456] = 1073741773; +inp[16457] = 0; +inp[16458] = 1073741772; +inp[16459] = 0; +inp[16460] = 1073741772; +inp[16461] = 0; +inp[16462] = 1073741771; +inp[16463] = 0; +inp[16464] = 1073741771; +inp[16465] = 0; +inp[16466] = 1073741770; +inp[16467] = 0; +inp[16468] = 1073741770; +inp[16469] = 0; +inp[16470] = 1073741769; +inp[16471] = 0; +inp[16472] = 1073741769; +inp[16473] = 0; +inp[16474] = 1073741768; +inp[16475] = 0; +inp[16476] = 1073741768; +inp[16477] = 0; +inp[16478] = 1073741767; +inp[16479] = 0; +inp[16480] = 1073741767; +inp[16481] = 0; +inp[16482] = 1073741766; +inp[16483] = 0; +inp[16484] = 1073741766; +inp[16485] = 0; +inp[16486] = 1073741765; +inp[16487] = 0; +inp[16488] = 1073741765; +inp[16489] = 0; +inp[16490] = 1073741764; +inp[16491] = 0; +inp[16492] = 1073741764; +inp[16493] = 0; +inp[16494] = 1073741763; +inp[16495] = 0; +inp[16496] = 1073741763; +inp[16497] = 0; +inp[16498] = 1073741762; +inp[16499] = 0; +inp[16500] = 1073741762; +inp[16501] = 0; +inp[16502] = 1073741761; +inp[16503] = 0; +inp[16504] = 1073741761; +inp[16505] = 0; +inp[16506] = 1073741760; +inp[16507] = 0; +inp[16508] = 1073741824; +inp[16509] = 1073741824; +inp[16510] = 1073741823; +inp[16511] = 0; +inp[16512] = 1073741823; +inp[16513] = 0; +inp[16514] = 1073741823; +inp[16515] = 0; +inp[16516] = 1073741823; +inp[16517] = 0; +inp[16518] = 1073741822; +inp[16519] = 0; +inp[16520] = 1073741822; +inp[16521] = 0; +inp[16522] = 1073741822; +inp[16523] = 0; +inp[16524] = 1073741822; +inp[16525] = 0; +inp[16526] = 1073741821; +inp[16527] = 0; +inp[16528] = 1073741821; +inp[16529] = 0; +inp[16530] = 1073741821; +inp[16531] = 0; +inp[16532] = 1073741821; +inp[16533] = 0; +inp[16534] = 1073741820; +inp[16535] = 0; +inp[16536] = 1073741820; +inp[16537] = 0; +inp[16538] = 1073741820; +inp[16539] = 0; +inp[16540] = 1073741820; +inp[16541] = 0; +inp[16542] = 1073741819; +inp[16543] = 0; +inp[16544] = 1073741819; +inp[16545] = 0; +inp[16546] = 1073741819; +inp[16547] = 0; +inp[16548] = 1073741819; +inp[16549] = 0; +inp[16550] = 1073741818; +inp[16551] = 0; +inp[16552] = 1073741818; +inp[16553] = 0; +inp[16554] = 1073741818; +inp[16555] = 0; +inp[16556] = 1073741818; +inp[16557] = 0; +inp[16558] = 1073741817; +inp[16559] = 0; +inp[16560] = 1073741817; +inp[16561] = 0; +inp[16562] = 1073741817; +inp[16563] = 0; +inp[16564] = 1073741817; +inp[16565] = 0; +inp[16566] = 1073741816; +inp[16567] = 0; +inp[16568] = 1073741816; +inp[16569] = 0; +inp[16570] = 1073741816; +inp[16571] = 0; +inp[16572] = 1073741816; +inp[16573] = 0; +inp[16574] = 1073741815; +inp[16575] = 0; +inp[16576] = 1073741815; +inp[16577] = 0; +inp[16578] = 1073741815; +inp[16579] = 0; +inp[16580] = 1073741815; +inp[16581] = 0; +inp[16582] = 1073741814; +inp[16583] = 0; +inp[16584] = 1073741814; +inp[16585] = 0; +inp[16586] = 1073741814; +inp[16587] = 0; +inp[16588] = 1073741814; +inp[16589] = 0; +inp[16590] = 1073741813; +inp[16591] = 0; +inp[16592] = 1073741813; +inp[16593] = 0; +inp[16594] = 1073741813; +inp[16595] = 0; +inp[16596] = 1073741813; +inp[16597] = 0; +inp[16598] = 1073741812; +inp[16599] = 0; +inp[16600] = 1073741812; +inp[16601] = 0; +inp[16602] = 1073741812; +inp[16603] = 0; +inp[16604] = 1073741812; +inp[16605] = 0; +inp[16606] = 1073741811; +inp[16607] = 0; +inp[16608] = 1073741811; +inp[16609] = 0; +inp[16610] = 1073741811; +inp[16611] = 0; +inp[16612] = 1073741811; +inp[16613] = 0; +inp[16614] = 1073741810; +inp[16615] = 0; +inp[16616] = 1073741810; +inp[16617] = 0; +inp[16618] = 1073741810; +inp[16619] = 0; +inp[16620] = 1073741810; +inp[16621] = 0; +inp[16622] = 1073741809; +inp[16623] = 0; +inp[16624] = 1073741809; +inp[16625] = 0; +inp[16626] = 1073741809; +inp[16627] = 0; +inp[16628] = 1073741809; +inp[16629] = 0; +inp[16630] = 1073741808; +inp[16631] = 0; +inp[16632] = 1073741808; +inp[16633] = 0; +inp[16634] = 1073741808; +inp[16635] = 0; +inp[16636] = 1073741808; +inp[16637] = 0; +inp[16638] = 1073741807; +inp[16639] = 0; +inp[16640] = 1073741807; +inp[16641] = 0; +inp[16642] = 1073741807; +inp[16643] = 0; +inp[16644] = 1073741807; +inp[16645] = 0; +inp[16646] = 1073741806; +inp[16647] = 0; +inp[16648] = 1073741806; +inp[16649] = 0; +inp[16650] = 1073741806; +inp[16651] = 0; +inp[16652] = 1073741806; +inp[16653] = 0; +inp[16654] = 1073741805; +inp[16655] = 0; +inp[16656] = 1073741805; +inp[16657] = 0; +inp[16658] = 1073741805; +inp[16659] = 0; +inp[16660] = 1073741805; +inp[16661] = 0; +inp[16662] = 1073741804; +inp[16663] = 0; +inp[16664] = 1073741804; +inp[16665] = 0; +inp[16666] = 1073741804; +inp[16667] = 0; +inp[16668] = 1073741804; +inp[16669] = 0; +inp[16670] = 1073741803; +inp[16671] = 0; +inp[16672] = 1073741803; +inp[16673] = 0; +inp[16674] = 1073741803; +inp[16675] = 0; +inp[16676] = 1073741803; +inp[16677] = 0; +inp[16678] = 1073741802; +inp[16679] = 0; +inp[16680] = 1073741802; +inp[16681] = 0; +inp[16682] = 1073741802; +inp[16683] = 0; +inp[16684] = 1073741802; +inp[16685] = 0; +inp[16686] = 1073741801; +inp[16687] = 0; +inp[16688] = 1073741801; +inp[16689] = 0; +inp[16690] = 1073741801; +inp[16691] = 0; +inp[16692] = 1073741801; +inp[16693] = 0; +inp[16694] = 1073741800; +inp[16695] = 0; +inp[16696] = 1073741800; +inp[16697] = 0; +inp[16698] = 1073741800; +inp[16699] = 0; +inp[16700] = 1073741800; +inp[16701] = 0; +inp[16702] = 1073741799; +inp[16703] = 0; +inp[16704] = 1073741799; +inp[16705] = 0; +inp[16706] = 1073741799; +inp[16707] = 0; +inp[16708] = 1073741799; +inp[16709] = 0; +inp[16710] = 1073741798; +inp[16711] = 0; +inp[16712] = 1073741798; +inp[16713] = 0; +inp[16714] = 1073741798; +inp[16715] = 0; +inp[16716] = 1073741798; +inp[16717] = 0; +inp[16718] = 1073741797; +inp[16719] = 0; +inp[16720] = 1073741797; +inp[16721] = 0; +inp[16722] = 1073741797; +inp[16723] = 0; +inp[16724] = 1073741797; +inp[16725] = 0; +inp[16726] = 1073741796; +inp[16727] = 0; +inp[16728] = 1073741796; +inp[16729] = 0; +inp[16730] = 1073741796; +inp[16731] = 0; +inp[16732] = 1073741796; +inp[16733] = 0; +inp[16734] = 1073741795; +inp[16735] = 0; +inp[16736] = 1073741795; +inp[16737] = 0; +inp[16738] = 1073741795; +inp[16739] = 0; +inp[16740] = 1073741795; +inp[16741] = 0; +inp[16742] = 1073741794; +inp[16743] = 0; +inp[16744] = 1073741794; +inp[16745] = 0; +inp[16746] = 1073741794; +inp[16747] = 0; +inp[16748] = 1073741794; +inp[16749] = 0; +inp[16750] = 1073741793; +inp[16751] = 0; +inp[16752] = 1073741793; +inp[16753] = 0; +inp[16754] = 1073741793; +inp[16755] = 0; +inp[16756] = 1073741793; +inp[16757] = 0; +inp[16758] = 1073741792; +inp[16759] = 0; +inp[16760] = 1073741792; +inp[16761] = 0; +inp[16762] = 1073741792; +inp[16763] = 0; +inp[16764] = 1073741824; +inp[16765] = 1073741824; +inp[16766] = 395007542; +inp[16767] = 395007542; +inp[16768] = 145315153; +inp[16769] = 145315153; +inp[16770] = 53458457; +inp[16771] = 53458457; +inp[16772] = 19666267; +inp[16773] = 19666267; +inp[16774] = 7234815; +inp[16775] = 7234815; +inp[16776] = 2661539; +inp[16777] = 2661539; +inp[16778] = 979125; +inp[16779] = 979125; +inp[16780] = 360200; +inp[16781] = 360200; +inp[16782] = 132510; +inp[16783] = 132510; +inp[16784] = 48747; +inp[16785] = 48747; +inp[16786] = 17933; +inp[16787] = 17933; +inp[16788] = 6597; +inp[16789] = 6597; +inp[16790] = 2427; +inp[16791] = 2427; +inp[16792] = 892; +inp[16793] = 892; +inp[16794] = 328; +inp[16795] = 328; +inp[16796] = 120; +inp[16797] = 120; +inp[16798] = 44; +inp[16799] = 44; +inp[16800] = 16; +inp[16801] = 16; +inp[16802] = 6; +inp[16803] = 6; +inp[16804] = 2; +inp[16805] = 2; +inp[16806] = 0; +inp[16807] = 0; +inp[16808] = 0; +inp[16809] = 0; +inp[16810] = 0; +inp[16811] = 0; +inp[16812] = 0; +inp[16813] = 0; +inp[16814] = 0; +inp[16815] = 0; +inp[16816] = 0; +inp[16817] = 0; +inp[16818] = 0; +inp[16819] = 0; +inp[16820] = 0; +inp[16821] = 0; +inp[16822] = 0; +inp[16823] = 0; +inp[16824] = 0; +inp[16825] = 0; +inp[16826] = 0; +inp[16827] = 0; +inp[16828] = 0; +inp[16829] = 0; +inp[16830] = 0; +inp[16831] = 0; +inp[16832] = 0; +inp[16833] = 0; +inp[16834] = 0; +inp[16835] = 0; +inp[16836] = 0; +inp[16837] = 0; +inp[16838] = 0; +inp[16839] = 0; +inp[16840] = 0; +inp[16841] = 0; +inp[16842] = 0; +inp[16843] = 0; +inp[16844] = 0; +inp[16845] = 0; +inp[16846] = 0; +inp[16847] = 0; +inp[16848] = 0; +inp[16849] = 0; +inp[16850] = 0; +inp[16851] = 0; +inp[16852] = 0; +inp[16853] = 0; +inp[16854] = 0; +inp[16855] = 0; +inp[16856] = 0; +inp[16857] = 0; +inp[16858] = 0; +inp[16859] = 0; +inp[16860] = 0; +inp[16861] = 0; +inp[16862] = 0; +inp[16863] = 0; +inp[16864] = 0; +inp[16865] = 0; +inp[16866] = 0; +inp[16867] = 0; +inp[16868] = 0; +inp[16869] = 0; +inp[16870] = 0; +inp[16871] = 0; +inp[16872] = 0; +inp[16873] = 0; +inp[16874] = 0; +inp[16875] = 0; +inp[16876] = 0; +inp[16877] = 0; +inp[16878] = 0; +inp[16879] = 0; +inp[16880] = 0; +inp[16881] = 0; +inp[16882] = 0; +inp[16883] = 0; +inp[16884] = 0; +inp[16885] = 0; +inp[16886] = 0; +inp[16887] = 0; +inp[16888] = 0; +inp[16889] = 0; +inp[16890] = 0; +inp[16891] = 0; +inp[16892] = 0; +inp[16893] = 0; +inp[16894] = 0; +inp[16895] = 0; +inp[16896] = 0; +inp[16897] = 0; +inp[16898] = 0; +inp[16899] = 0; +inp[16900] = 0; +inp[16901] = 0; +inp[16902] = 0; +inp[16903] = 0; +inp[16904] = 0; +inp[16905] = 0; +inp[16906] = 0; +inp[16907] = 0; +inp[16908] = 0; +inp[16909] = 0; +inp[16910] = 0; +inp[16911] = 0; +inp[16912] = 0; +inp[16913] = 0; +inp[16914] = 0; +inp[16915] = 0; +inp[16916] = 0; +inp[16917] = 0; +inp[16918] = 0; +inp[16919] = 0; +inp[16920] = 0; +inp[16921] = 0; +inp[16922] = 0; +inp[16923] = 0; +inp[16924] = 0; +inp[16925] = 0; +inp[16926] = 0; +inp[16927] = 0; +inp[16928] = 0; +inp[16929] = 0; +inp[16930] = 0; +inp[16931] = 0; +inp[16932] = 0; +inp[16933] = 0; +inp[16934] = 0; +inp[16935] = 0; +inp[16936] = 0; +inp[16937] = 0; +inp[16938] = 0; +inp[16939] = 0; +inp[16940] = 0; +inp[16941] = 0; +inp[16942] = 0; +inp[16943] = 0; +inp[16944] = 0; +inp[16945] = 0; +inp[16946] = 0; +inp[16947] = 0; +inp[16948] = 0; +inp[16949] = 0; +inp[16950] = 0; +inp[16951] = 0; +inp[16952] = 0; +inp[16953] = 0; +inp[16954] = 0; +inp[16955] = 0; +inp[16956] = 0; +inp[16957] = 0; +inp[16958] = 0; +inp[16959] = 0; +inp[16960] = 0; +inp[16961] = 0; +inp[16962] = 0; +inp[16963] = 0; +inp[16964] = 0; +inp[16965] = 0; +inp[16966] = 0; +inp[16967] = 0; +inp[16968] = 0; +inp[16969] = 0; +inp[16970] = 0; +inp[16971] = 0; +inp[16972] = 0; +inp[16973] = 0; +inp[16974] = 0; +inp[16975] = 0; +inp[16976] = 0; +inp[16977] = 0; +inp[16978] = 0; +inp[16979] = 0; +inp[16980] = 0; +inp[16981] = 0; +inp[16982] = 0; +inp[16983] = 0; +inp[16984] = 0; +inp[16985] = 0; +inp[16986] = 0; +inp[16987] = 0; +inp[16988] = 0; +inp[16989] = 0; +inp[16990] = 0; +inp[16991] = 0; +inp[16992] = 0; +inp[16993] = 0; +inp[16994] = 0; +inp[16995] = 0; +inp[16996] = 0; +inp[16997] = 0; +inp[16998] = 0; +inp[16999] = 0; +inp[17000] = 0; +inp[17001] = 0; +inp[17002] = 0; +inp[17003] = 0; +inp[17004] = 0; +inp[17005] = 0; +inp[17006] = 0; +inp[17007] = 0; +inp[17008] = 0; +inp[17009] = 0; +inp[17010] = 0; +inp[17011] = 0; +inp[17012] = 0; +inp[17013] = 0; +inp[17014] = 0; +inp[17015] = 0; +inp[17016] = 0; +inp[17017] = 0; +inp[17018] = 0; +inp[17019] = 0; +inp[17020] = 0; +inp[17021] = 0; +inp[17022] = 0; +inp[17023] = 0; +inp[17024] = 0; +inp[17025] = 0; +inp[17026] = 0; +inp[17027] = 0; +inp[17028] = 0; +inp[17029] = 0; +inp[17030] = 0; +inp[17031] = 0; +inp[17032] = 0; +inp[17033] = 0; +inp[17034] = 0; +inp[17035] = 0; +inp[17036] = 0; +inp[17037] = 0; +inp[17038] = 0; +inp[17039] = 0; +inp[17040] = 0; +inp[17041] = 0; +inp[17042] = 0; +inp[17043] = 0; +inp[17044] = 0; +inp[17045] = 0; +inp[17046] = 0; +inp[17047] = 0; +inp[17048] = 0; +inp[17049] = 0; +inp[17050] = 0; +inp[17051] = 0; +inp[17052] = 0; +inp[17053] = 0; +inp[17054] = 0; +inp[17055] = 0; +inp[17056] = 0; +inp[17057] = 0; +inp[17058] = 0; +inp[17059] = 0; +inp[17060] = 0; +inp[17061] = 0; +inp[17062] = 0; +inp[17063] = 0; +inp[17064] = 0; +inp[17065] = 0; +inp[17066] = 0; +inp[17067] = 0; +inp[17068] = 0; +inp[17069] = 0; +inp[17070] = 0; +inp[17071] = 0; +inp[17072] = 0; +inp[17073] = 0; +inp[17074] = 0; +inp[17075] = 0; +inp[17076] = 0; +inp[17077] = 0; +inp[17078] = 0; +inp[17079] = 0; +inp[17080] = 0; +inp[17081] = 0; +inp[17082] = 0; +inp[17083] = 0; +inp[17084] = 0; +inp[17085] = 0; +inp[17086] = 0; +inp[17087] = 0; +inp[17088] = 0; +inp[17089] = 0; +inp[17090] = 0; +inp[17091] = 0; +inp[17092] = 0; +inp[17093] = 0; +inp[17094] = 0; +inp[17095] = 0; +inp[17096] = 0; +inp[17097] = 0; +inp[17098] = 0; +inp[17099] = 0; +inp[17100] = 0; +inp[17101] = 0; +inp[17102] = 0; +inp[17103] = 0; +inp[17104] = 0; +inp[17105] = 0; +inp[17106] = 0; +inp[17107] = 0; +inp[17108] = 0; +inp[17109] = 0; +inp[17110] = 0; +inp[17111] = 0; +inp[17112] = 0; +inp[17113] = 0; +inp[17114] = 0; +inp[17115] = 0; +inp[17116] = 0; +inp[17117] = 0; +inp[17118] = 0; +inp[17119] = 0; +inp[17120] = 0; +inp[17121] = 0; +inp[17122] = 0; +inp[17123] = 0; +inp[17124] = 0; +inp[17125] = 0; +inp[17126] = 0; +inp[17127] = 0; +inp[17128] = 0; +inp[17129] = 0; +inp[17130] = 0; +inp[17131] = 0; +inp[17132] = 0; +inp[17133] = 0; +inp[17134] = 0; +inp[17135] = 0; +inp[17136] = 0; +inp[17137] = 0; +inp[17138] = 0; +inp[17139] = 0; +inp[17140] = 0; +inp[17141] = 0; +inp[17142] = 0; +inp[17143] = 0; +inp[17144] = 0; +inp[17145] = 0; +inp[17146] = 0; +inp[17147] = 0; +inp[17148] = 0; +inp[17149] = 0; +inp[17150] = 0; +inp[17151] = 0; +inp[17152] = 0; +inp[17153] = 0; +inp[17154] = 0; +inp[17155] = 0; +inp[17156] = 0; +inp[17157] = 0; +inp[17158] = 0; +inp[17159] = 0; +inp[17160] = 0; +inp[17161] = 0; +inp[17162] = 0; +inp[17163] = 0; +inp[17164] = 0; +inp[17165] = 0; +inp[17166] = 0; +inp[17167] = 0; +inp[17168] = 0; +inp[17169] = 0; +inp[17170] = 0; +inp[17171] = 0; +inp[17172] = 0; +inp[17173] = 0; +inp[17174] = 0; +inp[17175] = 0; +inp[17176] = 0; +inp[17177] = 0; +inp[17178] = 0; +inp[17179] = 0; +inp[17180] = 0; +inp[17181] = 0; +inp[17182] = 0; +inp[17183] = 0; +inp[17184] = 0; +inp[17185] = 0; +inp[17186] = 0; +inp[17187] = 0; +inp[17188] = 0; +inp[17189] = 0; +inp[17190] = 0; +inp[17191] = 0; +inp[17192] = 0; +inp[17193] = 0; +inp[17194] = 0; +inp[17195] = 0; +inp[17196] = 0; +inp[17197] = 0; +inp[17198] = 0; +inp[17199] = 0; +inp[17200] = 0; +inp[17201] = 0; +inp[17202] = 0; +inp[17203] = 0; +inp[17204] = 0; +inp[17205] = 0; +inp[17206] = 0; +inp[17207] = 0; +inp[17208] = 0; +inp[17209] = 0; +inp[17210] = 0; +inp[17211] = 0; +inp[17212] = 0; +inp[17213] = 0; +inp[17214] = 0; +inp[17215] = 0; +inp[17216] = 0; +inp[17217] = 0; +inp[17218] = 0; +inp[17219] = 0; +inp[17220] = 0; +inp[17221] = 0; +inp[17222] = 0; +inp[17223] = 0; +inp[17224] = 0; +inp[17225] = 0; +inp[17226] = 0; +inp[17227] = 0; +inp[17228] = 0; +inp[17229] = 0; +inp[17230] = 0; +inp[17231] = 0; +inp[17232] = 0; +inp[17233] = 0; +inp[17234] = 0; +inp[17235] = 0; +inp[17236] = 0; +inp[17237] = 0; +inp[17238] = 0; +inp[17239] = 0; +inp[17240] = 0; +inp[17241] = 0; +inp[17242] = 0; +inp[17243] = 0; +inp[17244] = 0; +inp[17245] = 0; +inp[17246] = 0; +inp[17247] = 0; +inp[17248] = 0; +inp[17249] = 0; +inp[17250] = 0; +inp[17251] = 0; +inp[17252] = 0; +inp[17253] = 0; +inp[17254] = 0; +inp[17255] = 0; +inp[17256] = 0; +inp[17257] = 0; +inp[17258] = 0; +inp[17259] = 0; +inp[17260] = 0; +inp[17261] = 0; +inp[17262] = 0; +inp[17263] = 0; +inp[17264] = 0; +inp[17265] = 0; +inp[17266] = 0; +inp[17267] = 0; +inp[17268] = 0; +inp[17269] = 0; +inp[17270] = 0; +inp[17271] = 0; +inp[17272] = 0; +inp[17273] = 0; +inp[17274] = 0; +inp[17275] = 0; +inp[17276] = 1073741824; +inp[17277] = 1073741824; +inp[17278] = 651257336; +inp[17279] = 145315153; +inp[17280] = 395007542; +inp[17281] = 19666267; +inp[17282] = 239584185; +inp[17283] = 2661539; +inp[17284] = 145315153; +inp[17285] = 360200; +inp[17286] = 88138096; +inp[17287] = 48747; +inp[17288] = 53458457; +inp[17289] = 6597; +inp[17290] = 32424193; +inp[17291] = 892; +inp[17292] = 19666267; +inp[17293] = 120; +inp[17294] = 11928194; +inp[17295] = 16; +inp[17296] = 7234815; +inp[17297] = 2; +inp[17298] = 4388137; +inp[17299] = 0; +inp[17300] = 2661539; +inp[17301] = 0; +inp[17302] = 1614305; +inp[17303] = 0; +inp[17304] = 979125; +inp[17305] = 0; +inp[17306] = 593869; +inp[17307] = 0; +inp[17308] = 360200; +inp[17309] = 0; +inp[17310] = 218472; +inp[17311] = 0; +inp[17312] = 132510; +inp[17313] = 0; +inp[17314] = 80371; +inp[17315] = 0; +inp[17316] = 48747; +inp[17317] = 0; +inp[17318] = 29567; +inp[17319] = 0; +inp[17320] = 17933; +inp[17321] = 0; +inp[17322] = 10877; +inp[17323] = 0; +inp[17324] = 6597; +inp[17325] = 0; +inp[17326] = 4001; +inp[17327] = 0; +inp[17328] = 2427; +inp[17329] = 0; +inp[17330] = 1472; +inp[17331] = 0; +inp[17332] = 892; +inp[17333] = 0; +inp[17334] = 541; +inp[17335] = 0; +inp[17336] = 328; +inp[17337] = 0; +inp[17338] = 199; +inp[17339] = 0; +inp[17340] = 120; +inp[17341] = 0; +inp[17342] = 73; +inp[17343] = 0; +inp[17344] = 44; +inp[17345] = 0; +inp[17346] = 26; +inp[17347] = 0; +inp[17348] = 16; +inp[17349] = 0; +inp[17350] = 9; +inp[17351] = 0; +inp[17352] = 6; +inp[17353] = 0; +inp[17354] = 3; +inp[17355] = 0; +inp[17356] = 2; +inp[17357] = 0; +inp[17358] = 1; +inp[17359] = 0; +inp[17360] = 0; +inp[17361] = 0; +inp[17362] = 0; +inp[17363] = 0; +inp[17364] = 0; +inp[17365] = 0; +inp[17366] = 0; +inp[17367] = 0; +inp[17368] = 0; +inp[17369] = 0; +inp[17370] = 0; +inp[17371] = 0; +inp[17372] = 0; +inp[17373] = 0; +inp[17374] = 0; +inp[17375] = 0; +inp[17376] = 0; +inp[17377] = 0; +inp[17378] = 0; +inp[17379] = 0; +inp[17380] = 0; +inp[17381] = 0; +inp[17382] = 0; +inp[17383] = 0; +inp[17384] = 0; +inp[17385] = 0; +inp[17386] = 0; +inp[17387] = 0; +inp[17388] = 0; +inp[17389] = 0; +inp[17390] = 0; +inp[17391] = 0; +inp[17392] = 0; +inp[17393] = 0; +inp[17394] = 0; +inp[17395] = 0; +inp[17396] = 0; +inp[17397] = 0; +inp[17398] = 0; +inp[17399] = 0; +inp[17400] = 0; +inp[17401] = 0; +inp[17402] = 0; +inp[17403] = 0; +inp[17404] = 0; +inp[17405] = 0; +inp[17406] = 0; +inp[17407] = 0; +inp[17408] = 0; +inp[17409] = 0; +inp[17410] = 0; +inp[17411] = 0; +inp[17412] = 0; +inp[17413] = 0; +inp[17414] = 0; +inp[17415] = 0; +inp[17416] = 0; +inp[17417] = 0; +inp[17418] = 0; +inp[17419] = 0; +inp[17420] = 0; +inp[17421] = 0; +inp[17422] = 0; +inp[17423] = 0; +inp[17424] = 0; +inp[17425] = 0; +inp[17426] = 0; +inp[17427] = 0; +inp[17428] = 0; +inp[17429] = 0; +inp[17430] = 0; +inp[17431] = 0; +inp[17432] = 0; +inp[17433] = 0; +inp[17434] = 0; +inp[17435] = 0; +inp[17436] = 0; +inp[17437] = 0; +inp[17438] = 0; +inp[17439] = 0; +inp[17440] = 0; +inp[17441] = 0; +inp[17442] = 0; +inp[17443] = 0; +inp[17444] = 0; +inp[17445] = 0; +inp[17446] = 0; +inp[17447] = 0; +inp[17448] = 0; +inp[17449] = 0; +inp[17450] = 0; +inp[17451] = 0; +inp[17452] = 0; +inp[17453] = 0; +inp[17454] = 0; +inp[17455] = 0; +inp[17456] = 0; +inp[17457] = 0; +inp[17458] = 0; +inp[17459] = 0; +inp[17460] = 0; +inp[17461] = 0; +inp[17462] = 0; +inp[17463] = 0; +inp[17464] = 0; +inp[17465] = 0; +inp[17466] = 0; +inp[17467] = 0; +inp[17468] = 0; +inp[17469] = 0; +inp[17470] = 0; +inp[17471] = 0; +inp[17472] = 0; +inp[17473] = 0; +inp[17474] = 0; +inp[17475] = 0; +inp[17476] = 0; +inp[17477] = 0; +inp[17478] = 0; +inp[17479] = 0; +inp[17480] = 0; +inp[17481] = 0; +inp[17482] = 0; +inp[17483] = 0; +inp[17484] = 0; +inp[17485] = 0; +inp[17486] = 0; +inp[17487] = 0; +inp[17488] = 0; +inp[17489] = 0; +inp[17490] = 0; +inp[17491] = 0; +inp[17492] = 0; +inp[17493] = 0; +inp[17494] = 0; +inp[17495] = 0; +inp[17496] = 0; +inp[17497] = 0; +inp[17498] = 0; +inp[17499] = 0; +inp[17500] = 0; +inp[17501] = 0; +inp[17502] = 0; +inp[17503] = 0; +inp[17504] = 0; +inp[17505] = 0; +inp[17506] = 0; +inp[17507] = 0; +inp[17508] = 0; +inp[17509] = 0; +inp[17510] = 0; +inp[17511] = 0; +inp[17512] = 0; +inp[17513] = 0; +inp[17514] = 0; +inp[17515] = 0; +inp[17516] = 0; +inp[17517] = 0; +inp[17518] = 0; +inp[17519] = 0; +inp[17520] = 0; +inp[17521] = 0; +inp[17522] = 0; +inp[17523] = 0; +inp[17524] = 0; +inp[17525] = 0; +inp[17526] = 0; +inp[17527] = 0; +inp[17528] = 0; +inp[17529] = 0; +inp[17530] = 0; +inp[17531] = 0; +inp[17532] = 0; +inp[17533] = 0; +inp[17534] = 0; +inp[17535] = 0; +inp[17536] = 0; +inp[17537] = 0; +inp[17538] = 0; +inp[17539] = 0; +inp[17540] = 0; +inp[17541] = 0; +inp[17542] = 0; +inp[17543] = 0; +inp[17544] = 0; +inp[17545] = 0; +inp[17546] = 0; +inp[17547] = 0; +inp[17548] = 0; +inp[17549] = 0; +inp[17550] = 0; +inp[17551] = 0; +inp[17552] = 0; +inp[17553] = 0; +inp[17554] = 0; +inp[17555] = 0; +inp[17556] = 0; +inp[17557] = 0; +inp[17558] = 0; +inp[17559] = 0; +inp[17560] = 0; +inp[17561] = 0; +inp[17562] = 0; +inp[17563] = 0; +inp[17564] = 0; +inp[17565] = 0; +inp[17566] = 0; +inp[17567] = 0; +inp[17568] = 0; +inp[17569] = 0; +inp[17570] = 0; +inp[17571] = 0; +inp[17572] = 0; +inp[17573] = 0; +inp[17574] = 0; +inp[17575] = 0; +inp[17576] = 0; +inp[17577] = 0; +inp[17578] = 0; +inp[17579] = 0; +inp[17580] = 0; +inp[17581] = 0; +inp[17582] = 0; +inp[17583] = 0; +inp[17584] = 0; +inp[17585] = 0; +inp[17586] = 0; +inp[17587] = 0; +inp[17588] = 0; +inp[17589] = 0; +inp[17590] = 0; +inp[17591] = 0; +inp[17592] = 0; +inp[17593] = 0; +inp[17594] = 0; +inp[17595] = 0; +inp[17596] = 0; +inp[17597] = 0; +inp[17598] = 0; +inp[17599] = 0; +inp[17600] = 0; +inp[17601] = 0; +inp[17602] = 0; +inp[17603] = 0; +inp[17604] = 0; +inp[17605] = 0; +inp[17606] = 0; +inp[17607] = 0; +inp[17608] = 0; +inp[17609] = 0; +inp[17610] = 0; +inp[17611] = 0; +inp[17612] = 0; +inp[17613] = 0; +inp[17614] = 0; +inp[17615] = 0; +inp[17616] = 0; +inp[17617] = 0; +inp[17618] = 0; +inp[17619] = 0; +inp[17620] = 0; +inp[17621] = 0; +inp[17622] = 0; +inp[17623] = 0; +inp[17624] = 0; +inp[17625] = 0; +inp[17626] = 0; +inp[17627] = 0; +inp[17628] = 0; +inp[17629] = 0; +inp[17630] = 0; +inp[17631] = 0; +inp[17632] = 0; +inp[17633] = 0; +inp[17634] = 0; +inp[17635] = 0; +inp[17636] = 0; +inp[17637] = 0; +inp[17638] = 0; +inp[17639] = 0; +inp[17640] = 0; +inp[17641] = 0; +inp[17642] = 0; +inp[17643] = 0; +inp[17644] = 0; +inp[17645] = 0; +inp[17646] = 0; +inp[17647] = 0; +inp[17648] = 0; +inp[17649] = 0; +inp[17650] = 0; +inp[17651] = 0; +inp[17652] = 0; +inp[17653] = 0; +inp[17654] = 0; +inp[17655] = 0; +inp[17656] = 0; +inp[17657] = 0; +inp[17658] = 0; +inp[17659] = 0; +inp[17660] = 0; +inp[17661] = 0; +inp[17662] = 0; +inp[17663] = 0; +inp[17664] = 0; +inp[17665] = 0; +inp[17666] = 0; +inp[17667] = 0; +inp[17668] = 0; +inp[17669] = 0; +inp[17670] = 0; +inp[17671] = 0; +inp[17672] = 0; +inp[17673] = 0; +inp[17674] = 0; +inp[17675] = 0; +inp[17676] = 0; +inp[17677] = 0; +inp[17678] = 0; +inp[17679] = 0; +inp[17680] = 0; +inp[17681] = 0; +inp[17682] = 0; +inp[17683] = 0; +inp[17684] = 0; +inp[17685] = 0; +inp[17686] = 0; +inp[17687] = 0; +inp[17688] = 0; +inp[17689] = 0; +inp[17690] = 0; +inp[17691] = 0; +inp[17692] = 0; +inp[17693] = 0; +inp[17694] = 0; +inp[17695] = 0; +inp[17696] = 0; +inp[17697] = 0; +inp[17698] = 0; +inp[17699] = 0; +inp[17700] = 0; +inp[17701] = 0; +inp[17702] = 0; +inp[17703] = 0; +inp[17704] = 0; +inp[17705] = 0; +inp[17706] = 0; +inp[17707] = 0; +inp[17708] = 0; +inp[17709] = 0; +inp[17710] = 0; +inp[17711] = 0; +inp[17712] = 0; +inp[17713] = 0; +inp[17714] = 0; +inp[17715] = 0; +inp[17716] = 0; +inp[17717] = 0; +inp[17718] = 0; +inp[17719] = 0; +inp[17720] = 0; +inp[17721] = 0; +inp[17722] = 0; +inp[17723] = 0; +inp[17724] = 0; +inp[17725] = 0; +inp[17726] = 0; +inp[17727] = 0; +inp[17728] = 0; +inp[17729] = 0; +inp[17730] = 0; +inp[17731] = 0; +inp[17732] = 0; +inp[17733] = 0; +inp[17734] = 0; +inp[17735] = 0; +inp[17736] = 0; +inp[17737] = 0; +inp[17738] = 0; +inp[17739] = 0; +inp[17740] = 0; +inp[17741] = 0; +inp[17742] = 0; +inp[17743] = 0; +inp[17744] = 0; +inp[17745] = 0; +inp[17746] = 0; +inp[17747] = 0; +inp[17748] = 0; +inp[17749] = 0; +inp[17750] = 0; +inp[17751] = 0; +inp[17752] = 0; +inp[17753] = 0; +inp[17754] = 0; +inp[17755] = 0; +inp[17756] = 0; +inp[17757] = 0; +inp[17758] = 0; +inp[17759] = 0; +inp[17760] = 0; +inp[17761] = 0; +inp[17762] = 0; +inp[17763] = 0; +inp[17764] = 0; +inp[17765] = 0; +inp[17766] = 0; +inp[17767] = 0; +inp[17768] = 0; +inp[17769] = 0; +inp[17770] = 0; +inp[17771] = 0; +inp[17772] = 0; +inp[17773] = 0; +inp[17774] = 0; +inp[17775] = 0; +inp[17776] = 0; +inp[17777] = 0; +inp[17778] = 0; +inp[17779] = 0; +inp[17780] = 0; +inp[17781] = 0; +inp[17782] = 0; +inp[17783] = 0; +inp[17784] = 0; +inp[17785] = 0; +inp[17786] = 0; +inp[17787] = 0; +inp[17788] = 1073741824; +inp[17789] = 1073741824; +inp[17790] = 836230973; +inp[17791] = 19666267; +inp[17792] = 651257336; +inp[17793] = 360200; +inp[17794] = 507199723; +inp[17795] = 6597; +inp[17796] = 395007542; +inp[17797] = 120; +inp[17798] = 307632183; +inp[17799] = 2; +inp[17800] = 239584185; +inp[17801] = 0; +inp[17802] = 186588351; +inp[17803] = 0; +inp[17804] = 145315153; +inp[17805] = 0; +inp[17806] = 113171555; +inp[17807] = 0; +inp[17808] = 88138096; +inp[17809] = 0; +inp[17810] = 68642018; +inp[17811] = 0; +inp[17812] = 53458457; +inp[17813] = 0; +inp[17814] = 41633488; +inp[17815] = 0; +inp[17816] = 32424193; +inp[17817] = 0; +inp[17818] = 25251987; +inp[17819] = 0; +inp[17820] = 19666267; +inp[17821] = 0; +inp[17822] = 15316104; +inp[17823] = 0; +inp[17824] = 11928194; +inp[17825] = 0; +inp[17826] = 9289686; +inp[17827] = 0; +inp[17828] = 7234815; +inp[17829] = 0; +inp[17830] = 5634479; +inp[17831] = 0; +inp[17832] = 4388137; +inp[17833] = 0; +inp[17834] = 3417484; +inp[17835] = 0; +inp[17836] = 2661539; +inp[17837] = 0; +inp[17838] = 2072809; +inp[17839] = 0; +inp[17840] = 1614305; +inp[17841] = 0; +inp[17842] = 1257222; +inp[17843] = 0; +inp[17844] = 979125; +inp[17845] = 0; +inp[17846] = 762543; +inp[17847] = 0; +inp[17848] = 593869; +inp[17849] = 0; +inp[17850] = 462506; +inp[17851] = 0; +inp[17852] = 360200; +inp[17853] = 0; +inp[17854] = 280524; +inp[17855] = 0; +inp[17856] = 218472; +inp[17857] = 0; +inp[17858] = 170146; +inp[17859] = 0; +inp[17860] = 132510; +inp[17861] = 0; +inp[17862] = 103199; +inp[17863] = 0; +inp[17864] = 80371; +inp[17865] = 0; +inp[17866] = 62593; +inp[17867] = 0; +inp[17868] = 48747; +inp[17869] = 0; +inp[17870] = 37964; +inp[17871] = 0; +inp[17872] = 29567; +inp[17873] = 0; +inp[17874] = 23026; +inp[17875] = 0; +inp[17876] = 17933; +inp[17877] = 0; +inp[17878] = 13966; +inp[17879] = 0; +inp[17880] = 10877; +inp[17881] = 0; +inp[17882] = 8471; +inp[17883] = 0; +inp[17884] = 6597; +inp[17885] = 0; +inp[17886] = 5137; +inp[17887] = 0; +inp[17888] = 4001; +inp[17889] = 0; +inp[17890] = 3116; +inp[17891] = 0; +inp[17892] = 2427; +inp[17893] = 0; +inp[17894] = 1890; +inp[17895] = 0; +inp[17896] = 1472; +inp[17897] = 0; +inp[17898] = 1146; +inp[17899] = 0; +inp[17900] = 892; +inp[17901] = 0; +inp[17902] = 695; +inp[17903] = 0; +inp[17904] = 541; +inp[17905] = 0; +inp[17906] = 421; +inp[17907] = 0; +inp[17908] = 328; +inp[17909] = 0; +inp[17910] = 255; +inp[17911] = 0; +inp[17912] = 199; +inp[17913] = 0; +inp[17914] = 155; +inp[17915] = 0; +inp[17916] = 120; +inp[17917] = 0; +inp[17918] = 94; +inp[17919] = 0; +inp[17920] = 73; +inp[17921] = 0; +inp[17922] = 57; +inp[17923] = 0; +inp[17924] = 44; +inp[17925] = 0; +inp[17926] = 34; +inp[17927] = 0; +inp[17928] = 26; +inp[17929] = 0; +inp[17930] = 20; +inp[17931] = 0; +inp[17932] = 16; +inp[17933] = 0; +inp[17934] = 12; +inp[17935] = 0; +inp[17936] = 9; +inp[17937] = 0; +inp[17938] = 7; +inp[17939] = 0; +inp[17940] = 6; +inp[17941] = 0; +inp[17942] = 4; +inp[17943] = 0; +inp[17944] = 3; +inp[17945] = 0; +inp[17946] = 2; +inp[17947] = 0; +inp[17948] = 2; +inp[17949] = 0; +inp[17950] = 1; +inp[17951] = 0; +inp[17952] = 1; +inp[17953] = 0; +inp[17954] = 1; +inp[17955] = 0; +inp[17956] = 0; +inp[17957] = 0; +inp[17958] = 0; +inp[17959] = 0; +inp[17960] = 0; +inp[17961] = 0; +inp[17962] = 0; +inp[17963] = 0; +inp[17964] = 0; +inp[17965] = 0; +inp[17966] = 0; +inp[17967] = 0; +inp[17968] = 0; +inp[17969] = 0; +inp[17970] = 0; +inp[17971] = 0; +inp[17972] = 0; +inp[17973] = 0; +inp[17974] = 0; +inp[17975] = 0; +inp[17976] = 0; +inp[17977] = 0; +inp[17978] = 0; +inp[17979] = 0; +inp[17980] = 0; +inp[17981] = 0; +inp[17982] = 0; +inp[17983] = 0; +inp[17984] = 0; +inp[17985] = 0; +inp[17986] = 0; +inp[17987] = 0; +inp[17988] = 0; +inp[17989] = 0; +inp[17990] = 0; +inp[17991] = 0; +inp[17992] = 0; +inp[17993] = 0; +inp[17994] = 0; +inp[17995] = 0; +inp[17996] = 0; +inp[17997] = 0; +inp[17998] = 0; +inp[17999] = 0; +inp[18000] = 0; +inp[18001] = 0; +inp[18002] = 0; +inp[18003] = 0; +inp[18004] = 0; +inp[18005] = 0; +inp[18006] = 0; +inp[18007] = 0; +inp[18008] = 0; +inp[18009] = 0; +inp[18010] = 0; +inp[18011] = 0; +inp[18012] = 0; +inp[18013] = 0; +inp[18014] = 0; +inp[18015] = 0; +inp[18016] = 0; +inp[18017] = 0; +inp[18018] = 0; +inp[18019] = 0; +inp[18020] = 0; +inp[18021] = 0; +inp[18022] = 0; +inp[18023] = 0; +inp[18024] = 0; +inp[18025] = 0; +inp[18026] = 0; +inp[18027] = 0; +inp[18028] = 0; +inp[18029] = 0; +inp[18030] = 0; +inp[18031] = 0; +inp[18032] = 0; +inp[18033] = 0; +inp[18034] = 0; +inp[18035] = 0; +inp[18036] = 0; +inp[18037] = 0; +inp[18038] = 0; +inp[18039] = 0; +inp[18040] = 0; +inp[18041] = 0; +inp[18042] = 0; +inp[18043] = 0; +inp[18044] = 0; +inp[18045] = 0; +inp[18046] = 0; +inp[18047] = 0; +inp[18048] = 0; +inp[18049] = 0; +inp[18050] = 0; +inp[18051] = 0; +inp[18052] = 0; +inp[18053] = 0; +inp[18054] = 0; +inp[18055] = 0; +inp[18056] = 0; +inp[18057] = 0; +inp[18058] = 0; +inp[18059] = 0; +inp[18060] = 0; +inp[18061] = 0; +inp[18062] = 0; +inp[18063] = 0; +inp[18064] = 0; +inp[18065] = 0; +inp[18066] = 0; +inp[18067] = 0; +inp[18068] = 0; +inp[18069] = 0; +inp[18070] = 0; +inp[18071] = 0; +inp[18072] = 0; +inp[18073] = 0; +inp[18074] = 0; +inp[18075] = 0; +inp[18076] = 0; +inp[18077] = 0; +inp[18078] = 0; +inp[18079] = 0; +inp[18080] = 0; +inp[18081] = 0; +inp[18082] = 0; +inp[18083] = 0; +inp[18084] = 0; +inp[18085] = 0; +inp[18086] = 0; +inp[18087] = 0; +inp[18088] = 0; +inp[18089] = 0; +inp[18090] = 0; +inp[18091] = 0; +inp[18092] = 0; +inp[18093] = 0; +inp[18094] = 0; +inp[18095] = 0; +inp[18096] = 0; +inp[18097] = 0; +inp[18098] = 0; +inp[18099] = 0; +inp[18100] = 0; +inp[18101] = 0; +inp[18102] = 0; +inp[18103] = 0; +inp[18104] = 0; +inp[18105] = 0; +inp[18106] = 0; +inp[18107] = 0; +inp[18108] = 0; +inp[18109] = 0; +inp[18110] = 0; +inp[18111] = 0; +inp[18112] = 0; +inp[18113] = 0; +inp[18114] = 0; +inp[18115] = 0; +inp[18116] = 0; +inp[18117] = 0; +inp[18118] = 0; +inp[18119] = 0; +inp[18120] = 0; +inp[18121] = 0; +inp[18122] = 0; +inp[18123] = 0; +inp[18124] = 0; +inp[18125] = 0; +inp[18126] = 0; +inp[18127] = 0; +inp[18128] = 0; +inp[18129] = 0; +inp[18130] = 0; +inp[18131] = 0; +inp[18132] = 0; +inp[18133] = 0; +inp[18134] = 0; +inp[18135] = 0; +inp[18136] = 0; +inp[18137] = 0; +inp[18138] = 0; +inp[18139] = 0; +inp[18140] = 0; +inp[18141] = 0; +inp[18142] = 0; +inp[18143] = 0; +inp[18144] = 0; +inp[18145] = 0; +inp[18146] = 0; +inp[18147] = 0; +inp[18148] = 0; +inp[18149] = 0; +inp[18150] = 0; +inp[18151] = 0; +inp[18152] = 0; +inp[18153] = 0; +inp[18154] = 0; +inp[18155] = 0; +inp[18156] = 0; +inp[18157] = 0; +inp[18158] = 0; +inp[18159] = 0; +inp[18160] = 0; +inp[18161] = 0; +inp[18162] = 0; +inp[18163] = 0; +inp[18164] = 0; +inp[18165] = 0; +inp[18166] = 0; +inp[18167] = 0; +inp[18168] = 0; +inp[18169] = 0; +inp[18170] = 0; +inp[18171] = 0; +inp[18172] = 0; +inp[18173] = 0; +inp[18174] = 0; +inp[18175] = 0; +inp[18176] = 0; +inp[18177] = 0; +inp[18178] = 0; +inp[18179] = 0; +inp[18180] = 0; +inp[18181] = 0; +inp[18182] = 0; +inp[18183] = 0; +inp[18184] = 0; +inp[18185] = 0; +inp[18186] = 0; +inp[18187] = 0; +inp[18188] = 0; +inp[18189] = 0; +inp[18190] = 0; +inp[18191] = 0; +inp[18192] = 0; +inp[18193] = 0; +inp[18194] = 0; +inp[18195] = 0; +inp[18196] = 0; +inp[18197] = 0; +inp[18198] = 0; +inp[18199] = 0; +inp[18200] = 0; +inp[18201] = 0; +inp[18202] = 0; +inp[18203] = 0; +inp[18204] = 0; +inp[18205] = 0; +inp[18206] = 0; +inp[18207] = 0; +inp[18208] = 0; +inp[18209] = 0; +inp[18210] = 0; +inp[18211] = 0; +inp[18212] = 0; +inp[18213] = 0; +inp[18214] = 0; +inp[18215] = 0; +inp[18216] = 0; +inp[18217] = 0; +inp[18218] = 0; +inp[18219] = 0; +inp[18220] = 0; +inp[18221] = 0; +inp[18222] = 0; +inp[18223] = 0; +inp[18224] = 0; +inp[18225] = 0; +inp[18226] = 0; +inp[18227] = 0; +inp[18228] = 0; +inp[18229] = 0; +inp[18230] = 0; +inp[18231] = 0; +inp[18232] = 0; +inp[18233] = 0; +inp[18234] = 0; +inp[18235] = 0; +inp[18236] = 0; +inp[18237] = 0; +inp[18238] = 0; +inp[18239] = 0; +inp[18240] = 0; +inp[18241] = 0; +inp[18242] = 0; +inp[18243] = 0; +inp[18244] = 0; +inp[18245] = 0; +inp[18246] = 0; +inp[18247] = 0; +inp[18248] = 0; +inp[18249] = 0; +inp[18250] = 0; +inp[18251] = 0; +inp[18252] = 0; +inp[18253] = 0; +inp[18254] = 0; +inp[18255] = 0; +inp[18256] = 0; +inp[18257] = 0; +inp[18258] = 0; +inp[18259] = 0; +inp[18260] = 0; +inp[18261] = 0; +inp[18262] = 0; +inp[18263] = 0; +inp[18264] = 0; +inp[18265] = 0; +inp[18266] = 0; +inp[18267] = 0; +inp[18268] = 0; +inp[18269] = 0; +inp[18270] = 0; +inp[18271] = 0; +inp[18272] = 0; +inp[18273] = 0; +inp[18274] = 0; +inp[18275] = 0; +inp[18276] = 0; +inp[18277] = 0; +inp[18278] = 0; +inp[18279] = 0; +inp[18280] = 0; +inp[18281] = 0; +inp[18282] = 0; +inp[18283] = 0; +inp[18284] = 0; +inp[18285] = 0; +inp[18286] = 0; +inp[18287] = 0; +inp[18288] = 0; +inp[18289] = 0; +inp[18290] = 0; +inp[18291] = 0; +inp[18292] = 0; +inp[18293] = 0; +inp[18294] = 0; +inp[18295] = 0; +inp[18296] = 0; +inp[18297] = 0; +inp[18298] = 0; +inp[18299] = 0; +inp[18300] = 1073741824; +inp[18301] = 1073741824; +inp[18302] = 947573833; +inp[18303] = 360200; +inp[18304] = 836230973; +inp[18305] = 120; +inp[18306] = 737971243; +inp[18307] = 0; +inp[18308] = 651257336; +inp[18309] = 0; +inp[18310] = 574732582; +inp[18311] = 0; +inp[18312] = 507199723; +inp[18313] = 0; +inp[18314] = 447602185; +inp[18315] = 0; +inp[18316] = 395007542; +inp[18317] = 0; +inp[18318] = 348592932; +inp[18319] = 0; +inp[18320] = 307632183; +inp[18321] = 0; +inp[18322] = 271484448; +inp[18323] = 0; +inp[18324] = 239584185; +inp[18325] = 0; +inp[18326] = 211432301; +inp[18327] = 0; +inp[18328] = 186588351; +inp[18329] = 0; +inp[18330] = 164663641; +inp[18331] = 0; +inp[18332] = 145315153; +inp[18333] = 0; +inp[18334] = 128240173; +inp[18335] = 0; +inp[18336] = 113171555; +inp[18337] = 0; +inp[18338] = 99873547; +inp[18339] = 0; +inp[18340] = 88138096; +inp[18341] = 0; +inp[18342] = 77781596; +inp[18343] = 0; +inp[18344] = 68642018; +inp[18345] = 0; +inp[18346] = 60576368; +inp[18347] = 0; +inp[18348] = 53458457; +inp[18349] = 0; +inp[18350] = 47176923; +inp[18351] = 0; +inp[18352] = 41633488; +inp[18353] = 0; +inp[18354] = 36741424; +inp[18355] = 0; +inp[18356] = 32424193; +inp[18357] = 0; +inp[18358] = 28614250; +inp[18359] = 0; +inp[18360] = 25251987; +inp[18361] = 0; +inp[18362] = 22284800; +inp[18363] = 0; +inp[18364] = 19666267; +inp[18365] = 0; +inp[18366] = 17355420; +inp[18367] = 0; +inp[18368] = 15316104; +inp[18369] = 0; +inp[18370] = 13516414; +inp[18371] = 0; +inp[18372] = 11928194; +inp[18373] = 0; +inp[18374] = 10526594; +inp[18375] = 0; +inp[18376] = 9289686; +inp[18377] = 0; +inp[18378] = 8198119; +inp[18379] = 0; +inp[18380] = 7234815; +inp[18381] = 0; +inp[18382] = 6384702; +inp[18383] = 0; +inp[18384] = 5634479; +inp[18385] = 0; +inp[18386] = 4972411; +inp[18387] = 0; +inp[18388] = 4388137; +inp[18389] = 0; +inp[18390] = 3872517; +inp[18391] = 0; +inp[18392] = 3417484; +inp[18393] = 0; +inp[18394] = 3015919; +inp[18395] = 0; +inp[18396] = 2661539; +inp[18397] = 0; +inp[18398] = 2348800; +inp[18399] = 0; +inp[18400] = 2072809; +inp[18401] = 0; +inp[18402] = 1829247; +inp[18403] = 0; +inp[18404] = 1614305; +inp[18405] = 0; +inp[18406] = 1424619; +inp[18407] = 0; +inp[18408] = 1257222; +inp[18409] = 0; +inp[18410] = 1109494; +inp[18411] = 0; +inp[18412] = 979125; +inp[18413] = 0; +inp[18414] = 864075; +inp[18415] = 0; +inp[18416] = 762543; +inp[18417] = 0; +inp[18418] = 672942; +inp[18419] = 0; +inp[18420] = 593869; +inp[18421] = 0; +inp[18422] = 524088; +inp[18423] = 0; +inp[18424] = 462506; +inp[18425] = 0; +inp[18426] = 408160; +inp[18427] = 0; +inp[18428] = 360200; +inp[18429] = 0; +inp[18430] = 317875; +inp[18431] = 0; +inp[18432] = 280524; +inp[18433] = 0; +inp[18434] = 247561; +inp[18435] = 0; +inp[18436] = 218472; +inp[18437] = 0; +inp[18438] = 192801; +inp[18439] = 0; +inp[18440] = 170146; +inp[18441] = 0; +inp[18442] = 150153; +inp[18443] = 0; +inp[18444] = 132510; +inp[18445] = 0; +inp[18446] = 116939; +inp[18447] = 0; +inp[18448] = 103199; +inp[18449] = 0; +inp[18450] = 91072; +inp[18451] = 0; +inp[18452] = 80371; +inp[18453] = 0; +inp[18454] = 70927; +inp[18455] = 0; +inp[18456] = 62593; +inp[18457] = 0; +inp[18458] = 55238; +inp[18459] = 0; +inp[18460] = 48747; +inp[18461] = 0; +inp[18462] = 43019; +inp[18463] = 0; +inp[18464] = 37964; +inp[18465] = 0; +inp[18466] = 33503; +inp[18467] = 0; +inp[18468] = 29567; +inp[18469] = 0; +inp[18470] = 26092; +inp[18471] = 0; +inp[18472] = 23026; +inp[18473] = 0; +inp[18474] = 20321; +inp[18475] = 0; +inp[18476] = 17933; +inp[18477] = 0; +inp[18478] = 15826; +inp[18479] = 0; +inp[18480] = 13966; +inp[18481] = 0; +inp[18482] = 12325; +inp[18483] = 0; +inp[18484] = 10877; +inp[18485] = 0; +inp[18486] = 9599; +inp[18487] = 0; +inp[18488] = 8471; +inp[18489] = 0; +inp[18490] = 7475; +inp[18491] = 0; +inp[18492] = 6597; +inp[18493] = 0; +inp[18494] = 5822; +inp[18495] = 0; +inp[18496] = 5137; +inp[18497] = 0; +inp[18498] = 4534; +inp[18499] = 0; +inp[18500] = 4001; +inp[18501] = 0; +inp[18502] = 3531; +inp[18503] = 0; +inp[18504] = 3116; +inp[18505] = 0; +inp[18506] = 2750; +inp[18507] = 0; +inp[18508] = 2427; +inp[18509] = 0; +inp[18510] = 2141; +inp[18511] = 0; +inp[18512] = 1890; +inp[18513] = 0; +inp[18514] = 1668; +inp[18515] = 0; +inp[18516] = 1472; +inp[18517] = 0; +inp[18518] = 1299; +inp[18519] = 0; +inp[18520] = 1146; +inp[18521] = 0; +inp[18522] = 1011; +inp[18523] = 0; +inp[18524] = 892; +inp[18525] = 0; +inp[18526] = 787; +inp[18527] = 0; +inp[18528] = 695; +inp[18529] = 0; +inp[18530] = 613; +inp[18531] = 0; +inp[18532] = 541; +inp[18533] = 0; +inp[18534] = 477; +inp[18535] = 0; +inp[18536] = 421; +inp[18537] = 0; +inp[18538] = 372; +inp[18539] = 0; +inp[18540] = 328; +inp[18541] = 0; +inp[18542] = 289; +inp[18543] = 0; +inp[18544] = 255; +inp[18545] = 0; +inp[18546] = 225; +inp[18547] = 0; +inp[18548] = 199; +inp[18549] = 0; +inp[18550] = 175; +inp[18551] = 0; +inp[18552] = 155; +inp[18553] = 0; +inp[18554] = 136; +inp[18555] = 0; +inp[18556] = 120; +inp[18557] = 0; +inp[18558] = 106; +inp[18559] = 0; +inp[18560] = 94; +inp[18561] = 0; +inp[18562] = 83; +inp[18563] = 0; +inp[18564] = 73; +inp[18565] = 0; +inp[18566] = 64; +inp[18567] = 0; +inp[18568] = 57; +inp[18569] = 0; +inp[18570] = 50; +inp[18571] = 0; +inp[18572] = 44; +inp[18573] = 0; +inp[18574] = 39; +inp[18575] = 0; +inp[18576] = 34; +inp[18577] = 0; +inp[18578] = 30; +inp[18579] = 0; +inp[18580] = 26; +inp[18581] = 0; +inp[18582] = 23; +inp[18583] = 0; +inp[18584] = 20; +inp[18585] = 0; +inp[18586] = 18; +inp[18587] = 0; +inp[18588] = 16; +inp[18589] = 0; +inp[18590] = 14; +inp[18591] = 0; +inp[18592] = 12; +inp[18593] = 0; +inp[18594] = 11; +inp[18595] = 0; +inp[18596] = 9; +inp[18597] = 0; +inp[18598] = 8; +inp[18599] = 0; +inp[18600] = 7; +inp[18601] = 0; +inp[18602] = 6; +inp[18603] = 0; +inp[18604] = 6; +inp[18605] = 0; +inp[18606] = 5; +inp[18607] = 0; +inp[18608] = 4; +inp[18609] = 0; +inp[18610] = 4; +inp[18611] = 0; +inp[18612] = 3; +inp[18613] = 0; +inp[18614] = 3; +inp[18615] = 0; +inp[18616] = 2; +inp[18617] = 0; +inp[18618] = 2; +inp[18619] = 0; +inp[18620] = 2; +inp[18621] = 0; +inp[18622] = 1; +inp[18623] = 0; +inp[18624] = 1; +inp[18625] = 0; +inp[18626] = 1; +inp[18627] = 0; +inp[18628] = 1; +inp[18629] = 0; +inp[18630] = 1; +inp[18631] = 0; +inp[18632] = 1; +inp[18633] = 0; +inp[18634] = 0; +inp[18635] = 0; +inp[18636] = 0; +inp[18637] = 0; +inp[18638] = 0; +inp[18639] = 0; +inp[18640] = 0; +inp[18641] = 0; +inp[18642] = 0; +inp[18643] = 0; +inp[18644] = 0; +inp[18645] = 0; +inp[18646] = 0; +inp[18647] = 0; +inp[18648] = 0; +inp[18649] = 0; +inp[18650] = 0; +inp[18651] = 0; +inp[18652] = 0; +inp[18653] = 0; +inp[18654] = 0; +inp[18655] = 0; +inp[18656] = 0; +inp[18657] = 0; +inp[18658] = 0; +inp[18659] = 0; +inp[18660] = 0; +inp[18661] = 0; +inp[18662] = 0; +inp[18663] = 0; +inp[18664] = 0; +inp[18665] = 0; +inp[18666] = 0; +inp[18667] = 0; +inp[18668] = 0; +inp[18669] = 0; +inp[18670] = 0; +inp[18671] = 0; +inp[18672] = 0; +inp[18673] = 0; +inp[18674] = 0; +inp[18675] = 0; +inp[18676] = 0; +inp[18677] = 0; +inp[18678] = 0; +inp[18679] = 0; +inp[18680] = 0; +inp[18681] = 0; +inp[18682] = 0; +inp[18683] = 0; +inp[18684] = 0; +inp[18685] = 0; +inp[18686] = 0; +inp[18687] = 0; +inp[18688] = 0; +inp[18689] = 0; +inp[18690] = 0; +inp[18691] = 0; +inp[18692] = 0; +inp[18693] = 0; +inp[18694] = 0; +inp[18695] = 0; +inp[18696] = 0; +inp[18697] = 0; +inp[18698] = 0; +inp[18699] = 0; +inp[18700] = 0; +inp[18701] = 0; +inp[18702] = 0; +inp[18703] = 0; +inp[18704] = 0; +inp[18705] = 0; +inp[18706] = 0; +inp[18707] = 0; +inp[18708] = 0; +inp[18709] = 0; +inp[18710] = 0; +inp[18711] = 0; +inp[18712] = 0; +inp[18713] = 0; +inp[18714] = 0; +inp[18715] = 0; +inp[18716] = 0; +inp[18717] = 0; +inp[18718] = 0; +inp[18719] = 0; +inp[18720] = 0; +inp[18721] = 0; +inp[18722] = 0; +inp[18723] = 0; +inp[18724] = 0; +inp[18725] = 0; +inp[18726] = 0; +inp[18727] = 0; +inp[18728] = 0; +inp[18729] = 0; +inp[18730] = 0; +inp[18731] = 0; +inp[18732] = 0; +inp[18733] = 0; +inp[18734] = 0; +inp[18735] = 0; +inp[18736] = 0; +inp[18737] = 0; +inp[18738] = 0; +inp[18739] = 0; +inp[18740] = 0; +inp[18741] = 0; +inp[18742] = 0; +inp[18743] = 0; +inp[18744] = 0; +inp[18745] = 0; +inp[18746] = 0; +inp[18747] = 0; +inp[18748] = 0; +inp[18749] = 0; +inp[18750] = 0; +inp[18751] = 0; +inp[18752] = 0; +inp[18753] = 0; +inp[18754] = 0; +inp[18755] = 0; +inp[18756] = 0; +inp[18757] = 0; +inp[18758] = 0; +inp[18759] = 0; +inp[18760] = 0; +inp[18761] = 0; +inp[18762] = 0; +inp[18763] = 0; +inp[18764] = 0; +inp[18765] = 0; +inp[18766] = 0; +inp[18767] = 0; +inp[18768] = 0; +inp[18769] = 0; +inp[18770] = 0; +inp[18771] = 0; +inp[18772] = 0; +inp[18773] = 0; +inp[18774] = 0; +inp[18775] = 0; +inp[18776] = 0; +inp[18777] = 0; +inp[18778] = 0; +inp[18779] = 0; +inp[18780] = 0; +inp[18781] = 0; +inp[18782] = 0; +inp[18783] = 0; +inp[18784] = 0; +inp[18785] = 0; +inp[18786] = 0; +inp[18787] = 0; +inp[18788] = 0; +inp[18789] = 0; +inp[18790] = 0; +inp[18791] = 0; +inp[18792] = 0; +inp[18793] = 0; +inp[18794] = 0; +inp[18795] = 0; +inp[18796] = 0; +inp[18797] = 0; +inp[18798] = 0; +inp[18799] = 0; +inp[18800] = 0; +inp[18801] = 0; +inp[18802] = 0; +inp[18803] = 0; +inp[18804] = 0; +inp[18805] = 0; +inp[18806] = 0; +inp[18807] = 0; +inp[18808] = 0; +inp[18809] = 0; +inp[18810] = 0; +inp[18811] = 0; +inp[18812] = 1073741824; +inp[18813] = 1073741824; +inp[18814] = 1008687095; +inp[18815] = 120; +inp[18816] = 947573833; +inp[18817] = 0; +inp[18818] = 890163237; +inp[18819] = 0; +inp[18820] = 836230973; +inp[18821] = 0; +inp[18822] = 785566299; +inp[18823] = 0; +inp[18824] = 737971243; +inp[18825] = 0; +inp[18826] = 693259826; +inp[18827] = 0; +inp[18828] = 651257336; +inp[18829] = 0; +inp[18830] = 611799649; +inp[18831] = 0; +inp[18832] = 574732582; +inp[18833] = 0; +inp[18834] = 539911295; +inp[18835] = 0; +inp[18836] = 507199723; +inp[18837] = 0; +inp[18838] = 476470046; +inp[18839] = 0; +inp[18840] = 447602185; +inp[18841] = 0; +inp[18842] = 420483339; +inp[18843] = 0; +inp[18844] = 395007542; +inp[18845] = 0; +inp[18846] = 371075245; +inp[18847] = 0; +inp[18848] = 348592932; +inp[18849] = 0; +inp[18850] = 327472754; +inp[18851] = 0; +inp[18852] = 307632183; +inp[18853] = 0; +inp[18854] = 288993691; +inp[18855] = 0; +inp[18856] = 271484448; +inp[18857] = 0; +inp[18858] = 255036037; +inp[18859] = 0; +inp[18860] = 239584185; +inp[18861] = 0; +inp[18862] = 225068513; +inp[18863] = 0; +inp[18864] = 211432301; +inp[18865] = 0; +inp[18866] = 198622265; +inp[18867] = 0; +inp[18868] = 186588351; +inp[18869] = 0; +inp[18870] = 175283534; +inp[18871] = 0; +inp[18872] = 164663641; +inp[18873] = 0; +inp[18874] = 154687176; +inp[18875] = 0; +inp[18876] = 145315153; +inp[18877] = 0; +inp[18878] = 136510953; +inp[18879] = 0; +inp[18880] = 128240173; +inp[18881] = 0; +inp[18882] = 120470493; +inp[18883] = 0; +inp[18884] = 113171555; +inp[18885] = 0; +inp[18886] = 106314837; +inp[18887] = 0; +inp[18888] = 99873547; +inp[18889] = 0; +inp[18890] = 93822514; +inp[18891] = 0; +inp[18892] = 88138096; +inp[18893] = 0; +inp[18894] = 82798078; +inp[18895] = 0; +inp[18896] = 77781596; +inp[18897] = 0; +inp[18898] = 73069048; +inp[18899] = 0; +inp[18900] = 68642018; +inp[18901] = 0; +inp[18902] = 64483208; +inp[18903] = 0; +inp[18904] = 60576368; +inp[18905] = 0; +inp[18906] = 56906231; +inp[18907] = 0; +inp[18908] = 53458457; +inp[18909] = 0; +inp[18910] = 50219573; +inp[18911] = 0; +inp[18912] = 47176923; +inp[18913] = 0; +inp[18914] = 44318617; +inp[18915] = 0; +inp[18916] = 41633488; +inp[18917] = 0; +inp[18918] = 39111043; +inp[18919] = 0; +inp[18920] = 36741424; +inp[18921] = 0; +inp[18922] = 34515374; +inp[18923] = 0; +inp[18924] = 32424193; +inp[18925] = 0; +inp[18926] = 30459710; +inp[18927] = 0; +inp[18928] = 28614250; +inp[18929] = 0; +inp[18930] = 26880600; +inp[18931] = 0; +inp[18932] = 25251987; +inp[18933] = 0; +inp[18934] = 23722046; +inp[18935] = 0; +inp[18936] = 22284800; +inp[18937] = 0; +inp[18938] = 20934632; +inp[18939] = 0; +inp[18940] = 19666267; +inp[18941] = 0; +inp[18942] = 18474748; +inp[18943] = 0; +inp[18944] = 17355420; +inp[18945] = 0; +inp[18946] = 16303908; +inp[18947] = 0; +inp[18948] = 15316104; +inp[18949] = 0; +inp[18950] = 14388148; +inp[18951] = 0; +inp[18952] = 13516414; +inp[18953] = 0; +inp[18954] = 12697496; +inp[18955] = 0; +inp[18956] = 11928194; +inp[18957] = 0; +inp[18958] = 11205501; +inp[18959] = 0; +inp[18960] = 10526594; +inp[18961] = 0; +inp[18962] = 9888820; +inp[18963] = 0; +inp[18964] = 9289686; +inp[18965] = 0; +inp[18966] = 8726853; +inp[18967] = 0; +inp[18968] = 8198119; +inp[18969] = 0; +inp[18970] = 7701421; +inp[18971] = 0; +inp[18972] = 7234815; +inp[18973] = 0; +inp[18974] = 6796480; +inp[18975] = 0; +inp[18976] = 6384702; +inp[18977] = 0; +inp[18978] = 5997872; +inp[18979] = 0; +inp[18980] = 5634479; +inp[18981] = 0; +inp[18982] = 5293104; +inp[18983] = 0; +inp[18984] = 4972411; +inp[18985] = 0; +inp[18986] = 4671147; +inp[18987] = 0; +inp[18988] = 4388137; +inp[18989] = 0; +inp[18990] = 4122273; +inp[18991] = 0; +inp[18992] = 3872517; +inp[18993] = 0; +inp[18994] = 3637893; +inp[18995] = 0; +inp[18996] = 3417484; +inp[18997] = 0; +inp[18998] = 3210429; +inp[18999] = 0; +inp[19000] = 3015919; +inp[19001] = 0; +inp[19002] = 2833194; +inp[19003] = 0; +inp[19004] = 2661539; +inp[19005] = 0; +inp[19006] = 2500285; +inp[19007] = 0; +inp[19008] = 2348800; +inp[19009] = 0; +inp[19010] = 2206494; +inp[19011] = 0; +inp[19012] = 2072809; +inp[19013] = 0; +inp[19014] = 1947224; +inp[19015] = 0; +inp[19016] = 1829247; +inp[19017] = 0; +inp[19018] = 1718419; +inp[19019] = 0; +inp[19020] = 1614305; +inp[19021] = 0; +inp[19022] = 1516499; +inp[19023] = 0; +inp[19024] = 1424619; +inp[19025] = 0; +inp[19026] = 1338306; +inp[19027] = 0; +inp[19028] = 1257222; +inp[19029] = 0; +inp[19030] = 1181051; +inp[19031] = 0; +inp[19032] = 1109494; +inp[19033] = 0; +inp[19034] = 1042273; +inp[19035] = 0; +inp[19036] = 979125; +inp[19037] = 0; +inp[19038] = 919803; +inp[19039] = 0; +inp[19040] = 864075; +inp[19041] = 0; +inp[19042] = 811723; +inp[19043] = 0; +inp[19044] = 762543; +inp[19045] = 0; +inp[19046] = 716343; +inp[19047] = 0; +inp[19048] = 672942; +inp[19049] = 0; +inp[19050] = 632171; +inp[19051] = 0; +inp[19052] = 593869; +inp[19053] = 0; +inp[19054] = 557889; +inp[19055] = 0; +inp[19056] = 524088; +inp[19057] = 0; +inp[19058] = 492335; +inp[19059] = 0; +inp[19060] = 462506; +inp[19061] = 0; +inp[19062] = 434484; +inp[19063] = 0; +inp[19064] = 408160; +inp[19065] = 0; +inp[19066] = 383431; +inp[19067] = 0; +inp[19068] = 360200; +inp[19069] = 0; +inp[19070] = 338376; +inp[19071] = 0; +inp[19072] = 317875; +inp[19073] = 0; +inp[19074] = 298616; +inp[19075] = 0; +inp[19076] = 280524; +inp[19077] = 0; +inp[19078] = 263528; +inp[19079] = 0; +inp[19080] = 247561; +inp[19081] = 0; +inp[19082] = 232562; +inp[19083] = 0; +inp[19084] = 218472; +inp[19085] = 0; +inp[19086] = 205235; +inp[19087] = 0; +inp[19088] = 192801; +inp[19089] = 0; +inp[19090] = 181120; +inp[19091] = 0; +inp[19092] = 170146; +inp[19093] = 0; +inp[19094] = 159837; +inp[19095] = 0; +inp[19096] = 150153; +inp[19097] = 0; +inp[19098] = 141056; +inp[19099] = 0; +inp[19100] = 132510; +inp[19101] = 0; +inp[19102] = 124481; +inp[19103] = 0; +inp[19104] = 116939; +inp[19105] = 0; +inp[19106] = 109854; +inp[19107] = 0; +inp[19108] = 103199; +inp[19109] = 0; +inp[19110] = 96946; +inp[19111] = 0; +inp[19112] = 91072; +inp[19113] = 0; +inp[19114] = 85555; +inp[19115] = 0; +inp[19116] = 80371; +inp[19117] = 0; +inp[19118] = 75502; +inp[19119] = 0; +inp[19120] = 70927; +inp[19121] = 0; +inp[19122] = 66630; +inp[19123] = 0; +inp[19124] = 62593; +inp[19125] = 0; +inp[19126] = 58801; +inp[19127] = 0; +inp[19128] = 55238; +inp[19129] = 0; +inp[19130] = 51891; +inp[19131] = 0; +inp[19132] = 48747; +inp[19133] = 0; +inp[19134] = 45794; +inp[19135] = 0; +inp[19136] = 43019; +inp[19137] = 0; +inp[19138] = 40413; +inp[19139] = 0; +inp[19140] = 37964; +inp[19141] = 0; +inp[19142] = 35664; +inp[19143] = 0; +inp[19144] = 33503; +inp[19145] = 0; +inp[19146] = 31473; +inp[19147] = 0; +inp[19148] = 29567; +inp[19149] = 0; +inp[19150] = 27775; +inp[19151] = 0; +inp[19152] = 26092; +inp[19153] = 0; +inp[19154] = 24511; +inp[19155] = 0; +inp[19156] = 23026; +inp[19157] = 0; +inp[19158] = 21631; +inp[19159] = 0; +inp[19160] = 20321; +inp[19161] = 0; +inp[19162] = 19089; +inp[19163] = 0; +inp[19164] = 17933; +inp[19165] = 0; +inp[19166] = 16846; +inp[19167] = 0; +inp[19168] = 15826; +inp[19169] = 0; +inp[19170] = 14867; +inp[19171] = 0; +inp[19172] = 13966; +inp[19173] = 0; +inp[19174] = 13120; +inp[19175] = 0; +inp[19176] = 12325; +inp[19177] = 0; +inp[19178] = 11578; +inp[19179] = 0; +inp[19180] = 10877; +inp[19181] = 0; +inp[19182] = 10218; +inp[19183] = 0; +inp[19184] = 9599; +inp[19185] = 0; +inp[19186] = 9017; +inp[19187] = 0; +inp[19188] = 8471; +inp[19189] = 0; +inp[19190] = 7957; +inp[19191] = 0; +inp[19192] = 7475; +inp[19193] = 0; +inp[19194] = 7022; +inp[19195] = 0; +inp[19196] = 6597; +inp[19197] = 0; +inp[19198] = 6197; +inp[19199] = 0; +inp[19200] = 5822; +inp[19201] = 0; +inp[19202] = 5469; +inp[19203] = 0; +inp[19204] = 5137; +inp[19205] = 0; +inp[19206] = 4826; +inp[19207] = 0; +inp[19208] = 4534; +inp[19209] = 0; +inp[19210] = 4259; +inp[19211] = 0; +inp[19212] = 4001; +inp[19213] = 0; +inp[19214] = 3759; +inp[19215] = 0; +inp[19216] = 3531; +inp[19217] = 0; +inp[19218] = 3317; +inp[19219] = 0; +inp[19220] = 3116; +inp[19221] = 0; +inp[19222] = 2927; +inp[19223] = 0; +inp[19224] = 2750; +inp[19225] = 0; +inp[19226] = 2583; +inp[19227] = 0; +inp[19228] = 2427; +inp[19229] = 0; +inp[19230] = 2279; +inp[19231] = 0; +inp[19232] = 2141; +inp[19233] = 0; +inp[19234] = 2012; +inp[19235] = 0; +inp[19236] = 1890; +inp[19237] = 0; +inp[19238] = 1775; +inp[19239] = 0; +inp[19240] = 1668; +inp[19241] = 0; +inp[19242] = 1566; +inp[19243] = 0; +inp[19244] = 1472; +inp[19245] = 0; +inp[19246] = 1382; +inp[19247] = 0; +inp[19248] = 1299; +inp[19249] = 0; +inp[19250] = 1220; +inp[19251] = 0; +inp[19252] = 1146; +inp[19253] = 0; +inp[19254] = 1076; +inp[19255] = 0; +inp[19256] = 1011; +inp[19257] = 0; +inp[19258] = 950; +inp[19259] = 0; +inp[19260] = 892; +inp[19261] = 0; +inp[19262] = 838; +inp[19263] = 0; +inp[19264] = 787; +inp[19265] = 0; +inp[19266] = 740; +inp[19267] = 0; +inp[19268] = 695; +inp[19269] = 0; +inp[19270] = 653; +inp[19271] = 0; +inp[19272] = 613; +inp[19273] = 0; +inp[19274] = 576; +inp[19275] = 0; +inp[19276] = 541; +inp[19277] = 0; +inp[19278] = 508; +inp[19279] = 0; +inp[19280] = 477; +inp[19281] = 0; +inp[19282] = 448; +inp[19283] = 0; +inp[19284] = 421; +inp[19285] = 0; +inp[19286] = 396; +inp[19287] = 0; +inp[19288] = 372; +inp[19289] = 0; +inp[19290] = 349; +inp[19291] = 0; +inp[19292] = 328; +inp[19293] = 0; +inp[19294] = 308; +inp[19295] = 0; +inp[19296] = 289; +inp[19297] = 0; +inp[19298] = 272; +inp[19299] = 0; +inp[19300] = 255; +inp[19301] = 0; +inp[19302] = 240; +inp[19303] = 0; +inp[19304] = 225; +inp[19305] = 0; +inp[19306] = 212; +inp[19307] = 0; +inp[19308] = 199; +inp[19309] = 0; +inp[19310] = 187; +inp[19311] = 0; +inp[19312] = 175; +inp[19313] = 0; +inp[19314] = 165; +inp[19315] = 0; +inp[19316] = 155; +inp[19317] = 0; +inp[19318] = 145; +inp[19319] = 0; +inp[19320] = 136; +inp[19321] = 0; +inp[19322] = 128; +inp[19323] = 0; +inp[19324] = 1073741824; +inp[19325] = 1073741824; +inp[19326] = 1040706261; +inp[19327] = 0; +inp[19328] = 1008687095; +inp[19329] = 0; +inp[19330] = 977653056; +inp[19331] = 0; +inp[19332] = 947573833; +inp[19333] = 0; +inp[19334] = 918420051; +inp[19335] = 0; +inp[19336] = 890163237; +inp[19337] = 0; +inp[19338] = 862775793; +inp[19339] = 0; +inp[19340] = 836230973; +inp[19341] = 0; +inp[19342] = 810502851; +inp[19343] = 0; +inp[19344] = 785566299; +inp[19345] = 0; +inp[19346] = 761396965; +inp[19347] = 0; +inp[19348] = 737971243; +inp[19349] = 0; +inp[19350] = 715266255; +inp[19351] = 0; +inp[19352] = 693259826; +inp[19353] = 0; +inp[19354] = 671930463; +inp[19355] = 0; +inp[19356] = 651257336; +inp[19357] = 0; +inp[19358] = 631220255; +inp[19359] = 0; +inp[19360] = 611799649; +inp[19361] = 0; +inp[19362] = 592976553; +inp[19363] = 0; +inp[19364] = 574732582; +inp[19365] = 0; +inp[19366] = 557049919; +inp[19367] = 0; +inp[19368] = 539911295; +inp[19369] = 0; +inp[19370] = 523299971; +inp[19371] = 0; +inp[19372] = 507199723; +inp[19373] = 0; +inp[19374] = 491594828; +inp[19375] = 0; +inp[19376] = 476470046; +inp[19377] = 0; +inp[19378] = 461810603; +inp[19379] = 0; +inp[19380] = 447602185; +inp[19381] = 0; +inp[19382] = 433830913; +inp[19383] = 0; +inp[19384] = 420483339; +inp[19385] = 0; +inp[19386] = 407546427; +inp[19387] = 0; +inp[19388] = 395007542; +inp[19389] = 0; +inp[19390] = 382854437; +inp[19391] = 0; +inp[19392] = 371075245; +inp[19393] = 0; +inp[19394] = 359658459; +inp[19395] = 0; +inp[19396] = 348592932; +inp[19397] = 0; +inp[19398] = 337867855; +inp[19399] = 0; +inp[19400] = 327472754; +inp[19401] = 0; +inp[19402] = 317397476; +inp[19403] = 0; +inp[19404] = 307632183; +inp[19405] = 0; +inp[19406] = 298167335; +inp[19407] = 0; +inp[19408] = 288993691; +inp[19409] = 0; +inp[19410] = 280102290; +inp[19411] = 0; +inp[19412] = 271484448; +inp[19413] = 0; +inp[19414] = 263131750; +inp[19415] = 0; +inp[19416] = 255036037; +inp[19417] = 0; +inp[19418] = 247189403; +inp[19419] = 0; +inp[19420] = 239584185; +inp[19421] = 0; +inp[19422] = 232212954; +inp[19423] = 0; +inp[19424] = 225068513; +inp[19425] = 0; +inp[19426] = 218143882; +inp[19427] = 0; +inp[19428] = 211432301; +inp[19429] = 0; +inp[19430] = 204927213; +inp[19431] = 0; +inp[19432] = 198622265; +inp[19433] = 0; +inp[19434] = 192511301; +inp[19435] = 0; +inp[19436] = 186588351; +inp[19437] = 0; +inp[19438] = 180847630; +inp[19439] = 0; +inp[19440] = 175283534; +inp[19441] = 0; +inp[19442] = 169890626; +inp[19443] = 0; +inp[19444] = 164663641; +inp[19445] = 0; +inp[19446] = 159597474; +inp[19447] = 0; +inp[19448] = 154687176; +inp[19449] = 0; +inp[19450] = 149927952; +inp[19451] = 0; +inp[19452] = 145315153; +inp[19453] = 0; +inp[19454] = 140844276; +inp[19455] = 0; +inp[19456] = 136510953; +inp[19457] = 0; +inp[19458] = 132310953; +inp[19459] = 0; +inp[19460] = 128240173; +inp[19461] = 0; +inp[19462] = 124294637; +inp[19463] = 0; +inp[19464] = 120470493; +inp[19465] = 0; +inp[19466] = 116764006; +inp[19467] = 0; +inp[19468] = 113171555; +inp[19469] = 0; +inp[19470] = 109689632; +inp[19471] = 0; +inp[19472] = 106314837; +inp[19473] = 0; +inp[19474] = 103043874; +inp[19475] = 0; +inp[19476] = 99873547; +inp[19477] = 0; +inp[19478] = 96800761; +inp[19479] = 0; +inp[19480] = 93822514; +inp[19481] = 0; +inp[19482] = 90935899; +inp[19483] = 0; +inp[19484] = 88138096; +inp[19485] = 0; +inp[19486] = 85426372; +inp[19487] = 0; +inp[19488] = 82798078; +inp[19489] = 0; +inp[19490] = 80250649; +inp[19491] = 0; +inp[19492] = 77781596; +inp[19493] = 0; +inp[19494] = 75388508; +inp[19495] = 0; +inp[19496] = 73069048; +inp[19497] = 0; +inp[19498] = 70820949; +inp[19499] = 0; +inp[19500] = 68642018; +inp[19501] = 0; +inp[19502] = 66530125; +inp[19503] = 0; +inp[19504] = 64483208; +inp[19505] = 0; +inp[19506] = 62499268; +inp[19507] = 0; +inp[19508] = 60576368; +inp[19509] = 0; +inp[19510] = 58712629; +inp[19511] = 0; +inp[19512] = 56906231; +inp[19513] = 0; +inp[19514] = 55155411; +inp[19515] = 0; +inp[19516] = 53458457; +inp[19517] = 0; +inp[19518] = 51813713; +inp[19519] = 0; +inp[19520] = 50219573; +inp[19521] = 0; +inp[19522] = 48674479; +inp[19523] = 0; +inp[19524] = 47176923; +inp[19525] = 0; +inp[19526] = 45725441; +inp[19527] = 0; +inp[19528] = 44318617; +inp[19529] = 0; +inp[19530] = 42955077; +inp[19531] = 0; +inp[19532] = 41633488; +inp[19533] = 0; +inp[19534] = 40352560; +inp[19535] = 0; +inp[19536] = 39111043; +inp[19537] = 0; +inp[19538] = 37907722; +inp[19539] = 0; +inp[19540] = 36741424; +inp[19541] = 0; +inp[19542] = 35611009; +inp[19543] = 0; +inp[19544] = 34515374; +inp[19545] = 0; +inp[19546] = 33453447; +inp[19547] = 0; +inp[19548] = 32424193; +inp[19549] = 0; +inp[19550] = 31426605; +inp[19551] = 0; +inp[19552] = 30459710; +inp[19553] = 0; +inp[19554] = 29522564; +inp[19555] = 0; +inp[19556] = 28614250; +inp[19557] = 0; +inp[19558] = 27733882; +inp[19559] = 0; +inp[19560] = 26880600; +inp[19561] = 0; +inp[19562] = 26053571; +inp[19563] = 0; +inp[19564] = 25251987; +inp[19565] = 0; +inp[19566] = 24475065; +inp[19567] = 0; +inp[19568] = 23722046; +inp[19569] = 0; +inp[19570] = 22992196; +inp[19571] = 0; +inp[19572] = 22284800; +inp[19573] = 0; +inp[19574] = 21599169; +inp[19575] = 0; +inp[19576] = 20934632; +inp[19577] = 0; +inp[19578] = 20290541; +inp[19579] = 0; +inp[19580] = 19666267; +inp[19581] = 0; +inp[19582] = 19061200; +inp[19583] = 0; +inp[19584] = 18474748; +inp[19585] = 0; +inp[19586] = 17906340; +inp[19587] = 0; +inp[19588] = 17355420; +inp[19589] = 0; +inp[19590] = 16821450; +inp[19591] = 0; +inp[19592] = 16303908; +inp[19593] = 0; +inp[19594] = 15802289; +inp[19595] = 0; +inp[19596] = 15316104; +inp[19597] = 0; +inp[19598] = 14844877; +inp[19599] = 0; +inp[19600] = 14388148; +inp[19601] = 0; +inp[19602] = 13945471; +inp[19603] = 0; +inp[19604] = 13516414; +inp[19605] = 0; +inp[19606] = 13100558; +inp[19607] = 0; +inp[19608] = 12697496; +inp[19609] = 0; +inp[19610] = 12306835; +inp[19611] = 0; +inp[19612] = 11928194; +inp[19613] = 0; +inp[19614] = 11561202; +inp[19615] = 0; +inp[19616] = 11205501; +inp[19617] = 0; +inp[19618] = 10860744; +inp[19619] = 0; +inp[19620] = 10526594; +inp[19621] = 0; +inp[19622] = 10202725; +inp[19623] = 0; +inp[19624] = 9888820; +inp[19625] = 0; +inp[19626] = 9584573; +inp[19627] = 0; +inp[19628] = 9289686; +inp[19629] = 0; +inp[19630] = 9003873; +inp[19631] = 0; +inp[19632] = 8726853; +inp[19633] = 0; +inp[19634] = 8458356; +inp[19635] = 0; +inp[19636] = 8198119; +inp[19637] = 0; +inp[19638] = 7945890; +inp[19639] = 0; +inp[19640] = 7701421; +inp[19641] = 0; +inp[19642] = 7464473; +inp[19643] = 0; +inp[19644] = 7234815; +inp[19645] = 0; +inp[19646] = 7012223; +inp[19647] = 0; +inp[19648] = 6796480; +inp[19649] = 0; +inp[19650] = 6587374; +inp[19651] = 0; +inp[19652] = 6384702; +inp[19653] = 0; +inp[19654] = 6188265; +inp[19655] = 0; +inp[19656] = 5997872; +inp[19657] = 0; +inp[19658] = 5813337; +inp[19659] = 0; +inp[19660] = 5634479; +inp[19661] = 0; +inp[19662] = 5461125; +inp[19663] = 0; +inp[19664] = 5293104; +inp[19665] = 0; +inp[19666] = 5130252; +inp[19667] = 0; +inp[19668] = 4972411; +inp[19669] = 0; +inp[19670] = 4819426; +inp[19671] = 0; +inp[19672] = 4671147; +inp[19673] = 0; +inp[19674] = 4527431; +inp[19675] = 0; +inp[19676] = 4388137; +inp[19677] = 0; +inp[19678] = 4253128; +inp[19679] = 0; +inp[19680] = 4122273; +inp[19681] = 0; +inp[19682] = 3995444; +inp[19683] = 0; +inp[19684] = 3872517; +inp[19685] = 0; +inp[19686] = 3753372; +inp[19687] = 0; +inp[19688] = 3637893; +inp[19689] = 0; +inp[19690] = 3525967; +inp[19691] = 0; +inp[19692] = 3417484; +inp[19693] = 0; +inp[19694] = 3312339; +inp[19695] = 0; +inp[19696] = 3210429; +inp[19697] = 0; +inp[19698] = 3111655; +inp[19699] = 0; +inp[19700] = 3015919; +inp[19701] = 0; +inp[19702] = 2923129; +inp[19703] = 0; +inp[19704] = 2833194; +inp[19705] = 0; +inp[19706] = 2746026; +inp[19707] = 0; +inp[19708] = 2661539; +inp[19709] = 0; +inp[19710] = 2579652; +inp[19711] = 0; +inp[19712] = 2500285; +inp[19713] = 0; +inp[19714] = 2423359; +inp[19715] = 0; +inp[19716] = 2348800; +inp[19717] = 0; +inp[19718] = 2276535; +inp[19719] = 0; +inp[19720] = 2206494; +inp[19721] = 0; +inp[19722] = 2138607; +inp[19723] = 0; +inp[19724] = 2072809; +inp[19725] = 0; +inp[19726] = 2009035; +inp[19727] = 0; +inp[19728] = 1947224; +inp[19729] = 0; +inp[19730] = 1887314; +inp[19731] = 0; +inp[19732] = 1829247; +inp[19733] = 0; +inp[19734] = 1772967; +inp[19735] = 0; +inp[19736] = 1718419; +inp[19737] = 0; +inp[19738] = 1665549; +inp[19739] = 0; +inp[19740] = 1614305; +inp[19741] = 0; +inp[19742] = 1564638; +inp[19743] = 0; +inp[19744] = 1516499; +inp[19745] = 0; +inp[19746] = 1469841; +inp[19747] = 0; +inp[19748] = 1424619; +inp[19749] = 0; +inp[19750] = 1380788; +inp[19751] = 0; +inp[19752] = 1338306; +inp[19753] = 0; +inp[19754] = 1297130; +inp[19755] = 0; +inp[19756] = 1257222; +inp[19757] = 0; +inp[19758] = 1218541; +inp[19759] = 0; +inp[19760] = 1181051; +inp[19761] = 0; +inp[19762] = 1144714; +inp[19763] = 0; +inp[19764] = 1109494; +inp[19765] = 0; +inp[19766] = 1075359; +inp[19767] = 0; +inp[19768] = 1042273; +inp[19769] = 0; +inp[19770] = 1010206; +inp[19771] = 0; +inp[19772] = 979125; +inp[19773] = 0; +inp[19774] = 949001; +inp[19775] = 0; +inp[19776] = 919803; +inp[19777] = 0; +inp[19778] = 891504; +inp[19779] = 0; +inp[19780] = 864075; +inp[19781] = 0; +inp[19782] = 837490; +inp[19783] = 0; +inp[19784] = 811723; +inp[19785] = 0; +inp[19786] = 786749; +inp[19787] = 0; +inp[19788] = 762543; +inp[19789] = 0; +inp[19790] = 739082; +inp[19791] = 0; +inp[19792] = 716343; +inp[19793] = 0; +inp[19794] = 694304; +inp[19795] = 0; +inp[19796] = 672942; +inp[19797] = 0; +inp[19798] = 652238; +inp[19799] = 0; +inp[19800] = 632171; +inp[19801] = 0; +inp[19802] = 612721; +inp[19803] = 0; +inp[19804] = 593869; +inp[19805] = 0; +inp[19806] = 575598; +inp[19807] = 0; +inp[19808] = 557889; +inp[19809] = 0; +inp[19810] = 540724; +inp[19811] = 0; +inp[19812] = 524088; +inp[19813] = 0; +inp[19814] = 507963; +inp[19815] = 0; +inp[19816] = 492335; +inp[19817] = 0; +inp[19818] = 477187; +inp[19819] = 0; +inp[19820] = 462506; +inp[19821] = 0; +inp[19822] = 448276; +inp[19823] = 0; +inp[19824] = 434484; +inp[19825] = 0; +inp[19826] = 421116; +inp[19827] = 0; +inp[19828] = 408160; +inp[19829] = 0; +inp[19830] = 395602; +inp[19831] = 0; +inp[19832] = 383431; +inp[19833] = 0; +inp[19834] = 371634; +inp[19835] = 0; +inp[19836] = 1073741824; +inp[19837] = 1073741824; +inp[19838] = 1057094999; +inp[19839] = 0; +inp[19840] = 1040706261; +inp[19841] = 0; +inp[19842] = 1024571605; +inp[19843] = 0; +inp[19844] = 1008687095; +inp[19845] = 0; +inp[19846] = 993048851; +inp[19847] = 0; +inp[19848] = 977653056; +inp[19849] = 0; +inp[19850] = 962495950; +inp[19851] = 0; +inp[19852] = 947573833; +inp[19853] = 0; +inp[19854] = 932883063; +inp[19855] = 0; +inp[19856] = 918420051; +inp[19857] = 0; +inp[19858] = 904181268; +inp[19859] = 0; +inp[19860] = 890163237; +inp[19861] = 0; +inp[19862] = 876362535; +inp[19863] = 0; +inp[19864] = 862775793; +inp[19865] = 0; +inp[19866] = 849399695; +inp[19867] = 0; +inp[19868] = 836230973; +inp[19869] = 0; +inp[19870] = 823266413; +inp[19871] = 0; +inp[19872] = 810502851; +inp[19873] = 0; +inp[19874] = 797937169; +inp[19875] = 0; +inp[19876] = 785566299; +inp[19877] = 0; +inp[19878] = 773387223; +inp[19879] = 0; +inp[19880] = 761396965; +inp[19881] = 0; +inp[19882] = 749592599; +inp[19883] = 0; +inp[19884] = 737971243; +inp[19885] = 0; +inp[19886] = 726530060; +inp[19887] = 0; +inp[19888] = 715266255; +inp[19889] = 0; +inp[19890] = 704177080; +inp[19891] = 0; +inp[19892] = 693259826; +inp[19893] = 0; +inp[19894] = 682511829; +inp[19895] = 0; +inp[19896] = 671930463; +inp[19897] = 0; +inp[19898] = 661513147; +inp[19899] = 0; +inp[19900] = 651257336; +inp[19901] = 0; +inp[19902] = 641160527; +inp[19903] = 0; +inp[19904] = 631220255; +inp[19905] = 0; +inp[19906] = 621434092; +inp[19907] = 0; +inp[19908] = 611799649; +inp[19909] = 0; +inp[19910] = 602314575; +inp[19911] = 0; +inp[19912] = 592976553; +inp[19913] = 0; +inp[19914] = 583783303; +inp[19915] = 0; +inp[19916] = 574732582; +inp[19917] = 0; +inp[19918] = 565822179; +inp[19919] = 0; +inp[19920] = 557049919; +inp[19921] = 0; +inp[19922] = 548413661; +inp[19923] = 0; +inp[19924] = 539911295; +inp[19925] = 0; +inp[19926] = 531540746; +inp[19927] = 0; +inp[19928] = 523299971; +inp[19929] = 0; +inp[19930] = 515186957; +inp[19931] = 0; +inp[19932] = 507199723; +inp[19933] = 0; +inp[19934] = 499336321; +inp[19935] = 0; +inp[19936] = 491594828; +inp[19937] = 0; +inp[19938] = 483973357; +inp[19939] = 0; +inp[19940] = 476470046; +inp[19941] = 0; +inp[19942] = 469083062; +inp[19943] = 0; +inp[19944] = 461810603; +inp[19945] = 0; +inp[19946] = 454650894; +inp[19947] = 0; +inp[19948] = 447602185; +inp[19949] = 0; +inp[19950] = 440662756; +inp[19951] = 0; +inp[19952] = 433830913; +inp[19953] = 0; +inp[19954] = 427104988; +inp[19955] = 0; +inp[19956] = 420483339; +inp[19957] = 0; +inp[19958] = 413964349; +inp[19959] = 0; +inp[19960] = 407546427; +inp[19961] = 0; +inp[19962] = 401228005; +inp[19963] = 0; +inp[19964] = 395007542; +inp[19965] = 0; +inp[19966] = 388883517; +inp[19967] = 0; +inp[19968] = 382854437; +inp[19969] = 0; +inp[19970] = 376918829; +inp[19971] = 0; +inp[19972] = 371075245; +inp[19973] = 0; +inp[19974] = 365322256; +inp[19975] = 0; +inp[19976] = 359658459; +inp[19977] = 0; +inp[19978] = 354082472; +inp[19979] = 0; +inp[19980] = 348592932; +inp[19981] = 0; +inp[19982] = 343188499; +inp[19983] = 0; +inp[19984] = 337867855; +inp[19985] = 0; +inp[19986] = 332629699; +inp[19987] = 0; +inp[19988] = 327472754; +inp[19989] = 0; +inp[19990] = 322395759; +inp[19991] = 0; +inp[19992] = 317397476; +inp[19993] = 0; +inp[19994] = 312476685; +inp[19995] = 0; +inp[19996] = 307632183; +inp[19997] = 0; +inp[19998] = 302862788; +inp[19999] = 0; +inp[20000] = 298167335; +inp[20001] = 0; +inp[20002] = 293544679; +inp[20003] = 0; +inp[20004] = 288993691; +inp[20005] = 0; +inp[20006] = 284513259; +inp[20007] = 0; +inp[20008] = 280102290; +inp[20009] = 0; +inp[20010] = 275759706; +inp[20011] = 0; +inp[20012] = 271484448; +inp[20013] = 0; +inp[20014] = 267275472; +inp[20015] = 0; +inp[20016] = 263131750; +inp[20017] = 0; +inp[20018] = 259052270; +inp[20019] = 0; +inp[20020] = 255036037; +inp[20021] = 0; +inp[20022] = 251082070; +inp[20023] = 0; +inp[20024] = 247189403; +inp[20025] = 0; +inp[20026] = 243357087; +inp[20027] = 0; +inp[20028] = 239584185; +inp[20029] = 0; +inp[20030] = 235869776; +inp[20031] = 0; +inp[20032] = 232212954; +inp[20033] = 0; +inp[20034] = 228612826; +inp[20035] = 0; +inp[20036] = 225068513; +inp[20037] = 0; +inp[20038] = 221579149; +inp[20039] = 0; +inp[20040] = 218143882; +inp[20041] = 0; +inp[20042] = 214761875; +inp[20043] = 0; +inp[20044] = 211432301; +inp[20045] = 0; +inp[20046] = 208154347; +inp[20047] = 0; +inp[20048] = 204927213; +inp[20049] = 0; +inp[20050] = 201750111; +inp[20051] = 0; +inp[20052] = 198622265; +inp[20053] = 0; +inp[20054] = 195542912; +inp[20055] = 0; +inp[20056] = 192511301; +inp[20057] = 0; +inp[20058] = 189526689; +inp[20059] = 0; +inp[20060] = 186588351; +inp[20061] = 0; +inp[20062] = 183695566; +inp[20063] = 0; +inp[20064] = 180847630; +inp[20065] = 0; +inp[20066] = 178043848; +inp[20067] = 0; +inp[20068] = 175283534; +inp[20069] = 0; +inp[20070] = 172566014; +inp[20071] = 0; +inp[20072] = 169890626; +inp[20073] = 0; +inp[20074] = 167256716; +inp[20075] = 0; +inp[20076] = 164663641; +inp[20077] = 0; +inp[20078] = 162110768; +inp[20079] = 0; +inp[20080] = 159597474; +inp[20081] = 0; +inp[20082] = 157123144; +inp[20083] = 0; +inp[20084] = 154687176; +inp[20085] = 0; +inp[20086] = 152288973; +inp[20087] = 0; +inp[20088] = 149927952; +inp[20089] = 0; +inp[20090] = 147603534; +inp[20091] = 0; +inp[20092] = 145315153; +inp[20093] = 0; +inp[20094] = 143062251; +inp[20095] = 0; +inp[20096] = 140844276; +inp[20097] = 0; +inp[20098] = 138660688; +inp[20099] = 0; +inp[20100] = 136510953; +inp[20101] = 0; +inp[20102] = 134394547; +inp[20103] = 0; +inp[20104] = 132310953; +inp[20105] = 0; +inp[20106] = 130259662; +inp[20107] = 0; +inp[20108] = 128240173; +inp[20109] = 0; +inp[20110] = 126251993; +inp[20111] = 0; +inp[20112] = 124294637; +inp[20113] = 0; +inp[20114] = 122367628; +inp[20115] = 0; +inp[20116] = 120470493; +inp[20117] = 0; +inp[20118] = 118602771; +inp[20119] = 0; +inp[20120] = 116764006; +inp[20121] = 0; +inp[20122] = 114953748; +inp[20123] = 0; +inp[20124] = 113171555; +inp[20125] = 0; +inp[20126] = 111416993; +inp[20127] = 0; +inp[20128] = 109689632; +inp[20129] = 0; +inp[20130] = 107989052; +inp[20131] = 0; +inp[20132] = 106314837; +inp[20133] = 0; +inp[20134] = 104666578; +inp[20135] = 0; +inp[20136] = 103043874; +inp[20137] = 0; +inp[20138] = 101446326; +inp[20139] = 0; +inp[20140] = 99873547; +inp[20141] = 0; +inp[20142] = 98325151; +inp[20143] = 0; +inp[20144] = 96800761; +inp[20145] = 0; +inp[20146] = 95300004; +inp[20147] = 0; +inp[20148] = 93822514; +inp[20149] = 0; +inp[20150] = 92367931; +inp[20151] = 0; +inp[20152] = 90935899; +inp[20153] = 0; +inp[20154] = 89526069; +inp[20155] = 0; +inp[20156] = 88138096; +inp[20157] = 0; +inp[20158] = 86771641; +inp[20159] = 0; +inp[20160] = 85426372; +inp[20161] = 0; +inp[20162] = 84101958; +inp[20163] = 0; +inp[20164] = 82798078; +inp[20165] = 0; +inp[20166] = 81514413; +inp[20167] = 0; +inp[20168] = 80250649; +inp[20169] = 0; +inp[20170] = 79006478; +inp[20171] = 0; +inp[20172] = 77781596; +inp[20173] = 0; +inp[20174] = 76575704; +inp[20175] = 0; +inp[20176] = 75388508; +inp[20177] = 0; +inp[20178] = 74219718; +inp[20179] = 0; +inp[20180] = 73069048; +inp[20181] = 0; +inp[20182] = 71936217; +inp[20183] = 0; +inp[20184] = 70820949; +inp[20185] = 0; +inp[20186] = 69722972; +inp[20187] = 0; +inp[20188] = 68642018; +inp[20189] = 0; +inp[20190] = 67577822; +inp[20191] = 0; +inp[20192] = 66530125; +inp[20193] = 0; +inp[20194] = 65498671; +inp[20195] = 0; +inp[20196] = 64483208; +inp[20197] = 0; +inp[20198] = 63483489; +inp[20199] = 0; +inp[20200] = 62499268; +inp[20201] = 0; +inp[20202] = 61530307; +inp[20203] = 0; +inp[20204] = 60576368; +inp[20205] = 0; +inp[20206] = 59637218; +inp[20207] = 0; +inp[20208] = 58712629; +inp[20209] = 0; +inp[20210] = 57802374; +inp[20211] = 0; +inp[20212] = 56906231; +inp[20213] = 0; +inp[20214] = 56023982; +inp[20215] = 0; +inp[20216] = 55155411; +inp[20217] = 0; +inp[20218] = 54300305; +inp[20219] = 0; +inp[20220] = 53458457; +inp[20221] = 0; +inp[20222] = 52629661; +inp[20223] = 0; +inp[20224] = 51813713; +inp[20225] = 0; +inp[20226] = 51010416; +inp[20227] = 0; +inp[20228] = 50219573; +inp[20229] = 0; +inp[20230] = 49440991; +inp[20231] = 0; +inp[20232] = 48674479; +inp[20233] = 0; +inp[20234] = 47919851; +inp[20235] = 0; +inp[20236] = 47176923; +inp[20237] = 0; +inp[20238] = 46445512; +inp[20239] = 0; +inp[20240] = 45725441; +inp[20241] = 0; +inp[20242] = 45016534; +inp[20243] = 0; +inp[20244] = 44318617; +inp[20245] = 0; +inp[20246] = 43631521; +inp[20247] = 0; +inp[20248] = 42955077; +inp[20249] = 0; +inp[20250] = 42289120; +inp[20251] = 0; +inp[20252] = 41633488; +inp[20253] = 0; +inp[20254] = 40988021; +inp[20255] = 0; +inp[20256] = 40352560; +inp[20257] = 0; +inp[20258] = 39726952; +inp[20259] = 0; +inp[20260] = 39111043; +inp[20261] = 0; +inp[20262] = 38504682; +inp[20263] = 0; +inp[20264] = 37907722; +inp[20265] = 0; +inp[20266] = 37320018; +inp[20267] = 0; +inp[20268] = 36741424; +inp[20269] = 0; +inp[20270] = 36171801; +inp[20271] = 0; +inp[20272] = 35611009; +inp[20273] = 0; +inp[20274] = 35058912; +inp[20275] = 0; +inp[20276] = 34515374; +inp[20277] = 0; +inp[20278] = 33980263; +inp[20279] = 0; +inp[20280] = 33453447; +inp[20281] = 0; +inp[20282] = 32934800; +inp[20283] = 0; +inp[20284] = 32424193; +inp[20285] = 0; +inp[20286] = 31921503; +inp[20287] = 0; +inp[20288] = 31426605; +inp[20289] = 0; +inp[20290] = 30939381; +inp[20291] = 0; +inp[20292] = 30459710; +inp[20293] = 0; +inp[20294] = 29987476; +inp[20295] = 0; +inp[20296] = 29522564; +inp[20297] = 0; +inp[20298] = 29064859; +inp[20299] = 0; +inp[20300] = 28614250; +inp[20301] = 0; +inp[20302] = 28170627; +inp[20303] = 0; +inp[20304] = 27733882; +inp[20305] = 0; +inp[20306] = 27303908; +inp[20307] = 0; +inp[20308] = 26880600; +inp[20309] = 0; +inp[20310] = 26463855; +inp[20311] = 0; +inp[20312] = 26053571; +inp[20313] = 0; +inp[20314] = 25649648; +inp[20315] = 0; +inp[20316] = 25251987; +inp[20317] = 0; +inp[20318] = 24860491; +inp[20319] = 0; +inp[20320] = 24475065; +inp[20321] = 0; +inp[20322] = 24095614; +inp[20323] = 0; +inp[20324] = 23722046; +inp[20325] = 0; +inp[20326] = 23354270; +inp[20327] = 0; +inp[20328] = 22992196; +inp[20329] = 0; +inp[20330] = 22635735; +inp[20331] = 0; +inp[20332] = 22284800; +inp[20333] = 0; +inp[20334] = 21939306; +inp[20335] = 0; +inp[20336] = 21599169; +inp[20337] = 0; +inp[20338] = 21264305; +inp[20339] = 0; +inp[20340] = 20934632; +inp[20341] = 0; +inp[20342] = 20610071; +inp[20343] = 0; +inp[20344] = 20290541; +inp[20345] = 0; +inp[20346] = 19975966; +inp[20347] = 0; +inp[20348] = 1073741824; +inp[20349] = 1073741824; +inp[20350] = 1065385898; +inp[20351] = 0; +inp[20352] = 1057094999; +inp[20353] = 0; +inp[20354] = 1048868621; +inp[20355] = 0; +inp[20356] = 1040706261; +inp[20357] = 0; +inp[20358] = 1032607420; +inp[20359] = 0; +inp[20360] = 1024571605; +inp[20361] = 0; +inp[20362] = 1016598326; +inp[20363] = 0; +inp[20364] = 1008687095; +inp[20365] = 0; +inp[20366] = 1000837430; +inp[20367] = 0; +inp[20368] = 993048851; +inp[20369] = 0; +inp[20370] = 985320884; +inp[20371] = 0; +inp[20372] = 977653056; +inp[20373] = 0; +inp[20374] = 970044899; +inp[20375] = 0; +inp[20376] = 962495950; +inp[20377] = 0; +inp[20378] = 955005747; +inp[20379] = 0; +inp[20380] = 947573833; +inp[20381] = 0; +inp[20382] = 940199755; +inp[20383] = 0; +inp[20384] = 932883063; +inp[20385] = 0; +inp[20386] = 925623309; +inp[20387] = 0; +inp[20388] = 918420051; +inp[20389] = 0; +inp[20390] = 911272850; +inp[20391] = 0; +inp[20392] = 904181268; +inp[20393] = 0; +inp[20394] = 897144874; +inp[20395] = 0; +inp[20396] = 890163237; +inp[20397] = 0; +inp[20398] = 883235932; +inp[20399] = 0; +inp[20400] = 876362535; +inp[20401] = 0; +inp[20402] = 869542628; +inp[20403] = 0; +inp[20404] = 862775793; +inp[20405] = 0; +inp[20406] = 856061619; +inp[20407] = 0; +inp[20408] = 849399695; +inp[20409] = 0; +inp[20410] = 842789614; +inp[20411] = 0; +inp[20412] = 836230973; +inp[20413] = 0; +inp[20414] = 829723372; +inp[20415] = 0; +inp[20416] = 823266413; +inp[20417] = 0; +inp[20418] = 816859703; +inp[20419] = 0; +inp[20420] = 810502851; +inp[20421] = 0; +inp[20422] = 804195467; +inp[20423] = 0; +inp[20424] = 797937169; +inp[20425] = 0; +inp[20426] = 791727572; +inp[20427] = 0; +inp[20428] = 785566299; +inp[20429] = 0; +inp[20430] = 779452974; +inp[20431] = 0; +inp[20432] = 773387223; +inp[20433] = 0; +inp[20434] = 767368676; +inp[20435] = 0; +inp[20436] = 761396965; +inp[20437] = 0; +inp[20438] = 755471727; +inp[20439] = 0; +inp[20440] = 749592599; +inp[20441] = 0; +inp[20442] = 743759224; +inp[20443] = 0; +inp[20444] = 737971243; +inp[20445] = 0; +inp[20446] = 732228306; +inp[20447] = 0; +inp[20448] = 726530060; +inp[20449] = 0; +inp[20450] = 720876158; +inp[20451] = 0; +inp[20452] = 715266255; +inp[20453] = 0; +inp[20454] = 709700009; +inp[20455] = 0; +inp[20456] = 704177080; +inp[20457] = 0; +inp[20458] = 698697130; +inp[20459] = 0; +inp[20460] = 693259826; +inp[20461] = 0; +inp[20462] = 687864835; +inp[20463] = 0; +inp[20464] = 682511829; +inp[20465] = 0; +inp[20466] = 677200479; +inp[20467] = 0; +inp[20468] = 671930463; +inp[20469] = 0; +inp[20470] = 666701459; +inp[20471] = 0; +inp[20472] = 661513147; +inp[20473] = 0; +inp[20474] = 656365211; +inp[20475] = 0; +inp[20476] = 651257336; +inp[20477] = 0; +inp[20478] = 646189212; +inp[20479] = 0; +inp[20480] = 641160527; +inp[20481] = 0; +inp[20482] = 636170976; +inp[20483] = 0; +inp[20484] = 631220255; +inp[20485] = 0; +inp[20486] = 626308060; +inp[20487] = 0; +inp[20488] = 621434092; +inp[20489] = 0; +inp[20490] = 616598053; +inp[20491] = 0; +inp[20492] = 611799649; +inp[20493] = 0; +inp[20494] = 607038586; +inp[20495] = 0; +inp[20496] = 602314575; +inp[20497] = 0; +inp[20498] = 597627325; +inp[20499] = 0; +inp[20500] = 592976553; +inp[20501] = 0; +inp[20502] = 588361972; +inp[20503] = 0; +inp[20504] = 583783303; +inp[20505] = 0; +inp[20506] = 579240266; +inp[20507] = 0; +inp[20508] = 574732582; +inp[20509] = 0; +inp[20510] = 570259978; +inp[20511] = 0; +inp[20512] = 565822179; +inp[20513] = 0; +inp[20514] = 561418916; +inp[20515] = 0; +inp[20516] = 557049919; +inp[20517] = 0; +inp[20518] = 552714923; +inp[20519] = 0; +inp[20520] = 548413661; +inp[20521] = 0; +inp[20522] = 544145872; +inp[20523] = 0; +inp[20524] = 539911295; +inp[20525] = 0; +inp[20526] = 535709672; +inp[20527] = 0; +inp[20528] = 531540746; +inp[20529] = 0; +inp[20530] = 527404264; +inp[20531] = 0; +inp[20532] = 523299971; +inp[20533] = 0; +inp[20534] = 519227618; +inp[20535] = 0; +inp[20536] = 515186957; +inp[20537] = 0; +inp[20538] = 511177740; +inp[20539] = 0; +inp[20540] = 507199723; +inp[20541] = 0; +inp[20542] = 503252664; +inp[20543] = 0; +inp[20544] = 499336321; +inp[20545] = 0; +inp[20546] = 495450454; +inp[20547] = 0; +inp[20548] = 491594828; +inp[20549] = 0; +inp[20550] = 487769207; +inp[20551] = 0; +inp[20552] = 483973357; +inp[20553] = 0; +inp[20554] = 480207047; +inp[20555] = 0; +inp[20556] = 476470046; +inp[20557] = 0; +inp[20558] = 472762126; +inp[20559] = 0; +inp[20560] = 469083062; +inp[20561] = 0; +inp[20562] = 465432629; +inp[20563] = 0; +inp[20564] = 461810603; +inp[20565] = 0; +inp[20566] = 458216765; +inp[20567] = 0; +inp[20568] = 454650894; +inp[20569] = 0; +inp[20570] = 451112772; +inp[20571] = 0; +inp[20572] = 447602185; +inp[20573] = 0; +inp[20574] = 444118917; +inp[20575] = 0; +inp[20576] = 440662756; +inp[20577] = 0; +inp[20578] = 437233491; +inp[20579] = 0; +inp[20580] = 433830913; +inp[20581] = 0; +inp[20582] = 430454814; +inp[20583] = 0; +inp[20584] = 427104988; +inp[20585] = 0; +inp[20586] = 423781231; +inp[20587] = 0; +inp[20588] = 420483339; +inp[20589] = 0; +inp[20590] = 417211112; +inp[20591] = 0; +inp[20592] = 413964349; +inp[20593] = 0; +inp[20594] = 410742853; +inp[20595] = 0; +inp[20596] = 407546427; +inp[20597] = 0; +inp[20598] = 404374876; +inp[20599] = 0; +inp[20600] = 401228005; +inp[20601] = 0; +inp[20602] = 398105624; +inp[20603] = 0; +inp[20604] = 395007542; +inp[20605] = 0; +inp[20606] = 391933569; +inp[20607] = 0; +inp[20608] = 388883517; +inp[20609] = 0; +inp[20610] = 385857202; +inp[20611] = 0; +inp[20612] = 382854437; +inp[20613] = 0; +inp[20614] = 379875040; +inp[20615] = 0; +inp[20616] = 376918829; +inp[20617] = 0; +inp[20618] = 373985624; +inp[20619] = 0; +inp[20620] = 371075245; +inp[20621] = 0; +inp[20622] = 368187514; +inp[20623] = 0; +inp[20624] = 365322256; +inp[20625] = 0; +inp[20626] = 362479296; +inp[20627] = 0; +inp[20628] = 359658459; +inp[20629] = 0; +inp[20630] = 356859575; +inp[20631] = 0; +inp[20632] = 354082472; +inp[20633] = 0; +inp[20634] = 351326980; +inp[20635] = 0; +inp[20636] = 348592932; +inp[20637] = 0; +inp[20638] = 345880160; +inp[20639] = 0; +inp[20640] = 343188499; +inp[20641] = 0; +inp[20642] = 340517785; +inp[20643] = 0; +inp[20644] = 337867855; +inp[20645] = 0; +inp[20646] = 335238546; +inp[20647] = 0; +inp[20648] = 332629699; +inp[20649] = 0; +inp[20650] = 330041155; +inp[20651] = 0; +inp[20652] = 327472754; +inp[20653] = 0; +inp[20654] = 324924341; +inp[20655] = 0; +inp[20656] = 322395759; +inp[20657] = 0; +inp[20658] = 319886856; +inp[20659] = 0; +inp[20660] = 317397476; +inp[20661] = 0; +inp[20662] = 314927470; +inp[20663] = 0; +inp[20664] = 312476685; +inp[20665] = 0; +inp[20666] = 310044972; +inp[20667] = 0; +inp[20668] = 307632183; +inp[20669] = 0; +inp[20670] = 305238170; +inp[20671] = 0; +inp[20672] = 302862788; +inp[20673] = 0; +inp[20674] = 300505891; +inp[20675] = 0; +inp[20676] = 298167335; +inp[20677] = 0; +inp[20678] = 295846979; +inp[20679] = 0; +inp[20680] = 293544679; +inp[20681] = 0; +inp[20682] = 291260297; +inp[20683] = 0; +inp[20684] = 288993691; +inp[20685] = 0; +inp[20686] = 286744724; +inp[20687] = 0; +inp[20688] = 284513259; +inp[20689] = 0; +inp[20690] = 282299159; +inp[20691] = 0; +inp[20692] = 280102290; +inp[20693] = 0; +inp[20694] = 277922516; +inp[20695] = 0; +inp[20696] = 275759706; +inp[20697] = 0; +inp[20698] = 273613727; +inp[20699] = 0; +inp[20700] = 271484448; +inp[20701] = 0; +inp[20702] = 269371740; +inp[20703] = 0; +inp[20704] = 267275472; +inp[20705] = 0; +inp[20706] = 265195518; +inp[20707] = 0; +inp[20708] = 263131750; +inp[20709] = 0; +inp[20710] = 261084042; +inp[20711] = 0; +inp[20712] = 259052270; +inp[20713] = 0; +inp[20714] = 257036309; +inp[20715] = 0; +inp[20716] = 255036037; +inp[20717] = 0; +inp[20718] = 253051331; +inp[20719] = 0; +inp[20720] = 251082070; +inp[20721] = 0; +inp[20722] = 249128134; +inp[20723] = 0; +inp[20724] = 247189403; +inp[20725] = 0; +inp[20726] = 245265760; +inp[20727] = 0; +inp[20728] = 243357087; +inp[20729] = 0; +inp[20730] = 241463267; +inp[20731] = 0; +inp[20732] = 239584185; +inp[20733] = 0; +inp[20734] = 237719726; +inp[20735] = 0; +inp[20736] = 235869776; +inp[20737] = 0; +inp[20738] = 234034223; +inp[20739] = 0; +inp[20740] = 232212954; +inp[20741] = 0; +inp[20742] = 230405859; +inp[20743] = 0; +inp[20744] = 228612826; +inp[20745] = 0; +inp[20746] = 226833747; +inp[20747] = 0; +inp[20748] = 225068513; +inp[20749] = 0; +inp[20750] = 223317016; +inp[20751] = 0; +inp[20752] = 221579149; +inp[20753] = 0; +inp[20754] = 219854806; +inp[20755] = 0; +inp[20756] = 218143882; +inp[20757] = 0; +inp[20758] = 216446273; +inp[20759] = 0; +inp[20760] = 214761875; +inp[20761] = 0; +inp[20762] = 213090585; +inp[20763] = 0; +inp[20764] = 211432301; +inp[20765] = 0; +inp[20766] = 209786922; +inp[20767] = 0; +inp[20768] = 208154347; +inp[20769] = 0; +inp[20770] = 206534477; +inp[20771] = 0; +inp[20772] = 204927213; +inp[20773] = 0; +inp[20774] = 203332457; +inp[20775] = 0; +inp[20776] = 201750111; +inp[20777] = 0; +inp[20778] = 200180079; +inp[20779] = 0; +inp[20780] = 198622265; +inp[20781] = 0; +inp[20782] = 197076575; +inp[20783] = 0; +inp[20784] = 195542912; +inp[20785] = 0; +inp[20786] = 194021185; +inp[20787] = 0; +inp[20788] = 192511301; +inp[20789] = 0; +inp[20790] = 191013166; +inp[20791] = 0; +inp[20792] = 189526689; +inp[20793] = 0; +inp[20794] = 188051781; +inp[20795] = 0; +inp[20796] = 186588351; +inp[20797] = 0; +inp[20798] = 185136308; +inp[20799] = 0; +inp[20800] = 183695566; +inp[20801] = 0; +inp[20802] = 182266036; +inp[20803] = 0; +inp[20804] = 180847630; +inp[20805] = 0; +inp[20806] = 179440263; +inp[20807] = 0; +inp[20808] = 178043848; +inp[20809] = 0; +inp[20810] = 176658300; +inp[20811] = 0; +inp[20812] = 175283534; +inp[20813] = 0; +inp[20814] = 173919467; +inp[20815] = 0; +inp[20816] = 172566014; +inp[20817] = 0; +inp[20818] = 171223095; +inp[20819] = 0; +inp[20820] = 169890626; +inp[20821] = 0; +inp[20822] = 168568527; +inp[20823] = 0; +inp[20824] = 167256716; +inp[20825] = 0; +inp[20826] = 165955114; +inp[20827] = 0; +inp[20828] = 164663641; +inp[20829] = 0; +inp[20830] = 163382219; +inp[20831] = 0; +inp[20832] = 162110768; +inp[20833] = 0; +inp[20834] = 160849212; +inp[20835] = 0; +inp[20836] = 159597474; +inp[20837] = 0; +inp[20838] = 158355476; +inp[20839] = 0; +inp[20840] = 157123144; +inp[20841] = 0; +inp[20842] = 155900402; +inp[20843] = 0; +inp[20844] = 154687176; +inp[20845] = 0; +inp[20846] = 153483390; +inp[20847] = 0; +inp[20848] = 152288973; +inp[20849] = 0; +inp[20850] = 151103851; +inp[20851] = 0; +inp[20852] = 149927952; +inp[20853] = 0; +inp[20854] = 148761203; +inp[20855] = 0; +inp[20856] = 147603534; +inp[20857] = 0; +inp[20858] = 146454874; +inp[20859] = 0; +inp[20860] = 1073741824; +inp[20861] = 1073741824; +inp[20862] = 1069555701; +inp[20863] = 0; +inp[20864] = 1065385898; +inp[20865] = 0; +inp[20866] = 1061232352; +inp[20867] = 0; +inp[20868] = 1057094999; +inp[20869] = 0; +inp[20870] = 1052973777; +inp[20871] = 0; +inp[20872] = 1048868621; +inp[20873] = 0; +inp[20874] = 1044779470; +inp[20875] = 0; +inp[20876] = 1040706261; +inp[20877] = 0; +inp[20878] = 1036648931; +inp[20879] = 0; +inp[20880] = 1032607420; +inp[20881] = 0; +inp[20882] = 1028581665; +inp[20883] = 0; +inp[20884] = 1024571605; +inp[20885] = 0; +inp[20886] = 1020577179; +inp[20887] = 0; +inp[20888] = 1016598326; +inp[20889] = 0; +inp[20890] = 1012634985; +inp[20891] = 0; +inp[20892] = 1008687095; +inp[20893] = 0; +inp[20894] = 1004754597; +inp[20895] = 0; +inp[20896] = 1000837430; +inp[20897] = 0; +inp[20898] = 996935534; +inp[20899] = 0; +inp[20900] = 993048851; +inp[20901] = 0; +inp[20902] = 989177321; +inp[20903] = 0; +inp[20904] = 985320884; +inp[20905] = 0; +inp[20906] = 981479482; +inp[20907] = 0; +inp[20908] = 977653056; +inp[20909] = 0; +inp[20910] = 973841548; +inp[20911] = 0; +inp[20912] = 970044899; +inp[20913] = 0; +inp[20914] = 966263053; +inp[20915] = 0; +inp[20916] = 962495950; +inp[20917] = 0; +inp[20918] = 958743534; +inp[20919] = 0; +inp[20920] = 955005747; +inp[20921] = 0; +inp[20922] = 951282532; +inp[20923] = 0; +inp[20924] = 947573833; +inp[20925] = 0; +inp[20926] = 943879593; +inp[20927] = 0; +inp[20928] = 940199755; +inp[20929] = 0; +inp[20930] = 936534264; +inp[20931] = 0; +inp[20932] = 932883063; +inp[20933] = 0; +inp[20934] = 929246096; +inp[20935] = 0; +inp[20936] = 925623309; +inp[20937] = 0; +inp[20938] = 922014646; +inp[20939] = 0; +inp[20940] = 918420051; +inp[20941] = 0; +inp[20942] = 914839471; +inp[20943] = 0; +inp[20944] = 911272850; +inp[20945] = 0; +inp[20946] = 907720134; +inp[20947] = 0; +inp[20948] = 904181268; +inp[20949] = 0; +inp[20950] = 900656200; +inp[20951] = 0; +inp[20952] = 897144874; +inp[20953] = 0; +inp[20954] = 893647237; +inp[20955] = 0; +inp[20956] = 890163237; +inp[20957] = 0; +inp[20958] = 886692819; +inp[20959] = 0; +inp[20960] = 883235932; +inp[20961] = 0; +inp[20962] = 879792521; +inp[20963] = 0; +inp[20964] = 876362535; +inp[20965] = 0; +inp[20966] = 872945921; +inp[20967] = 0; +inp[20968] = 869542628; +inp[20969] = 0; +inp[20970] = 866152602; +inp[20971] = 0; +inp[20972] = 862775793; +inp[20973] = 0; +inp[20974] = 859412149; +inp[20975] = 0; +inp[20976] = 856061619; +inp[20977] = 0; +inp[20978] = 852724151; +inp[20979] = 0; +inp[20980] = 849399695; +inp[20981] = 0; +inp[20982] = 846088199; +inp[20983] = 0; +inp[20984] = 842789614; +inp[20985] = 0; +inp[20986] = 839503888; +inp[20987] = 0; +inp[20988] = 836230973; +inp[20989] = 0; +inp[20990] = 832970817; +inp[20991] = 0; +inp[20992] = 829723372; +inp[20993] = 0; +inp[20994] = 826488587; +inp[20995] = 0; +inp[20996] = 823266413; +inp[20997] = 0; +inp[20998] = 820056802; +inp[20999] = 0; +inp[21000] = 816859703; +inp[21001] = 0; +inp[21002] = 813675069; +inp[21003] = 0; +inp[21004] = 810502851; +inp[21005] = 0; +inp[21006] = 807342999; +inp[21007] = 0; +inp[21008] = 804195467; +inp[21009] = 0; +inp[21010] = 801060206; +inp[21011] = 0; +inp[21012] = 797937169; +inp[21013] = 0; +inp[21014] = 794826306; +inp[21015] = 0; +inp[21016] = 791727572; +inp[21017] = 0; +inp[21018] = 788640919; +inp[21019] = 0; +inp[21020] = 785566299; +inp[21021] = 0; +inp[21022] = 782503667; +inp[21023] = 0; +inp[21024] = 779452974; +inp[21025] = 0; +inp[21026] = 776414175; +inp[21027] = 0; +inp[21028] = 773387223; +inp[21029] = 0; +inp[21030] = 770372072; +inp[21031] = 0; +inp[21032] = 767368676; +inp[21033] = 0; +inp[21034] = 764376989; +inp[21035] = 0; +inp[21036] = 761396965; +inp[21037] = 0; +inp[21038] = 758428560; +inp[21039] = 0; +inp[21040] = 755471727; +inp[21041] = 0; +inp[21042] = 752526422; +inp[21043] = 0; +inp[21044] = 749592599; +inp[21045] = 0; +inp[21046] = 746670215; +inp[21047] = 0; +inp[21048] = 743759224; +inp[21049] = 0; +inp[21050] = 740859581; +inp[21051] = 0; +inp[21052] = 737971243; +inp[21053] = 0; +inp[21054] = 735094166; +inp[21055] = 0; +inp[21056] = 732228306; +inp[21057] = 0; +inp[21058] = 729373618; +inp[21059] = 0; +inp[21060] = 726530060; +inp[21061] = 0; +inp[21062] = 723697587; +inp[21063] = 0; +inp[21064] = 720876158; +inp[21065] = 0; +inp[21066] = 718065728; +inp[21067] = 0; +inp[21068] = 715266255; +inp[21069] = 0; +inp[21070] = 712477696; +inp[21071] = 0; +inp[21072] = 709700009; +inp[21073] = 0; +inp[21074] = 706933151; +inp[21075] = 0; +inp[21076] = 704177080; +inp[21077] = 0; +inp[21078] = 701431753; +inp[21079] = 0; +inp[21080] = 698697130; +inp[21081] = 0; +inp[21082] = 695973168; +inp[21083] = 0; +inp[21084] = 693259826; +inp[21085] = 0; +inp[21086] = 690557062; +inp[21087] = 0; +inp[21088] = 687864835; +inp[21089] = 0; +inp[21090] = 685183104; +inp[21091] = 0; +inp[21092] = 682511829; +inp[21093] = 0; +inp[21094] = 679850967; +inp[21095] = 0; +inp[21096] = 677200479; +inp[21097] = 0; +inp[21098] = 674560325; +inp[21099] = 0; +inp[21100] = 671930463; +inp[21101] = 0; +inp[21102] = 669310855; +inp[21103] = 0; +inp[21104] = 666701459; +inp[21105] = 0; +inp[21106] = 664102236; +inp[21107] = 0; +inp[21108] = 661513147; +inp[21109] = 0; +inp[21110] = 658934152; +inp[21111] = 0; +inp[21112] = 656365211; +inp[21113] = 0; +inp[21114] = 653806286; +inp[21115] = 0; +inp[21116] = 651257336; +inp[21117] = 0; +inp[21118] = 648718325; +inp[21119] = 0; +inp[21120] = 646189212; +inp[21121] = 0; +inp[21122] = 643669959; +inp[21123] = 0; +inp[21124] = 641160527; +inp[21125] = 0; +inp[21126] = 638660879; +inp[21127] = 0; +inp[21128] = 636170976; +inp[21129] = 0; +inp[21130] = 633690781; +inp[21131] = 0; +inp[21132] = 631220255; +inp[21133] = 0; +inp[21134] = 628759360; +inp[21135] = 0; +inp[21136] = 626308060; +inp[21137] = 0; +inp[21138] = 623866316; +inp[21139] = 0; +inp[21140] = 621434092; +inp[21141] = 0; +inp[21142] = 619011350; +inp[21143] = 0; +inp[21144] = 616598053; +inp[21145] = 0; +inp[21146] = 614194165; +inp[21147] = 0; +inp[21148] = 611799649; +inp[21149] = 0; +inp[21150] = 609414468; +inp[21151] = 0; +inp[21152] = 607038586; +inp[21153] = 0; +inp[21154] = 604671967; +inp[21155] = 0; +inp[21156] = 602314575; +inp[21157] = 0; +inp[21158] = 599966373; +inp[21159] = 0; +inp[21160] = 597627325; +inp[21161] = 0; +inp[21162] = 595297397; +inp[21163] = 0; +inp[21164] = 592976553; +inp[21165] = 0; +inp[21166] = 590664756; +inp[21167] = 0; +inp[21168] = 588361972; +inp[21169] = 0; +inp[21170] = 586068167; +inp[21171] = 0; +inp[21172] = 583783303; +inp[21173] = 0; +inp[21174] = 581507348; +inp[21175] = 0; +inp[21176] = 579240266; +inp[21177] = 0; +inp[21178] = 576982022; +inp[21179] = 0; +inp[21180] = 574732582; +inp[21181] = 0; +inp[21182] = 572491912; +inp[21183] = 0; +inp[21184] = 570259978; +inp[21185] = 0; +inp[21186] = 568036745; +inp[21187] = 0; +inp[21188] = 565822179; +inp[21189] = 0; +inp[21190] = 563616248; +inp[21191] = 0; +inp[21192] = 561418916; +inp[21193] = 0; +inp[21194] = 559230151; +inp[21195] = 0; +inp[21196] = 557049919; +inp[21197] = 0; +inp[21198] = 554878188; +inp[21199] = 0; +inp[21200] = 552714923; +inp[21201] = 0; +inp[21202] = 550560091; +inp[21203] = 0; +inp[21204] = 548413661; +inp[21205] = 0; +inp[21206] = 546275599; +inp[21207] = 0; +inp[21208] = 544145872; +inp[21209] = 0; +inp[21210] = 542024448; +inp[21211] = 0; +inp[21212] = 539911295; +inp[21213] = 0; +inp[21214] = 537806381; +inp[21215] = 0; +inp[21216] = 535709672; +inp[21217] = 0; +inp[21218] = 533621138; +inp[21219] = 0; +inp[21220] = 531540746; +inp[21221] = 0; +inp[21222] = 529468465; +inp[21223] = 0; +inp[21224] = 527404264; +inp[21225] = 0; +inp[21226] = 525348109; +inp[21227] = 0; +inp[21228] = 523299971; +inp[21229] = 0; +inp[21230] = 521259818; +inp[21231] = 0; +inp[21232] = 519227618; +inp[21233] = 0; +inp[21234] = 517203342; +inp[21235] = 0; +inp[21236] = 515186957; +inp[21237] = 0; +inp[21238] = 513178433; +inp[21239] = 0; +inp[21240] = 511177740; +inp[21241] = 0; +inp[21242] = 509184847; +inp[21243] = 0; +inp[21244] = 507199723; +inp[21245] = 0; +inp[21246] = 505222339; +inp[21247] = 0; +inp[21248] = 503252664; +inp[21249] = 0; +inp[21250] = 501290668; +inp[21251] = 0; +inp[21252] = 499336321; +inp[21253] = 0; +inp[21254] = 497389593; +inp[21255] = 0; +inp[21256] = 495450454; +inp[21257] = 0; +inp[21258] = 493518876; +inp[21259] = 0; +inp[21260] = 491594828; +inp[21261] = 0; +inp[21262] = 489678282; +inp[21263] = 0; +inp[21264] = 487769207; +inp[21265] = 0; +inp[21266] = 485867575; +inp[21267] = 0; +inp[21268] = 483973357; +inp[21269] = 0; +inp[21270] = 482086524; +inp[21271] = 0; +inp[21272] = 480207047; +inp[21273] = 0; +inp[21274] = 478334897; +inp[21275] = 0; +inp[21276] = 476470046; +inp[21277] = 0; +inp[21278] = 474612465; +inp[21279] = 0; +inp[21280] = 472762126; +inp[21281] = 0; +inp[21282] = 470919001; +inp[21283] = 0; +inp[21284] = 469083062; +inp[21285] = 0; +inp[21286] = 467254281; +inp[21287] = 0; +inp[21288] = 465432629; +inp[21289] = 0; +inp[21290] = 463618079; +inp[21291] = 0; +inp[21292] = 461810603; +inp[21293] = 0; +inp[21294] = 460010175; +inp[21295] = 0; +inp[21296] = 458216765; +inp[21297] = 0; +inp[21298] = 456430347; +inp[21299] = 0; +inp[21300] = 454650894; +inp[21301] = 0; +inp[21302] = 452878378; +inp[21303] = 0; +inp[21304] = 451112772; +inp[21305] = 0; +inp[21306] = 449354050; +inp[21307] = 0; +inp[21308] = 447602185; +inp[21309] = 0; +inp[21310] = 445857149; +inp[21311] = 0; +inp[21312] = 444118917; +inp[21313] = 0; +inp[21314] = 442387461; +inp[21315] = 0; +inp[21316] = 440662756; +inp[21317] = 0; +inp[21318] = 438944775; +inp[21319] = 0; +inp[21320] = 437233491; +inp[21321] = 0; +inp[21322] = 435528880; +inp[21323] = 0; +inp[21324] = 433830913; +inp[21325] = 0; +inp[21326] = 432139567; +inp[21327] = 0; +inp[21328] = 430454814; +inp[21329] = 0; +inp[21330] = 428776630; +inp[21331] = 0; +inp[21332] = 427104988; +inp[21333] = 0; +inp[21334] = 425439864; +inp[21335] = 0; +inp[21336] = 423781231; +inp[21337] = 0; +inp[21338] = 422129065; +inp[21339] = 0; +inp[21340] = 420483339; +inp[21341] = 0; +inp[21342] = 418844030; +inp[21343] = 0; +inp[21344] = 417211112; +inp[21345] = 0; +inp[21346] = 415584560; +inp[21347] = 0; +inp[21348] = 413964349; +inp[21349] = 0; +inp[21350] = 412350455; +inp[21351] = 0; +inp[21352] = 410742853; +inp[21353] = 0; +inp[21354] = 409141519; +inp[21355] = 0; +inp[21356] = 407546427; +inp[21357] = 0; +inp[21358] = 405957554; +inp[21359] = 0; +inp[21360] = 404374876; +inp[21361] = 0; +inp[21362] = 402798367; +inp[21363] = 0; +inp[21364] = 401228005; +inp[21365] = 0; +inp[21366] = 399663766; +inp[21367] = 0; +inp[21368] = 398105624; +inp[21369] = 0; +inp[21370] = 396553557; +inp[21371] = 0; +inp[21372] = 1073741824; +inp[21373] = 1073741824; +inp[21374] = 1071646718; +inp[21375] = 0; +inp[21376] = 1069555701; +inp[21377] = 0; +inp[21378] = 1067468764; +inp[21379] = 0; +inp[21380] = 1065385898; +inp[21381] = 0; +inp[21382] = 1063307097; +inp[21383] = 0; +inp[21384] = 1061232352; +inp[21385] = 0; +inp[21386] = 1059161656; +inp[21387] = 0; +inp[21388] = 1057094999; +inp[21389] = 0; +inp[21390] = 1055032376; +inp[21391] = 0; +inp[21392] = 1052973777; +inp[21393] = 0; +inp[21394] = 1050919194; +inp[21395] = 0; +inp[21396] = 1048868621; +inp[21397] = 0; +inp[21398] = 1046822049; +inp[21399] = 0; +inp[21400] = 1044779470; +inp[21401] = 0; +inp[21402] = 1042740876; +inp[21403] = 0; +inp[21404] = 1040706261; +inp[21405] = 0; +inp[21406] = 1038675615; +inp[21407] = 0; +inp[21408] = 1036648931; +inp[21409] = 0; +inp[21410] = 1034626202; +inp[21411] = 0; +inp[21412] = 1032607420; +inp[21413] = 0; +inp[21414] = 1030592577; +inp[21415] = 0; +inp[21416] = 1028581665; +inp[21417] = 0; +inp[21418] = 1026574677; +inp[21419] = 0; +inp[21420] = 1024571605; +inp[21421] = 0; +inp[21422] = 1022572442; +inp[21423] = 0; +inp[21424] = 1020577179; +inp[21425] = 0; +inp[21426] = 1018585810; +inp[21427] = 0; +inp[21428] = 1016598326; +inp[21429] = 0; +inp[21430] = 1014614720; +inp[21431] = 0; +inp[21432] = 1012634985; +inp[21433] = 0; +inp[21434] = 1010659112; +inp[21435] = 0; +inp[21436] = 1008687095; +inp[21437] = 0; +inp[21438] = 1006718926; +inp[21439] = 0; +inp[21440] = 1004754597; +inp[21441] = 0; +inp[21442] = 1002794101; +inp[21443] = 0; +inp[21444] = 1000837430; +inp[21445] = 0; +inp[21446] = 998884577; +inp[21447] = 0; +inp[21448] = 996935534; +inp[21449] = 0; +inp[21450] = 994990295; +inp[21451] = 0; +inp[21452] = 993048851; +inp[21453] = 0; +inp[21454] = 991111195; +inp[21455] = 0; +inp[21456] = 989177321; +inp[21457] = 0; +inp[21458] = 987247219; +inp[21459] = 0; +inp[21460] = 985320884; +inp[21461] = 0; +inp[21462] = 983398307; +inp[21463] = 0; +inp[21464] = 981479482; +inp[21465] = 0; +inp[21466] = 979564400; +inp[21467] = 0; +inp[21468] = 977653056; +inp[21469] = 0; +inp[21470] = 975745441; +inp[21471] = 0; +inp[21472] = 973841548; +inp[21473] = 0; +inp[21474] = 971941370; +inp[21475] = 0; +inp[21476] = 970044899; +inp[21477] = 0; +inp[21478] = 968152129; +inp[21479] = 0; +inp[21480] = 966263053; +inp[21481] = 0; +inp[21482] = 964377662; +inp[21483] = 0; +inp[21484] = 962495950; +inp[21485] = 0; +inp[21486] = 960617910; +inp[21487] = 0; +inp[21488] = 958743534; +inp[21489] = 0; +inp[21490] = 956872815; +inp[21491] = 0; +inp[21492] = 955005747; +inp[21493] = 0; +inp[21494] = 953142322; +inp[21495] = 0; +inp[21496] = 951282532; +inp[21497] = 0; +inp[21498] = 949426372; +inp[21499] = 0; +inp[21500] = 947573833; +inp[21501] = 0; +inp[21502] = 945724909; +inp[21503] = 0; +inp[21504] = 943879593; +inp[21505] = 0; +inp[21506] = 942037877; +inp[21507] = 0; +inp[21508] = 940199755; +inp[21509] = 0; +inp[21510] = 938365220; +inp[21511] = 0; +inp[21512] = 936534264; +inp[21513] = 0; +inp[21514] = 934706880; +inp[21515] = 0; +inp[21516] = 932883063; +inp[21517] = 0; +inp[21518] = 931062804; +inp[21519] = 0; +inp[21520] = 929246096; +inp[21521] = 0; +inp[21522] = 927432934; +inp[21523] = 0; +inp[21524] = 925623309; +inp[21525] = 0; +inp[21526] = 923817215; +inp[21527] = 0; +inp[21528] = 922014646; +inp[21529] = 0; +inp[21530] = 920215593; +inp[21531] = 0; +inp[21532] = 918420051; +inp[21533] = 0; +inp[21534] = 916628013; +inp[21535] = 0; +inp[21536] = 914839471; +inp[21537] = 0; +inp[21538] = 913054419; +inp[21539] = 0; +inp[21540] = 911272850; +inp[21541] = 0; +inp[21542] = 909494757; +inp[21543] = 0; +inp[21544] = 907720134; +inp[21545] = 0; +inp[21546] = 905948973; +inp[21547] = 0; +inp[21548] = 904181268; +inp[21549] = 0; +inp[21550] = 902417013; +inp[21551] = 0; +inp[21552] = 900656200; +inp[21553] = 0; +inp[21554] = 898898822; +inp[21555] = 0; +inp[21556] = 897144874; +inp[21557] = 0; +inp[21558] = 895394348; +inp[21559] = 0; +inp[21560] = 893647237; +inp[21561] = 0; +inp[21562] = 891903536; +inp[21563] = 0; +inp[21564] = 890163237; +inp[21565] = 0; +inp[21566] = 888426334; +inp[21567] = 0; +inp[21568] = 886692819; +inp[21569] = 0; +inp[21570] = 884962688; +inp[21571] = 0; +inp[21572] = 883235932; +inp[21573] = 0; +inp[21574] = 881512545; +inp[21575] = 0; +inp[21576] = 879792521; +inp[21577] = 0; +inp[21578] = 878075853; +inp[21579] = 0; +inp[21580] = 876362535; +inp[21581] = 0; +inp[21582] = 874652560; +inp[21583] = 0; +inp[21584] = 872945921; +inp[21585] = 0; +inp[21586] = 871242613; +inp[21587] = 0; +inp[21588] = 869542628; +inp[21589] = 0; +inp[21590] = 867845960; +inp[21591] = 0; +inp[21592] = 866152602; +inp[21593] = 0; +inp[21594] = 864462549; +inp[21595] = 0; +inp[21596] = 862775793; +inp[21597] = 0; +inp[21598] = 861092329; +inp[21599] = 0; +inp[21600] = 859412149; +inp[21601] = 0; +inp[21602] = 857735248; +inp[21603] = 0; +inp[21604] = 856061619; +inp[21605] = 0; +inp[21606] = 854391255; +inp[21607] = 0; +inp[21608] = 852724151; +inp[21609] = 0; +inp[21610] = 851060299; +inp[21611] = 0; +inp[21612] = 849399695; +inp[21613] = 0; +inp[21614] = 847742330; +inp[21615] = 0; +inp[21616] = 846088199; +inp[21617] = 0; +inp[21618] = 844437296; +inp[21619] = 0; +inp[21620] = 842789614; +inp[21621] = 0; +inp[21622] = 841145147; +inp[21623] = 0; +inp[21624] = 839503888; +inp[21625] = 0; +inp[21626] = 837865832; +inp[21627] = 0; +inp[21628] = 836230973; +inp[21629] = 0; +inp[21630] = 834599303; +inp[21631] = 0; +inp[21632] = 832970817; +inp[21633] = 0; +inp[21634] = 831345509; +inp[21635] = 0; +inp[21636] = 829723372; +inp[21637] = 0; +inp[21638] = 828104400; +inp[21639] = 0; +inp[21640] = 826488587; +inp[21641] = 0; +inp[21642] = 824875927; +inp[21643] = 0; +inp[21644] = 823266413; +inp[21645] = 0; +inp[21646] = 821660040; +inp[21647] = 0; +inp[21648] = 820056802; +inp[21649] = 0; +inp[21650] = 818456691; +inp[21651] = 0; +inp[21652] = 816859703; +inp[21653] = 0; +inp[21654] = 815265831; +inp[21655] = 0; +inp[21656] = 813675069; +inp[21657] = 0; +inp[21658] = 812087411; +inp[21659] = 0; +inp[21660] = 810502851; +inp[21661] = 0; +inp[21662] = 808921382; +inp[21663] = 0; +inp[21664] = 807342999; +inp[21665] = 0; +inp[21666] = 805767696; +inp[21667] = 0; +inp[21668] = 804195467; +inp[21669] = 0; +inp[21670] = 802626306; +inp[21671] = 0; +inp[21672] = 801060206; +inp[21673] = 0; +inp[21674] = 799497163; +inp[21675] = 0; +inp[21676] = 797937169; +inp[21677] = 0; +inp[21678] = 796380218; +inp[21679] = 0; +inp[21680] = 794826306; +inp[21681] = 0; +inp[21682] = 793275426; +inp[21683] = 0; +inp[21684] = 791727572; +inp[21685] = 0; +inp[21686] = 790182738; +inp[21687] = 0; +inp[21688] = 788640919; +inp[21689] = 0; +inp[21690] = 787102108; +inp[21691] = 0; +inp[21692] = 785566299; +inp[21693] = 0; +inp[21694] = 784033488; +inp[21695] = 0; +inp[21696] = 782503667; +inp[21697] = 0; +inp[21698] = 780976831; +inp[21699] = 0; +inp[21700] = 779452974; +inp[21701] = 0; +inp[21702] = 777932091; +inp[21703] = 0; +inp[21704] = 776414175; +inp[21705] = 0; +inp[21706] = 774899221; +inp[21707] = 0; +inp[21708] = 773387223; +inp[21709] = 0; +inp[21710] = 771878175; +inp[21711] = 0; +inp[21712] = 770372072; +inp[21713] = 0; +inp[21714] = 768868907; +inp[21715] = 0; +inp[21716] = 767368676; +inp[21717] = 0; +inp[21718] = 765871371; +inp[21719] = 0; +inp[21720] = 764376989; +inp[21721] = 0; +inp[21722] = 762885522; +inp[21723] = 0; +inp[21724] = 761396965; +inp[21725] = 0; +inp[21726] = 759911313; +inp[21727] = 0; +inp[21728] = 758428560; +inp[21729] = 0; +inp[21730] = 756948700; +inp[21731] = 0; +inp[21732] = 755471727; +inp[21733] = 0; +inp[21734] = 753997636; +inp[21735] = 0; +inp[21736] = 752526422; +inp[21737] = 0; +inp[21738] = 751058078; +inp[21739] = 0; +inp[21740] = 749592599; +inp[21741] = 0; +inp[21742] = 748129980; +inp[21743] = 0; +inp[21744] = 746670215; +inp[21745] = 0; +inp[21746] = 745213298; +inp[21747] = 0; +inp[21748] = 743759224; +inp[21749] = 0; +inp[21750] = 742307986; +inp[21751] = 0; +inp[21752] = 740859581; +inp[21753] = 0; +inp[21754] = 739414002; +inp[21755] = 0; +inp[21756] = 737971243; +inp[21757] = 0; +inp[21758] = 736531300; +inp[21759] = 0; +inp[21760] = 735094166; +inp[21761] = 0; +inp[21762] = 733659836; +inp[21763] = 0; +inp[21764] = 732228306; +inp[21765] = 0; +inp[21766] = 730799568; +inp[21767] = 0; +inp[21768] = 729373618; +inp[21769] = 0; +inp[21770] = 727950450; +inp[21771] = 0; +inp[21772] = 726530060; +inp[21773] = 0; +inp[21774] = 725112440; +inp[21775] = 0; +inp[21776] = 723697587; +inp[21777] = 0; +inp[21778] = 722285495; +inp[21779] = 0; +inp[21780] = 720876158; +inp[21781] = 0; +inp[21782] = 719469571; +inp[21783] = 0; +inp[21784] = 718065728; +inp[21785] = 0; +inp[21786] = 716664625; +inp[21787] = 0; +inp[21788] = 715266255; +inp[21789] = 0; +inp[21790] = 713870614; +inp[21791] = 0; +inp[21792] = 712477696; +inp[21793] = 0; +inp[21794] = 711087496; +inp[21795] = 0; +inp[21796] = 709700009; +inp[21797] = 0; +inp[21798] = 708315229; +inp[21799] = 0; +inp[21800] = 706933151; +inp[21801] = 0; +inp[21802] = 705553769; +inp[21803] = 0; +inp[21804] = 704177080; +inp[21805] = 0; +inp[21806] = 702803076; +inp[21807] = 0; +inp[21808] = 701431753; +inp[21809] = 0; +inp[21810] = 700063106; +inp[21811] = 0; +inp[21812] = 698697130; +inp[21813] = 0; +inp[21814] = 697333819; +inp[21815] = 0; +inp[21816] = 695973168; +inp[21817] = 0; +inp[21818] = 694615172; +inp[21819] = 0; +inp[21820] = 693259826; +inp[21821] = 0; +inp[21822] = 691907124; +inp[21823] = 0; +inp[21824] = 690557062; +inp[21825] = 0; +inp[21826] = 689209634; +inp[21827] = 0; +inp[21828] = 687864835; +inp[21829] = 0; +inp[21830] = 686522660; +inp[21831] = 0; +inp[21832] = 685183104; +inp[21833] = 0; +inp[21834] = 683846162; +inp[21835] = 0; +inp[21836] = 682511829; +inp[21837] = 0; +inp[21838] = 681180099; +inp[21839] = 0; +inp[21840] = 679850967; +inp[21841] = 0; +inp[21842] = 678524429; +inp[21843] = 0; +inp[21844] = 677200479; +inp[21845] = 0; +inp[21846] = 675879113; +inp[21847] = 0; +inp[21848] = 674560325; +inp[21849] = 0; +inp[21850] = 673244110; +inp[21851] = 0; +inp[21852] = 671930463; +inp[21853] = 0; +inp[21854] = 670619380; +inp[21855] = 0; +inp[21856] = 669310855; +inp[21857] = 0; +inp[21858] = 668004883; +inp[21859] = 0; +inp[21860] = 666701459; +inp[21861] = 0; +inp[21862] = 665400579; +inp[21863] = 0; +inp[21864] = 664102236; +inp[21865] = 0; +inp[21866] = 662806428; +inp[21867] = 0; +inp[21868] = 661513147; +inp[21869] = 0; +inp[21870] = 660222390; +inp[21871] = 0; +inp[21872] = 658934152; +inp[21873] = 0; +inp[21874] = 657648427; +inp[21875] = 0; +inp[21876] = 656365211; +inp[21877] = 0; +inp[21878] = 655084499; +inp[21879] = 0; +inp[21880] = 653806286; +inp[21881] = 0; +inp[21882] = 652530566; +inp[21883] = 0; +inp[21884] = 1073741824; +inp[21885] = 1073741824; +inp[21886] = 1072693759; +inp[21887] = 0; +inp[21888] = 1071646718; +inp[21889] = 0; +inp[21890] = 1070600699; +inp[21891] = 0; +inp[21892] = 1069555701; +inp[21893] = 0; +inp[21894] = 1068511723; +inp[21895] = 0; +inp[21896] = 1067468764; +inp[21897] = 0; +inp[21898] = 1066426822; +inp[21899] = 0; +inp[21900] = 1065385898; +inp[21901] = 0; +inp[21902] = 1064345990; +inp[21903] = 0; +inp[21904] = 1063307097; +inp[21905] = 0; +inp[21906] = 1062269218; +inp[21907] = 0; +inp[21908] = 1061232352; +inp[21909] = 0; +inp[21910] = 1060196498; +inp[21911] = 0; +inp[21912] = 1059161656; +inp[21913] = 0; +inp[21914] = 1058127823; +inp[21915] = 0; +inp[21916] = 1057094999; +inp[21917] = 0; +inp[21918] = 1056063184; +inp[21919] = 0; +inp[21920] = 1055032376; +inp[21921] = 0; +inp[21922] = 1054002574; +inp[21923] = 0; +inp[21924] = 1052973777; +inp[21925] = 0; +inp[21926] = 1051945984; +inp[21927] = 0; +inp[21928] = 1050919194; +inp[21929] = 0; +inp[21930] = 1049893407; +inp[21931] = 0; +inp[21932] = 1048868621; +inp[21933] = 0; +inp[21934] = 1047844835; +inp[21935] = 0; +inp[21936] = 1046822049; +inp[21937] = 0; +inp[21938] = 1045800261; +inp[21939] = 0; +inp[21940] = 1044779470; +inp[21941] = 0; +inp[21942] = 1043759675; +inp[21943] = 0; +inp[21944] = 1042740876; +inp[21945] = 0; +inp[21946] = 1041723072; +inp[21947] = 0; +inp[21948] = 1040706261; +inp[21949] = 0; +inp[21950] = 1039690442; +inp[21951] = 0; +inp[21952] = 1038675615; +inp[21953] = 0; +inp[21954] = 1037661778; +inp[21955] = 0; +inp[21956] = 1036648931; +inp[21957] = 0; +inp[21958] = 1035637073; +inp[21959] = 0; +inp[21960] = 1034626202; +inp[21961] = 0; +inp[21962] = 1033616318; +inp[21963] = 0; +inp[21964] = 1032607420; +inp[21965] = 0; +inp[21966] = 1031599507; +inp[21967] = 0; +inp[21968] = 1030592577; +inp[21969] = 0; +inp[21970] = 1029586630; +inp[21971] = 0; +inp[21972] = 1028581665; +inp[21973] = 0; +inp[21974] = 1027577681; +inp[21975] = 0; +inp[21976] = 1026574677; +inp[21977] = 0; +inp[21978] = 1025572652; +inp[21979] = 0; +inp[21980] = 1024571605; +inp[21981] = 0; +inp[21982] = 1023571536; +inp[21983] = 0; +inp[21984] = 1022572442; +inp[21985] = 0; +inp[21986] = 1021574324; +inp[21987] = 0; +inp[21988] = 1020577179; +inp[21989] = 0; +inp[21990] = 1019581008; +inp[21991] = 0; +inp[21992] = 1018585810; +inp[21993] = 0; +inp[21994] = 1017591583; +inp[21995] = 0; +inp[21996] = 1016598326; +inp[21997] = 0; +inp[21998] = 1015606039; +inp[21999] = 0; +inp[22000] = 1014614720; +inp[22001] = 0; +inp[22002] = 1013624369; +inp[22003] = 0; +inp[22004] = 1012634985; +inp[22005] = 0; +inp[22006] = 1011646566; +inp[22007] = 0; +inp[22008] = 1010659112; +inp[22009] = 0; +inp[22010] = 1009672622; +inp[22011] = 0; +inp[22012] = 1008687095; +inp[22013] = 0; +inp[22014] = 1007702530; +inp[22015] = 0; +inp[22016] = 1006718926; +inp[22017] = 0; +inp[22018] = 1005736282; +inp[22019] = 0; +inp[22020] = 1004754597; +inp[22021] = 0; +inp[22022] = 1003773870; +inp[22023] = 0; +inp[22024] = 1002794101; +inp[22025] = 0; +inp[22026] = 1001815287; +inp[22027] = 0; +inp[22028] = 1000837430; +inp[22029] = 0; +inp[22030] = 999860527; +inp[22031] = 0; +inp[22032] = 998884577; +inp[22033] = 0; +inp[22034] = 997909580; +inp[22035] = 0; +inp[22036] = 996935534; +inp[22037] = 0; +inp[22038] = 995962440; +inp[22039] = 0; +inp[22040] = 994990295; +inp[22041] = 0; +inp[22042] = 994019099; +inp[22043] = 0; +inp[22044] = 993048851; +inp[22045] = 0; +inp[22046] = 992079550; +inp[22047] = 0; +inp[22048] = 991111195; +inp[22049] = 0; +inp[22050] = 990143786; +inp[22051] = 0; +inp[22052] = 989177321; +inp[22053] = 0; +inp[22054] = 988211799; +inp[22055] = 0; +inp[22056] = 987247219; +inp[22057] = 0; +inp[22058] = 986283581; +inp[22059] = 0; +inp[22060] = 985320884; +inp[22061] = 0; +inp[22062] = 984359126; +inp[22063] = 0; +inp[22064] = 983398307; +inp[22065] = 0; +inp[22066] = 982438426; +inp[22067] = 0; +inp[22068] = 981479482; +inp[22069] = 0; +inp[22070] = 980521473; +inp[22071] = 0; +inp[22072] = 979564400; +inp[22073] = 0; +inp[22074] = 978608261; +inp[22075] = 0; +inp[22076] = 977653056; +inp[22077] = 0; +inp[22078] = 976698782; +inp[22079] = 0; +inp[22080] = 975745441; +inp[22081] = 0; +inp[22082] = 974793029; +inp[22083] = 0; +inp[22084] = 973841548; +inp[22085] = 0; +inp[22086] = 972890995; +inp[22087] = 0; +inp[22088] = 971941370; +inp[22089] = 0; +inp[22090] = 970992671; +inp[22091] = 0; +inp[22092] = 970044899; +inp[22093] = 0; +inp[22094] = 969098052; +inp[22095] = 0; +inp[22096] = 968152129; +inp[22097] = 0; +inp[22098] = 967207130; +inp[22099] = 0; +inp[22100] = 966263053; +inp[22101] = 0; +inp[22102] = 965319897; +inp[22103] = 0; +inp[22104] = 964377662; +inp[22105] = 0; +inp[22106] = 963436347; +inp[22107] = 0; +inp[22108] = 962495950; +inp[22109] = 0; +inp[22110] = 961556471; +inp[22111] = 0; +inp[22112] = 960617910; +inp[22113] = 0; +inp[22114] = 959680264; +inp[22115] = 0; +inp[22116] = 958743534; +inp[22117] = 0; +inp[22118] = 957807718; +inp[22119] = 0; +inp[22120] = 956872815; +inp[22121] = 0; +inp[22122] = 955938825; +inp[22123] = 0; +inp[22124] = 955005747; +inp[22125] = 0; +inp[22126] = 954073579; +inp[22127] = 0; +inp[22128] = 953142322; +inp[22129] = 0; +inp[22130] = 952211973; +inp[22131] = 0; +inp[22132] = 951282532; +inp[22133] = 0; +inp[22134] = 950353999; +inp[22135] = 0; +inp[22136] = 949426372; +inp[22137] = 0; +inp[22138] = 948499650; +inp[22139] = 0; +inp[22140] = 947573833; +inp[22141] = 0; +inp[22142] = 946648920; +inp[22143] = 0; +inp[22144] = 945724909; +inp[22145] = 0; +inp[22146] = 944801801; +inp[22147] = 0; +inp[22148] = 943879593; +inp[22149] = 0; +inp[22150] = 942958286; +inp[22151] = 0; +inp[22152] = 942037877; +inp[22153] = 0; +inp[22154] = 941118368; +inp[22155] = 0; +inp[22156] = 940199755; +inp[22157] = 0; +inp[22158] = 939282040; +inp[22159] = 0; +inp[22160] = 938365220; +inp[22161] = 0; +inp[22162] = 937449295; +inp[22163] = 0; +inp[22164] = 936534264; +inp[22165] = 0; +inp[22166] = 935620126; +inp[22167] = 0; +inp[22168] = 934706880; +inp[22169] = 0; +inp[22170] = 933794526; +inp[22171] = 0; +inp[22172] = 932883063; +inp[22173] = 0; +inp[22174] = 931972489; +inp[22175] = 0; +inp[22176] = 931062804; +inp[22177] = 0; +inp[22178] = 930154006; +inp[22179] = 0; +inp[22180] = 929246096; +inp[22181] = 0; +inp[22182] = 928339072; +inp[22183] = 0; +inp[22184] = 927432934; +inp[22185] = 0; +inp[22186] = 926527680; +inp[22187] = 0; +inp[22188] = 925623309; +inp[22189] = 0; +inp[22190] = 924719821; +inp[22191] = 0; +inp[22192] = 923817215; +inp[22193] = 0; +inp[22194] = 922915491; +inp[22195] = 0; +inp[22196] = 922014646; +inp[22197] = 0; +inp[22198] = 921114680; +inp[22199] = 0; +inp[22200] = 920215593; +inp[22201] = 0; +inp[22202] = 919317384; +inp[22203] = 0; +inp[22204] = 918420051; +inp[22205] = 0; +inp[22206] = 917523595; +inp[22207] = 0; +inp[22208] = 916628013; +inp[22209] = 0; +inp[22210] = 915733305; +inp[22211] = 0; +inp[22212] = 914839471; +inp[22213] = 0; +inp[22214] = 913946509; +inp[22215] = 0; +inp[22216] = 913054419; +inp[22217] = 0; +inp[22218] = 912163199; +inp[22219] = 0; +inp[22220] = 911272850; +inp[22221] = 0; +inp[22222] = 910383369; +inp[22223] = 0; +inp[22224] = 909494757; +inp[22225] = 0; +inp[22226] = 908607012; +inp[22227] = 0; +inp[22228] = 907720134; +inp[22229] = 0; +inp[22230] = 906834121; +inp[22231] = 0; +inp[22232] = 905948973; +inp[22233] = 0; +inp[22234] = 905064689; +inp[22235] = 0; +inp[22236] = 904181268; +inp[22237] = 0; +inp[22238] = 903298710; +inp[22239] = 0; +inp[22240] = 902417013; +inp[22241] = 0; +inp[22242] = 901536176; +inp[22243] = 0; +inp[22244] = 900656200; +inp[22245] = 0; +inp[22246] = 899777082; +inp[22247] = 0; +inp[22248] = 898898822; +inp[22249] = 0; +inp[22250] = 898021420; +inp[22251] = 0; +inp[22252] = 897144874; +inp[22253] = 0; +inp[22254] = 896269183; +inp[22255] = 0; +inp[22256] = 895394348; +inp[22257] = 0; +inp[22258] = 894520366; +inp[22259] = 0; +inp[22260] = 893647237; +inp[22261] = 0; +inp[22262] = 892774961; +inp[22263] = 0; +inp[22264] = 891903536; +inp[22265] = 0; +inp[22266] = 891032962; +inp[22267] = 0; +inp[22268] = 890163237; +inp[22269] = 0; +inp[22270] = 889294361; +inp[22271] = 0; +inp[22272] = 888426334; +inp[22273] = 0; +inp[22274] = 887559153; +inp[22275] = 0; +inp[22276] = 886692819; +inp[22277] = 0; +inp[22278] = 885827331; +inp[22279] = 0; +inp[22280] = 884962688; +inp[22281] = 0; +inp[22282] = 884098888; +inp[22283] = 0; +inp[22284] = 883235932; +inp[22285] = 0; +inp[22286] = 882373818; +inp[22287] = 0; +inp[22288] = 881512545; +inp[22289] = 0; +inp[22290] = 880652113; +inp[22291] = 0; +inp[22292] = 879792521; +inp[22293] = 0; +inp[22294] = 878933768; +inp[22295] = 0; +inp[22296] = 878075853; +inp[22297] = 0; +inp[22298] = 877218776; +inp[22299] = 0; +inp[22300] = 876362535; +inp[22301] = 0; +inp[22302] = 875507130; +inp[22303] = 0; +inp[22304] = 874652560; +inp[22305] = 0; +inp[22306] = 873798824; +inp[22307] = 0; +inp[22308] = 872945921; +inp[22309] = 0; +inp[22310] = 872093851; +inp[22311] = 0; +inp[22312] = 871242613; +inp[22313] = 0; +inp[22314] = 870392205; +inp[22315] = 0; +inp[22316] = 869542628; +inp[22317] = 0; +inp[22318] = 868693880; +inp[22319] = 0; +inp[22320] = 867845960; +inp[22321] = 0; +inp[22322] = 866998868; +inp[22323] = 0; +inp[22324] = 866152602; +inp[22325] = 0; +inp[22326] = 865307163; +inp[22327] = 0; +inp[22328] = 864462549; +inp[22329] = 0; +inp[22330] = 863618759; +inp[22331] = 0; +inp[22332] = 862775793; +inp[22333] = 0; +inp[22334] = 861933650; +inp[22335] = 0; +inp[22336] = 861092329; +inp[22337] = 0; +inp[22338] = 860251829; +inp[22339] = 0; +inp[22340] = 859412149; +inp[22341] = 0; +inp[22342] = 858573289; +inp[22343] = 0; +inp[22344] = 857735248; +inp[22345] = 0; +inp[22346] = 856898025; +inp[22347] = 0; +inp[22348] = 856061619; +inp[22349] = 0; +inp[22350] = 855226029; +inp[22351] = 0; +inp[22352] = 854391255; +inp[22353] = 0; +inp[22354] = 853557296; +inp[22355] = 0; +inp[22356] = 852724151; +inp[22357] = 0; +inp[22358] = 851891819; +inp[22359] = 0; +inp[22360] = 851060299; +inp[22361] = 0; +inp[22362] = 850229592; +inp[22363] = 0; +inp[22364] = 849399695; +inp[22365] = 0; +inp[22366] = 848570608; +inp[22367] = 0; +inp[22368] = 847742330; +inp[22369] = 0; +inp[22370] = 846914861; +inp[22371] = 0; +inp[22372] = 846088199; +inp[22373] = 0; +inp[22374] = 845262344; +inp[22375] = 0; +inp[22376] = 844437296; +inp[22377] = 0; +inp[22378] = 843613052; +inp[22379] = 0; +inp[22380] = 842789614; +inp[22381] = 0; +inp[22382] = 841966979; +inp[22383] = 0; +inp[22384] = 841145147; +inp[22385] = 0; +inp[22386] = 840324117; +inp[22387] = 0; +inp[22388] = 839503888; +inp[22389] = 0; +inp[22390] = 838684460; +inp[22391] = 0; +inp[22392] = 837865832; +inp[22393] = 0; +inp[22394] = 837048004; +inp[22395] = 0; +inp[22396] = 1073741824; +inp[22397] = 1073741824; +inp[22398] = 1073217663; +inp[22399] = 0; +inp[22400] = 1072693759; +inp[22401] = 0; +inp[22402] = 1072170111; +inp[22403] = 0; +inp[22404] = 1071646718; +inp[22405] = 0; +inp[22406] = 1071123581; +inp[22407] = 0; +inp[22408] = 1070600699; +inp[22409] = 0; +inp[22410] = 1070078072; +inp[22411] = 0; +inp[22412] = 1069555701; +inp[22413] = 0; +inp[22414] = 1069033584; +inp[22415] = 0; +inp[22416] = 1068511723; +inp[22417] = 0; +inp[22418] = 1067990116; +inp[22419] = 0; +inp[22420] = 1067468764; +inp[22421] = 0; +inp[22422] = 1066947666; +inp[22423] = 0; +inp[22424] = 1066426822; +inp[22425] = 0; +inp[22426] = 1065906233; +inp[22427] = 0; +inp[22428] = 1065385898; +inp[22429] = 0; +inp[22430] = 1064865817; +inp[22431] = 0; +inp[22432] = 1064345990; +inp[22433] = 0; +inp[22434] = 1063826417; +inp[22435] = 0; +inp[22436] = 1063307097; +inp[22437] = 0; +inp[22438] = 1062788031; +inp[22439] = 0; +inp[22440] = 1062269218; +inp[22441] = 0; +inp[22442] = 1061750659; +inp[22443] = 0; +inp[22444] = 1061232352; +inp[22445] = 0; +inp[22446] = 1060714299; +inp[22447] = 0; +inp[22448] = 1060196498; +inp[22449] = 0; +inp[22450] = 1059678951; +inp[22451] = 0; +inp[22452] = 1059161656; +inp[22453] = 0; +inp[22454] = 1058644613; +inp[22455] = 0; +inp[22456] = 1058127823; +inp[22457] = 0; +inp[22458] = 1057611285; +inp[22459] = 0; +inp[22460] = 1057094999; +inp[22461] = 0; +inp[22462] = 1056578966; +inp[22463] = 0; +inp[22464] = 1056063184; +inp[22465] = 0; +inp[22466] = 1055547654; +inp[22467] = 0; +inp[22468] = 1055032376; +inp[22469] = 0; +inp[22470] = 1054517349; +inp[22471] = 0; +inp[22472] = 1054002574; +inp[22473] = 0; +inp[22474] = 1053488050; +inp[22475] = 0; +inp[22476] = 1052973777; +inp[22477] = 0; +inp[22478] = 1052459755; +inp[22479] = 0; +inp[22480] = 1051945984; +inp[22481] = 0; +inp[22482] = 1051432464; +inp[22483] = 0; +inp[22484] = 1050919194; +inp[22485] = 0; +inp[22486] = 1050406175; +inp[22487] = 0; +inp[22488] = 1049893407; +inp[22489] = 0; +inp[22490] = 1049380889; +inp[22491] = 0; +inp[22492] = 1048868621; +inp[22493] = 0; +inp[22494] = 1048356603; +inp[22495] = 0; +inp[22496] = 1047844835; +inp[22497] = 0; +inp[22498] = 1047333317; +inp[22499] = 0; +inp[22500] = 1046822049; +inp[22501] = 0; +inp[22502] = 1046311030; +inp[22503] = 0; +inp[22504] = 1045800261; +inp[22505] = 0; +inp[22506] = 1045289741; +inp[22507] = 0; +inp[22508] = 1044779470; +inp[22509] = 0; +inp[22510] = 1044269448; +inp[22511] = 0; +inp[22512] = 1043759675; +inp[22513] = 0; +inp[22514] = 1043250151; +inp[22515] = 0; +inp[22516] = 1042740876; +inp[22517] = 0; +inp[22518] = 1042231850; +inp[22519] = 0; +inp[22520] = 1041723072; +inp[22521] = 0; +inp[22522] = 1041214542; +inp[22523] = 0; +inp[22524] = 1040706261; +inp[22525] = 0; +inp[22526] = 1040198227; +inp[22527] = 0; +inp[22528] = 1039690442; +inp[22529] = 0; +inp[22530] = 1039182905; +inp[22531] = 0; +inp[22532] = 1038675615; +inp[22533] = 0; +inp[22534] = 1038168573; +inp[22535] = 0; +inp[22536] = 1037661778; +inp[22537] = 0; +inp[22538] = 1037155231; +inp[22539] = 0; +inp[22540] = 1036648931; +inp[22541] = 0; +inp[22542] = 1036142879; +inp[22543] = 0; +inp[22544] = 1035637073; +inp[22545] = 0; +inp[22546] = 1035131514; +inp[22547] = 0; +inp[22548] = 1034626202; +inp[22549] = 0; +inp[22550] = 1034121137; +inp[22551] = 0; +inp[22552] = 1033616318; +inp[22553] = 0; +inp[22554] = 1033111746; +inp[22555] = 0; +inp[22556] = 1032607420; +inp[22557] = 0; +inp[22558] = 1032103340; +inp[22559] = 0; +inp[22560] = 1031599507; +inp[22561] = 0; +inp[22562] = 1031095919; +inp[22563] = 0; +inp[22564] = 1030592577; +inp[22565] = 0; +inp[22566] = 1030089481; +inp[22567] = 0; +inp[22568] = 1029586630; +inp[22569] = 0; +inp[22570] = 1029084025; +inp[22571] = 0; +inp[22572] = 1028581665; +inp[22573] = 0; +inp[22574] = 1028079551; +inp[22575] = 0; +inp[22576] = 1027577681; +inp[22577] = 0; +inp[22578] = 1027076057; +inp[22579] = 0; +inp[22580] = 1026574677; +inp[22581] = 0; +inp[22582] = 1026073543; +inp[22583] = 0; +inp[22584] = 1025572652; +inp[22585] = 0; +inp[22586] = 1025072007; +inp[22587] = 0; +inp[22588] = 1024571605; +inp[22589] = 0; +inp[22590] = 1024071449; +inp[22591] = 0; +inp[22592] = 1023571536; +inp[22593] = 0; +inp[22594] = 1023071867; +inp[22595] = 0; +inp[22596] = 1022572442; +inp[22597] = 0; +inp[22598] = 1022073261; +inp[22599] = 0; +inp[22600] = 1021574324; +inp[22601] = 0; +inp[22602] = 1021075630; +inp[22603] = 0; +inp[22604] = 1020577179; +inp[22605] = 0; +inp[22606] = 1020078972; +inp[22607] = 0; +inp[22608] = 1019581008; +inp[22609] = 0; +inp[22610] = 1019083288; +inp[22611] = 0; +inp[22612] = 1018585810; +inp[22613] = 0; +inp[22614] = 1018088575; +inp[22615] = 0; +inp[22616] = 1017591583; +inp[22617] = 0; +inp[22618] = 1017094833; +inp[22619] = 0; +inp[22620] = 1016598326; +inp[22621] = 0; +inp[22622] = 1016102061; +inp[22623] = 0; +inp[22624] = 1015606039; +inp[22625] = 0; +inp[22626] = 1015110258; +inp[22627] = 0; +inp[22628] = 1014614720; +inp[22629] = 0; +inp[22630] = 1014119424; +inp[22631] = 0; +inp[22632] = 1013624369; +inp[22633] = 0; +inp[22634] = 1013129556; +inp[22635] = 0; +inp[22636] = 1012634985; +inp[22637] = 0; +inp[22638] = 1012140655; +inp[22639] = 0; +inp[22640] = 1011646566; +inp[22641] = 0; +inp[22642] = 1011152719; +inp[22643] = 0; +inp[22644] = 1010659112; +inp[22645] = 0; +inp[22646] = 1010165747; +inp[22647] = 0; +inp[22648] = 1009672622; +inp[22649] = 0; +inp[22650] = 1009179738; +inp[22651] = 0; +inp[22652] = 1008687095; +inp[22653] = 0; +inp[22654] = 1008194692; +inp[22655] = 0; +inp[22656] = 1007702530; +inp[22657] = 0; +inp[22658] = 1007210608; +inp[22659] = 0; +inp[22660] = 1006718926; +inp[22661] = 0; +inp[22662] = 1006227484; +inp[22663] = 0; +inp[22664] = 1005736282; +inp[22665] = 0; +inp[22666] = 1005245319; +inp[22667] = 0; +inp[22668] = 1004754597; +inp[22669] = 0; +inp[22670] = 1004264114; +inp[22671] = 0; +inp[22672] = 1003773870; +inp[22673] = 0; +inp[22674] = 1003283866; +inp[22675] = 0; +inp[22676] = 1002794101; +inp[22677] = 0; +inp[22678] = 1002304575; +inp[22679] = 0; +inp[22680] = 1001815287; +inp[22681] = 0; +inp[22682] = 1001326239; +inp[22683] = 0; +inp[22684] = 1000837430; +inp[22685] = 0; +inp[22686] = 1000348859; +inp[22687] = 0; +inp[22688] = 999860527; +inp[22689] = 0; +inp[22690] = 999372433; +inp[22691] = 0; +inp[22692] = 998884577; +inp[22693] = 0; +inp[22694] = 998396959; +inp[22695] = 0; +inp[22696] = 997909580; +inp[22697] = 0; +inp[22698] = 997422438; +inp[22699] = 0; +inp[22700] = 996935534; +inp[22701] = 0; +inp[22702] = 996448868; +inp[22703] = 0; +inp[22704] = 995962440; +inp[22705] = 0; +inp[22706] = 995476249; +inp[22707] = 0; +inp[22708] = 994990295; +inp[22709] = 0; +inp[22710] = 994504578; +inp[22711] = 0; +inp[22712] = 994019099; +inp[22713] = 0; +inp[22714] = 993533857; +inp[22715] = 0; +inp[22716] = 993048851; +inp[22717] = 0; +inp[22718] = 992564082; +inp[22719] = 0; +inp[22720] = 992079550; +inp[22721] = 0; +inp[22722] = 991595255; +inp[22723] = 0; +inp[22724] = 991111195; +inp[22725] = 0; +inp[22726] = 990627373; +inp[22727] = 0; +inp[22728] = 990143786; +inp[22729] = 0; +inp[22730] = 989660435; +inp[22731] = 0; +inp[22732] = 989177321; +inp[22733] = 0; +inp[22734] = 988694442; +inp[22735] = 0; +inp[22736] = 988211799; +inp[22737] = 0; +inp[22738] = 987729391; +inp[22739] = 0; +inp[22740] = 987247219; +inp[22741] = 0; +inp[22742] = 986765282; +inp[22743] = 0; +inp[22744] = 986283581; +inp[22745] = 0; +inp[22746] = 985802115; +inp[22747] = 0; +inp[22748] = 985320884; +inp[22749] = 0; +inp[22750] = 984839887; +inp[22751] = 0; +inp[22752] = 984359126; +inp[22753] = 0; +inp[22754] = 983878599; +inp[22755] = 0; +inp[22756] = 983398307; +inp[22757] = 0; +inp[22758] = 982918249; +inp[22759] = 0; +inp[22760] = 982438426; +inp[22761] = 0; +inp[22762] = 981958837; +inp[22763] = 0; +inp[22764] = 981479482; +inp[22765] = 0; +inp[22766] = 981000361; +inp[22767] = 0; +inp[22768] = 980521473; +inp[22769] = 0; +inp[22770] = 980042820; +inp[22771] = 0; +inp[22772] = 979564400; +inp[22773] = 0; +inp[22774] = 979086214; +inp[22775] = 0; +inp[22776] = 978608261; +inp[22777] = 0; +inp[22778] = 978130542; +inp[22779] = 0; +inp[22780] = 977653056; +inp[22781] = 0; +inp[22782] = 977175803; +inp[22783] = 0; +inp[22784] = 976698782; +inp[22785] = 0; +inp[22786] = 976221995; +inp[22787] = 0; +inp[22788] = 975745441; +inp[22789] = 0; +inp[22790] = 975269119; +inp[22791] = 0; +inp[22792] = 974793029; +inp[22793] = 0; +inp[22794] = 974317172; +inp[22795] = 0; +inp[22796] = 973841548; +inp[22797] = 0; +inp[22798] = 973366155; +inp[22799] = 0; +inp[22800] = 972890995; +inp[22801] = 0; +inp[22802] = 972416066; +inp[22803] = 0; +inp[22804] = 971941370; +inp[22805] = 0; +inp[22806] = 971466905; +inp[22807] = 0; +inp[22808] = 970992671; +inp[22809] = 0; +inp[22810] = 970518670; +inp[22811] = 0; +inp[22812] = 970044899; +inp[22813] = 0; +inp[22814] = 969571360; +inp[22815] = 0; +inp[22816] = 969098052; +inp[22817] = 0; +inp[22818] = 968624975; +inp[22819] = 0; +inp[22820] = 968152129; +inp[22821] = 0; +inp[22822] = 967679514; +inp[22823] = 0; +inp[22824] = 967207130; +inp[22825] = 0; +inp[22826] = 966734976; +inp[22827] = 0; +inp[22828] = 966263053; +inp[22829] = 0; +inp[22830] = 965791360; +inp[22831] = 0; +inp[22832] = 965319897; +inp[22833] = 0; +inp[22834] = 964848664; +inp[22835] = 0; +inp[22836] = 964377662; +inp[22837] = 0; +inp[22838] = 963906889; +inp[22839] = 0; +inp[22840] = 963436347; +inp[22841] = 0; +inp[22842] = 962966033; +inp[22843] = 0; +inp[22844] = 962495950; +inp[22845] = 0; +inp[22846] = 962026096; +inp[22847] = 0; +inp[22848] = 961556471; +inp[22849] = 0; +inp[22850] = 961087076; +inp[22851] = 0; +inp[22852] = 960617910; +inp[22853] = 0; +inp[22854] = 960148972; +inp[22855] = 0; +inp[22856] = 959680264; +inp[22857] = 0; +inp[22858] = 959211785; +inp[22859] = 0; +inp[22860] = 958743534; +inp[22861] = 0; +inp[22862] = 958275512; +inp[22863] = 0; +inp[22864] = 957807718; +inp[22865] = 0; +inp[22866] = 957340153; +inp[22867] = 0; +inp[22868] = 956872815; +inp[22869] = 0; +inp[22870] = 956405706; +inp[22871] = 0; +inp[22872] = 955938825; +inp[22873] = 0; +inp[22874] = 955472172; +inp[22875] = 0; +inp[22876] = 955005747; +inp[22877] = 0; +inp[22878] = 954539549; +inp[22879] = 0; +inp[22880] = 954073579; +inp[22881] = 0; +inp[22882] = 953607837; +inp[22883] = 0; +inp[22884] = 953142322; +inp[22885] = 0; +inp[22886] = 952677034; +inp[22887] = 0; +inp[22888] = 952211973; +inp[22889] = 0; +inp[22890] = 951747139; +inp[22891] = 0; +inp[22892] = 951282532; +inp[22893] = 0; +inp[22894] = 950818152; +inp[22895] = 0; +inp[22896] = 950353999; +inp[22897] = 0; +inp[22898] = 949890072; +inp[22899] = 0; +inp[22900] = 949426372; +inp[22901] = 0; +inp[22902] = 948962898; +inp[22903] = 0; +inp[22904] = 948499650; +inp[22905] = 0; +inp[22906] = 948036629; +inp[22907] = 0; +inp[22908] = 1073741824; +inp[22909] = 1073741824; +inp[22910] = 1073479711; +inp[22911] = 0; +inp[22912] = 1073217663; +inp[22913] = 0; +inp[22914] = 1072955679; +inp[22915] = 0; +inp[22916] = 1072693759; +inp[22917] = 0; +inp[22918] = 1072431903; +inp[22919] = 0; +inp[22920] = 1072170111; +inp[22921] = 0; +inp[22922] = 1071908383; +inp[22923] = 0; +inp[22924] = 1071646718; +inp[22925] = 0; +inp[22926] = 1071385118; +inp[22927] = 0; +inp[22928] = 1071123581; +inp[22929] = 0; +inp[22930] = 1070862108; +inp[22931] = 0; +inp[22932] = 1070600699; +inp[22933] = 0; +inp[22934] = 1070339354; +inp[22935] = 0; +inp[22936] = 1070078072; +inp[22937] = 0; +inp[22938] = 1069816855; +inp[22939] = 0; +inp[22940] = 1069555701; +inp[22941] = 0; +inp[22942] = 1069294611; +inp[22943] = 0; +inp[22944] = 1069033584; +inp[22945] = 0; +inp[22946] = 1068772622; +inp[22947] = 0; +inp[22948] = 1068511723; +inp[22949] = 0; +inp[22950] = 1068250887; +inp[22951] = 0; +inp[22952] = 1067990116; +inp[22953] = 0; +inp[22954] = 1067729408; +inp[22955] = 0; +inp[22956] = 1067468764; +inp[22957] = 0; +inp[22958] = 1067208183; +inp[22959] = 0; +inp[22960] = 1066947666; +inp[22961] = 0; +inp[22962] = 1066687212; +inp[22963] = 0; +inp[22964] = 1066426822; +inp[22965] = 0; +inp[22966] = 1066166496; +inp[22967] = 0; +inp[22968] = 1065906233; +inp[22969] = 0; +inp[22970] = 1065646034; +inp[22971] = 0; +inp[22972] = 1065385898; +inp[22973] = 0; +inp[22974] = 1065125826; +inp[22975] = 0; +inp[22976] = 1064865817; +inp[22977] = 0; +inp[22978] = 1064605872; +inp[22979] = 0; +inp[22980] = 1064345990; +inp[22981] = 0; +inp[22982] = 1064086172; +inp[22983] = 0; +inp[22984] = 1063826417; +inp[22985] = 0; +inp[22986] = 1063566725; +inp[22987] = 0; +inp[22988] = 1063307097; +inp[22989] = 0; +inp[22990] = 1063047532; +inp[22991] = 0; +inp[22992] = 1062788031; +inp[22993] = 0; +inp[22994] = 1062528593; +inp[22995] = 0; +inp[22996] = 1062269218; +inp[22997] = 0; +inp[22998] = 1062009907; +inp[22999] = 0; +inp[23000] = 1061750659; +inp[23001] = 0; +inp[23002] = 1061491474; +inp[23003] = 0; +inp[23004] = 1061232352; +inp[23005] = 0; +inp[23006] = 1060973294; +inp[23007] = 0; +inp[23008] = 1060714299; +inp[23009] = 0; +inp[23010] = 1060455367; +inp[23011] = 0; +inp[23012] = 1060196498; +inp[23013] = 0; +inp[23014] = 1059937693; +inp[23015] = 0; +inp[23016] = 1059678951; +inp[23017] = 0; +inp[23018] = 1059420272; +inp[23019] = 0; +inp[23020] = 1059161656; +inp[23021] = 0; +inp[23022] = 1058903103; +inp[23023] = 0; +inp[23024] = 1058644613; +inp[23025] = 0; +inp[23026] = 1058386187; +inp[23027] = 0; +inp[23028] = 1058127823; +inp[23029] = 0; +inp[23030] = 1057869523; +inp[23031] = 0; +inp[23032] = 1057611285; +inp[23033] = 0; +inp[23034] = 1057353111; +inp[23035] = 0; +inp[23036] = 1057094999; +inp[23037] = 0; +inp[23038] = 1056836951; +inp[23039] = 0; +inp[23040] = 1056578966; +inp[23041] = 0; +inp[23042] = 1056321043; +inp[23043] = 0; +inp[23044] = 1056063184; +inp[23045] = 0; +inp[23046] = 1055805388; +inp[23047] = 0; +inp[23048] = 1055547654; +inp[23049] = 0; +inp[23050] = 1055289983; +inp[23051] = 0; +inp[23052] = 1055032376; +inp[23053] = 0; +inp[23054] = 1054774831; +inp[23055] = 0; +inp[23056] = 1054517349; +inp[23057] = 0; +inp[23058] = 1054259930; +inp[23059] = 0; +inp[23060] = 1054002574; +inp[23061] = 0; +inp[23062] = 1053745280; +inp[23063] = 0; +inp[23064] = 1053488050; +inp[23065] = 0; +inp[23066] = 1053230882; +inp[23067] = 0; +inp[23068] = 1052973777; +inp[23069] = 0; +inp[23070] = 1052716734; +inp[23071] = 0; +inp[23072] = 1052459755; +inp[23073] = 0; +inp[23074] = 1052202838; +inp[23075] = 0; +inp[23076] = 1051945984; +inp[23077] = 0; +inp[23078] = 1051689192; +inp[23079] = 0; +inp[23080] = 1051432464; +inp[23081] = 0; +inp[23082] = 1051175798; +inp[23083] = 0; +inp[23084] = 1050919194; +inp[23085] = 0; +inp[23086] = 1050662654; +inp[23087] = 0; +inp[23088] = 1050406175; +inp[23089] = 0; +inp[23090] = 1050149760; +inp[23091] = 0; +inp[23092] = 1049893407; +inp[23093] = 0; +inp[23094] = 1049637117; +inp[23095] = 0; +inp[23096] = 1049380889; +inp[23097] = 0; +inp[23098] = 1049124724; +inp[23099] = 0; +inp[23100] = 1048868621; +inp[23101] = 0; +inp[23102] = 1048612581; +inp[23103] = 0; +inp[23104] = 1048356603; +inp[23105] = 0; +inp[23106] = 1048100688; +inp[23107] = 0; +inp[23108] = 1047844835; +inp[23109] = 0; +inp[23110] = 1047589045; +inp[23111] = 0; +inp[23112] = 1047333317; +inp[23113] = 0; +inp[23114] = 1047077652; +inp[23115] = 0; +inp[23116] = 1046822049; +inp[23117] = 0; +inp[23118] = 1046566508; +inp[23119] = 0; +inp[23120] = 1046311030; +inp[23121] = 0; +inp[23122] = 1046055614; +inp[23123] = 0; +inp[23124] = 1045800261; +inp[23125] = 0; +inp[23126] = 1045544969; +inp[23127] = 0; +inp[23128] = 1045289741; +inp[23129] = 0; +inp[23130] = 1045034574; +inp[23131] = 0; +inp[23132] = 1044779470; +inp[23133] = 0; +inp[23134] = 1044524428; +inp[23135] = 0; +inp[23136] = 1044269448; +inp[23137] = 0; +inp[23138] = 1044014531; +inp[23139] = 0; +inp[23140] = 1043759675; +inp[23141] = 0; +inp[23142] = 1043504882; +inp[23143] = 0; +inp[23144] = 1043250151; +inp[23145] = 0; +inp[23146] = 1042995483; +inp[23147] = 0; +inp[23148] = 1042740876; +inp[23149] = 0; +inp[23150] = 1042486332; +inp[23151] = 0; +inp[23152] = 1042231850; +inp[23153] = 0; +inp[23154] = 1041977430; +inp[23155] = 0; +inp[23156] = 1041723072; +inp[23157] = 0; +inp[23158] = 1041468776; +inp[23159] = 0; +inp[23160] = 1041214542; +inp[23161] = 0; +inp[23162] = 1040960370; +inp[23163] = 0; +inp[23164] = 1040706261; +inp[23165] = 0; +inp[23166] = 1040452213; +inp[23167] = 0; +inp[23168] = 1040198227; +inp[23169] = 0; +inp[23170] = 1039944304; +inp[23171] = 0; +inp[23172] = 1039690442; +inp[23173] = 0; +inp[23174] = 1039436642; +inp[23175] = 0; +inp[23176] = 1039182905; +inp[23177] = 0; +inp[23178] = 1038929229; +inp[23179] = 0; +inp[23180] = 1038675615; +inp[23181] = 0; +inp[23182] = 1038422063; +inp[23183] = 0; +inp[23184] = 1038168573; +inp[23185] = 0; +inp[23186] = 1037915145; +inp[23187] = 0; +inp[23188] = 1037661778; +inp[23189] = 0; +inp[23190] = 1037408474; +inp[23191] = 0; +inp[23192] = 1037155231; +inp[23193] = 0; +inp[23194] = 1036902050; +inp[23195] = 0; +inp[23196] = 1036648931; +inp[23197] = 0; +inp[23198] = 1036395874; +inp[23199] = 0; +inp[23200] = 1036142879; +inp[23201] = 0; +inp[23202] = 1035889945; +inp[23203] = 0; +inp[23204] = 1035637073; +inp[23205] = 0; +inp[23206] = 1035384263; +inp[23207] = 0; +inp[23208] = 1035131514; +inp[23209] = 0; +inp[23210] = 1034878828; +inp[23211] = 0; +inp[23212] = 1034626202; +inp[23213] = 0; +inp[23214] = 1034373639; +inp[23215] = 0; +inp[23216] = 1034121137; +inp[23217] = 0; +inp[23218] = 1033868697; +inp[23219] = 0; +inp[23220] = 1033616318; +inp[23221] = 0; +inp[23222] = 1033364001; +inp[23223] = 0; +inp[23224] = 1033111746; +inp[23225] = 0; +inp[23226] = 1032859552; +inp[23227] = 0; +inp[23228] = 1032607420; +inp[23229] = 0; +inp[23230] = 1032355350; +inp[23231] = 0; +inp[23232] = 1032103340; +inp[23233] = 0; +inp[23234] = 1031851393; +inp[23235] = 0; +inp[23236] = 1031599507; +inp[23237] = 0; +inp[23238] = 1031347682; +inp[23239] = 0; +inp[23240] = 1031095919; +inp[23241] = 0; +inp[23242] = 1030844217; +inp[23243] = 0; +inp[23244] = 1030592577; +inp[23245] = 0; +inp[23246] = 1030340998; +inp[23247] = 0; +inp[23248] = 1030089481; +inp[23249] = 0; +inp[23250] = 1029838025; +inp[23251] = 0; +inp[23252] = 1029586630; +inp[23253] = 0; +inp[23254] = 1029335297; +inp[23255] = 0; +inp[23256] = 1029084025; +inp[23257] = 0; +inp[23258] = 1028832815; +inp[23259] = 0; +inp[23260] = 1028581665; +inp[23261] = 0; +inp[23262] = 1028330577; +inp[23263] = 0; +inp[23264] = 1028079551; +inp[23265] = 0; +inp[23266] = 1027828585; +inp[23267] = 0; +inp[23268] = 1027577681; +inp[23269] = 0; +inp[23270] = 1027326839; +inp[23271] = 0; +inp[23272] = 1027076057; +inp[23273] = 0; +inp[23274] = 1026825337; +inp[23275] = 0; +inp[23276] = 1026574677; +inp[23277] = 0; +inp[23278] = 1026324079; +inp[23279] = 0; +inp[23280] = 1026073543; +inp[23281] = 0; +inp[23282] = 1025823067; +inp[23283] = 0; +inp[23284] = 1025572652; +inp[23285] = 0; +inp[23286] = 1025322299; +inp[23287] = 0; +inp[23288] = 1025072007; +inp[23289] = 0; +inp[23290] = 1024821776; +inp[23291] = 0; +inp[23292] = 1024571605; +inp[23293] = 0; +inp[23294] = 1024321496; +inp[23295] = 0; +inp[23296] = 1024071449; +inp[23297] = 0; +inp[23298] = 1023821462; +inp[23299] = 0; +inp[23300] = 1023571536; +inp[23301] = 0; +inp[23302] = 1023321671; +inp[23303] = 0; +inp[23304] = 1023071867; +inp[23305] = 0; +inp[23306] = 1022822124; +inp[23307] = 0; +inp[23308] = 1022572442; +inp[23309] = 0; +inp[23310] = 1022322821; +inp[23311] = 0; +inp[23312] = 1022073261; +inp[23313] = 0; +inp[23314] = 1021823762; +inp[23315] = 0; +inp[23316] = 1021574324; +inp[23317] = 0; +inp[23318] = 1021324946; +inp[23319] = 0; +inp[23320] = 1021075630; +inp[23321] = 0; +inp[23322] = 1020826374; +inp[23323] = 0; +inp[23324] = 1020577179; +inp[23325] = 0; +inp[23326] = 1020328045; +inp[23327] = 0; +inp[23328] = 1020078972; +inp[23329] = 0; +inp[23330] = 1019829960; +inp[23331] = 0; +inp[23332] = 1019581008; +inp[23333] = 0; +inp[23334] = 1019332118; +inp[23335] = 0; +inp[23336] = 1019083288; +inp[23337] = 0; +inp[23338] = 1018834518; +inp[23339] = 0; +inp[23340] = 1018585810; +inp[23341] = 0; +inp[23342] = 1018337162; +inp[23343] = 0; +inp[23344] = 1018088575; +inp[23345] = 0; +inp[23346] = 1017840048; +inp[23347] = 0; +inp[23348] = 1017591583; +inp[23349] = 0; +inp[23350] = 1017343178; +inp[23351] = 0; +inp[23352] = 1017094833; +inp[23353] = 0; +inp[23354] = 1016846549; +inp[23355] = 0; +inp[23356] = 1016598326; +inp[23357] = 0; +inp[23358] = 1016350163; +inp[23359] = 0; +inp[23360] = 1016102061; +inp[23361] = 0; +inp[23362] = 1015854020; +inp[23363] = 0; +inp[23364] = 1015606039; +inp[23365] = 0; +inp[23366] = 1015358118; +inp[23367] = 0; +inp[23368] = 1015110258; +inp[23369] = 0; +inp[23370] = 1014862459; +inp[23371] = 0; +inp[23372] = 1014614720; +inp[23373] = 0; +inp[23374] = 1014367042; +inp[23375] = 0; +inp[23376] = 1014119424; +inp[23377] = 0; +inp[23378] = 1013871866; +inp[23379] = 0; +inp[23380] = 1013624369; +inp[23381] = 0; +inp[23382] = 1013376932; +inp[23383] = 0; +inp[23384] = 1013129556; +inp[23385] = 0; +inp[23386] = 1012882240; +inp[23387] = 0; +inp[23388] = 1012634985; +inp[23389] = 0; +inp[23390] = 1012387790; +inp[23391] = 0; +inp[23392] = 1012140655; +inp[23393] = 0; +inp[23394] = 1011893580; +inp[23395] = 0; +inp[23396] = 1011646566; +inp[23397] = 0; +inp[23398] = 1011399612; +inp[23399] = 0; +inp[23400] = 1011152719; +inp[23401] = 0; +inp[23402] = 1010905885; +inp[23403] = 0; +inp[23404] = 1010659112; +inp[23405] = 0; +inp[23406] = 1010412399; +inp[23407] = 0; +inp[23408] = 1010165747; +inp[23409] = 0; +inp[23410] = 1009919154; +inp[23411] = 0; +inp[23412] = 1009672622; +inp[23413] = 0; +inp[23414] = 1009426150; +inp[23415] = 0; +inp[23416] = 1009179738; +inp[23417] = 0; +inp[23418] = 1008933387; +inp[23419] = 0; +inp[23420] = 1073741824; +inp[23421] = 1073741824; +inp[23422] = 1073610759; +inp[23423] = 0; +inp[23424] = 1073479711; +inp[23425] = 0; +inp[23426] = 1073348679; +inp[23427] = 0; +inp[23428] = 1073217663; +inp[23429] = 0; +inp[23430] = 1073086663; +inp[23431] = 0; +inp[23432] = 1072955679; +inp[23433] = 0; +inp[23434] = 1072824711; +inp[23435] = 0; +inp[23436] = 1072693759; +inp[23437] = 0; +inp[23438] = 1072562823; +inp[23439] = 0; +inp[23440] = 1072431903; +inp[23441] = 0; +inp[23442] = 1072300999; +inp[23443] = 0; +inp[23444] = 1072170111; +inp[23445] = 0; +inp[23446] = 1072039239; +inp[23447] = 0; +inp[23448] = 1071908383; +inp[23449] = 0; +inp[23450] = 1071777542; +inp[23451] = 0; +inp[23452] = 1071646718; +inp[23453] = 0; +inp[23454] = 1071515910; +inp[23455] = 0; +inp[23456] = 1071385118; +inp[23457] = 0; +inp[23458] = 1071254341; +inp[23459] = 0; +inp[23460] = 1071123581; +inp[23461] = 0; +inp[23462] = 1070992836; +inp[23463] = 0; +inp[23464] = 1070862108; +inp[23465] = 0; +inp[23466] = 1070731396; +inp[23467] = 0; +inp[23468] = 1070600699; +inp[23469] = 0; +inp[23470] = 1070470018; +inp[23471] = 0; +inp[23472] = 1070339354; +inp[23473] = 0; +inp[23474] = 1070208705; +inp[23475] = 0; +inp[23476] = 1070078072; +inp[23477] = 0; +inp[23478] = 1069947456; +inp[23479] = 0; +inp[23480] = 1069816855; +inp[23481] = 0; +inp[23482] = 1069686270; +inp[23483] = 0; +inp[23484] = 1069555701; +inp[23485] = 0; +inp[23486] = 1069425148; +inp[23487] = 0; +inp[23488] = 1069294611; +inp[23489] = 0; +inp[23490] = 1069164090; +inp[23491] = 0; +inp[23492] = 1069033584; +inp[23493] = 0; +inp[23494] = 1068903095; +inp[23495] = 0; +inp[23496] = 1068772622; +inp[23497] = 0; +inp[23498] = 1068642164; +inp[23499] = 0; +inp[23500] = 1068511723; +inp[23501] = 0; +inp[23502] = 1068381297; +inp[23503] = 0; +inp[23504] = 1068250887; +inp[23505] = 0; +inp[23506] = 1068120494; +inp[23507] = 0; +inp[23508] = 1067990116; +inp[23509] = 0; +inp[23510] = 1067859754; +inp[23511] = 0; +inp[23512] = 1067729408; +inp[23513] = 0; +inp[23514] = 1067599078; +inp[23515] = 0; +inp[23516] = 1067468764; +inp[23517] = 0; +inp[23518] = 1067338465; +inp[23519] = 0; +inp[23520] = 1067208183; +inp[23521] = 0; +inp[23522] = 1067077916; +inp[23523] = 0; +inp[23524] = 1066947666; +inp[23525] = 0; +inp[23526] = 1066817431; +inp[23527] = 0; +inp[23528] = 1066687212; +inp[23529] = 0; +inp[23530] = 1066557009; +inp[23531] = 0; +inp[23532] = 1066426822; +inp[23533] = 0; +inp[23534] = 1066296651; +inp[23535] = 0; +inp[23536] = 1066166496; +inp[23537] = 0; +inp[23538] = 1066036357; +inp[23539] = 0; +inp[23540] = 1065906233; +inp[23541] = 0; +inp[23542] = 1065776126; +inp[23543] = 0; +inp[23544] = 1065646034; +inp[23545] = 0; +inp[23546] = 1065515958; +inp[23547] = 0; +inp[23548] = 1065385898; +inp[23549] = 0; +inp[23550] = 1065255854; +inp[23551] = 0; +inp[23552] = 1065125826; +inp[23553] = 0; +inp[23554] = 1064995814; +inp[23555] = 0; +inp[23556] = 1064865817; +inp[23557] = 0; +inp[23558] = 1064735837; +inp[23559] = 0; +inp[23560] = 1064605872; +inp[23561] = 0; +inp[23562] = 1064475923; +inp[23563] = 0; +inp[23564] = 1064345990; +inp[23565] = 0; +inp[23566] = 1064216073; +inp[23567] = 0; +inp[23568] = 1064086172; +inp[23569] = 0; +inp[23570] = 1063956286; +inp[23571] = 0; +inp[23572] = 1063826417; +inp[23573] = 0; +inp[23574] = 1063696563; +inp[23575] = 0; +inp[23576] = 1063566725; +inp[23577] = 0; +inp[23578] = 1063436903; +inp[23579] = 0; +inp[23580] = 1063307097; +inp[23581] = 0; +inp[23582] = 1063177307; +inp[23583] = 0; +inp[23584] = 1063047532; +inp[23585] = 0; +inp[23586] = 1062917774; +inp[23587] = 0; +inp[23588] = 1062788031; +inp[23589] = 0; +inp[23590] = 1062658304; +inp[23591] = 0; +inp[23592] = 1062528593; +inp[23593] = 0; +inp[23594] = 1062398898; +inp[23595] = 0; +inp[23596] = 1062269218; +inp[23597] = 0; +inp[23598] = 1062139555; +inp[23599] = 0; +inp[23600] = 1062009907; +inp[23601] = 0; +inp[23602] = 1061880275; +inp[23603] = 0; +inp[23604] = 1061750659; +inp[23605] = 0; +inp[23606] = 1061621058; +inp[23607] = 0; +inp[23608] = 1061491474; +inp[23609] = 0; +inp[23610] = 1061361905; +inp[23611] = 0; +inp[23612] = 1061232352; +inp[23613] = 0; +inp[23614] = 1061102815; +inp[23615] = 0; +inp[23616] = 1060973294; +inp[23617] = 0; +inp[23618] = 1060843789; +inp[23619] = 0; +inp[23620] = 1060714299; +inp[23621] = 0; +inp[23622] = 1060584825; +inp[23623] = 0; +inp[23624] = 1060455367; +inp[23625] = 0; +inp[23626] = 1060325925; +inp[23627] = 0; +inp[23628] = 1060196498; +inp[23629] = 0; +inp[23630] = 1060067088; +inp[23631] = 0; +inp[23632] = 1059937693; +inp[23633] = 0; +inp[23634] = 1059808314; +inp[23635] = 0; +inp[23636] = 1059678951; +inp[23637] = 0; +inp[23638] = 1059549603; +inp[23639] = 0; +inp[23640] = 1059420272; +inp[23641] = 0; +inp[23642] = 1059290956; +inp[23643] = 0; +inp[23644] = 1059161656; +inp[23645] = 0; +inp[23646] = 1059032371; +inp[23647] = 0; +inp[23648] = 1058903103; +inp[23649] = 0; +inp[23650] = 1058773850; +inp[23651] = 0; +inp[23652] = 1058644613; +inp[23653] = 0; +inp[23654] = 1058515392; +inp[23655] = 0; +inp[23656] = 1058386187; +inp[23657] = 0; +inp[23658] = 1058256997; +inp[23659] = 0; +inp[23660] = 1058127823; +inp[23661] = 0; +inp[23662] = 1057998665; +inp[23663] = 0; +inp[23664] = 1057869523; +inp[23665] = 0; +inp[23666] = 1057740396; +inp[23667] = 0; +inp[23668] = 1057611285; +inp[23669] = 0; +inp[23670] = 1057482190; +inp[23671] = 0; +inp[23672] = 1057353111; +inp[23673] = 0; +inp[23674] = 1057224047; +inp[23675] = 0; +inp[23676] = 1057094999; +inp[23677] = 0; +inp[23678] = 1056965967; +inp[23679] = 0; +inp[23680] = 1056836951; +inp[23681] = 0; +inp[23682] = 1056707951; +inp[23683] = 0; +inp[23684] = 1056578966; +inp[23685] = 0; +inp[23686] = 1056449997; +inp[23687] = 0; +inp[23688] = 1056321043; +inp[23689] = 0; +inp[23690] = 1056192106; +inp[23691] = 0; +inp[23692] = 1056063184; +inp[23693] = 0; +inp[23694] = 1055934278; +inp[23695] = 0; +inp[23696] = 1055805388; +inp[23697] = 0; +inp[23698] = 1055676513; +inp[23699] = 0; +inp[23700] = 1055547654; +inp[23701] = 0; +inp[23702] = 1055418811; +inp[23703] = 0; +inp[23704] = 1055289983; +inp[23705] = 0; +inp[23706] = 1055161172; +inp[23707] = 0; +inp[23708] = 1055032376; +inp[23709] = 0; +inp[23710] = 1054903595; +inp[23711] = 0; +inp[23712] = 1054774831; +inp[23713] = 0; +inp[23714] = 1054646082; +inp[23715] = 0; +inp[23716] = 1054517349; +inp[23717] = 0; +inp[23718] = 1054388632; +inp[23719] = 0; +inp[23720] = 1054259930; +inp[23721] = 0; +inp[23722] = 1054131244; +inp[23723] = 0; +inp[23724] = 1054002574; +inp[23725] = 0; +inp[23726] = 1053873919; +inp[23727] = 0; +inp[23728] = 1053745280; +inp[23729] = 0; +inp[23730] = 1053616657; +inp[23731] = 0; +inp[23732] = 1053488050; +inp[23733] = 0; +inp[23734] = 1053359458; +inp[23735] = 0; +inp[23736] = 1053230882; +inp[23737] = 0; +inp[23738] = 1053102321; +inp[23739] = 0; +inp[23740] = 1052973777; +inp[23741] = 0; +inp[23742] = 1052845248; +inp[23743] = 0; +inp[23744] = 1052716734; +inp[23745] = 0; +inp[23746] = 1052588237; +inp[23747] = 0; +inp[23748] = 1052459755; +inp[23749] = 0; +inp[23750] = 1052331289; +inp[23751] = 0; +inp[23752] = 1052202838; +inp[23753] = 0; +inp[23754] = 1052074403; +inp[23755] = 0; +inp[23756] = 1051945984; +inp[23757] = 0; +inp[23758] = 1051817580; +inp[23759] = 0; +inp[23760] = 1051689192; +inp[23761] = 0; +inp[23762] = 1051560820; +inp[23763] = 0; +inp[23764] = 1051432464; +inp[23765] = 0; +inp[23766] = 1051304123; +inp[23767] = 0; +inp[23768] = 1051175798; +inp[23769] = 0; +inp[23770] = 1051047488; +inp[23771] = 0; +inp[23772] = 1050919194; +inp[23773] = 0; +inp[23774] = 1050790916; +inp[23775] = 0; +inp[23776] = 1050662654; +inp[23777] = 0; +inp[23778] = 1050534407; +inp[23779] = 0; +inp[23780] = 1050406175; +inp[23781] = 0; +inp[23782] = 1050277960; +inp[23783] = 0; +inp[23784] = 1050149760; +inp[23785] = 0; +inp[23786] = 1050021576; +inp[23787] = 0; +inp[23788] = 1049893407; +inp[23789] = 0; +inp[23790] = 1049765254; +inp[23791] = 0; +inp[23792] = 1049637117; +inp[23793] = 0; +inp[23794] = 1049508995; +inp[23795] = 0; +inp[23796] = 1049380889; +inp[23797] = 0; +inp[23798] = 1049252798; +inp[23799] = 0; +inp[23800] = 1049124724; +inp[23801] = 0; +inp[23802] = 1048996664; +inp[23803] = 0; +inp[23804] = 1048868621; +inp[23805] = 0; +inp[23806] = 1048740593; +inp[23807] = 0; +inp[23808] = 1048612581; +inp[23809] = 0; +inp[23810] = 1048484584; +inp[23811] = 0; +inp[23812] = 1048356603; +inp[23813] = 0; +inp[23814] = 1048228638; +inp[23815] = 0; +inp[23816] = 1048100688; +inp[23817] = 0; +inp[23818] = 1047972754; +inp[23819] = 0; +inp[23820] = 1047844835; +inp[23821] = 0; +inp[23822] = 1047716932; +inp[23823] = 0; +inp[23824] = 1047589045; +inp[23825] = 0; +inp[23826] = 1047461173; +inp[23827] = 0; +inp[23828] = 1047333317; +inp[23829] = 0; +inp[23830] = 1047205477; +inp[23831] = 0; +inp[23832] = 1047077652; +inp[23833] = 0; +inp[23834] = 1046949842; +inp[23835] = 0; +inp[23836] = 1046822049; +inp[23837] = 0; +inp[23838] = 1046694271; +inp[23839] = 0; +inp[23840] = 1046566508; +inp[23841] = 0; +inp[23842] = 1046438761; +inp[23843] = 0; +inp[23844] = 1046311030; +inp[23845] = 0; +inp[23846] = 1046183314; +inp[23847] = 0; +inp[23848] = 1046055614; +inp[23849] = 0; +inp[23850] = 1045927929; +inp[23851] = 0; +inp[23852] = 1045800261; +inp[23853] = 0; +inp[23854] = 1045672607; +inp[23855] = 0; +inp[23856] = 1045544969; +inp[23857] = 0; +inp[23858] = 1045417347; +inp[23859] = 0; +inp[23860] = 1045289741; +inp[23861] = 0; +inp[23862] = 1045162149; +inp[23863] = 0; +inp[23864] = 1045034574; +inp[23865] = 0; +inp[23866] = 1044907014; +inp[23867] = 0; +inp[23868] = 1044779470; +inp[23869] = 0; +inp[23870] = 1044651941; +inp[23871] = 0; +inp[23872] = 1044524428; +inp[23873] = 0; +inp[23874] = 1044396930; +inp[23875] = 0; +inp[23876] = 1044269448; +inp[23877] = 0; +inp[23878] = 1044141981; +inp[23879] = 0; +inp[23880] = 1044014531; +inp[23881] = 0; +inp[23882] = 1043887095; +inp[23883] = 0; +inp[23884] = 1043759675; +inp[23885] = 0; +inp[23886] = 1043632271; +inp[23887] = 0; +inp[23888] = 1043504882; +inp[23889] = 0; +inp[23890] = 1043377509; +inp[23891] = 0; +inp[23892] = 1043250151; +inp[23893] = 0; +inp[23894] = 1043122809; +inp[23895] = 0; +inp[23896] = 1042995483; +inp[23897] = 0; +inp[23898] = 1042868172; +inp[23899] = 0; +inp[23900] = 1042740876; +inp[23901] = 0; +inp[23902] = 1042613596; +inp[23903] = 0; +inp[23904] = 1042486332; +inp[23905] = 0; +inp[23906] = 1042359083; +inp[23907] = 0; +inp[23908] = 1042231850; +inp[23909] = 0; +inp[23910] = 1042104632; +inp[23911] = 0; +inp[23912] = 1041977430; +inp[23913] = 0; +inp[23914] = 1041850243; +inp[23915] = 0; +inp[23916] = 1041723072; +inp[23917] = 0; +inp[23918] = 1041595916; +inp[23919] = 0; +inp[23920] = 1041468776; +inp[23921] = 0; +inp[23922] = 1041341651; +inp[23923] = 0; +inp[23924] = 1041214542; +inp[23925] = 0; +inp[23926] = 1041087448; +inp[23927] = 0; +inp[23928] = 1040960370; +inp[23929] = 0; +inp[23930] = 1040833308; +inp[23931] = 0; +inp[23932] = 1073741824; +inp[23933] = 1073741824; +inp[23934] = 1073676289; +inp[23935] = 0; +inp[23936] = 1073610759; +inp[23937] = 0; +inp[23938] = 1073545233; +inp[23939] = 0; +inp[23940] = 1073479711; +inp[23941] = 0; +inp[23942] = 1073414193; +inp[23943] = 0; +inp[23944] = 1073348679; +inp[23945] = 0; +inp[23946] = 1073283169; +inp[23947] = 0; +inp[23948] = 1073217663; +inp[23949] = 0; +inp[23950] = 1073152161; +inp[23951] = 0; +inp[23952] = 1073086663; +inp[23953] = 0; +inp[23954] = 1073021169; +inp[23955] = 0; +inp[23956] = 1072955679; +inp[23957] = 0; +inp[23958] = 1072890193; +inp[23959] = 0; +inp[23960] = 1072824711; +inp[23961] = 0; +inp[23962] = 1072759233; +inp[23963] = 0; +inp[23964] = 1072693759; +inp[23965] = 0; +inp[23966] = 1072628289; +inp[23967] = 0; +inp[23968] = 1072562823; +inp[23969] = 0; +inp[23970] = 1072497361; +inp[23971] = 0; +inp[23972] = 1072431903; +inp[23973] = 0; +inp[23974] = 1072366449; +inp[23975] = 0; +inp[23976] = 1072300999; +inp[23977] = 0; +inp[23978] = 1072235553; +inp[23979] = 0; +inp[23980] = 1072170111; +inp[23981] = 0; +inp[23982] = 1072104673; +inp[23983] = 0; +inp[23984] = 1072039239; +inp[23985] = 0; +inp[23986] = 1071973809; +inp[23987] = 0; +inp[23988] = 1071908383; +inp[23989] = 0; +inp[23990] = 1071842961; +inp[23991] = 0; +inp[23992] = 1071777542; +inp[23993] = 0; +inp[23994] = 1071712128; +inp[23995] = 0; +inp[23996] = 1071646718; +inp[23997] = 0; +inp[23998] = 1071581312; +inp[23999] = 0; +inp[24000] = 1071515910; +inp[24001] = 0; +inp[24002] = 1071450512; +inp[24003] = 0; +inp[24004] = 1071385118; +inp[24005] = 0; +inp[24006] = 1071319727; +inp[24007] = 0; +inp[24008] = 1071254341; +inp[24009] = 0; +inp[24010] = 1071188959; +inp[24011] = 0; +inp[24012] = 1071123581; +inp[24013] = 0; +inp[24014] = 1071058207; +inp[24015] = 0; +inp[24016] = 1070992836; +inp[24017] = 0; +inp[24018] = 1070927470; +inp[24019] = 0; +inp[24020] = 1070862108; +inp[24021] = 0; +inp[24022] = 1070796750; +inp[24023] = 0; +inp[24024] = 1070731396; +inp[24025] = 0; +inp[24026] = 1070666045; +inp[24027] = 0; +inp[24028] = 1070600699; +inp[24029] = 0; +inp[24030] = 1070535357; +inp[24031] = 0; +inp[24032] = 1070470018; +inp[24033] = 0; +inp[24034] = 1070404684; +inp[24035] = 0; +inp[24036] = 1070339354; +inp[24037] = 0; +inp[24038] = 1070274027; +inp[24039] = 0; +inp[24040] = 1070208705; +inp[24041] = 0; +inp[24042] = 1070143387; +inp[24043] = 0; +inp[24044] = 1070078072; +inp[24045] = 0; +inp[24046] = 1070012762; +inp[24047] = 0; +inp[24048] = 1069947456; +inp[24049] = 0; +inp[24050] = 1069882153; +inp[24051] = 0; +inp[24052] = 1069816855; +inp[24053] = 0; +inp[24054] = 1069751560; +inp[24055] = 0; +inp[24056] = 1069686270; +inp[24057] = 0; +inp[24058] = 1069620983; +inp[24059] = 0; +inp[24060] = 1069555701; +inp[24061] = 0; +inp[24062] = 1069490422; +inp[24063] = 0; +inp[24064] = 1069425148; +inp[24065] = 0; +inp[24066] = 1069359877; +inp[24067] = 0; +inp[24068] = 1069294611; +inp[24069] = 0; +inp[24070] = 1069229348; +inp[24071] = 0; +inp[24072] = 1069164090; +inp[24073] = 0; +inp[24074] = 1069098835; +inp[24075] = 0; +inp[24076] = 1069033584; +inp[24077] = 0; +inp[24078] = 1068968338; +inp[24079] = 0; +inp[24080] = 1068903095; +inp[24081] = 0; +inp[24082] = 1068837856; +inp[24083] = 0; +inp[24084] = 1068772622; +inp[24085] = 0; +inp[24086] = 1068707391; +inp[24087] = 0; +inp[24088] = 1068642164; +inp[24089] = 0; +inp[24090] = 1068576941; +inp[24091] = 0; +inp[24092] = 1068511723; +inp[24093] = 0; +inp[24094] = 1068446508; +inp[24095] = 0; +inp[24096] = 1068381297; +inp[24097] = 0; +inp[24098] = 1068316090; +inp[24099] = 0; +inp[24100] = 1068250887; +inp[24101] = 0; +inp[24102] = 1068185689; +inp[24103] = 0; +inp[24104] = 1068120494; +inp[24105] = 0; +inp[24106] = 1068055303; +inp[24107] = 0; +inp[24108] = 1067990116; +inp[24109] = 0; +inp[24110] = 1067924933; +inp[24111] = 0; +inp[24112] = 1067859754; +inp[24113] = 0; +inp[24114] = 1067794579; +inp[24115] = 0; +inp[24116] = 1067729408; +inp[24117] = 0; +inp[24118] = 1067664241; +inp[24119] = 0; +inp[24120] = 1067599078; +inp[24121] = 0; +inp[24122] = 1067533919; +inp[24123] = 0; +inp[24124] = 1067468764; +inp[24125] = 0; +inp[24126] = 1067403612; +inp[24127] = 0; +inp[24128] = 1067338465; +inp[24129] = 0; +inp[24130] = 1067273322; +inp[24131] = 0; +inp[24132] = 1067208183; +inp[24133] = 0; +inp[24134] = 1067143048; +inp[24135] = 0; +inp[24136] = 1067077916; +inp[24137] = 0; +inp[24138] = 1067012789; +inp[24139] = 0; +inp[24140] = 1066947666; +inp[24141] = 0; +inp[24142] = 1066882546; +inp[24143] = 0; +inp[24144] = 1066817431; +inp[24145] = 0; +inp[24146] = 1066752320; +inp[24147] = 0; +inp[24148] = 1066687212; +inp[24149] = 0; +inp[24150] = 1066622109; +inp[24151] = 0; +inp[24152] = 1066557009; +inp[24153] = 0; +inp[24154] = 1066491914; +inp[24155] = 0; +inp[24156] = 1066426822; +inp[24157] = 0; +inp[24158] = 1066361735; +inp[24159] = 0; +inp[24160] = 1066296651; +inp[24161] = 0; +inp[24162] = 1066231572; +inp[24163] = 0; +inp[24164] = 1066166496; +inp[24165] = 0; +inp[24166] = 1066101424; +inp[24167] = 0; +inp[24168] = 1066036357; +inp[24169] = 0; +inp[24170] = 1065971293; +inp[24171] = 0; +inp[24172] = 1065906233; +inp[24173] = 0; +inp[24174] = 1065841178; +inp[24175] = 0; +inp[24176] = 1065776126; +inp[24177] = 0; +inp[24178] = 1065711078; +inp[24179] = 0; +inp[24180] = 1065646034; +inp[24181] = 0; +inp[24182] = 1065580994; +inp[24183] = 0; +inp[24184] = 1065515958; +inp[24185] = 0; +inp[24186] = 1065450926; +inp[24187] = 0; +inp[24188] = 1065385898; +inp[24189] = 0; +inp[24190] = 1065320874; +inp[24191] = 0; +inp[24192] = 1065255854; +inp[24193] = 0; +inp[24194] = 1065190838; +inp[24195] = 0; +inp[24196] = 1065125826; +inp[24197] = 0; +inp[24198] = 1065060818; +inp[24199] = 0; +inp[24200] = 1064995814; +inp[24201] = 0; +inp[24202] = 1064930814; +inp[24203] = 0; +inp[24204] = 1064865817; +inp[24205] = 0; +inp[24206] = 1064800825; +inp[24207] = 0; +inp[24208] = 1064735837; +inp[24209] = 0; +inp[24210] = 1064670852; +inp[24211] = 0; +inp[24212] = 1064605872; +inp[24213] = 0; +inp[24214] = 1064540896; +inp[24215] = 0; +inp[24216] = 1064475923; +inp[24217] = 0; +inp[24218] = 1064410955; +inp[24219] = 0; +inp[24220] = 1064345990; +inp[24221] = 0; +inp[24222] = 1064281030; +inp[24223] = 0; +inp[24224] = 1064216073; +inp[24225] = 0; +inp[24226] = 1064151121; +inp[24227] = 0; +inp[24228] = 1064086172; +inp[24229] = 0; +inp[24230] = 1064021227; +inp[24231] = 0; +inp[24232] = 1063956286; +inp[24233] = 0; +inp[24234] = 1063891350; +inp[24235] = 0; +inp[24236] = 1063826417; +inp[24237] = 0; +inp[24238] = 1063761488; +inp[24239] = 0; +inp[24240] = 1063696563; +inp[24241] = 0; +inp[24242] = 1063631642; +inp[24243] = 0; +inp[24244] = 1063566725; +inp[24245] = 0; +inp[24246] = 1063501812; +inp[24247] = 0; +inp[24248] = 1063436903; +inp[24249] = 0; +inp[24250] = 1063371998; +inp[24251] = 0; +inp[24252] = 1063307097; +inp[24253] = 0; +inp[24254] = 1063242200; +inp[24255] = 0; +inp[24256] = 1063177307; +inp[24257] = 0; +inp[24258] = 1063112418; +inp[24259] = 0; +inp[24260] = 1063047532; +inp[24261] = 0; +inp[24262] = 1062982651; +inp[24263] = 0; +inp[24264] = 1062917774; +inp[24265] = 0; +inp[24266] = 1062852900; +inp[24267] = 0; +inp[24268] = 1062788031; +inp[24269] = 0; +inp[24270] = 1062723166; +inp[24271] = 0; +inp[24272] = 1062658304; +inp[24273] = 0; +inp[24274] = 1062593447; +inp[24275] = 0; +inp[24276] = 1062528593; +inp[24277] = 0; +inp[24278] = 1062463743; +inp[24279] = 0; +inp[24280] = 1062398898; +inp[24281] = 0; +inp[24282] = 1062334056; +inp[24283] = 0; +inp[24284] = 1062269218; +inp[24285] = 0; +inp[24286] = 1062204384; +inp[24287] = 0; +inp[24288] = 1062139555; +inp[24289] = 0; +inp[24290] = 1062074729; +inp[24291] = 0; +inp[24292] = 1062009907; +inp[24293] = 0; +inp[24294] = 1061945089; +inp[24295] = 0; +inp[24296] = 1061880275; +inp[24297] = 0; +inp[24298] = 1061815465; +inp[24299] = 0; +inp[24300] = 1061750659; +inp[24301] = 0; +inp[24302] = 1061685857; +inp[24303] = 0; +inp[24304] = 1061621058; +inp[24305] = 0; +inp[24306] = 1061556264; +inp[24307] = 0; +inp[24308] = 1061491474; +inp[24309] = 0; +inp[24310] = 1061426688; +inp[24311] = 0; +inp[24312] = 1061361905; +inp[24313] = 0; +inp[24314] = 1061297127; +inp[24315] = 0; +inp[24316] = 1061232352; +inp[24317] = 0; +inp[24318] = 1061167582; +inp[24319] = 0; +inp[24320] = 1061102815; +inp[24321] = 0; +inp[24322] = 1061038053; +inp[24323] = 0; +inp[24324] = 1060973294; +inp[24325] = 0; +inp[24326] = 1060908539; +inp[24327] = 0; +inp[24328] = 1060843789; +inp[24329] = 0; +inp[24330] = 1060779042; +inp[24331] = 0; +inp[24332] = 1060714299; +inp[24333] = 0; +inp[24334] = 1060649560; +inp[24335] = 0; +inp[24336] = 1060584825; +inp[24337] = 0; +inp[24338] = 1060520094; +inp[24339] = 0; +inp[24340] = 1060455367; +inp[24341] = 0; +inp[24342] = 1060390644; +inp[24343] = 0; +inp[24344] = 1060325925; +inp[24345] = 0; +inp[24346] = 1060261210; +inp[24347] = 0; +inp[24348] = 1060196498; +inp[24349] = 0; +inp[24350] = 1060131791; +inp[24351] = 0; +inp[24352] = 1060067088; +inp[24353] = 0; +inp[24354] = 1060002388; +inp[24355] = 0; +inp[24356] = 1059937693; +inp[24357] = 0; +inp[24358] = 1059873002; +inp[24359] = 0; +inp[24360] = 1059808314; +inp[24361] = 0; +inp[24362] = 1059743630; +inp[24363] = 0; +inp[24364] = 1059678951; +inp[24365] = 0; +inp[24366] = 1059614275; +inp[24367] = 0; +inp[24368] = 1059549603; +inp[24369] = 0; +inp[24370] = 1059484936; +inp[24371] = 0; +inp[24372] = 1059420272; +inp[24373] = 0; +inp[24374] = 1059355612; +inp[24375] = 0; +inp[24376] = 1059290956; +inp[24377] = 0; +inp[24378] = 1059226304; +inp[24379] = 0; +inp[24380] = 1059161656; +inp[24381] = 0; +inp[24382] = 1059097012; +inp[24383] = 0; +inp[24384] = 1059032371; +inp[24385] = 0; +inp[24386] = 1058967735; +inp[24387] = 0; +inp[24388] = 1058903103; +inp[24389] = 0; +inp[24390] = 1058838475; +inp[24391] = 0; +inp[24392] = 1058773850; +inp[24393] = 0; +inp[24394] = 1058709230; +inp[24395] = 0; +inp[24396] = 1058644613; +inp[24397] = 0; +inp[24398] = 1058580001; +inp[24399] = 0; +inp[24400] = 1058515392; +inp[24401] = 0; +inp[24402] = 1058450787; +inp[24403] = 0; +inp[24404] = 1058386187; +inp[24405] = 0; +inp[24406] = 1058321590; +inp[24407] = 0; +inp[24408] = 1058256997; +inp[24409] = 0; +inp[24410] = 1058192408; +inp[24411] = 0; +inp[24412] = 1058127823; +inp[24413] = 0; +inp[24414] = 1058063242; +inp[24415] = 0; +inp[24416] = 1057998665; +inp[24417] = 0; +inp[24418] = 1057934092; +inp[24419] = 0; +inp[24420] = 1057869523; +inp[24421] = 0; +inp[24422] = 1057804957; +inp[24423] = 0; +inp[24424] = 1057740396; +inp[24425] = 0; +inp[24426] = 1057675839; +inp[24427] = 0; +inp[24428] = 1057611285; +inp[24429] = 0; +inp[24430] = 1057546736; +inp[24431] = 0; +inp[24432] = 1057482190; +inp[24433] = 0; +inp[24434] = 1057417649; +inp[24435] = 0; +inp[24436] = 1057353111; +inp[24437] = 0; +inp[24438] = 1057288577; +inp[24439] = 0; +inp[24440] = 1057224047; +inp[24441] = 0; +inp[24442] = 1057159521; +inp[24443] = 0; +inp[24444] = 1073741824; +inp[24445] = 1073741824; +inp[24446] = 1073709056; +inp[24447] = 0; +inp[24448] = 1073676289; +inp[24449] = 0; +inp[24450] = 1073643524; +inp[24451] = 0; +inp[24452] = 1073610759; +inp[24453] = 0; +inp[24454] = 1073577996; +inp[24455] = 0; +inp[24456] = 1073545233; +inp[24457] = 0; +inp[24458] = 1073512472; +inp[24459] = 0; +inp[24460] = 1073479711; +inp[24461] = 0; +inp[24462] = 1073446952; +inp[24463] = 0; +inp[24464] = 1073414193; +inp[24465] = 0; +inp[24466] = 1073381436; +inp[24467] = 0; +inp[24468] = 1073348679; +inp[24469] = 0; +inp[24470] = 1073315924; +inp[24471] = 0; +inp[24472] = 1073283169; +inp[24473] = 0; +inp[24474] = 1073250416; +inp[24475] = 0; +inp[24476] = 1073217663; +inp[24477] = 0; +inp[24478] = 1073184912; +inp[24479] = 0; +inp[24480] = 1073152161; +inp[24481] = 0; +inp[24482] = 1073119412; +inp[24483] = 0; +inp[24484] = 1073086663; +inp[24485] = 0; +inp[24486] = 1073053916; +inp[24487] = 0; +inp[24488] = 1073021169; +inp[24489] = 0; +inp[24490] = 1072988424; +inp[24491] = 0; +inp[24492] = 1072955679; +inp[24493] = 0; +inp[24494] = 1072922936; +inp[24495] = 0; +inp[24496] = 1072890193; +inp[24497] = 0; +inp[24498] = 1072857452; +inp[24499] = 0; +inp[24500] = 1072824711; +inp[24501] = 0; +inp[24502] = 1072791972; +inp[24503] = 0; +inp[24504] = 1072759233; +inp[24505] = 0; +inp[24506] = 1072726496; +inp[24507] = 0; +inp[24508] = 1072693759; +inp[24509] = 0; +inp[24510] = 1072661024; +inp[24511] = 0; +inp[24512] = 1072628289; +inp[24513] = 0; +inp[24514] = 1072595556; +inp[24515] = 0; +inp[24516] = 1072562823; +inp[24517] = 0; +inp[24518] = 1072530092; +inp[24519] = 0; +inp[24520] = 1072497361; +inp[24521] = 0; +inp[24522] = 1072464632; +inp[24523] = 0; +inp[24524] = 1072431903; +inp[24525] = 0; +inp[24526] = 1072399176; +inp[24527] = 0; +inp[24528] = 1072366449; +inp[24529] = 0; +inp[24530] = 1072333724; +inp[24531] = 0; +inp[24532] = 1072300999; +inp[24533] = 0; +inp[24534] = 1072268276; +inp[24535] = 0; +inp[24536] = 1072235553; +inp[24537] = 0; +inp[24538] = 1072202831; +inp[24539] = 0; +inp[24540] = 1072170111; +inp[24541] = 0; +inp[24542] = 1072137391; +inp[24543] = 0; +inp[24544] = 1072104673; +inp[24545] = 0; +inp[24546] = 1072071955; +inp[24547] = 0; +inp[24548] = 1072039239; +inp[24549] = 0; +inp[24550] = 1072006523; +inp[24551] = 0; +inp[24552] = 1071973809; +inp[24553] = 0; +inp[24554] = 1071941095; +inp[24555] = 0; +inp[24556] = 1071908383; +inp[24557] = 0; +inp[24558] = 1071875671; +inp[24559] = 0; +inp[24560] = 1071842961; +inp[24561] = 0; +inp[24562] = 1071810251; +inp[24563] = 0; +inp[24564] = 1071777542; +inp[24565] = 0; +inp[24566] = 1071744835; +inp[24567] = 0; +inp[24568] = 1071712128; +inp[24569] = 0; +inp[24570] = 1071679423; +inp[24571] = 0; +inp[24572] = 1071646718; +inp[24573] = 0; +inp[24574] = 1071614015; +inp[24575] = 0; +inp[24576] = 1071581312; +inp[24577] = 0; +inp[24578] = 1071548610; +inp[24579] = 0; +inp[24580] = 1071515910; +inp[24581] = 0; +inp[24582] = 1071483210; +inp[24583] = 0; +inp[24584] = 1071450512; +inp[24585] = 0; +inp[24586] = 1071417814; +inp[24587] = 0; +inp[24588] = 1071385118; +inp[24589] = 0; +inp[24590] = 1071352422; +inp[24591] = 0; +inp[24592] = 1071319727; +inp[24593] = 0; +inp[24594] = 1071287034; +inp[24595] = 0; +inp[24596] = 1071254341; +inp[24597] = 0; +inp[24598] = 1071221650; +inp[24599] = 0; +inp[24600] = 1071188959; +inp[24601] = 0; +inp[24602] = 1071156269; +inp[24603] = 0; +inp[24604] = 1071123581; +inp[24605] = 0; +inp[24606] = 1071090893; +inp[24607] = 0; +inp[24608] = 1071058207; +inp[24609] = 0; +inp[24610] = 1071025521; +inp[24611] = 0; +inp[24612] = 1070992836; +inp[24613] = 0; +inp[24614] = 1070960153; +inp[24615] = 0; +inp[24616] = 1070927470; +inp[24617] = 0; +inp[24618] = 1070894789; +inp[24619] = 0; +inp[24620] = 1070862108; +inp[24621] = 0; +inp[24622] = 1070829428; +inp[24623] = 0; +inp[24624] = 1070796750; +inp[24625] = 0; +inp[24626] = 1070764072; +inp[24627] = 0; +inp[24628] = 1070731396; +inp[24629] = 0; +inp[24630] = 1070698720; +inp[24631] = 0; +inp[24632] = 1070666045; +inp[24633] = 0; +inp[24634] = 1070633372; +inp[24635] = 0; +inp[24636] = 1070600699; +inp[24637] = 0; +inp[24638] = 1070568027; +inp[24639] = 0; +inp[24640] = 1070535357; +inp[24641] = 0; +inp[24642] = 1070502687; +inp[24643] = 0; +inp[24644] = 1070470018; +inp[24645] = 0; +inp[24646] = 1070437351; +inp[24647] = 0; +inp[24648] = 1070404684; +inp[24649] = 0; +inp[24650] = 1070372018; +inp[24651] = 0; +inp[24652] = 1070339354; +inp[24653] = 0; +inp[24654] = 1070306690; +inp[24655] = 0; +inp[24656] = 1070274027; +inp[24657] = 0; +inp[24658] = 1070241366; +inp[24659] = 0; +inp[24660] = 1070208705; +inp[24661] = 0; +inp[24662] = 1070176045; +inp[24663] = 0; +inp[24664] = 1070143387; +inp[24665] = 0; +inp[24666] = 1070110729; +inp[24667] = 0; +inp[24668] = 1070078072; +inp[24669] = 0; +inp[24670] = 1070045417; +inp[24671] = 0; +inp[24672] = 1070012762; +inp[24673] = 0; +inp[24674] = 1069980108; +inp[24675] = 0; +inp[24676] = 1069947456; +inp[24677] = 0; +inp[24678] = 1069914804; +inp[24679] = 0; +inp[24680] = 1069882153; +inp[24681] = 0; +inp[24682] = 1069849503; +inp[24683] = 0; +inp[24684] = 1069816855; +inp[24685] = 0; +inp[24686] = 1069784207; +inp[24687] = 0; +inp[24688] = 1069751560; +inp[24689] = 0; +inp[24690] = 1069718915; +inp[24691] = 0; +inp[24692] = 1069686270; +inp[24693] = 0; +inp[24694] = 1069653626; +inp[24695] = 0; +inp[24696] = 1069620983; +inp[24697] = 0; +inp[24698] = 1069588342; +inp[24699] = 0; +inp[24700] = 1069555701; +inp[24701] = 0; +inp[24702] = 1069523061; +inp[24703] = 0; +inp[24704] = 1069490422; +inp[24705] = 0; +inp[24706] = 1069457785; +inp[24707] = 0; +inp[24708] = 1069425148; +inp[24709] = 0; +inp[24710] = 1069392512; +inp[24711] = 0; +inp[24712] = 1069359877; +inp[24713] = 0; +inp[24714] = 1069327243; +inp[24715] = 0; +inp[24716] = 1069294611; +inp[24717] = 0; +inp[24718] = 1069261979; +inp[24719] = 0; +inp[24720] = 1069229348; +inp[24721] = 0; +inp[24722] = 1069196718; +inp[24723] = 0; +inp[24724] = 1069164090; +inp[24725] = 0; +inp[24726] = 1069131462; +inp[24727] = 0; +inp[24728] = 1069098835; +inp[24729] = 0; +inp[24730] = 1069066209; +inp[24731] = 0; +inp[24732] = 1069033584; +inp[24733] = 0; +inp[24734] = 1069000961; +inp[24735] = 0; +inp[24736] = 1068968338; +inp[24737] = 0; +inp[24738] = 1068935716; +inp[24739] = 0; +inp[24740] = 1068903095; +inp[24741] = 0; +inp[24742] = 1068870475; +inp[24743] = 0; +inp[24744] = 1068837856; +inp[24745] = 0; +inp[24746] = 1068805239; +inp[24747] = 0; +inp[24748] = 1068772622; +inp[24749] = 0; +inp[24750] = 1068740006; +inp[24751] = 0; +inp[24752] = 1068707391; +inp[24753] = 0; +inp[24754] = 1068674777; +inp[24755] = 0; +inp[24756] = 1068642164; +inp[24757] = 0; +inp[24758] = 1068609552; +inp[24759] = 0; +inp[24760] = 1068576941; +inp[24761] = 0; +inp[24762] = 1068544332; +inp[24763] = 0; +inp[24764] = 1068511723; +inp[24765] = 0; +inp[24766] = 1068479115; +inp[24767] = 0; +inp[24768] = 1068446508; +inp[24769] = 0; +inp[24770] = 1068413902; +inp[24771] = 0; +inp[24772] = 1068381297; +inp[24773] = 0; +inp[24774] = 1068348693; +inp[24775] = 0; +inp[24776] = 1068316090; +inp[24777] = 0; +inp[24778] = 1068283488; +inp[24779] = 0; +inp[24780] = 1068250887; +inp[24781] = 0; +inp[24782] = 1068218287; +inp[24783] = 0; +inp[24784] = 1068185689; +inp[24785] = 0; +inp[24786] = 1068153091; +inp[24787] = 0; +inp[24788] = 1068120494; +inp[24789] = 0; +inp[24790] = 1068087898; +inp[24791] = 0; +inp[24792] = 1068055303; +inp[24793] = 0; +inp[24794] = 1068022709; +inp[24795] = 0; +inp[24796] = 1067990116; +inp[24797] = 0; +inp[24798] = 1067957524; +inp[24799] = 0; +inp[24800] = 1067924933; +inp[24801] = 0; +inp[24802] = 1067892343; +inp[24803] = 0; +inp[24804] = 1067859754; +inp[24805] = 0; +inp[24806] = 1067827166; +inp[24807] = 0; +inp[24808] = 1067794579; +inp[24809] = 0; +inp[24810] = 1067761993; +inp[24811] = 0; +inp[24812] = 1067729408; +inp[24813] = 0; +inp[24814] = 1067696824; +inp[24815] = 0; +inp[24816] = 1067664241; +inp[24817] = 0; +inp[24818] = 1067631659; +inp[24819] = 0; +inp[24820] = 1067599078; +inp[24821] = 0; +inp[24822] = 1067566498; +inp[24823] = 0; +inp[24824] = 1067533919; +inp[24825] = 0; +inp[24826] = 1067501341; +inp[24827] = 0; +inp[24828] = 1067468764; +inp[24829] = 0; +inp[24830] = 1067436187; +inp[24831] = 0; +inp[24832] = 1067403612; +inp[24833] = 0; +inp[24834] = 1067371038; +inp[24835] = 0; +inp[24836] = 1067338465; +inp[24837] = 0; +inp[24838] = 1067305893; +inp[24839] = 0; +inp[24840] = 1067273322; +inp[24841] = 0; +inp[24842] = 1067240752; +inp[24843] = 0; +inp[24844] = 1067208183; +inp[24845] = 0; +inp[24846] = 1067175615; +inp[24847] = 0; +inp[24848] = 1067143048; +inp[24849] = 0; +inp[24850] = 1067110482; +inp[24851] = 0; +inp[24852] = 1067077916; +inp[24853] = 0; +inp[24854] = 1067045352; +inp[24855] = 0; +inp[24856] = 1067012789; +inp[24857] = 0; +inp[24858] = 1066980227; +inp[24859] = 0; +inp[24860] = 1066947666; +inp[24861] = 0; +inp[24862] = 1066915106; +inp[24863] = 0; +inp[24864] = 1066882546; +inp[24865] = 0; +inp[24866] = 1066849988; +inp[24867] = 0; +inp[24868] = 1066817431; +inp[24869] = 0; +inp[24870] = 1066784875; +inp[24871] = 0; +inp[24872] = 1066752320; +inp[24873] = 0; +inp[24874] = 1066719766; +inp[24875] = 0; +inp[24876] = 1066687212; +inp[24877] = 0; +inp[24878] = 1066654660; +inp[24879] = 0; +inp[24880] = 1066622109; +inp[24881] = 0; +inp[24882] = 1066589559; +inp[24883] = 0; +inp[24884] = 1066557009; +inp[24885] = 0; +inp[24886] = 1066524461; +inp[24887] = 0; +inp[24888] = 1066491914; +inp[24889] = 0; +inp[24890] = 1066459368; +inp[24891] = 0; +inp[24892] = 1066426822; +inp[24893] = 0; +inp[24894] = 1066394278; +inp[24895] = 0; +inp[24896] = 1066361735; +inp[24897] = 0; +inp[24898] = 1066329193; +inp[24899] = 0; +inp[24900] = 1066296651; +inp[24901] = 0; +inp[24902] = 1066264111; +inp[24903] = 0; +inp[24904] = 1066231572; +inp[24905] = 0; +inp[24906] = 1066199033; +inp[24907] = 0; +inp[24908] = 1066166496; +inp[24909] = 0; +inp[24910] = 1066133960; +inp[24911] = 0; +inp[24912] = 1066101424; +inp[24913] = 0; +inp[24914] = 1066068890; +inp[24915] = 0; +inp[24916] = 1066036357; +inp[24917] = 0; +inp[24918] = 1066003824; +inp[24919] = 0; +inp[24920] = 1065971293; +inp[24921] = 0; +inp[24922] = 1065938763; +inp[24923] = 0; +inp[24924] = 1065906233; +inp[24925] = 0; +inp[24926] = 1065873705; +inp[24927] = 0; +inp[24928] = 1065841178; +inp[24929] = 0; +inp[24930] = 1065808651; +inp[24931] = 0; +inp[24932] = 1065776126; +inp[24933] = 0; +inp[24934] = 1065743601; +inp[24935] = 0; +inp[24936] = 1065711078; +inp[24937] = 0; +inp[24938] = 1065678555; +inp[24939] = 0; +inp[24940] = 1065646034; +inp[24941] = 0; +inp[24942] = 1065613514; +inp[24943] = 0; +inp[24944] = 1065580994; +inp[24945] = 0; +inp[24946] = 1065548476; +inp[24947] = 0; +inp[24948] = 1065515958; +inp[24949] = 0; +inp[24950] = 1065483442; +inp[24951] = 0; +inp[24952] = 1065450926; +inp[24953] = 0; +inp[24954] = 1065418412; +inp[24955] = 0; +inp[24956] = 1073741824; +inp[24957] = 1073741824; +inp[24958] = 1073725440; +inp[24959] = 0; +inp[24960] = 1073709056; +inp[24961] = 0; +inp[24962] = 1073692673; +inp[24963] = 0; +inp[24964] = 1073676289; +inp[24965] = 0; +inp[24966] = 1073659907; +inp[24967] = 0; +inp[24968] = 1073643524; +inp[24969] = 0; +inp[24970] = 1073627142; +inp[24971] = 0; +inp[24972] = 1073610759; +inp[24973] = 0; +inp[24974] = 1073594378; +inp[24975] = 0; +inp[24976] = 1073577996; +inp[24977] = 0; +inp[24978] = 1073561615; +inp[24979] = 0; +inp[24980] = 1073545233; +inp[24981] = 0; +inp[24982] = 1073528853; +inp[24983] = 0; +inp[24984] = 1073512472; +inp[24985] = 0; +inp[24986] = 1073496092; +inp[24987] = 0; +inp[24988] = 1073479711; +inp[24989] = 0; +inp[24990] = 1073463332; +inp[24991] = 0; +inp[24992] = 1073446952; +inp[24993] = 0; +inp[24994] = 1073430573; +inp[24995] = 0; +inp[24996] = 1073414193; +inp[24997] = 0; +inp[24998] = 1073397815; +inp[24999] = 0; +inp[25000] = 1073381436; +inp[25001] = 0; +inp[25002] = 1073365058; +inp[25003] = 0; +inp[25004] = 1073348679; +inp[25005] = 0; +inp[25006] = 1073332302; +inp[25007] = 0; +inp[25008] = 1073315924; +inp[25009] = 0; +inp[25010] = 1073299547; +inp[25011] = 0; +inp[25012] = 1073283169; +inp[25013] = 0; +inp[25014] = 1073266793; +inp[25015] = 0; +inp[25016] = 1073250416; +inp[25017] = 0; +inp[25018] = 1073234040; +inp[25019] = 0; +inp[25020] = 1073217663; +inp[25021] = 0; +inp[25022] = 1073201288; +inp[25023] = 0; +inp[25024] = 1073184912; +inp[25025] = 0; +inp[25026] = 1073168537; +inp[25027] = 0; +inp[25028] = 1073152161; +inp[25029] = 0; +inp[25030] = 1073135787; +inp[25031] = 0; +inp[25032] = 1073119412; +inp[25033] = 0; +inp[25034] = 1073103038; +inp[25035] = 0; +inp[25036] = 1073086663; +inp[25037] = 0; +inp[25038] = 1073070290; +inp[25039] = 0; +inp[25040] = 1073053916; +inp[25041] = 0; +inp[25042] = 1073037543; +inp[25043] = 0; +inp[25044] = 1073021169; +inp[25045] = 0; +inp[25046] = 1073004797; +inp[25047] = 0; +inp[25048] = 1072988424; +inp[25049] = 0; +inp[25050] = 1072972052; +inp[25051] = 0; +inp[25052] = 1072955679; +inp[25053] = 0; +inp[25054] = 1072939308; +inp[25055] = 0; +inp[25056] = 1072922936; +inp[25057] = 0; +inp[25058] = 1072906565; +inp[25059] = 0; +inp[25060] = 1072890193; +inp[25061] = 0; +inp[25062] = 1072873823; +inp[25063] = 0; +inp[25064] = 1072857452; +inp[25065] = 0; +inp[25066] = 1072841082; +inp[25067] = 0; +inp[25068] = 1072824711; +inp[25069] = 0; +inp[25070] = 1072808342; +inp[25071] = 0; +inp[25072] = 1072791972; +inp[25073] = 0; +inp[25074] = 1072775602; +inp[25075] = 0; +inp[25076] = 1072759233; +inp[25077] = 0; +inp[25078] = 1072742864; +inp[25079] = 0; +inp[25080] = 1072726496; +inp[25081] = 0; +inp[25082] = 1072710127; +inp[25083] = 0; +inp[25084] = 1072693759; +inp[25085] = 0; +inp[25086] = 1072677391; +inp[25087] = 0; +inp[25088] = 1072661024; +inp[25089] = 0; +inp[25090] = 1072644656; +inp[25091] = 0; +inp[25092] = 1072628289; +inp[25093] = 0; +inp[25094] = 1072611922; +inp[25095] = 0; +inp[25096] = 1072595556; +inp[25097] = 0; +inp[25098] = 1072579189; +inp[25099] = 0; +inp[25100] = 1072562823; +inp[25101] = 0; +inp[25102] = 1072546457; +inp[25103] = 0; +inp[25104] = 1072530092; +inp[25105] = 0; +inp[25106] = 1072513726; +inp[25107] = 0; +inp[25108] = 1072497361; +inp[25109] = 0; +inp[25110] = 1072480996; +inp[25111] = 0; +inp[25112] = 1072464632; +inp[25113] = 0; +inp[25114] = 1072448267; +inp[25115] = 0; +inp[25116] = 1072431903; +inp[25117] = 0; +inp[25118] = 1072415539; +inp[25119] = 0; +inp[25120] = 1072399176; +inp[25121] = 0; +inp[25122] = 1072382812; +inp[25123] = 0; +inp[25124] = 1072366449; +inp[25125] = 0; +inp[25126] = 1072350086; +inp[25127] = 0; +inp[25128] = 1072333724; +inp[25129] = 0; +inp[25130] = 1072317361; +inp[25131] = 0; +inp[25132] = 1072300999; +inp[25133] = 0; +inp[25134] = 1072284637; +inp[25135] = 0; +inp[25136] = 1072268276; +inp[25137] = 0; +inp[25138] = 1072251914; +inp[25139] = 0; +inp[25140] = 1072235553; +inp[25141] = 0; +inp[25142] = 1072219192; +inp[25143] = 0; +inp[25144] = 1072202831; +inp[25145] = 0; +inp[25146] = 1072186471; +inp[25147] = 0; +inp[25148] = 1072170111; +inp[25149] = 0; +inp[25150] = 1072153751; +inp[25151] = 0; +inp[25152] = 1072137391; +inp[25153] = 0; +inp[25154] = 1072121032; +inp[25155] = 0; +inp[25156] = 1072104673; +inp[25157] = 0; +inp[25158] = 1072088314; +inp[25159] = 0; +inp[25160] = 1072071955; +inp[25161] = 0; +inp[25162] = 1072055597; +inp[25163] = 0; +inp[25164] = 1072039239; +inp[25165] = 0; +inp[25166] = 1072022881; +inp[25167] = 0; +inp[25168] = 1072006523; +inp[25169] = 0; +inp[25170] = 1071990166; +inp[25171] = 0; +inp[25172] = 1071973809; +inp[25173] = 0; +inp[25174] = 1071957452; +inp[25175] = 0; +inp[25176] = 1071941095; +inp[25177] = 0; +inp[25178] = 1071924739; +inp[25179] = 0; +inp[25180] = 1071908383; +inp[25181] = 0; +inp[25182] = 1071892027; +inp[25183] = 0; +inp[25184] = 1071875671; +inp[25185] = 0; +inp[25186] = 1071859316; +inp[25187] = 0; +inp[25188] = 1071842961; +inp[25189] = 0; +inp[25190] = 1071826606; +inp[25191] = 0; +inp[25192] = 1071810251; +inp[25193] = 0; +inp[25194] = 1071793897; +inp[25195] = 0; +inp[25196] = 1071777542; +inp[25197] = 0; +inp[25198] = 1071761188; +inp[25199] = 0; +inp[25200] = 1071744835; +inp[25201] = 0; +inp[25202] = 1071728481; +inp[25203] = 0; +inp[25204] = 1071712128; +inp[25205] = 0; +inp[25206] = 1071695775; +inp[25207] = 0; +inp[25208] = 1071679423; +inp[25209] = 0; +inp[25210] = 1071663070; +inp[25211] = 0; +inp[25212] = 1071646718; +inp[25213] = 0; +inp[25214] = 1071630366; +inp[25215] = 0; +inp[25216] = 1071614015; +inp[25217] = 0; +inp[25218] = 1071597663; +inp[25219] = 0; +inp[25220] = 1071581312; +inp[25221] = 0; +inp[25222] = 1071564961; +inp[25223] = 0; +inp[25224] = 1071548610; +inp[25225] = 0; +inp[25226] = 1071532260; +inp[25227] = 0; +inp[25228] = 1071515910; +inp[25229] = 0; +inp[25230] = 1071499560; +inp[25231] = 0; +inp[25232] = 1071483210; +inp[25233] = 0; +inp[25234] = 1071466861; +inp[25235] = 0; +inp[25236] = 1071450512; +inp[25237] = 0; +inp[25238] = 1071434163; +inp[25239] = 0; +inp[25240] = 1071417814; +inp[25241] = 0; +inp[25242] = 1071401466; +inp[25243] = 0; +inp[25244] = 1071385118; +inp[25245] = 0; +inp[25246] = 1071368770; +inp[25247] = 0; +inp[25248] = 1071352422; +inp[25249] = 0; +inp[25250] = 1071336075; +inp[25251] = 0; +inp[25252] = 1071319727; +inp[25253] = 0; +inp[25254] = 1071303381; +inp[25255] = 0; +inp[25256] = 1071287034; +inp[25257] = 0; +inp[25258] = 1071270687; +inp[25259] = 0; +inp[25260] = 1071254341; +inp[25261] = 0; +inp[25262] = 1071237995; +inp[25263] = 0; +inp[25264] = 1071221650; +inp[25265] = 0; +inp[25266] = 1071205304; +inp[25267] = 0; +inp[25268] = 1071188959; +inp[25269] = 0; +inp[25270] = 1071172614; +inp[25271] = 0; +inp[25272] = 1071156269; +inp[25273] = 0; +inp[25274] = 1071139925; +inp[25275] = 0; +inp[25276] = 1071123581; +inp[25277] = 0; +inp[25278] = 1071107237; +inp[25279] = 0; +inp[25280] = 1071090893; +inp[25281] = 0; +inp[25282] = 1071074550; +inp[25283] = 0; +inp[25284] = 1071058207; +inp[25285] = 0; +inp[25286] = 1071041864; +inp[25287] = 0; +inp[25288] = 1071025521; +inp[25289] = 0; +inp[25290] = 1071009179; +inp[25291] = 0; +inp[25292] = 1070992836; +inp[25293] = 0; +inp[25294] = 1070976495; +inp[25295] = 0; +inp[25296] = 1070960153; +inp[25297] = 0; +inp[25298] = 1070943811; +inp[25299] = 0; +inp[25300] = 1070927470; +inp[25301] = 0; +inp[25302] = 1070911129; +inp[25303] = 0; +inp[25304] = 1070894789; +inp[25305] = 0; +inp[25306] = 1070878448; +inp[25307] = 0; +inp[25308] = 1070862108; +inp[25309] = 0; +inp[25310] = 1070845768; +inp[25311] = 0; +inp[25312] = 1070829428; +inp[25313] = 0; +inp[25314] = 1070813089; +inp[25315] = 0; +inp[25316] = 1070796750; +inp[25317] = 0; +inp[25318] = 1070780411; +inp[25319] = 0; +inp[25320] = 1070764072; +inp[25321] = 0; +inp[25322] = 1070747734; +inp[25323] = 0; +inp[25324] = 1070731396; +inp[25325] = 0; +inp[25326] = 1070715058; +inp[25327] = 0; +inp[25328] = 1070698720; +inp[25329] = 0; +inp[25330] = 1070682382; +inp[25331] = 0; +inp[25332] = 1070666045; +inp[25333] = 0; +inp[25334] = 1070649708; +inp[25335] = 0; +inp[25336] = 1070633372; +inp[25337] = 0; +inp[25338] = 1070617035; +inp[25339] = 0; +inp[25340] = 1070600699; +inp[25341] = 0; +inp[25342] = 1070584363; +inp[25343] = 0; +inp[25344] = 1070568027; +inp[25345] = 0; +inp[25346] = 1070551692; +inp[25347] = 0; +inp[25348] = 1070535357; +inp[25349] = 0; +inp[25350] = 1070519022; +inp[25351] = 0; +inp[25352] = 1070502687; +inp[25353] = 0; +inp[25354] = 1070486353; +inp[25355] = 0; +inp[25356] = 1070470018; +inp[25357] = 0; +inp[25358] = 1070453684; +inp[25359] = 0; +inp[25360] = 1070437351; +inp[25361] = 0; +inp[25362] = 1070421017; +inp[25363] = 0; +inp[25364] = 1070404684; +inp[25365] = 0; +inp[25366] = 1070388351; +inp[25367] = 0; +inp[25368] = 1070372018; +inp[25369] = 0; +inp[25370] = 1070355686; +inp[25371] = 0; +inp[25372] = 1070339354; +inp[25373] = 0; +inp[25374] = 1070323022; +inp[25375] = 0; +inp[25376] = 1070306690; +inp[25377] = 0; +inp[25378] = 1070290359; +inp[25379] = 0; +inp[25380] = 1070274027; +inp[25381] = 0; +inp[25382] = 1070257696; +inp[25383] = 0; +inp[25384] = 1070241366; +inp[25385] = 0; +inp[25386] = 1070225035; +inp[25387] = 0; +inp[25388] = 1070208705; +inp[25389] = 0; +inp[25390] = 1070192375; +inp[25391] = 0; +inp[25392] = 1070176045; +inp[25393] = 0; +inp[25394] = 1070159716; +inp[25395] = 0; +inp[25396] = 1070143387; +inp[25397] = 0; +inp[25398] = 1070127058; +inp[25399] = 0; +inp[25400] = 1070110729; +inp[25401] = 0; +inp[25402] = 1070094401; +inp[25403] = 0; +inp[25404] = 1070078072; +inp[25405] = 0; +inp[25406] = 1070061744; +inp[25407] = 0; +inp[25408] = 1070045417; +inp[25409] = 0; +inp[25410] = 1070029089; +inp[25411] = 0; +inp[25412] = 1070012762; +inp[25413] = 0; +inp[25414] = 1069996435; +inp[25415] = 0; +inp[25416] = 1069980108; +inp[25417] = 0; +inp[25418] = 1069963782; +inp[25419] = 0; +inp[25420] = 1069947456; +inp[25421] = 0; +inp[25422] = 1069931130; +inp[25423] = 0; +inp[25424] = 1069914804; +inp[25425] = 0; +inp[25426] = 1069898478; +inp[25427] = 0; +inp[25428] = 1069882153; +inp[25429] = 0; +inp[25430] = 1069865828; +inp[25431] = 0; +inp[25432] = 1069849503; +inp[25433] = 0; +inp[25434] = 1069833179; +inp[25435] = 0; +inp[25436] = 1069816855; +inp[25437] = 0; +inp[25438] = 1069800531; +inp[25439] = 0; +inp[25440] = 1069784207; +inp[25441] = 0; +inp[25442] = 1069767884; +inp[25443] = 0; +inp[25444] = 1069751560; +inp[25445] = 0; +inp[25446] = 1069735237; +inp[25447] = 0; +inp[25448] = 1069718915; +inp[25449] = 0; +inp[25450] = 1069702592; +inp[25451] = 0; +inp[25452] = 1069686270; +inp[25453] = 0; +inp[25454] = 1069669948; +inp[25455] = 0; +inp[25456] = 1069653626; +inp[25457] = 0; +inp[25458] = 1069637305; +inp[25459] = 0; +inp[25460] = 1069620983; +inp[25461] = 0; +inp[25462] = 1069604662; +inp[25463] = 0; +inp[25464] = 1069588342; +inp[25465] = 0; +inp[25466] = 1069572021; +inp[25467] = 0; +inp[25468] = 1073741824; +inp[25469] = 1073741824; +inp[25470] = 1073733632; +inp[25471] = 0; +inp[25472] = 1073725440; +inp[25473] = 0; +inp[25474] = 1073717248; +inp[25475] = 0; +inp[25476] = 1073709056; +inp[25477] = 0; +inp[25478] = 1073700864; +inp[25479] = 0; +inp[25480] = 1073692673; +inp[25481] = 0; +inp[25482] = 1073684481; +inp[25483] = 0; +inp[25484] = 1073676289; +inp[25485] = 0; +inp[25486] = 1073668098; +inp[25487] = 0; +inp[25488] = 1073659907; +inp[25489] = 0; +inp[25490] = 1073651715; +inp[25491] = 0; +inp[25492] = 1073643524; +inp[25493] = 0; +inp[25494] = 1073635333; +inp[25495] = 0; +inp[25496] = 1073627142; +inp[25497] = 0; +inp[25498] = 1073618951; +inp[25499] = 0; +inp[25500] = 1073610759; +inp[25501] = 0; +inp[25502] = 1073602569; +inp[25503] = 0; +inp[25504] = 1073594378; +inp[25505] = 0; +inp[25506] = 1073586187; +inp[25507] = 0; +inp[25508] = 1073577996; +inp[25509] = 0; +inp[25510] = 1073569805; +inp[25511] = 0; +inp[25512] = 1073561615; +inp[25513] = 0; +inp[25514] = 1073553424; +inp[25515] = 0; +inp[25516] = 1073545233; +inp[25517] = 0; +inp[25518] = 1073537043; +inp[25519] = 0; +inp[25520] = 1073528853; +inp[25521] = 0; +inp[25522] = 1073520662; +inp[25523] = 0; +inp[25524] = 1073512472; +inp[25525] = 0; +inp[25526] = 1073504282; +inp[25527] = 0; +inp[25528] = 1073496092; +inp[25529] = 0; +inp[25530] = 1073487902; +inp[25531] = 0; +inp[25532] = 1073479711; +inp[25533] = 0; +inp[25534] = 1073471522; +inp[25535] = 0; +inp[25536] = 1073463332; +inp[25537] = 0; +inp[25538] = 1073455142; +inp[25539] = 0; +inp[25540] = 1073446952; +inp[25541] = 0; +inp[25542] = 1073438762; +inp[25543] = 0; +inp[25544] = 1073430573; +inp[25545] = 0; +inp[25546] = 1073422383; +inp[25547] = 0; +inp[25548] = 1073414193; +inp[25549] = 0; +inp[25550] = 1073406004; +inp[25551] = 0; +inp[25552] = 1073397815; +inp[25553] = 0; +inp[25554] = 1073389625; +inp[25555] = 0; +inp[25556] = 1073381436; +inp[25557] = 0; +inp[25558] = 1073373247; +inp[25559] = 0; +inp[25560] = 1073365058; +inp[25561] = 0; +inp[25562] = 1073356869; +inp[25563] = 0; +inp[25564] = 1073348679; +inp[25565] = 0; +inp[25566] = 1073340491; +inp[25567] = 0; +inp[25568] = 1073332302; +inp[25569] = 0; +inp[25570] = 1073324113; +inp[25571] = 0; +inp[25572] = 1073315924; +inp[25573] = 0; +inp[25574] = 1073307735; +inp[25575] = 0; +inp[25576] = 1073299547; +inp[25577] = 0; +inp[25578] = 1073291358; +inp[25579] = 0; +inp[25580] = 1073283169; +inp[25581] = 0; +inp[25582] = 1073274981; +inp[25583] = 0; +inp[25584] = 1073266793; +inp[25585] = 0; +inp[25586] = 1073258604; +inp[25587] = 0; +inp[25588] = 1073250416; +inp[25589] = 0; +inp[25590] = 1073242228; +inp[25591] = 0; +inp[25592] = 1073234040; +inp[25593] = 0; +inp[25594] = 1073225852; +inp[25595] = 0; +inp[25596] = 1073217663; +inp[25597] = 0; +inp[25598] = 1073209476; +inp[25599] = 0; +inp[25600] = 1073201288; +inp[25601] = 0; +inp[25602] = 1073193100; +inp[25603] = 0; +inp[25604] = 1073184912; +inp[25605] = 0; +inp[25606] = 1073176724; +inp[25607] = 0; +inp[25608] = 1073168537; +inp[25609] = 0; +inp[25610] = 1073160349; +inp[25611] = 0; +inp[25612] = 1073152161; +inp[25613] = 0; +inp[25614] = 1073143974; +inp[25615] = 0; +inp[25616] = 1073135787; +inp[25617] = 0; +inp[25618] = 1073127599; +inp[25619] = 0; +inp[25620] = 1073119412; +inp[25621] = 0; +inp[25622] = 1073111225; +inp[25623] = 0; +inp[25624] = 1073103038; +inp[25625] = 0; +inp[25626] = 1073094850; +inp[25627] = 0; +inp[25628] = 1073086663; +inp[25629] = 0; +inp[25630] = 1073078476; +inp[25631] = 0; +inp[25632] = 1073070290; +inp[25633] = 0; +inp[25634] = 1073062103; +inp[25635] = 0; +inp[25636] = 1073053916; +inp[25637] = 0; +inp[25638] = 1073045729; +inp[25639] = 0; +inp[25640] = 1073037543; +inp[25641] = 0; +inp[25642] = 1073029356; +inp[25643] = 0; +inp[25644] = 1073021169; +inp[25645] = 0; +inp[25646] = 1073012983; +inp[25647] = 0; +inp[25648] = 1073004797; +inp[25649] = 0; +inp[25650] = 1072996610; +inp[25651] = 0; +inp[25652] = 1072988424; +inp[25653] = 0; +inp[25654] = 1072980238; +inp[25655] = 0; +inp[25656] = 1072972052; +inp[25657] = 0; +inp[25658] = 1072963865; +inp[25659] = 0; +inp[25660] = 1072955679; +inp[25661] = 0; +inp[25662] = 1072947493; +inp[25663] = 0; +inp[25664] = 1072939308; +inp[25665] = 0; +inp[25666] = 1072931122; +inp[25667] = 0; +inp[25668] = 1072922936; +inp[25669] = 0; +inp[25670] = 1072914750; +inp[25671] = 0; +inp[25672] = 1072906565; +inp[25673] = 0; +inp[25674] = 1072898379; +inp[25675] = 0; +inp[25676] = 1072890193; +inp[25677] = 0; +inp[25678] = 1072882008; +inp[25679] = 0; +inp[25680] = 1072873823; +inp[25681] = 0; +inp[25682] = 1072865637; +inp[25683] = 0; +inp[25684] = 1072857452; +inp[25685] = 0; +inp[25686] = 1072849267; +inp[25687] = 0; +inp[25688] = 1072841082; +inp[25689] = 0; +inp[25690] = 1072832896; +inp[25691] = 0; +inp[25692] = 1072824711; +inp[25693] = 0; +inp[25694] = 1072816526; +inp[25695] = 0; +inp[25696] = 1072808342; +inp[25697] = 0; +inp[25698] = 1072800157; +inp[25699] = 0; +inp[25700] = 1072791972; +inp[25701] = 0; +inp[25702] = 1072783787; +inp[25703] = 0; +inp[25704] = 1072775602; +inp[25705] = 0; +inp[25706] = 1072767418; +inp[25707] = 0; +inp[25708] = 1072759233; +inp[25709] = 0; +inp[25710] = 1072751049; +inp[25711] = 0; +inp[25712] = 1072742864; +inp[25713] = 0; +inp[25714] = 1072734680; +inp[25715] = 0; +inp[25716] = 1072726496; +inp[25717] = 0; +inp[25718] = 1072718312; +inp[25719] = 0; +inp[25720] = 1072710127; +inp[25721] = 0; +inp[25722] = 1072701943; +inp[25723] = 0; +inp[25724] = 1072693759; +inp[25725] = 0; +inp[25726] = 1072685575; +inp[25727] = 0; +inp[25728] = 1072677391; +inp[25729] = 0; +inp[25730] = 1072669208; +inp[25731] = 0; +inp[25732] = 1072661024; +inp[25733] = 0; +inp[25734] = 1072652840; +inp[25735] = 0; +inp[25736] = 1072644656; +inp[25737] = 0; +inp[25738] = 1072636473; +inp[25739] = 0; +inp[25740] = 1072628289; +inp[25741] = 0; +inp[25742] = 1072620106; +inp[25743] = 0; +inp[25744] = 1072611922; +inp[25745] = 0; +inp[25746] = 1072603739; +inp[25747] = 0; +inp[25748] = 1072595556; +inp[25749] = 0; +inp[25750] = 1072587373; +inp[25751] = 0; +inp[25752] = 1072579189; +inp[25753] = 0; +inp[25754] = 1072571006; +inp[25755] = 0; +inp[25756] = 1072562823; +inp[25757] = 0; +inp[25758] = 1072554640; +inp[25759] = 0; +inp[25760] = 1072546457; +inp[25761] = 0; +inp[25762] = 1072538275; +inp[25763] = 0; +inp[25764] = 1072530092; +inp[25765] = 0; +inp[25766] = 1072521909; +inp[25767] = 0; +inp[25768] = 1072513726; +inp[25769] = 0; +inp[25770] = 1072505544; +inp[25771] = 0; +inp[25772] = 1072497361; +inp[25773] = 0; +inp[25774] = 1072489179; +inp[25775] = 0; +inp[25776] = 1072480996; +inp[25777] = 0; +inp[25778] = 1072472814; +inp[25779] = 0; +inp[25780] = 1072464632; +inp[25781] = 0; +inp[25782] = 1072456449; +inp[25783] = 0; +inp[25784] = 1072448267; +inp[25785] = 0; +inp[25786] = 1072440085; +inp[25787] = 0; +inp[25788] = 1072431903; +inp[25789] = 0; +inp[25790] = 1072423721; +inp[25791] = 0; +inp[25792] = 1072415539; +inp[25793] = 0; +inp[25794] = 1072407357; +inp[25795] = 0; +inp[25796] = 1072399176; +inp[25797] = 0; +inp[25798] = 1072390994; +inp[25799] = 0; +inp[25800] = 1072382812; +inp[25801] = 0; +inp[25802] = 1072374631; +inp[25803] = 0; +inp[25804] = 1072366449; +inp[25805] = 0; +inp[25806] = 1072358268; +inp[25807] = 0; +inp[25808] = 1072350086; +inp[25809] = 0; +inp[25810] = 1072341905; +inp[25811] = 0; +inp[25812] = 1072333724; +inp[25813] = 0; +inp[25814] = 1072325542; +inp[25815] = 0; +inp[25816] = 1072317361; +inp[25817] = 0; +inp[25818] = 1072309180; +inp[25819] = 0; +inp[25820] = 1072300999; +inp[25821] = 0; +inp[25822] = 1072292818; +inp[25823] = 0; +inp[25824] = 1072284637; +inp[25825] = 0; +inp[25826] = 1072276456; +inp[25827] = 0; +inp[25828] = 1072268276; +inp[25829] = 0; +inp[25830] = 1072260095; +inp[25831] = 0; +inp[25832] = 1072251914; +inp[25833] = 0; +inp[25834] = 1072243734; +inp[25835] = 0; +inp[25836] = 1072235553; +inp[25837] = 0; +inp[25838] = 1072227373; +inp[25839] = 0; +inp[25840] = 1072219192; +inp[25841] = 0; +inp[25842] = 1072211012; +inp[25843] = 0; +inp[25844] = 1072202831; +inp[25845] = 0; +inp[25846] = 1072194651; +inp[25847] = 0; +inp[25848] = 1072186471; +inp[25849] = 0; +inp[25850] = 1072178291; +inp[25851] = 0; +inp[25852] = 1072170111; +inp[25853] = 0; +inp[25854] = 1072161931; +inp[25855] = 0; +inp[25856] = 1072153751; +inp[25857] = 0; +inp[25858] = 1072145571; +inp[25859] = 0; +inp[25860] = 1072137391; +inp[25861] = 0; +inp[25862] = 1072129212; +inp[25863] = 0; +inp[25864] = 1072121032; +inp[25865] = 0; +inp[25866] = 1072112852; +inp[25867] = 0; +inp[25868] = 1072104673; +inp[25869] = 0; +inp[25870] = 1072096493; +inp[25871] = 0; +inp[25872] = 1072088314; +inp[25873] = 0; +inp[25874] = 1072080135; +inp[25875] = 0; +inp[25876] = 1072071955; +inp[25877] = 0; +inp[25878] = 1072063776; +inp[25879] = 0; +inp[25880] = 1072055597; +inp[25881] = 0; +inp[25882] = 1072047418; +inp[25883] = 0; +inp[25884] = 1072039239; +inp[25885] = 0; +inp[25886] = 1072031060; +inp[25887] = 0; +inp[25888] = 1072022881; +inp[25889] = 0; +inp[25890] = 1072014702; +inp[25891] = 0; +inp[25892] = 1072006523; +inp[25893] = 0; +inp[25894] = 1071998345; +inp[25895] = 0; +inp[25896] = 1071990166; +inp[25897] = 0; +inp[25898] = 1071981987; +inp[25899] = 0; +inp[25900] = 1071973809; +inp[25901] = 0; +inp[25902] = 1071965630; +inp[25903] = 0; +inp[25904] = 1071957452; +inp[25905] = 0; +inp[25906] = 1071949273; +inp[25907] = 0; +inp[25908] = 1071941095; +inp[25909] = 0; +inp[25910] = 1071932917; +inp[25911] = 0; +inp[25912] = 1071924739; +inp[25913] = 0; +inp[25914] = 1071916561; +inp[25915] = 0; +inp[25916] = 1071908383; +inp[25917] = 0; +inp[25918] = 1071900205; +inp[25919] = 0; +inp[25920] = 1071892027; +inp[25921] = 0; +inp[25922] = 1071883849; +inp[25923] = 0; +inp[25924] = 1071875671; +inp[25925] = 0; +inp[25926] = 1071867493; +inp[25927] = 0; +inp[25928] = 1071859316; +inp[25929] = 0; +inp[25930] = 1071851138; +inp[25931] = 0; +inp[25932] = 1071842961; +inp[25933] = 0; +inp[25934] = 1071834783; +inp[25935] = 0; +inp[25936] = 1071826606; +inp[25937] = 0; +inp[25938] = 1071818428; +inp[25939] = 0; +inp[25940] = 1071810251; +inp[25941] = 0; +inp[25942] = 1071802074; +inp[25943] = 0; +inp[25944] = 1071793897; +inp[25945] = 0; +inp[25946] = 1071785719; +inp[25947] = 0; +inp[25948] = 1071777542; +inp[25949] = 0; +inp[25950] = 1071769365; +inp[25951] = 0; +inp[25952] = 1071761188; +inp[25953] = 0; +inp[25954] = 1071753012; +inp[25955] = 0; +inp[25956] = 1071744835; +inp[25957] = 0; +inp[25958] = 1071736658; +inp[25959] = 0; +inp[25960] = 1071728481; +inp[25961] = 0; +inp[25962] = 1071720305; +inp[25963] = 0; +inp[25964] = 1071712128; +inp[25965] = 0; +inp[25966] = 1071703952; +inp[25967] = 0; +inp[25968] = 1071695775; +inp[25969] = 0; +inp[25970] = 1071687599; +inp[25971] = 0; +inp[25972] = 1071679423; +inp[25973] = 0; +inp[25974] = 1071671246; +inp[25975] = 0; +inp[25976] = 1071663070; +inp[25977] = 0; +inp[25978] = 1071654894; +inp[25979] = 0; +inp[25980] = 1073741824; +inp[25981] = 1073741824; +inp[25982] = 1073737728; +inp[25983] = 0; +inp[25984] = 1073733632; +inp[25985] = 0; +inp[25986] = 1073729536; +inp[25987] = 0; +inp[25988] = 1073725440; +inp[25989] = 0; +inp[25990] = 1073721344; +inp[25991] = 0; +inp[25992] = 1073717248; +inp[25993] = 0; +inp[25994] = 1073713152; +inp[25995] = 0; +inp[25996] = 1073709056; +inp[25997] = 0; +inp[25998] = 1073704960; +inp[25999] = 0; +inp[26000] = 1073700864; +inp[26001] = 0; +inp[26002] = 1073696768; +inp[26003] = 0; +inp[26004] = 1073692673; +inp[26005] = 0; +inp[26006] = 1073688577; +inp[26007] = 0; +inp[26008] = 1073684481; +inp[26009] = 0; +inp[26010] = 1073680385; +inp[26011] = 0; +inp[26012] = 1073676289; +inp[26013] = 0; +inp[26014] = 1073672194; +inp[26015] = 0; +inp[26016] = 1073668098; +inp[26017] = 0; +inp[26018] = 1073664002; +inp[26019] = 0; +inp[26020] = 1073659907; +inp[26021] = 0; +inp[26022] = 1073655811; +inp[26023] = 0; +inp[26024] = 1073651715; +inp[26025] = 0; +inp[26026] = 1073647620; +inp[26027] = 0; +inp[26028] = 1073643524; +inp[26029] = 0; +inp[26030] = 1073639428; +inp[26031] = 0; +inp[26032] = 1073635333; +inp[26033] = 0; +inp[26034] = 1073631237; +inp[26035] = 0; +inp[26036] = 1073627142; +inp[26037] = 0; +inp[26038] = 1073623046; +inp[26039] = 0; +inp[26040] = 1073618951; +inp[26041] = 0; +inp[26042] = 1073614855; +inp[26043] = 0; +inp[26044] = 1073610759; +inp[26045] = 0; +inp[26046] = 1073606664; +inp[26047] = 0; +inp[26048] = 1073602569; +inp[26049] = 0; +inp[26050] = 1073598473; +inp[26051] = 0; +inp[26052] = 1073594378; +inp[26053] = 0; +inp[26054] = 1073590282; +inp[26055] = 0; +inp[26056] = 1073586187; +inp[26057] = 0; +inp[26058] = 1073582091; +inp[26059] = 0; +inp[26060] = 1073577996; +inp[26061] = 0; +inp[26062] = 1073573901; +inp[26063] = 0; +inp[26064] = 1073569805; +inp[26065] = 0; +inp[26066] = 1073565710; +inp[26067] = 0; +inp[26068] = 1073561615; +inp[26069] = 0; +inp[26070] = 1073557519; +inp[26071] = 0; +inp[26072] = 1073553424; +inp[26073] = 0; +inp[26074] = 1073549329; +inp[26075] = 0; +inp[26076] = 1073545233; +inp[26077] = 0; +inp[26078] = 1073541138; +inp[26079] = 0; +inp[26080] = 1073537043; +inp[26081] = 0; +inp[26082] = 1073532948; +inp[26083] = 0; +inp[26084] = 1073528853; +inp[26085] = 0; +inp[26086] = 1073524757; +inp[26087] = 0; +inp[26088] = 1073520662; +inp[26089] = 0; +inp[26090] = 1073516567; +inp[26091] = 0; +inp[26092] = 1073512472; +inp[26093] = 0; +inp[26094] = 1073508377; +inp[26095] = 0; +inp[26096] = 1073504282; +inp[26097] = 0; +inp[26098] = 1073500187; +inp[26099] = 0; +inp[26100] = 1073496092; +inp[26101] = 0; +inp[26102] = 1073491997; +inp[26103] = 0; +inp[26104] = 1073487902; +inp[26105] = 0; +inp[26106] = 1073483807; +inp[26107] = 0; +inp[26108] = 1073479711; +inp[26109] = 0; +inp[26110] = 1073475617; +inp[26111] = 0; +inp[26112] = 1073471522; +inp[26113] = 0; +inp[26114] = 1073467427; +inp[26115] = 0; +inp[26116] = 1073463332; +inp[26117] = 0; +inp[26118] = 1073459237; +inp[26119] = 0; +inp[26120] = 1073455142; +inp[26121] = 0; +inp[26122] = 1073451047; +inp[26123] = 0; +inp[26124] = 1073446952; +inp[26125] = 0; +inp[26126] = 1073442857; +inp[26127] = 0; +inp[26128] = 1073438762; +inp[26129] = 0; +inp[26130] = 1073434667; +inp[26131] = 0; +inp[26132] = 1073430573; +inp[26133] = 0; +inp[26134] = 1073426478; +inp[26135] = 0; +inp[26136] = 1073422383; +inp[26137] = 0; +inp[26138] = 1073418288; +inp[26139] = 0; +inp[26140] = 1073414193; +inp[26141] = 0; +inp[26142] = 1073410099; +inp[26143] = 0; +inp[26144] = 1073406004; +inp[26145] = 0; +inp[26146] = 1073401909; +inp[26147] = 0; +inp[26148] = 1073397815; +inp[26149] = 0; +inp[26150] = 1073393720; +inp[26151] = 0; +inp[26152] = 1073389625; +inp[26153] = 0; +inp[26154] = 1073385531; +inp[26155] = 0; +inp[26156] = 1073381436; +inp[26157] = 0; +inp[26158] = 1073377341; +inp[26159] = 0; +inp[26160] = 1073373247; +inp[26161] = 0; +inp[26162] = 1073369152; +inp[26163] = 0; +inp[26164] = 1073365058; +inp[26165] = 0; +inp[26166] = 1073360963; +inp[26167] = 0; +inp[26168] = 1073356869; +inp[26169] = 0; +inp[26170] = 1073352774; +inp[26171] = 0; +inp[26172] = 1073348679; +inp[26173] = 0; +inp[26174] = 1073344585; +inp[26175] = 0; +inp[26176] = 1073340491; +inp[26177] = 0; +inp[26178] = 1073336396; +inp[26179] = 0; +inp[26180] = 1073332302; +inp[26181] = 0; +inp[26182] = 1073328207; +inp[26183] = 0; +inp[26184] = 1073324113; +inp[26185] = 0; +inp[26186] = 1073320018; +inp[26187] = 0; +inp[26188] = 1073315924; +inp[26189] = 0; +inp[26190] = 1073311830; +inp[26191] = 0; +inp[26192] = 1073307735; +inp[26193] = 0; +inp[26194] = 1073303641; +inp[26195] = 0; +inp[26196] = 1073299547; +inp[26197] = 0; +inp[26198] = 1073295452; +inp[26199] = 0; +inp[26200] = 1073291358; +inp[26201] = 0; +inp[26202] = 1073287264; +inp[26203] = 0; +inp[26204] = 1073283169; +inp[26205] = 0; +inp[26206] = 1073279075; +inp[26207] = 0; +inp[26208] = 1073274981; +inp[26209] = 0; +inp[26210] = 1073270887; +inp[26211] = 0; +inp[26212] = 1073266793; +inp[26213] = 0; +inp[26214] = 1073262698; +inp[26215] = 0; +inp[26216] = 1073258604; +inp[26217] = 0; +inp[26218] = 1073254510; +inp[26219] = 0; +inp[26220] = 1073250416; +inp[26221] = 0; +inp[26222] = 1073246322; +inp[26223] = 0; +inp[26224] = 1073242228; +inp[26225] = 0; +inp[26226] = 1073238134; +inp[26227] = 0; +inp[26228] = 1073234040; +inp[26229] = 0; +inp[26230] = 1073229946; +inp[26231] = 0; +inp[26232] = 1073225852; +inp[26233] = 0; +inp[26234] = 1073221757; +inp[26235] = 0; +inp[26236] = 1073217663; +inp[26237] = 0; +inp[26238] = 1073213569; +inp[26239] = 0; +inp[26240] = 1073209476; +inp[26241] = 0; +inp[26242] = 1073205382; +inp[26243] = 0; +inp[26244] = 1073201288; +inp[26245] = 0; +inp[26246] = 1073197194; +inp[26247] = 0; +inp[26248] = 1073193100; +inp[26249] = 0; +inp[26250] = 1073189006; +inp[26251] = 0; +inp[26252] = 1073184912; +inp[26253] = 0; +inp[26254] = 1073180818; +inp[26255] = 0; +inp[26256] = 1073176724; +inp[26257] = 0; +inp[26258] = 1073172630; +inp[26259] = 0; +inp[26260] = 1073168537; +inp[26261] = 0; +inp[26262] = 1073164443; +inp[26263] = 0; +inp[26264] = 1073160349; +inp[26265] = 0; +inp[26266] = 1073156255; +inp[26267] = 0; +inp[26268] = 1073152161; +inp[26269] = 0; +inp[26270] = 1073148068; +inp[26271] = 0; +inp[26272] = 1073143974; +inp[26273] = 0; +inp[26274] = 1073139880; +inp[26275] = 0; +inp[26276] = 1073135787; +inp[26277] = 0; +inp[26278] = 1073131693; +inp[26279] = 0; +inp[26280] = 1073127599; +inp[26281] = 0; +inp[26282] = 1073123506; +inp[26283] = 0; +inp[26284] = 1073119412; +inp[26285] = 0; +inp[26286] = 1073115318; +inp[26287] = 0; +inp[26288] = 1073111225; +inp[26289] = 0; +inp[26290] = 1073107131; +inp[26291] = 0; +inp[26292] = 1073103038; +inp[26293] = 0; +inp[26294] = 1073098944; +inp[26295] = 0; +inp[26296] = 1073094850; +inp[26297] = 0; +inp[26298] = 1073090757; +inp[26299] = 0; +inp[26300] = 1073086663; +inp[26301] = 0; +inp[26302] = 1073082570; +inp[26303] = 0; +inp[26304] = 1073078476; +inp[26305] = 0; +inp[26306] = 1073074383; +inp[26307] = 0; +inp[26308] = 1073070290; +inp[26309] = 0; +inp[26310] = 1073066196; +inp[26311] = 0; +inp[26312] = 1073062103; +inp[26313] = 0; +inp[26314] = 1073058009; +inp[26315] = 0; +inp[26316] = 1073053916; +inp[26317] = 0; +inp[26318] = 1073049823; +inp[26319] = 0; +inp[26320] = 1073045729; +inp[26321] = 0; +inp[26322] = 1073041636; +inp[26323] = 0; +inp[26324] = 1073037543; +inp[26325] = 0; +inp[26326] = 1073033449; +inp[26327] = 0; +inp[26328] = 1073029356; +inp[26329] = 0; +inp[26330] = 1073025263; +inp[26331] = 0; +inp[26332] = 1073021169; +inp[26333] = 0; +inp[26334] = 1073017076; +inp[26335] = 0; +inp[26336] = 1073012983; +inp[26337] = 0; +inp[26338] = 1073008890; +inp[26339] = 0; +inp[26340] = 1073004797; +inp[26341] = 0; +inp[26342] = 1073000703; +inp[26343] = 0; +inp[26344] = 1072996610; +inp[26345] = 0; +inp[26346] = 1072992517; +inp[26347] = 0; +inp[26348] = 1072988424; +inp[26349] = 0; +inp[26350] = 1072984331; +inp[26351] = 0; +inp[26352] = 1072980238; +inp[26353] = 0; +inp[26354] = 1072976145; +inp[26355] = 0; +inp[26356] = 1072972052; +inp[26357] = 0; +inp[26358] = 1072967959; +inp[26359] = 0; +inp[26360] = 1072963865; +inp[26361] = 0; +inp[26362] = 1072959772; +inp[26363] = 0; +inp[26364] = 1072955679; +inp[26365] = 0; +inp[26366] = 1072951586; +inp[26367] = 0; +inp[26368] = 1072947493; +inp[26369] = 0; +inp[26370] = 1072943400; +inp[26371] = 0; +inp[26372] = 1072939308; +inp[26373] = 0; +inp[26374] = 1072935215; +inp[26375] = 0; +inp[26376] = 1072931122; +inp[26377] = 0; +inp[26378] = 1072927029; +inp[26379] = 0; +inp[26380] = 1072922936; +inp[26381] = 0; +inp[26382] = 1072918843; +inp[26383] = 0; +inp[26384] = 1072914750; +inp[26385] = 0; +inp[26386] = 1072910657; +inp[26387] = 0; +inp[26388] = 1072906565; +inp[26389] = 0; +inp[26390] = 1072902472; +inp[26391] = 0; +inp[26392] = 1072898379; +inp[26393] = 0; +inp[26394] = 1072894286; +inp[26395] = 0; +inp[26396] = 1072890193; +inp[26397] = 0; +inp[26398] = 1072886101; +inp[26399] = 0; +inp[26400] = 1072882008; +inp[26401] = 0; +inp[26402] = 1072877915; +inp[26403] = 0; +inp[26404] = 1072873823; +inp[26405] = 0; +inp[26406] = 1072869730; +inp[26407] = 0; +inp[26408] = 1072865637; +inp[26409] = 0; +inp[26410] = 1072861545; +inp[26411] = 0; +inp[26412] = 1072857452; +inp[26413] = 0; +inp[26414] = 1072853359; +inp[26415] = 0; +inp[26416] = 1072849267; +inp[26417] = 0; +inp[26418] = 1072845174; +inp[26419] = 0; +inp[26420] = 1072841082; +inp[26421] = 0; +inp[26422] = 1072836989; +inp[26423] = 0; +inp[26424] = 1072832896; +inp[26425] = 0; +inp[26426] = 1072828804; +inp[26427] = 0; +inp[26428] = 1072824711; +inp[26429] = 0; +inp[26430] = 1072820619; +inp[26431] = 0; +inp[26432] = 1072816526; +inp[26433] = 0; +inp[26434] = 1072812434; +inp[26435] = 0; +inp[26436] = 1072808342; +inp[26437] = 0; +inp[26438] = 1072804249; +inp[26439] = 0; +inp[26440] = 1072800157; +inp[26441] = 0; +inp[26442] = 1072796064; +inp[26443] = 0; +inp[26444] = 1072791972; +inp[26445] = 0; +inp[26446] = 1072787880; +inp[26447] = 0; +inp[26448] = 1072783787; +inp[26449] = 0; +inp[26450] = 1072779695; +inp[26451] = 0; +inp[26452] = 1072775602; +inp[26453] = 0; +inp[26454] = 1072771510; +inp[26455] = 0; +inp[26456] = 1072767418; +inp[26457] = 0; +inp[26458] = 1072763326; +inp[26459] = 0; +inp[26460] = 1072759233; +inp[26461] = 0; +inp[26462] = 1072755141; +inp[26463] = 0; +inp[26464] = 1072751049; +inp[26465] = 0; +inp[26466] = 1072746957; +inp[26467] = 0; +inp[26468] = 1072742864; +inp[26469] = 0; +inp[26470] = 1072738772; +inp[26471] = 0; +inp[26472] = 1072734680; +inp[26473] = 0; +inp[26474] = 1072730588; +inp[26475] = 0; +inp[26476] = 1072726496; +inp[26477] = 0; +inp[26478] = 1072722404; +inp[26479] = 0; +inp[26480] = 1072718312; +inp[26481] = 0; +inp[26482] = 1072714220; +inp[26483] = 0; +inp[26484] = 1072710127; +inp[26485] = 0; +inp[26486] = 1072706035; +inp[26487] = 0; +inp[26488] = 1072701943; +inp[26489] = 0; +inp[26490] = 1072697851; +inp[26491] = 0; +inp[26492] = 1073741824; +inp[26493] = 1073741824; +inp[26494] = 1073739776; +inp[26495] = 0; +inp[26496] = 1073737728; +inp[26497] = 0; +inp[26498] = 1073735680; +inp[26499] = 0; +inp[26500] = 1073733632; +inp[26501] = 0; +inp[26502] = 1073731584; +inp[26503] = 0; +inp[26504] = 1073729536; +inp[26505] = 0; +inp[26506] = 1073727488; +inp[26507] = 0; +inp[26508] = 1073725440; +inp[26509] = 0; +inp[26510] = 1073723392; +inp[26511] = 0; +inp[26512] = 1073721344; +inp[26513] = 0; +inp[26514] = 1073719296; +inp[26515] = 0; +inp[26516] = 1073717248; +inp[26517] = 0; +inp[26518] = 1073715200; +inp[26519] = 0; +inp[26520] = 1073713152; +inp[26521] = 0; +inp[26522] = 1073711104; +inp[26523] = 0; +inp[26524] = 1073709056; +inp[26525] = 0; +inp[26526] = 1073707008; +inp[26527] = 0; +inp[26528] = 1073704960; +inp[26529] = 0; +inp[26530] = 1073702912; +inp[26531] = 0; +inp[26532] = 1073700864; +inp[26533] = 0; +inp[26534] = 1073698816; +inp[26535] = 0; +inp[26536] = 1073696768; +inp[26537] = 0; +inp[26538] = 1073694721; +inp[26539] = 0; +inp[26540] = 1073692673; +inp[26541] = 0; +inp[26542] = 1073690625; +inp[26543] = 0; +inp[26544] = 1073688577; +inp[26545] = 0; +inp[26546] = 1073686529; +inp[26547] = 0; +inp[26548] = 1073684481; +inp[26549] = 0; +inp[26550] = 1073682433; +inp[26551] = 0; +inp[26552] = 1073680385; +inp[26553] = 0; +inp[26554] = 1073678337; +inp[26555] = 0; +inp[26556] = 1073676289; +inp[26557] = 0; +inp[26558] = 1073674242; +inp[26559] = 0; +inp[26560] = 1073672194; +inp[26561] = 0; +inp[26562] = 1073670146; +inp[26563] = 0; +inp[26564] = 1073668098; +inp[26565] = 0; +inp[26566] = 1073666050; +inp[26567] = 0; +inp[26568] = 1073664002; +inp[26569] = 0; +inp[26570] = 1073661954; +inp[26571] = 0; +inp[26572] = 1073659907; +inp[26573] = 0; +inp[26574] = 1073657859; +inp[26575] = 0; +inp[26576] = 1073655811; +inp[26577] = 0; +inp[26578] = 1073653763; +inp[26579] = 0; +inp[26580] = 1073651715; +inp[26581] = 0; +inp[26582] = 1073649667; +inp[26583] = 0; +inp[26584] = 1073647620; +inp[26585] = 0; +inp[26586] = 1073645572; +inp[26587] = 0; +inp[26588] = 1073643524; +inp[26589] = 0; +inp[26590] = 1073641476; +inp[26591] = 0; +inp[26592] = 1073639428; +inp[26593] = 0; +inp[26594] = 1073637381; +inp[26595] = 0; +inp[26596] = 1073635333; +inp[26597] = 0; +inp[26598] = 1073633285; +inp[26599] = 0; +inp[26600] = 1073631237; +inp[26601] = 0; +inp[26602] = 1073629189; +inp[26603] = 0; +inp[26604] = 1073627142; +inp[26605] = 0; +inp[26606] = 1073625094; +inp[26607] = 0; +inp[26608] = 1073623046; +inp[26609] = 0; +inp[26610] = 1073620998; +inp[26611] = 0; +inp[26612] = 1073618951; +inp[26613] = 0; +inp[26614] = 1073616903; +inp[26615] = 0; +inp[26616] = 1073614855; +inp[26617] = 0; +inp[26618] = 1073612807; +inp[26619] = 0; +inp[26620] = 1073610759; +inp[26621] = 0; +inp[26622] = 1073608712; +inp[26623] = 0; +inp[26624] = 1073606664; +inp[26625] = 0; +inp[26626] = 1073604616; +inp[26627] = 0; +inp[26628] = 1073602569; +inp[26629] = 0; +inp[26630] = 1073600521; +inp[26631] = 0; +inp[26632] = 1073598473; +inp[26633] = 0; +inp[26634] = 1073596425; +inp[26635] = 0; +inp[26636] = 1073594378; +inp[26637] = 0; +inp[26638] = 1073592330; +inp[26639] = 0; +inp[26640] = 1073590282; +inp[26641] = 0; +inp[26642] = 1073588234; +inp[26643] = 0; +inp[26644] = 1073586187; +inp[26645] = 0; +inp[26646] = 1073584139; +inp[26647] = 0; +inp[26648] = 1073582091; +inp[26649] = 0; +inp[26650] = 1073580044; +inp[26651] = 0; +inp[26652] = 1073577996; +inp[26653] = 0; +inp[26654] = 1073575948; +inp[26655] = 0; +inp[26656] = 1073573901; +inp[26657] = 0; +inp[26658] = 1073571853; +inp[26659] = 0; +inp[26660] = 1073569805; +inp[26661] = 0; +inp[26662] = 1073567758; +inp[26663] = 0; +inp[26664] = 1073565710; +inp[26665] = 0; +inp[26666] = 1073563662; +inp[26667] = 0; +inp[26668] = 1073561615; +inp[26669] = 0; +inp[26670] = 1073559567; +inp[26671] = 0; +inp[26672] = 1073557519; +inp[26673] = 0; +inp[26674] = 1073555472; +inp[26675] = 0; +inp[26676] = 1073553424; +inp[26677] = 0; +inp[26678] = 1073551376; +inp[26679] = 0; +inp[26680] = 1073549329; +inp[26681] = 0; +inp[26682] = 1073547281; +inp[26683] = 0; +inp[26684] = 1073545233; +inp[26685] = 0; +inp[26686] = 1073543186; +inp[26687] = 0; +inp[26688] = 1073541138; +inp[26689] = 0; +inp[26690] = 1073539091; +inp[26691] = 0; +inp[26692] = 1073537043; +inp[26693] = 0; +inp[26694] = 1073534995; +inp[26695] = 0; +inp[26696] = 1073532948; +inp[26697] = 0; +inp[26698] = 1073530900; +inp[26699] = 0; +inp[26700] = 1073528853; +inp[26701] = 0; +inp[26702] = 1073526805; +inp[26703] = 0; +inp[26704] = 1073524757; +inp[26705] = 0; +inp[26706] = 1073522710; +inp[26707] = 0; +inp[26708] = 1073520662; +inp[26709] = 0; +inp[26710] = 1073518615; +inp[26711] = 0; +inp[26712] = 1073516567; +inp[26713] = 0; +inp[26714] = 1073514520; +inp[26715] = 0; +inp[26716] = 1073512472; +inp[26717] = 0; +inp[26718] = 1073510424; +inp[26719] = 0; +inp[26720] = 1073508377; +inp[26721] = 0; +inp[26722] = 1073506329; +inp[26723] = 0; +inp[26724] = 1073504282; +inp[26725] = 0; +inp[26726] = 1073502234; +inp[26727] = 0; +inp[26728] = 1073500187; +inp[26729] = 0; +inp[26730] = 1073498139; +inp[26731] = 0; +inp[26732] = 1073496092; +inp[26733] = 0; +inp[26734] = 1073494044; +inp[26735] = 0; +inp[26736] = 1073491997; +inp[26737] = 0; +inp[26738] = 1073489949; +inp[26739] = 0; +inp[26740] = 1073487902; +inp[26741] = 0; +inp[26742] = 1073485854; +inp[26743] = 0; +inp[26744] = 1073483807; +inp[26745] = 0; +inp[26746] = 1073481759; +inp[26747] = 0; +inp[26748] = 1073479711; +inp[26749] = 0; +inp[26750] = 1073477664; +inp[26751] = 0; +inp[26752] = 1073475617; +inp[26753] = 0; +inp[26754] = 1073473569; +inp[26755] = 0; +inp[26756] = 1073471522; +inp[26757] = 0; +inp[26758] = 1073469474; +inp[26759] = 0; +inp[26760] = 1073467427; +inp[26761] = 0; +inp[26762] = 1073465379; +inp[26763] = 0; +inp[26764] = 1073463332; +inp[26765] = 0; +inp[26766] = 1073461284; +inp[26767] = 0; +inp[26768] = 1073459237; +inp[26769] = 0; +inp[26770] = 1073457189; +inp[26771] = 0; +inp[26772] = 1073455142; +inp[26773] = 0; +inp[26774] = 1073453094; +inp[26775] = 0; +inp[26776] = 1073451047; +inp[26777] = 0; +inp[26778] = 1073448999; +inp[26779] = 0; +inp[26780] = 1073446952; +inp[26781] = 0; +inp[26782] = 1073444905; +inp[26783] = 0; +inp[26784] = 1073442857; +inp[26785] = 0; +inp[26786] = 1073440810; +inp[26787] = 0; +inp[26788] = 1073438762; +inp[26789] = 0; +inp[26790] = 1073436715; +inp[26791] = 0; +inp[26792] = 1073434667; +inp[26793] = 0; +inp[26794] = 1073432620; +inp[26795] = 0; +inp[26796] = 1073430573; +inp[26797] = 0; +inp[26798] = 1073428525; +inp[26799] = 0; +inp[26800] = 1073426478; +inp[26801] = 0; +inp[26802] = 1073424430; +inp[26803] = 0; +inp[26804] = 1073422383; +inp[26805] = 0; +inp[26806] = 1073420336; +inp[26807] = 0; +inp[26808] = 1073418288; +inp[26809] = 0; +inp[26810] = 1073416241; +inp[26811] = 0; +inp[26812] = 1073414193; +inp[26813] = 0; +inp[26814] = 1073412146; +inp[26815] = 0; +inp[26816] = 1073410099; +inp[26817] = 0; +inp[26818] = 1073408051; +inp[26819] = 0; +inp[26820] = 1073406004; +inp[26821] = 0; +inp[26822] = 1073403957; +inp[26823] = 0; +inp[26824] = 1073401909; +inp[26825] = 0; +inp[26826] = 1073399862; +inp[26827] = 0; +inp[26828] = 1073397815; +inp[26829] = 0; +inp[26830] = 1073395767; +inp[26831] = 0; +inp[26832] = 1073393720; +inp[26833] = 0; +inp[26834] = 1073391673; +inp[26835] = 0; +inp[26836] = 1073389625; +inp[26837] = 0; +inp[26838] = 1073387578; +inp[26839] = 0; +inp[26840] = 1073385531; +inp[26841] = 0; +inp[26842] = 1073383483; +inp[26843] = 0; +inp[26844] = 1073381436; +inp[26845] = 0; +inp[26846] = 1073379389; +inp[26847] = 0; +inp[26848] = 1073377341; +inp[26849] = 0; +inp[26850] = 1073375294; +inp[26851] = 0; +inp[26852] = 1073373247; +inp[26853] = 0; +inp[26854] = 1073371199; +inp[26855] = 0; +inp[26856] = 1073369152; +inp[26857] = 0; +inp[26858] = 1073367105; +inp[26859] = 0; +inp[26860] = 1073365058; +inp[26861] = 0; +inp[26862] = 1073363010; +inp[26863] = 0; +inp[26864] = 1073360963; +inp[26865] = 0; +inp[26866] = 1073358916; +inp[26867] = 0; +inp[26868] = 1073356869; +inp[26869] = 0; +inp[26870] = 1073354821; +inp[26871] = 0; +inp[26872] = 1073352774; +inp[26873] = 0; +inp[26874] = 1073350727; +inp[26875] = 0; +inp[26876] = 1073348679; +inp[26877] = 0; +inp[26878] = 1073346632; +inp[26879] = 0; +inp[26880] = 1073344585; +inp[26881] = 0; +inp[26882] = 1073342538; +inp[26883] = 0; +inp[26884] = 1073340491; +inp[26885] = 0; +inp[26886] = 1073338443; +inp[26887] = 0; +inp[26888] = 1073336396; +inp[26889] = 0; +inp[26890] = 1073334349; +inp[26891] = 0; +inp[26892] = 1073332302; +inp[26893] = 0; +inp[26894] = 1073330254; +inp[26895] = 0; +inp[26896] = 1073328207; +inp[26897] = 0; +inp[26898] = 1073326160; +inp[26899] = 0; +inp[26900] = 1073324113; +inp[26901] = 0; +inp[26902] = 1073322066; +inp[26903] = 0; +inp[26904] = 1073320018; +inp[26905] = 0; +inp[26906] = 1073317971; +inp[26907] = 0; +inp[26908] = 1073315924; +inp[26909] = 0; +inp[26910] = 1073313877; +inp[26911] = 0; +inp[26912] = 1073311830; +inp[26913] = 0; +inp[26914] = 1073309782; +inp[26915] = 0; +inp[26916] = 1073307735; +inp[26917] = 0; +inp[26918] = 1073305688; +inp[26919] = 0; +inp[26920] = 1073303641; +inp[26921] = 0; +inp[26922] = 1073301594; +inp[26923] = 0; +inp[26924] = 1073299547; +inp[26925] = 0; +inp[26926] = 1073297499; +inp[26927] = 0; +inp[26928] = 1073295452; +inp[26929] = 0; +inp[26930] = 1073293405; +inp[26931] = 0; +inp[26932] = 1073291358; +inp[26933] = 0; +inp[26934] = 1073289311; +inp[26935] = 0; +inp[26936] = 1073287264; +inp[26937] = 0; +inp[26938] = 1073285217; +inp[26939] = 0; +inp[26940] = 1073283169; +inp[26941] = 0; +inp[26942] = 1073281122; +inp[26943] = 0; +inp[26944] = 1073279075; +inp[26945] = 0; +inp[26946] = 1073277028; +inp[26947] = 0; +inp[26948] = 1073274981; +inp[26949] = 0; +inp[26950] = 1073272934; +inp[26951] = 0; +inp[26952] = 1073270887; +inp[26953] = 0; +inp[26954] = 1073268840; +inp[26955] = 0; +inp[26956] = 1073266793; +inp[26957] = 0; +inp[26958] = 1073264746; +inp[26959] = 0; +inp[26960] = 1073262698; +inp[26961] = 0; +inp[26962] = 1073260651; +inp[26963] = 0; +inp[26964] = 1073258604; +inp[26965] = 0; +inp[26966] = 1073256557; +inp[26967] = 0; +inp[26968] = 1073254510; +inp[26969] = 0; +inp[26970] = 1073252463; +inp[26971] = 0; +inp[26972] = 1073250416; +inp[26973] = 0; +inp[26974] = 1073248369; +inp[26975] = 0; +inp[26976] = 1073246322; +inp[26977] = 0; +inp[26978] = 1073244275; +inp[26979] = 0; +inp[26980] = 1073242228; +inp[26981] = 0; +inp[26982] = 1073240181; +inp[26983] = 0; +inp[26984] = 1073238134; +inp[26985] = 0; +inp[26986] = 1073236087; +inp[26987] = 0; +inp[26988] = 1073234040; +inp[26989] = 0; +inp[26990] = 1073231993; +inp[26991] = 0; +inp[26992] = 1073229946; +inp[26993] = 0; +inp[26994] = 1073227899; +inp[26995] = 0; +inp[26996] = 1073225852; +inp[26997] = 0; +inp[26998] = 1073223804; +inp[26999] = 0; +inp[27000] = 1073221757; +inp[27001] = 0; +inp[27002] = 1073219710; +inp[27003] = 0; +inp[27004] = 1073741824; +inp[27005] = 1073741824; +inp[27006] = 1073740800; +inp[27007] = 0; +inp[27008] = 1073739776; +inp[27009] = 0; +inp[27010] = 1073738752; +inp[27011] = 0; +inp[27012] = 1073737728; +inp[27013] = 0; +inp[27014] = 1073736704; +inp[27015] = 0; +inp[27016] = 1073735680; +inp[27017] = 0; +inp[27018] = 1073734656; +inp[27019] = 0; +inp[27020] = 1073733632; +inp[27021] = 0; +inp[27022] = 1073732608; +inp[27023] = 0; +inp[27024] = 1073731584; +inp[27025] = 0; +inp[27026] = 1073730560; +inp[27027] = 0; +inp[27028] = 1073729536; +inp[27029] = 0; +inp[27030] = 1073728512; +inp[27031] = 0; +inp[27032] = 1073727488; +inp[27033] = 0; +inp[27034] = 1073726464; +inp[27035] = 0; +inp[27036] = 1073725440; +inp[27037] = 0; +inp[27038] = 1073724416; +inp[27039] = 0; +inp[27040] = 1073723392; +inp[27041] = 0; +inp[27042] = 1073722368; +inp[27043] = 0; +inp[27044] = 1073721344; +inp[27045] = 0; +inp[27046] = 1073720320; +inp[27047] = 0; +inp[27048] = 1073719296; +inp[27049] = 0; +inp[27050] = 1073718272; +inp[27051] = 0; +inp[27052] = 1073717248; +inp[27053] = 0; +inp[27054] = 1073716224; +inp[27055] = 0; +inp[27056] = 1073715200; +inp[27057] = 0; +inp[27058] = 1073714176; +inp[27059] = 0; +inp[27060] = 1073713152; +inp[27061] = 0; +inp[27062] = 1073712128; +inp[27063] = 0; +inp[27064] = 1073711104; +inp[27065] = 0; +inp[27066] = 1073710080; +inp[27067] = 0; +inp[27068] = 1073709056; +inp[27069] = 0; +inp[27070] = 1073708032; +inp[27071] = 0; +inp[27072] = 1073707008; +inp[27073] = 0; +inp[27074] = 1073705984; +inp[27075] = 0; +inp[27076] = 1073704960; +inp[27077] = 0; +inp[27078] = 1073703936; +inp[27079] = 0; +inp[27080] = 1073702912; +inp[27081] = 0; +inp[27082] = 1073701888; +inp[27083] = 0; +inp[27084] = 1073700864; +inp[27085] = 0; +inp[27086] = 1073699840; +inp[27087] = 0; +inp[27088] = 1073698816; +inp[27089] = 0; +inp[27090] = 1073697792; +inp[27091] = 0; +inp[27092] = 1073696768; +inp[27093] = 0; +inp[27094] = 1073695744; +inp[27095] = 0; +inp[27096] = 1073694721; +inp[27097] = 0; +inp[27098] = 1073693697; +inp[27099] = 0; +inp[27100] = 1073692673; +inp[27101] = 0; +inp[27102] = 1073691649; +inp[27103] = 0; +inp[27104] = 1073690625; +inp[27105] = 0; +inp[27106] = 1073689601; +inp[27107] = 0; +inp[27108] = 1073688577; +inp[27109] = 0; +inp[27110] = 1073687553; +inp[27111] = 0; +inp[27112] = 1073686529; +inp[27113] = 0; +inp[27114] = 1073685505; +inp[27115] = 0; +inp[27116] = 1073684481; +inp[27117] = 0; +inp[27118] = 1073683457; +inp[27119] = 0; +inp[27120] = 1073682433; +inp[27121] = 0; +inp[27122] = 1073681409; +inp[27123] = 0; +inp[27124] = 1073680385; +inp[27125] = 0; +inp[27126] = 1073679361; +inp[27127] = 0; +inp[27128] = 1073678337; +inp[27129] = 0; +inp[27130] = 1073677313; +inp[27131] = 0; +inp[27132] = 1073676289; +inp[27133] = 0; +inp[27134] = 1073675266; +inp[27135] = 0; +inp[27136] = 1073674242; +inp[27137] = 0; +inp[27138] = 1073673218; +inp[27139] = 0; +inp[27140] = 1073672194; +inp[27141] = 0; +inp[27142] = 1073671170; +inp[27143] = 0; +inp[27144] = 1073670146; +inp[27145] = 0; +inp[27146] = 1073669122; +inp[27147] = 0; +inp[27148] = 1073668098; +inp[27149] = 0; +inp[27150] = 1073667074; +inp[27151] = 0; +inp[27152] = 1073666050; +inp[27153] = 0; +inp[27154] = 1073665026; +inp[27155] = 0; +inp[27156] = 1073664002; +inp[27157] = 0; +inp[27158] = 1073662978; +inp[27159] = 0; +inp[27160] = 1073661954; +inp[27161] = 0; +inp[27162] = 1073660931; +inp[27163] = 0; +inp[27164] = 1073659907; +inp[27165] = 0; +inp[27166] = 1073658883; +inp[27167] = 0; +inp[27168] = 1073657859; +inp[27169] = 0; +inp[27170] = 1073656835; +inp[27171] = 0; +inp[27172] = 1073655811; +inp[27173] = 0; +inp[27174] = 1073654787; +inp[27175] = 0; +inp[27176] = 1073653763; +inp[27177] = 0; +inp[27178] = 1073652739; +inp[27179] = 0; +inp[27180] = 1073651715; +inp[27181] = 0; +inp[27182] = 1073650691; +inp[27183] = 0; +inp[27184] = 1073649667; +inp[27185] = 0; +inp[27186] = 1073648644; +inp[27187] = 0; +inp[27188] = 1073647620; +inp[27189] = 0; +inp[27190] = 1073646596; +inp[27191] = 0; +inp[27192] = 1073645572; +inp[27193] = 0; +inp[27194] = 1073644548; +inp[27195] = 0; +inp[27196] = 1073643524; +inp[27197] = 0; +inp[27198] = 1073642500; +inp[27199] = 0; +inp[27200] = 1073641476; +inp[27201] = 0; +inp[27202] = 1073640452; +inp[27203] = 0; +inp[27204] = 1073639428; +inp[27205] = 0; +inp[27206] = 1073638404; +inp[27207] = 0; +inp[27208] = 1073637381; +inp[27209] = 0; +inp[27210] = 1073636357; +inp[27211] = 0; +inp[27212] = 1073635333; +inp[27213] = 0; +inp[27214] = 1073634309; +inp[27215] = 0; +inp[27216] = 1073633285; +inp[27217] = 0; +inp[27218] = 1073632261; +inp[27219] = 0; +inp[27220] = 1073631237; +inp[27221] = 0; +inp[27222] = 1073630213; +inp[27223] = 0; +inp[27224] = 1073629189; +inp[27225] = 0; +inp[27226] = 1073628166; +inp[27227] = 0; +inp[27228] = 1073627142; +inp[27229] = 0; +inp[27230] = 1073626118; +inp[27231] = 0; +inp[27232] = 1073625094; +inp[27233] = 0; +inp[27234] = 1073624070; +inp[27235] = 0; +inp[27236] = 1073623046; +inp[27237] = 0; +inp[27238] = 1073622022; +inp[27239] = 0; +inp[27240] = 1073620998; +inp[27241] = 0; +inp[27242] = 1073619974; +inp[27243] = 0; +inp[27244] = 1073618951; +inp[27245] = 0; +inp[27246] = 1073617927; +inp[27247] = 0; +inp[27248] = 1073616903; +inp[27249] = 0; +inp[27250] = 1073615879; +inp[27251] = 0; +inp[27252] = 1073614855; +inp[27253] = 0; +inp[27254] = 1073613831; +inp[27255] = 0; +inp[27256] = 1073612807; +inp[27257] = 0; +inp[27258] = 1073611783; +inp[27259] = 0; +inp[27260] = 1073610759; +inp[27261] = 0; +inp[27262] = 1073609736; +inp[27263] = 0; +inp[27264] = 1073608712; +inp[27265] = 0; +inp[27266] = 1073607688; +inp[27267] = 0; +inp[27268] = 1073606664; +inp[27269] = 0; +inp[27270] = 1073605640; +inp[27271] = 0; +inp[27272] = 1073604616; +inp[27273] = 0; +inp[27274] = 1073603592; +inp[27275] = 0; +inp[27276] = 1073602569; +inp[27277] = 0; +inp[27278] = 1073601545; +inp[27279] = 0; +inp[27280] = 1073600521; +inp[27281] = 0; +inp[27282] = 1073599497; +inp[27283] = 0; +inp[27284] = 1073598473; +inp[27285] = 0; +inp[27286] = 1073597449; +inp[27287] = 0; +inp[27288] = 1073596425; +inp[27289] = 0; +inp[27290] = 1073595401; +inp[27291] = 0; +inp[27292] = 1073594378; +inp[27293] = 0; +inp[27294] = 1073593354; +inp[27295] = 0; +inp[27296] = 1073592330; +inp[27297] = 0; +inp[27298] = 1073591306; +inp[27299] = 0; +inp[27300] = 1073590282; +inp[27301] = 0; +inp[27302] = 1073589258; +inp[27303] = 0; +inp[27304] = 1073588234; +inp[27305] = 0; +inp[27306] = 1073587211; +inp[27307] = 0; +inp[27308] = 1073586187; +inp[27309] = 0; +inp[27310] = 1073585163; +inp[27311] = 0; +inp[27312] = 1073584139; +inp[27313] = 0; +inp[27314] = 1073583115; +inp[27315] = 0; +inp[27316] = 1073582091; +inp[27317] = 0; +inp[27318] = 1073581068; +inp[27319] = 0; +inp[27320] = 1073580044; +inp[27321] = 0; +inp[27322] = 1073579020; +inp[27323] = 0; +inp[27324] = 1073577996; +inp[27325] = 0; +inp[27326] = 1073576972; +inp[27327] = 0; +inp[27328] = 1073575948; +inp[27329] = 0; +inp[27330] = 1073574924; +inp[27331] = 0; +inp[27332] = 1073573901; +inp[27333] = 0; +inp[27334] = 1073572877; +inp[27335] = 0; +inp[27336] = 1073571853; +inp[27337] = 0; +inp[27338] = 1073570829; +inp[27339] = 0; +inp[27340] = 1073569805; +inp[27341] = 0; +inp[27342] = 1073568781; +inp[27343] = 0; +inp[27344] = 1073567758; +inp[27345] = 0; +inp[27346] = 1073566734; +inp[27347] = 0; +inp[27348] = 1073565710; +inp[27349] = 0; +inp[27350] = 1073564686; +inp[27351] = 0; +inp[27352] = 1073563662; +inp[27353] = 0; +inp[27354] = 1073562638; +inp[27355] = 0; +inp[27356] = 1073561615; +inp[27357] = 0; +inp[27358] = 1073560591; +inp[27359] = 0; +inp[27360] = 1073559567; +inp[27361] = 0; +inp[27362] = 1073558543; +inp[27363] = 0; +inp[27364] = 1073557519; +inp[27365] = 0; +inp[27366] = 1073556495; +inp[27367] = 0; +inp[27368] = 1073555472; +inp[27369] = 0; +inp[27370] = 1073554448; +inp[27371] = 0; +inp[27372] = 1073553424; +inp[27373] = 0; +inp[27374] = 1073552400; +inp[27375] = 0; +inp[27376] = 1073551376; +inp[27377] = 0; +inp[27378] = 1073550353; +inp[27379] = 0; +inp[27380] = 1073549329; +inp[27381] = 0; +inp[27382] = 1073548305; +inp[27383] = 0; +inp[27384] = 1073547281; +inp[27385] = 0; +inp[27386] = 1073546257; +inp[27387] = 0; +inp[27388] = 1073545233; +inp[27389] = 0; +inp[27390] = 1073544210; +inp[27391] = 0; +inp[27392] = 1073543186; +inp[27393] = 0; +inp[27394] = 1073542162; +inp[27395] = 0; +inp[27396] = 1073541138; +inp[27397] = 0; +inp[27398] = 1073540114; +inp[27399] = 0; +inp[27400] = 1073539091; +inp[27401] = 0; +inp[27402] = 1073538067; +inp[27403] = 0; +inp[27404] = 1073537043; +inp[27405] = 0; +inp[27406] = 1073536019; +inp[27407] = 0; +inp[27408] = 1073534995; +inp[27409] = 0; +inp[27410] = 1073533972; +inp[27411] = 0; +inp[27412] = 1073532948; +inp[27413] = 0; +inp[27414] = 1073531924; +inp[27415] = 0; +inp[27416] = 1073530900; +inp[27417] = 0; +inp[27418] = 1073529876; +inp[27419] = 0; +inp[27420] = 1073528853; +inp[27421] = 0; +inp[27422] = 1073527829; +inp[27423] = 0; +inp[27424] = 1073526805; +inp[27425] = 0; +inp[27426] = 1073525781; +inp[27427] = 0; +inp[27428] = 1073524757; +inp[27429] = 0; +inp[27430] = 1073523734; +inp[27431] = 0; +inp[27432] = 1073522710; +inp[27433] = 0; +inp[27434] = 1073521686; +inp[27435] = 0; +inp[27436] = 1073520662; +inp[27437] = 0; +inp[27438] = 1073519638; +inp[27439] = 0; +inp[27440] = 1073518615; +inp[27441] = 0; +inp[27442] = 1073517591; +inp[27443] = 0; +inp[27444] = 1073516567; +inp[27445] = 0; +inp[27446] = 1073515543; +inp[27447] = 0; +inp[27448] = 1073514520; +inp[27449] = 0; +inp[27450] = 1073513496; +inp[27451] = 0; +inp[27452] = 1073512472; +inp[27453] = 0; +inp[27454] = 1073511448; +inp[27455] = 0; +inp[27456] = 1073510424; +inp[27457] = 0; +inp[27458] = 1073509401; +inp[27459] = 0; +inp[27460] = 1073508377; +inp[27461] = 0; +inp[27462] = 1073507353; +inp[27463] = 0; +inp[27464] = 1073506329; +inp[27465] = 0; +inp[27466] = 1073505306; +inp[27467] = 0; +inp[27468] = 1073504282; +inp[27469] = 0; +inp[27470] = 1073503258; +inp[27471] = 0; +inp[27472] = 1073502234; +inp[27473] = 0; +inp[27474] = 1073501210; +inp[27475] = 0; +inp[27476] = 1073500187; +inp[27477] = 0; +inp[27478] = 1073499163; +inp[27479] = 0; +inp[27480] = 1073498139; +inp[27481] = 0; +inp[27482] = 1073497115; +inp[27483] = 0; +inp[27484] = 1073496092; +inp[27485] = 0; +inp[27486] = 1073495068; +inp[27487] = 0; +inp[27488] = 1073494044; +inp[27489] = 0; +inp[27490] = 1073493020; +inp[27491] = 0; +inp[27492] = 1073491997; +inp[27493] = 0; +inp[27494] = 1073490973; +inp[27495] = 0; +inp[27496] = 1073489949; +inp[27497] = 0; +inp[27498] = 1073488925; +inp[27499] = 0; +inp[27500] = 1073487902; +inp[27501] = 0; +inp[27502] = 1073486878; +inp[27503] = 0; +inp[27504] = 1073485854; +inp[27505] = 0; +inp[27506] = 1073484830; +inp[27507] = 0; +inp[27508] = 1073483807; +inp[27509] = 0; +inp[27510] = 1073482783; +inp[27511] = 0; +inp[27512] = 1073481759; +inp[27513] = 0; +inp[27514] = 1073480735; +inp[27515] = 0; +inp[27516] = 1073741824; +inp[27517] = 1073741824; +inp[27518] = 1073741312; +inp[27519] = 0; +inp[27520] = 1073740800; +inp[27521] = 0; +inp[27522] = 1073740288; +inp[27523] = 0; +inp[27524] = 1073739776; +inp[27525] = 0; +inp[27526] = 1073739264; +inp[27527] = 0; +inp[27528] = 1073738752; +inp[27529] = 0; +inp[27530] = 1073738240; +inp[27531] = 0; +inp[27532] = 1073737728; +inp[27533] = 0; +inp[27534] = 1073737216; +inp[27535] = 0; +inp[27536] = 1073736704; +inp[27537] = 0; +inp[27538] = 1073736192; +inp[27539] = 0; +inp[27540] = 1073735680; +inp[27541] = 0; +inp[27542] = 1073735168; +inp[27543] = 0; +inp[27544] = 1073734656; +inp[27545] = 0; +inp[27546] = 1073734144; +inp[27547] = 0; +inp[27548] = 1073733632; +inp[27549] = 0; +inp[27550] = 1073733120; +inp[27551] = 0; +inp[27552] = 1073732608; +inp[27553] = 0; +inp[27554] = 1073732096; +inp[27555] = 0; +inp[27556] = 1073731584; +inp[27557] = 0; +inp[27558] = 1073731072; +inp[27559] = 0; +inp[27560] = 1073730560; +inp[27561] = 0; +inp[27562] = 1073730048; +inp[27563] = 0; +inp[27564] = 1073729536; +inp[27565] = 0; +inp[27566] = 1073729024; +inp[27567] = 0; +inp[27568] = 1073728512; +inp[27569] = 0; +inp[27570] = 1073728000; +inp[27571] = 0; +inp[27572] = 1073727488; +inp[27573] = 0; +inp[27574] = 1073726976; +inp[27575] = 0; +inp[27576] = 1073726464; +inp[27577] = 0; +inp[27578] = 1073725952; +inp[27579] = 0; +inp[27580] = 1073725440; +inp[27581] = 0; +inp[27582] = 1073724928; +inp[27583] = 0; +inp[27584] = 1073724416; +inp[27585] = 0; +inp[27586] = 1073723904; +inp[27587] = 0; +inp[27588] = 1073723392; +inp[27589] = 0; +inp[27590] = 1073722880; +inp[27591] = 0; +inp[27592] = 1073722368; +inp[27593] = 0; +inp[27594] = 1073721856; +inp[27595] = 0; +inp[27596] = 1073721344; +inp[27597] = 0; +inp[27598] = 1073720832; +inp[27599] = 0; +inp[27600] = 1073720320; +inp[27601] = 0; +inp[27602] = 1073719808; +inp[27603] = 0; +inp[27604] = 1073719296; +inp[27605] = 0; +inp[27606] = 1073718784; +inp[27607] = 0; +inp[27608] = 1073718272; +inp[27609] = 0; +inp[27610] = 1073717760; +inp[27611] = 0; +inp[27612] = 1073717248; +inp[27613] = 0; +inp[27614] = 1073716736; +inp[27615] = 0; +inp[27616] = 1073716224; +inp[27617] = 0; +inp[27618] = 1073715712; +inp[27619] = 0; +inp[27620] = 1073715200; +inp[27621] = 0; +inp[27622] = 1073714688; +inp[27623] = 0; +inp[27624] = 1073714176; +inp[27625] = 0; +inp[27626] = 1073713664; +inp[27627] = 0; +inp[27628] = 1073713152; +inp[27629] = 0; +inp[27630] = 1073712640; +inp[27631] = 0; +inp[27632] = 1073712128; +inp[27633] = 0; +inp[27634] = 1073711616; +inp[27635] = 0; +inp[27636] = 1073711104; +inp[27637] = 0; +inp[27638] = 1073710592; +inp[27639] = 0; +inp[27640] = 1073710080; +inp[27641] = 0; +inp[27642] = 1073709568; +inp[27643] = 0; +inp[27644] = 1073709056; +inp[27645] = 0; +inp[27646] = 1073708544; +inp[27647] = 0; +inp[27648] = 1073708032; +inp[27649] = 0; +inp[27650] = 1073707520; +inp[27651] = 0; +inp[27652] = 1073707008; +inp[27653] = 0; +inp[27654] = 1073706496; +inp[27655] = 0; +inp[27656] = 1073705984; +inp[27657] = 0; +inp[27658] = 1073705472; +inp[27659] = 0; +inp[27660] = 1073704960; +inp[27661] = 0; +inp[27662] = 1073704448; +inp[27663] = 0; +inp[27664] = 1073703936; +inp[27665] = 0; +inp[27666] = 1073703424; +inp[27667] = 0; +inp[27668] = 1073702912; +inp[27669] = 0; +inp[27670] = 1073702400; +inp[27671] = 0; +inp[27672] = 1073701888; +inp[27673] = 0; +inp[27674] = 1073701376; +inp[27675] = 0; +inp[27676] = 1073700864; +inp[27677] = 0; +inp[27678] = 1073700352; +inp[27679] = 0; +inp[27680] = 1073699840; +inp[27681] = 0; +inp[27682] = 1073699328; +inp[27683] = 0; +inp[27684] = 1073698816; +inp[27685] = 0; +inp[27686] = 1073698304; +inp[27687] = 0; +inp[27688] = 1073697792; +inp[27689] = 0; +inp[27690] = 1073697280; +inp[27691] = 0; +inp[27692] = 1073696768; +inp[27693] = 0; +inp[27694] = 1073696256; +inp[27695] = 0; +inp[27696] = 1073695744; +inp[27697] = 0; +inp[27698] = 1073695233; +inp[27699] = 0; +inp[27700] = 1073694721; +inp[27701] = 0; +inp[27702] = 1073694209; +inp[27703] = 0; +inp[27704] = 1073693697; +inp[27705] = 0; +inp[27706] = 1073693185; +inp[27707] = 0; +inp[27708] = 1073692673; +inp[27709] = 0; +inp[27710] = 1073692161; +inp[27711] = 0; +inp[27712] = 1073691649; +inp[27713] = 0; +inp[27714] = 1073691137; +inp[27715] = 0; +inp[27716] = 1073690625; +inp[27717] = 0; +inp[27718] = 1073690113; +inp[27719] = 0; +inp[27720] = 1073689601; +inp[27721] = 0; +inp[27722] = 1073689089; +inp[27723] = 0; +inp[27724] = 1073688577; +inp[27725] = 0; +inp[27726] = 1073688065; +inp[27727] = 0; +inp[27728] = 1073687553; +inp[27729] = 0; +inp[27730] = 1073687041; +inp[27731] = 0; +inp[27732] = 1073686529; +inp[27733] = 0; +inp[27734] = 1073686017; +inp[27735] = 0; +inp[27736] = 1073685505; +inp[27737] = 0; +inp[27738] = 1073684993; +inp[27739] = 0; +inp[27740] = 1073684481; +inp[27741] = 0; +inp[27742] = 1073683969; +inp[27743] = 0; +inp[27744] = 1073683457; +inp[27745] = 0; +inp[27746] = 1073682945; +inp[27747] = 0; +inp[27748] = 1073682433; +inp[27749] = 0; +inp[27750] = 1073681921; +inp[27751] = 0; +inp[27752] = 1073681409; +inp[27753] = 0; +inp[27754] = 1073680897; +inp[27755] = 0; +inp[27756] = 1073680385; +inp[27757] = 0; +inp[27758] = 1073679873; +inp[27759] = 0; +inp[27760] = 1073679361; +inp[27761] = 0; +inp[27762] = 1073678849; +inp[27763] = 0; +inp[27764] = 1073678337; +inp[27765] = 0; +inp[27766] = 1073677825; +inp[27767] = 0; +inp[27768] = 1073677313; +inp[27769] = 0; +inp[27770] = 1073676801; +inp[27771] = 0; +inp[27772] = 1073676289; +inp[27773] = 0; +inp[27774] = 1073675778; +inp[27775] = 0; +inp[27776] = 1073675266; +inp[27777] = 0; +inp[27778] = 1073674754; +inp[27779] = 0; +inp[27780] = 1073674242; +inp[27781] = 0; +inp[27782] = 1073673730; +inp[27783] = 0; +inp[27784] = 1073673218; +inp[27785] = 0; +inp[27786] = 1073672706; +inp[27787] = 0; +inp[27788] = 1073672194; +inp[27789] = 0; +inp[27790] = 1073671682; +inp[27791] = 0; +inp[27792] = 1073671170; +inp[27793] = 0; +inp[27794] = 1073670658; +inp[27795] = 0; +inp[27796] = 1073670146; +inp[27797] = 0; +inp[27798] = 1073669634; +inp[27799] = 0; +inp[27800] = 1073669122; +inp[27801] = 0; +inp[27802] = 1073668610; +inp[27803] = 0; +inp[27804] = 1073668098; +inp[27805] = 0; +inp[27806] = 1073667586; +inp[27807] = 0; +inp[27808] = 1073667074; +inp[27809] = 0; +inp[27810] = 1073666562; +inp[27811] = 0; +inp[27812] = 1073666050; +inp[27813] = 0; +inp[27814] = 1073665538; +inp[27815] = 0; +inp[27816] = 1073665026; +inp[27817] = 0; +inp[27818] = 1073664514; +inp[27819] = 0; +inp[27820] = 1073664002; +inp[27821] = 0; +inp[27822] = 1073663490; +inp[27823] = 0; +inp[27824] = 1073662978; +inp[27825] = 0; +inp[27826] = 1073662466; +inp[27827] = 0; +inp[27828] = 1073661954; +inp[27829] = 0; +inp[27830] = 1073661443; +inp[27831] = 0; +inp[27832] = 1073660931; +inp[27833] = 0; +inp[27834] = 1073660419; +inp[27835] = 0; +inp[27836] = 1073659907; +inp[27837] = 0; +inp[27838] = 1073659395; +inp[27839] = 0; +inp[27840] = 1073658883; +inp[27841] = 0; +inp[27842] = 1073658371; +inp[27843] = 0; +inp[27844] = 1073657859; +inp[27845] = 0; +inp[27846] = 1073657347; +inp[27847] = 0; +inp[27848] = 1073656835; +inp[27849] = 0; +inp[27850] = 1073656323; +inp[27851] = 0; +inp[27852] = 1073655811; +inp[27853] = 0; +inp[27854] = 1073655299; +inp[27855] = 0; +inp[27856] = 1073654787; +inp[27857] = 0; +inp[27858] = 1073654275; +inp[27859] = 0; +inp[27860] = 1073653763; +inp[27861] = 0; +inp[27862] = 1073653251; +inp[27863] = 0; +inp[27864] = 1073652739; +inp[27865] = 0; +inp[27866] = 1073652227; +inp[27867] = 0; +inp[27868] = 1073651715; +inp[27869] = 0; +inp[27870] = 1073651203; +inp[27871] = 0; +inp[27872] = 1073650691; +inp[27873] = 0; +inp[27874] = 1073650179; +inp[27875] = 0; +inp[27876] = 1073649667; +inp[27877] = 0; +inp[27878] = 1073649155; +inp[27879] = 0; +inp[27880] = 1073648644; +inp[27881] = 0; +inp[27882] = 1073648132; +inp[27883] = 0; +inp[27884] = 1073647620; +inp[27885] = 0; +inp[27886] = 1073647108; +inp[27887] = 0; +inp[27888] = 1073646596; +inp[27889] = 0; +inp[27890] = 1073646084; +inp[27891] = 0; +inp[27892] = 1073645572; +inp[27893] = 0; +inp[27894] = 1073645060; +inp[27895] = 0; +inp[27896] = 1073644548; +inp[27897] = 0; +inp[27898] = 1073644036; +inp[27899] = 0; +inp[27900] = 1073643524; +inp[27901] = 0; +inp[27902] = 1073643012; +inp[27903] = 0; +inp[27904] = 1073642500; +inp[27905] = 0; +inp[27906] = 1073641988; +inp[27907] = 0; +inp[27908] = 1073641476; +inp[27909] = 0; +inp[27910] = 1073640964; +inp[27911] = 0; +inp[27912] = 1073640452; +inp[27913] = 0; +inp[27914] = 1073639940; +inp[27915] = 0; +inp[27916] = 1073639428; +inp[27917] = 0; +inp[27918] = 1073638916; +inp[27919] = 0; +inp[27920] = 1073638404; +inp[27921] = 0; +inp[27922] = 1073637893; +inp[27923] = 0; +inp[27924] = 1073637381; +inp[27925] = 0; +inp[27926] = 1073636869; +inp[27927] = 0; +inp[27928] = 1073636357; +inp[27929] = 0; +inp[27930] = 1073635845; +inp[27931] = 0; +inp[27932] = 1073635333; +inp[27933] = 0; +inp[27934] = 1073634821; +inp[27935] = 0; +inp[27936] = 1073634309; +inp[27937] = 0; +inp[27938] = 1073633797; +inp[27939] = 0; +inp[27940] = 1073633285; +inp[27941] = 0; +inp[27942] = 1073632773; +inp[27943] = 0; +inp[27944] = 1073632261; +inp[27945] = 0; +inp[27946] = 1073631749; +inp[27947] = 0; +inp[27948] = 1073631237; +inp[27949] = 0; +inp[27950] = 1073630725; +inp[27951] = 0; +inp[27952] = 1073630213; +inp[27953] = 0; +inp[27954] = 1073629701; +inp[27955] = 0; +inp[27956] = 1073629189; +inp[27957] = 0; +inp[27958] = 1073628677; +inp[27959] = 0; +inp[27960] = 1073628166; +inp[27961] = 0; +inp[27962] = 1073627654; +inp[27963] = 0; +inp[27964] = 1073627142; +inp[27965] = 0; +inp[27966] = 1073626630; +inp[27967] = 0; +inp[27968] = 1073626118; +inp[27969] = 0; +inp[27970] = 1073625606; +inp[27971] = 0; +inp[27972] = 1073625094; +inp[27973] = 0; +inp[27974] = 1073624582; +inp[27975] = 0; +inp[27976] = 1073624070; +inp[27977] = 0; +inp[27978] = 1073623558; +inp[27979] = 0; +inp[27980] = 1073623046; +inp[27981] = 0; +inp[27982] = 1073622534; +inp[27983] = 0; +inp[27984] = 1073622022; +inp[27985] = 0; +inp[27986] = 1073621510; +inp[27987] = 0; +inp[27988] = 1073620998; +inp[27989] = 0; +inp[27990] = 1073620486; +inp[27991] = 0; +inp[27992] = 1073619974; +inp[27993] = 0; +inp[27994] = 1073619462; +inp[27995] = 0; +inp[27996] = 1073618951; +inp[27997] = 0; +inp[27998] = 1073618439; +inp[27999] = 0; +inp[28000] = 1073617927; +inp[28001] = 0; +inp[28002] = 1073617415; +inp[28003] = 0; +inp[28004] = 1073616903; +inp[28005] = 0; +inp[28006] = 1073616391; +inp[28007] = 0; +inp[28008] = 1073615879; +inp[28009] = 0; +inp[28010] = 1073615367; +inp[28011] = 0; +inp[28012] = 1073614855; +inp[28013] = 0; +inp[28014] = 1073614343; +inp[28015] = 0; +inp[28016] = 1073613831; +inp[28017] = 0; +inp[28018] = 1073613319; +inp[28019] = 0; +inp[28020] = 1073612807; +inp[28021] = 0; +inp[28022] = 1073612295; +inp[28023] = 0; +inp[28024] = 1073611783; +inp[28025] = 0; +inp[28026] = 1073611271; +inp[28027] = 0; +inp[28028] = 1073741824; +inp[28029] = 1073741824; +inp[28030] = 1073741568; +inp[28031] = 0; +inp[28032] = 1073741312; +inp[28033] = 0; +inp[28034] = 1073741056; +inp[28035] = 0; +inp[28036] = 1073740800; +inp[28037] = 0; +inp[28038] = 1073740544; +inp[28039] = 0; +inp[28040] = 1073740288; +inp[28041] = 0; +inp[28042] = 1073740032; +inp[28043] = 0; +inp[28044] = 1073739776; +inp[28045] = 0; +inp[28046] = 1073739520; +inp[28047] = 0; +inp[28048] = 1073739264; +inp[28049] = 0; +inp[28050] = 1073739008; +inp[28051] = 0; +inp[28052] = 1073738752; +inp[28053] = 0; +inp[28054] = 1073738496; +inp[28055] = 0; +inp[28056] = 1073738240; +inp[28057] = 0; +inp[28058] = 1073737984; +inp[28059] = 0; +inp[28060] = 1073737728; +inp[28061] = 0; +inp[28062] = 1073737472; +inp[28063] = 0; +inp[28064] = 1073737216; +inp[28065] = 0; +inp[28066] = 1073736960; +inp[28067] = 0; +inp[28068] = 1073736704; +inp[28069] = 0; +inp[28070] = 1073736448; +inp[28071] = 0; +inp[28072] = 1073736192; +inp[28073] = 0; +inp[28074] = 1073735936; +inp[28075] = 0; +inp[28076] = 1073735680; +inp[28077] = 0; +inp[28078] = 1073735424; +inp[28079] = 0; +inp[28080] = 1073735168; +inp[28081] = 0; +inp[28082] = 1073734912; +inp[28083] = 0; +inp[28084] = 1073734656; +inp[28085] = 0; +inp[28086] = 1073734400; +inp[28087] = 0; +inp[28088] = 1073734144; +inp[28089] = 0; +inp[28090] = 1073733888; +inp[28091] = 0; +inp[28092] = 1073733632; +inp[28093] = 0; +inp[28094] = 1073733376; +inp[28095] = 0; +inp[28096] = 1073733120; +inp[28097] = 0; +inp[28098] = 1073732864; +inp[28099] = 0; +inp[28100] = 1073732608; +inp[28101] = 0; +inp[28102] = 1073732352; +inp[28103] = 0; +inp[28104] = 1073732096; +inp[28105] = 0; +inp[28106] = 1073731840; +inp[28107] = 0; +inp[28108] = 1073731584; +inp[28109] = 0; +inp[28110] = 1073731328; +inp[28111] = 0; +inp[28112] = 1073731072; +inp[28113] = 0; +inp[28114] = 1073730816; +inp[28115] = 0; +inp[28116] = 1073730560; +inp[28117] = 0; +inp[28118] = 1073730304; +inp[28119] = 0; +inp[28120] = 1073730048; +inp[28121] = 0; +inp[28122] = 1073729792; +inp[28123] = 0; +inp[28124] = 1073729536; +inp[28125] = 0; +inp[28126] = 1073729280; +inp[28127] = 0; +inp[28128] = 1073729024; +inp[28129] = 0; +inp[28130] = 1073728768; +inp[28131] = 0; +inp[28132] = 1073728512; +inp[28133] = 0; +inp[28134] = 1073728256; +inp[28135] = 0; +inp[28136] = 1073728000; +inp[28137] = 0; +inp[28138] = 1073727744; +inp[28139] = 0; +inp[28140] = 1073727488; +inp[28141] = 0; +inp[28142] = 1073727232; +inp[28143] = 0; +inp[28144] = 1073726976; +inp[28145] = 0; +inp[28146] = 1073726720; +inp[28147] = 0; +inp[28148] = 1073726464; +inp[28149] = 0; +inp[28150] = 1073726208; +inp[28151] = 0; +inp[28152] = 1073725952; +inp[28153] = 0; +inp[28154] = 1073725696; +inp[28155] = 0; +inp[28156] = 1073725440; +inp[28157] = 0; +inp[28158] = 1073725184; +inp[28159] = 0; +inp[28160] = 1073724928; +inp[28161] = 0; +inp[28162] = 1073724672; +inp[28163] = 0; +inp[28164] = 1073724416; +inp[28165] = 0; +inp[28166] = 1073724160; +inp[28167] = 0; +inp[28168] = 1073723904; +inp[28169] = 0; +inp[28170] = 1073723648; +inp[28171] = 0; +inp[28172] = 1073723392; +inp[28173] = 0; +inp[28174] = 1073723136; +inp[28175] = 0; +inp[28176] = 1073722880; +inp[28177] = 0; +inp[28178] = 1073722624; +inp[28179] = 0; +inp[28180] = 1073722368; +inp[28181] = 0; +inp[28182] = 1073722112; +inp[28183] = 0; +inp[28184] = 1073721856; +inp[28185] = 0; +inp[28186] = 1073721600; +inp[28187] = 0; +inp[28188] = 1073721344; +inp[28189] = 0; +inp[28190] = 1073721088; +inp[28191] = 0; +inp[28192] = 1073720832; +inp[28193] = 0; +inp[28194] = 1073720576; +inp[28195] = 0; +inp[28196] = 1073720320; +inp[28197] = 0; +inp[28198] = 1073720064; +inp[28199] = 0; +inp[28200] = 1073719808; +inp[28201] = 0; +inp[28202] = 1073719552; +inp[28203] = 0; +inp[28204] = 1073719296; +inp[28205] = 0; +inp[28206] = 1073719040; +inp[28207] = 0; +inp[28208] = 1073718784; +inp[28209] = 0; +inp[28210] = 1073718528; +inp[28211] = 0; +inp[28212] = 1073718272; +inp[28213] = 0; +inp[28214] = 1073718016; +inp[28215] = 0; +inp[28216] = 1073717760; +inp[28217] = 0; +inp[28218] = 1073717504; +inp[28219] = 0; +inp[28220] = 1073717248; +inp[28221] = 0; +inp[28222] = 1073716992; +inp[28223] = 0; +inp[28224] = 1073716736; +inp[28225] = 0; +inp[28226] = 1073716480; +inp[28227] = 0; +inp[28228] = 1073716224; +inp[28229] = 0; +inp[28230] = 1073715968; +inp[28231] = 0; +inp[28232] = 1073715712; +inp[28233] = 0; +inp[28234] = 1073715456; +inp[28235] = 0; +inp[28236] = 1073715200; +inp[28237] = 0; +inp[28238] = 1073714944; +inp[28239] = 0; +inp[28240] = 1073714688; +inp[28241] = 0; +inp[28242] = 1073714432; +inp[28243] = 0; +inp[28244] = 1073714176; +inp[28245] = 0; +inp[28246] = 1073713920; +inp[28247] = 0; +inp[28248] = 1073713664; +inp[28249] = 0; +inp[28250] = 1073713408; +inp[28251] = 0; +inp[28252] = 1073713152; +inp[28253] = 0; +inp[28254] = 1073712896; +inp[28255] = 0; +inp[28256] = 1073712640; +inp[28257] = 0; +inp[28258] = 1073712384; +inp[28259] = 0; +inp[28260] = 1073712128; +inp[28261] = 0; +inp[28262] = 1073711872; +inp[28263] = 0; +inp[28264] = 1073711616; +inp[28265] = 0; +inp[28266] = 1073711360; +inp[28267] = 0; +inp[28268] = 1073711104; +inp[28269] = 0; +inp[28270] = 1073710848; +inp[28271] = 0; +inp[28272] = 1073710592; +inp[28273] = 0; +inp[28274] = 1073710336; +inp[28275] = 0; +inp[28276] = 1073710080; +inp[28277] = 0; +inp[28278] = 1073709824; +inp[28279] = 0; +inp[28280] = 1073709568; +inp[28281] = 0; +inp[28282] = 1073709312; +inp[28283] = 0; +inp[28284] = 1073709056; +inp[28285] = 0; +inp[28286] = 1073708800; +inp[28287] = 0; +inp[28288] = 1073708544; +inp[28289] = 0; +inp[28290] = 1073708288; +inp[28291] = 0; +inp[28292] = 1073708032; +inp[28293] = 0; +inp[28294] = 1073707776; +inp[28295] = 0; +inp[28296] = 1073707520; +inp[28297] = 0; +inp[28298] = 1073707264; +inp[28299] = 0; +inp[28300] = 1073707008; +inp[28301] = 0; +inp[28302] = 1073706752; +inp[28303] = 0; +inp[28304] = 1073706496; +inp[28305] = 0; +inp[28306] = 1073706240; +inp[28307] = 0; +inp[28308] = 1073705984; +inp[28309] = 0; +inp[28310] = 1073705728; +inp[28311] = 0; +inp[28312] = 1073705472; +inp[28313] = 0; +inp[28314] = 1073705216; +inp[28315] = 0; +inp[28316] = 1073704960; +inp[28317] = 0; +inp[28318] = 1073704704; +inp[28319] = 0; +inp[28320] = 1073704448; +inp[28321] = 0; +inp[28322] = 1073704192; +inp[28323] = 0; +inp[28324] = 1073703936; +inp[28325] = 0; +inp[28326] = 1073703680; +inp[28327] = 0; +inp[28328] = 1073703424; +inp[28329] = 0; +inp[28330] = 1073703168; +inp[28331] = 0; +inp[28332] = 1073702912; +inp[28333] = 0; +inp[28334] = 1073702656; +inp[28335] = 0; +inp[28336] = 1073702400; +inp[28337] = 0; +inp[28338] = 1073702144; +inp[28339] = 0; +inp[28340] = 1073701888; +inp[28341] = 0; +inp[28342] = 1073701632; +inp[28343] = 0; +inp[28344] = 1073701376; +inp[28345] = 0; +inp[28346] = 1073701120; +inp[28347] = 0; +inp[28348] = 1073700864; +inp[28349] = 0; +inp[28350] = 1073700608; +inp[28351] = 0; +inp[28352] = 1073700352; +inp[28353] = 0; +inp[28354] = 1073700096; +inp[28355] = 0; +inp[28356] = 1073699840; +inp[28357] = 0; +inp[28358] = 1073699584; +inp[28359] = 0; +inp[28360] = 1073699328; +inp[28361] = 0; +inp[28362] = 1073699072; +inp[28363] = 0; +inp[28364] = 1073698816; +inp[28365] = 0; +inp[28366] = 1073698560; +inp[28367] = 0; +inp[28368] = 1073698304; +inp[28369] = 0; +inp[28370] = 1073698048; +inp[28371] = 0; +inp[28372] = 1073697792; +inp[28373] = 0; +inp[28374] = 1073697536; +inp[28375] = 0; +inp[28376] = 1073697280; +inp[28377] = 0; +inp[28378] = 1073697024; +inp[28379] = 0; +inp[28380] = 1073696768; +inp[28381] = 0; +inp[28382] = 1073696512; +inp[28383] = 0; +inp[28384] = 1073696256; +inp[28385] = 0; +inp[28386] = 1073696000; +inp[28387] = 0; +inp[28388] = 1073695744; +inp[28389] = 0; +inp[28390] = 1073695488; +inp[28391] = 0; +inp[28392] = 1073695233; +inp[28393] = 0; +inp[28394] = 1073694977; +inp[28395] = 0; +inp[28396] = 1073694721; +inp[28397] = 0; +inp[28398] = 1073694465; +inp[28399] = 0; +inp[28400] = 1073694209; +inp[28401] = 0; +inp[28402] = 1073693953; +inp[28403] = 0; +inp[28404] = 1073693697; +inp[28405] = 0; +inp[28406] = 1073693441; +inp[28407] = 0; +inp[28408] = 1073693185; +inp[28409] = 0; +inp[28410] = 1073692929; +inp[28411] = 0; +inp[28412] = 1073692673; +inp[28413] = 0; +inp[28414] = 1073692417; +inp[28415] = 0; +inp[28416] = 1073692161; +inp[28417] = 0; +inp[28418] = 1073691905; +inp[28419] = 0; +inp[28420] = 1073691649; +inp[28421] = 0; +inp[28422] = 1073691393; +inp[28423] = 0; +inp[28424] = 1073691137; +inp[28425] = 0; +inp[28426] = 1073690881; +inp[28427] = 0; +inp[28428] = 1073690625; +inp[28429] = 0; +inp[28430] = 1073690369; +inp[28431] = 0; +inp[28432] = 1073690113; +inp[28433] = 0; +inp[28434] = 1073689857; +inp[28435] = 0; +inp[28436] = 1073689601; +inp[28437] = 0; +inp[28438] = 1073689345; +inp[28439] = 0; +inp[28440] = 1073689089; +inp[28441] = 0; +inp[28442] = 1073688833; +inp[28443] = 0; +inp[28444] = 1073688577; +inp[28445] = 0; +inp[28446] = 1073688321; +inp[28447] = 0; +inp[28448] = 1073688065; +inp[28449] = 0; +inp[28450] = 1073687809; +inp[28451] = 0; +inp[28452] = 1073687553; +inp[28453] = 0; +inp[28454] = 1073687297; +inp[28455] = 0; +inp[28456] = 1073687041; +inp[28457] = 0; +inp[28458] = 1073686785; +inp[28459] = 0; +inp[28460] = 1073686529; +inp[28461] = 0; +inp[28462] = 1073686273; +inp[28463] = 0; +inp[28464] = 1073686017; +inp[28465] = 0; +inp[28466] = 1073685761; +inp[28467] = 0; +inp[28468] = 1073685505; +inp[28469] = 0; +inp[28470] = 1073685249; +inp[28471] = 0; +inp[28472] = 1073684993; +inp[28473] = 0; +inp[28474] = 1073684737; +inp[28475] = 0; +inp[28476] = 1073684481; +inp[28477] = 0; +inp[28478] = 1073684225; +inp[28479] = 0; +inp[28480] = 1073683969; +inp[28481] = 0; +inp[28482] = 1073683713; +inp[28483] = 0; +inp[28484] = 1073683457; +inp[28485] = 0; +inp[28486] = 1073683201; +inp[28487] = 0; +inp[28488] = 1073682945; +inp[28489] = 0; +inp[28490] = 1073682689; +inp[28491] = 0; +inp[28492] = 1073682433; +inp[28493] = 0; +inp[28494] = 1073682177; +inp[28495] = 0; +inp[28496] = 1073681921; +inp[28497] = 0; +inp[28498] = 1073681665; +inp[28499] = 0; +inp[28500] = 1073681409; +inp[28501] = 0; +inp[28502] = 1073681153; +inp[28503] = 0; +inp[28504] = 1073680897; +inp[28505] = 0; +inp[28506] = 1073680641; +inp[28507] = 0; +inp[28508] = 1073680385; +inp[28509] = 0; +inp[28510] = 1073680129; +inp[28511] = 0; +inp[28512] = 1073679873; +inp[28513] = 0; +inp[28514] = 1073679617; +inp[28515] = 0; +inp[28516] = 1073679361; +inp[28517] = 0; +inp[28518] = 1073679105; +inp[28519] = 0; +inp[28520] = 1073678849; +inp[28521] = 0; +inp[28522] = 1073678593; +inp[28523] = 0; +inp[28524] = 1073678337; +inp[28525] = 0; +inp[28526] = 1073678081; +inp[28527] = 0; +inp[28528] = 1073677825; +inp[28529] = 0; +inp[28530] = 1073677569; +inp[28531] = 0; +inp[28532] = 1073677313; +inp[28533] = 0; +inp[28534] = 1073677057; +inp[28535] = 0; +inp[28536] = 1073676801; +inp[28537] = 0; +inp[28538] = 1073676545; +inp[28539] = 0; +inp[28540] = 1073741824; +inp[28541] = 1073741824; +inp[28542] = 1073741696; +inp[28543] = 0; +inp[28544] = 1073741568; +inp[28545] = 0; +inp[28546] = 1073741440; +inp[28547] = 0; +inp[28548] = 1073741312; +inp[28549] = 0; +inp[28550] = 1073741184; +inp[28551] = 0; +inp[28552] = 1073741056; +inp[28553] = 0; +inp[28554] = 1073740928; +inp[28555] = 0; +inp[28556] = 1073740800; +inp[28557] = 0; +inp[28558] = 1073740672; +inp[28559] = 0; +inp[28560] = 1073740544; +inp[28561] = 0; +inp[28562] = 1073740416; +inp[28563] = 0; +inp[28564] = 1073740288; +inp[28565] = 0; +inp[28566] = 1073740160; +inp[28567] = 0; +inp[28568] = 1073740032; +inp[28569] = 0; +inp[28570] = 1073739904; +inp[28571] = 0; +inp[28572] = 1073739776; +inp[28573] = 0; +inp[28574] = 1073739648; +inp[28575] = 0; +inp[28576] = 1073739520; +inp[28577] = 0; +inp[28578] = 1073739392; +inp[28579] = 0; +inp[28580] = 1073739264; +inp[28581] = 0; +inp[28582] = 1073739136; +inp[28583] = 0; +inp[28584] = 1073739008; +inp[28585] = 0; +inp[28586] = 1073738880; +inp[28587] = 0; +inp[28588] = 1073738752; +inp[28589] = 0; +inp[28590] = 1073738624; +inp[28591] = 0; +inp[28592] = 1073738496; +inp[28593] = 0; +inp[28594] = 1073738368; +inp[28595] = 0; +inp[28596] = 1073738240; +inp[28597] = 0; +inp[28598] = 1073738112; +inp[28599] = 0; +inp[28600] = 1073737984; +inp[28601] = 0; +inp[28602] = 1073737856; +inp[28603] = 0; +inp[28604] = 1073737728; +inp[28605] = 0; +inp[28606] = 1073737600; +inp[28607] = 0; +inp[28608] = 1073737472; +inp[28609] = 0; +inp[28610] = 1073737344; +inp[28611] = 0; +inp[28612] = 1073737216; +inp[28613] = 0; +inp[28614] = 1073737088; +inp[28615] = 0; +inp[28616] = 1073736960; +inp[28617] = 0; +inp[28618] = 1073736832; +inp[28619] = 0; +inp[28620] = 1073736704; +inp[28621] = 0; +inp[28622] = 1073736576; +inp[28623] = 0; +inp[28624] = 1073736448; +inp[28625] = 0; +inp[28626] = 1073736320; +inp[28627] = 0; +inp[28628] = 1073736192; +inp[28629] = 0; +inp[28630] = 1073736064; +inp[28631] = 0; +inp[28632] = 1073735936; +inp[28633] = 0; +inp[28634] = 1073735808; +inp[28635] = 0; +inp[28636] = 1073735680; +inp[28637] = 0; +inp[28638] = 1073735552; +inp[28639] = 0; +inp[28640] = 1073735424; +inp[28641] = 0; +inp[28642] = 1073735296; +inp[28643] = 0; +inp[28644] = 1073735168; +inp[28645] = 0; +inp[28646] = 1073735040; +inp[28647] = 0; +inp[28648] = 1073734912; +inp[28649] = 0; +inp[28650] = 1073734784; +inp[28651] = 0; +inp[28652] = 1073734656; +inp[28653] = 0; +inp[28654] = 1073734528; +inp[28655] = 0; +inp[28656] = 1073734400; +inp[28657] = 0; +inp[28658] = 1073734272; +inp[28659] = 0; +inp[28660] = 1073734144; +inp[28661] = 0; +inp[28662] = 1073734016; +inp[28663] = 0; +inp[28664] = 1073733888; +inp[28665] = 0; +inp[28666] = 1073733760; +inp[28667] = 0; +inp[28668] = 1073733632; +inp[28669] = 0; +inp[28670] = 1073733504; +inp[28671] = 0; +inp[28672] = 1073733376; +inp[28673] = 0; +inp[28674] = 1073733248; +inp[28675] = 0; +inp[28676] = 1073733120; +inp[28677] = 0; +inp[28678] = 1073732992; +inp[28679] = 0; +inp[28680] = 1073732864; +inp[28681] = 0; +inp[28682] = 1073732736; +inp[28683] = 0; +inp[28684] = 1073732608; +inp[28685] = 0; +inp[28686] = 1073732480; +inp[28687] = 0; +inp[28688] = 1073732352; +inp[28689] = 0; +inp[28690] = 1073732224; +inp[28691] = 0; +inp[28692] = 1073732096; +inp[28693] = 0; +inp[28694] = 1073731968; +inp[28695] = 0; +inp[28696] = 1073731840; +inp[28697] = 0; +inp[28698] = 1073731712; +inp[28699] = 0; +inp[28700] = 1073731584; +inp[28701] = 0; +inp[28702] = 1073731456; +inp[28703] = 0; +inp[28704] = 1073731328; +inp[28705] = 0; +inp[28706] = 1073731200; +inp[28707] = 0; +inp[28708] = 1073731072; +inp[28709] = 0; +inp[28710] = 1073730944; +inp[28711] = 0; +inp[28712] = 1073730816; +inp[28713] = 0; +inp[28714] = 1073730688; +inp[28715] = 0; +inp[28716] = 1073730560; +inp[28717] = 0; +inp[28718] = 1073730432; +inp[28719] = 0; +inp[28720] = 1073730304; +inp[28721] = 0; +inp[28722] = 1073730176; +inp[28723] = 0; +inp[28724] = 1073730048; +inp[28725] = 0; +inp[28726] = 1073729920; +inp[28727] = 0; +inp[28728] = 1073729792; +inp[28729] = 0; +inp[28730] = 1073729664; +inp[28731] = 0; +inp[28732] = 1073729536; +inp[28733] = 0; +inp[28734] = 1073729408; +inp[28735] = 0; +inp[28736] = 1073729280; +inp[28737] = 0; +inp[28738] = 1073729152; +inp[28739] = 0; +inp[28740] = 1073729024; +inp[28741] = 0; +inp[28742] = 1073728896; +inp[28743] = 0; +inp[28744] = 1073728768; +inp[28745] = 0; +inp[28746] = 1073728640; +inp[28747] = 0; +inp[28748] = 1073728512; +inp[28749] = 0; +inp[28750] = 1073728384; +inp[28751] = 0; +inp[28752] = 1073728256; +inp[28753] = 0; +inp[28754] = 1073728128; +inp[28755] = 0; +inp[28756] = 1073728000; +inp[28757] = 0; +inp[28758] = 1073727872; +inp[28759] = 0; +inp[28760] = 1073727744; +inp[28761] = 0; +inp[28762] = 1073727616; +inp[28763] = 0; +inp[28764] = 1073727488; +inp[28765] = 0; +inp[28766] = 1073727360; +inp[28767] = 0; +inp[28768] = 1073727232; +inp[28769] = 0; +inp[28770] = 1073727104; +inp[28771] = 0; +inp[28772] = 1073726976; +inp[28773] = 0; +inp[28774] = 1073726848; +inp[28775] = 0; +inp[28776] = 1073726720; +inp[28777] = 0; +inp[28778] = 1073726592; +inp[28779] = 0; +inp[28780] = 1073726464; +inp[28781] = 0; +inp[28782] = 1073726336; +inp[28783] = 0; +inp[28784] = 1073726208; +inp[28785] = 0; +inp[28786] = 1073726080; +inp[28787] = 0; +inp[28788] = 1073725952; +inp[28789] = 0; +inp[28790] = 1073725824; +inp[28791] = 0; +inp[28792] = 1073725696; +inp[28793] = 0; +inp[28794] = 1073725568; +inp[28795] = 0; +inp[28796] = 1073725440; +inp[28797] = 0; +inp[28798] = 1073725312; +inp[28799] = 0; +inp[28800] = 1073725184; +inp[28801] = 0; +inp[28802] = 1073725056; +inp[28803] = 0; +inp[28804] = 1073724928; +inp[28805] = 0; +inp[28806] = 1073724800; +inp[28807] = 0; +inp[28808] = 1073724672; +inp[28809] = 0; +inp[28810] = 1073724544; +inp[28811] = 0; +inp[28812] = 1073724416; +inp[28813] = 0; +inp[28814] = 1073724288; +inp[28815] = 0; +inp[28816] = 1073724160; +inp[28817] = 0; +inp[28818] = 1073724032; +inp[28819] = 0; +inp[28820] = 1073723904; +inp[28821] = 0; +inp[28822] = 1073723776; +inp[28823] = 0; +inp[28824] = 1073723648; +inp[28825] = 0; +inp[28826] = 1073723520; +inp[28827] = 0; +inp[28828] = 1073723392; +inp[28829] = 0; +inp[28830] = 1073723264; +inp[28831] = 0; +inp[28832] = 1073723136; +inp[28833] = 0; +inp[28834] = 1073723008; +inp[28835] = 0; +inp[28836] = 1073722880; +inp[28837] = 0; +inp[28838] = 1073722752; +inp[28839] = 0; +inp[28840] = 1073722624; +inp[28841] = 0; +inp[28842] = 1073722496; +inp[28843] = 0; +inp[28844] = 1073722368; +inp[28845] = 0; +inp[28846] = 1073722240; +inp[28847] = 0; +inp[28848] = 1073722112; +inp[28849] = 0; +inp[28850] = 1073721984; +inp[28851] = 0; +inp[28852] = 1073721856; +inp[28853] = 0; +inp[28854] = 1073721728; +inp[28855] = 0; +inp[28856] = 1073721600; +inp[28857] = 0; +inp[28858] = 1073721472; +inp[28859] = 0; +inp[28860] = 1073721344; +inp[28861] = 0; +inp[28862] = 1073721216; +inp[28863] = 0; +inp[28864] = 1073721088; +inp[28865] = 0; +inp[28866] = 1073720960; +inp[28867] = 0; +inp[28868] = 1073720832; +inp[28869] = 0; +inp[28870] = 1073720704; +inp[28871] = 0; +inp[28872] = 1073720576; +inp[28873] = 0; +inp[28874] = 1073720448; +inp[28875] = 0; +inp[28876] = 1073720320; +inp[28877] = 0; +inp[28878] = 1073720192; +inp[28879] = 0; +inp[28880] = 1073720064; +inp[28881] = 0; +inp[28882] = 1073719936; +inp[28883] = 0; +inp[28884] = 1073719808; +inp[28885] = 0; +inp[28886] = 1073719680; +inp[28887] = 0; +inp[28888] = 1073719552; +inp[28889] = 0; +inp[28890] = 1073719424; +inp[28891] = 0; +inp[28892] = 1073719296; +inp[28893] = 0; +inp[28894] = 1073719168; +inp[28895] = 0; +inp[28896] = 1073719040; +inp[28897] = 0; +inp[28898] = 1073718912; +inp[28899] = 0; +inp[28900] = 1073718784; +inp[28901] = 0; +inp[28902] = 1073718656; +inp[28903] = 0; +inp[28904] = 1073718528; +inp[28905] = 0; +inp[28906] = 1073718400; +inp[28907] = 0; +inp[28908] = 1073718272; +inp[28909] = 0; +inp[28910] = 1073718144; +inp[28911] = 0; +inp[28912] = 1073718016; +inp[28913] = 0; +inp[28914] = 1073717888; +inp[28915] = 0; +inp[28916] = 1073717760; +inp[28917] = 0; +inp[28918] = 1073717632; +inp[28919] = 0; +inp[28920] = 1073717504; +inp[28921] = 0; +inp[28922] = 1073717376; +inp[28923] = 0; +inp[28924] = 1073717248; +inp[28925] = 0; +inp[28926] = 1073717120; +inp[28927] = 0; +inp[28928] = 1073716992; +inp[28929] = 0; +inp[28930] = 1073716864; +inp[28931] = 0; +inp[28932] = 1073716736; +inp[28933] = 0; +inp[28934] = 1073716608; +inp[28935] = 0; +inp[28936] = 1073716480; +inp[28937] = 0; +inp[28938] = 1073716352; +inp[28939] = 0; +inp[28940] = 1073716224; +inp[28941] = 0; +inp[28942] = 1073716096; +inp[28943] = 0; +inp[28944] = 1073715968; +inp[28945] = 0; +inp[28946] = 1073715840; +inp[28947] = 0; +inp[28948] = 1073715712; +inp[28949] = 0; +inp[28950] = 1073715584; +inp[28951] = 0; +inp[28952] = 1073715456; +inp[28953] = 0; +inp[28954] = 1073715328; +inp[28955] = 0; +inp[28956] = 1073715200; +inp[28957] = 0; +inp[28958] = 1073715072; +inp[28959] = 0; +inp[28960] = 1073714944; +inp[28961] = 0; +inp[28962] = 1073714816; +inp[28963] = 0; +inp[28964] = 1073714688; +inp[28965] = 0; +inp[28966] = 1073714560; +inp[28967] = 0; +inp[28968] = 1073714432; +inp[28969] = 0; +inp[28970] = 1073714304; +inp[28971] = 0; +inp[28972] = 1073714176; +inp[28973] = 0; +inp[28974] = 1073714048; +inp[28975] = 0; +inp[28976] = 1073713920; +inp[28977] = 0; +inp[28978] = 1073713792; +inp[28979] = 0; +inp[28980] = 1073713664; +inp[28981] = 0; +inp[28982] = 1073713536; +inp[28983] = 0; +inp[28984] = 1073713408; +inp[28985] = 0; +inp[28986] = 1073713280; +inp[28987] = 0; +inp[28988] = 1073713152; +inp[28989] = 0; +inp[28990] = 1073713024; +inp[28991] = 0; +inp[28992] = 1073712896; +inp[28993] = 0; +inp[28994] = 1073712768; +inp[28995] = 0; +inp[28996] = 1073712640; +inp[28997] = 0; +inp[28998] = 1073712512; +inp[28999] = 0; +inp[29000] = 1073712384; +inp[29001] = 0; +inp[29002] = 1073712256; +inp[29003] = 0; +inp[29004] = 1073712128; +inp[29005] = 0; +inp[29006] = 1073712000; +inp[29007] = 0; +inp[29008] = 1073711872; +inp[29009] = 0; +inp[29010] = 1073711744; +inp[29011] = 0; +inp[29012] = 1073711616; +inp[29013] = 0; +inp[29014] = 1073711488; +inp[29015] = 0; +inp[29016] = 1073711360; +inp[29017] = 0; +inp[29018] = 1073711232; +inp[29019] = 0; +inp[29020] = 1073711104; +inp[29021] = 0; +inp[29022] = 1073710976; +inp[29023] = 0; +inp[29024] = 1073710848; +inp[29025] = 0; +inp[29026] = 1073710720; +inp[29027] = 0; +inp[29028] = 1073710592; +inp[29029] = 0; +inp[29030] = 1073710464; +inp[29031] = 0; +inp[29032] = 1073710336; +inp[29033] = 0; +inp[29034] = 1073710208; +inp[29035] = 0; +inp[29036] = 1073710080; +inp[29037] = 0; +inp[29038] = 1073709952; +inp[29039] = 0; +inp[29040] = 1073709824; +inp[29041] = 0; +inp[29042] = 1073709696; +inp[29043] = 0; +inp[29044] = 1073709568; +inp[29045] = 0; +inp[29046] = 1073709440; +inp[29047] = 0; +inp[29048] = 1073709312; +inp[29049] = 0; +inp[29050] = 1073709184; +inp[29051] = 0; +inp[29052] = 1073741824; +inp[29053] = 1073741824; +inp[29054] = 1073741760; +inp[29055] = 0; +inp[29056] = 1073741696; +inp[29057] = 0; +inp[29058] = 1073741632; +inp[29059] = 0; +inp[29060] = 1073741568; +inp[29061] = 0; +inp[29062] = 1073741504; +inp[29063] = 0; +inp[29064] = 1073741440; +inp[29065] = 0; +inp[29066] = 1073741376; +inp[29067] = 0; +inp[29068] = 1073741312; +inp[29069] = 0; +inp[29070] = 1073741248; +inp[29071] = 0; +inp[29072] = 1073741184; +inp[29073] = 0; +inp[29074] = 1073741120; +inp[29075] = 0; +inp[29076] = 1073741056; +inp[29077] = 0; +inp[29078] = 1073740992; +inp[29079] = 0; +inp[29080] = 1073740928; +inp[29081] = 0; +inp[29082] = 1073740864; +inp[29083] = 0; +inp[29084] = 1073740800; +inp[29085] = 0; +inp[29086] = 1073740736; +inp[29087] = 0; +inp[29088] = 1073740672; +inp[29089] = 0; +inp[29090] = 1073740608; +inp[29091] = 0; +inp[29092] = 1073740544; +inp[29093] = 0; +inp[29094] = 1073740480; +inp[29095] = 0; +inp[29096] = 1073740416; +inp[29097] = 0; +inp[29098] = 1073740352; +inp[29099] = 0; +inp[29100] = 1073740288; +inp[29101] = 0; +inp[29102] = 1073740224; +inp[29103] = 0; +inp[29104] = 1073740160; +inp[29105] = 0; +inp[29106] = 1073740096; +inp[29107] = 0; +inp[29108] = 1073740032; +inp[29109] = 0; +inp[29110] = 1073739968; +inp[29111] = 0; +inp[29112] = 1073739904; +inp[29113] = 0; +inp[29114] = 1073739840; +inp[29115] = 0; +inp[29116] = 1073739776; +inp[29117] = 0; +inp[29118] = 1073739712; +inp[29119] = 0; +inp[29120] = 1073739648; +inp[29121] = 0; +inp[29122] = 1073739584; +inp[29123] = 0; +inp[29124] = 1073739520; +inp[29125] = 0; +inp[29126] = 1073739456; +inp[29127] = 0; +inp[29128] = 1073739392; +inp[29129] = 0; +inp[29130] = 1073739328; +inp[29131] = 0; +inp[29132] = 1073739264; +inp[29133] = 0; +inp[29134] = 1073739200; +inp[29135] = 0; +inp[29136] = 1073739136; +inp[29137] = 0; +inp[29138] = 1073739072; +inp[29139] = 0; +inp[29140] = 1073739008; +inp[29141] = 0; +inp[29142] = 1073738944; +inp[29143] = 0; +inp[29144] = 1073738880; +inp[29145] = 0; +inp[29146] = 1073738816; +inp[29147] = 0; +inp[29148] = 1073738752; +inp[29149] = 0; +inp[29150] = 1073738688; +inp[29151] = 0; +inp[29152] = 1073738624; +inp[29153] = 0; +inp[29154] = 1073738560; +inp[29155] = 0; +inp[29156] = 1073738496; +inp[29157] = 0; +inp[29158] = 1073738432; +inp[29159] = 0; +inp[29160] = 1073738368; +inp[29161] = 0; +inp[29162] = 1073738304; +inp[29163] = 0; +inp[29164] = 1073738240; +inp[29165] = 0; +inp[29166] = 1073738176; +inp[29167] = 0; +inp[29168] = 1073738112; +inp[29169] = 0; +inp[29170] = 1073738048; +inp[29171] = 0; +inp[29172] = 1073737984; +inp[29173] = 0; +inp[29174] = 1073737920; +inp[29175] = 0; +inp[29176] = 1073737856; +inp[29177] = 0; +inp[29178] = 1073737792; +inp[29179] = 0; +inp[29180] = 1073737728; +inp[29181] = 0; +inp[29182] = 1073737664; +inp[29183] = 0; +inp[29184] = 1073737600; +inp[29185] = 0; +inp[29186] = 1073737536; +inp[29187] = 0; +inp[29188] = 1073737472; +inp[29189] = 0; +inp[29190] = 1073737408; +inp[29191] = 0; +inp[29192] = 1073737344; +inp[29193] = 0; +inp[29194] = 1073737280; +inp[29195] = 0; +inp[29196] = 1073737216; +inp[29197] = 0; +inp[29198] = 1073737152; +inp[29199] = 0; +inp[29200] = 1073737088; +inp[29201] = 0; +inp[29202] = 1073737024; +inp[29203] = 0; +inp[29204] = 1073736960; +inp[29205] = 0; +inp[29206] = 1073736896; +inp[29207] = 0; +inp[29208] = 1073736832; +inp[29209] = 0; +inp[29210] = 1073736768; +inp[29211] = 0; +inp[29212] = 1073736704; +inp[29213] = 0; +inp[29214] = 1073736640; +inp[29215] = 0; +inp[29216] = 1073736576; +inp[29217] = 0; +inp[29218] = 1073736512; +inp[29219] = 0; +inp[29220] = 1073736448; +inp[29221] = 0; +inp[29222] = 1073736384; +inp[29223] = 0; +inp[29224] = 1073736320; +inp[29225] = 0; +inp[29226] = 1073736256; +inp[29227] = 0; +inp[29228] = 1073736192; +inp[29229] = 0; +inp[29230] = 1073736128; +inp[29231] = 0; +inp[29232] = 1073736064; +inp[29233] = 0; +inp[29234] = 1073736000; +inp[29235] = 0; +inp[29236] = 1073735936; +inp[29237] = 0; +inp[29238] = 1073735872; +inp[29239] = 0; +inp[29240] = 1073735808; +inp[29241] = 0; +inp[29242] = 1073735744; +inp[29243] = 0; +inp[29244] = 1073735680; +inp[29245] = 0; +inp[29246] = 1073735616; +inp[29247] = 0; +inp[29248] = 1073735552; +inp[29249] = 0; +inp[29250] = 1073735488; +inp[29251] = 0; +inp[29252] = 1073735424; +inp[29253] = 0; +inp[29254] = 1073735360; +inp[29255] = 0; +inp[29256] = 1073735296; +inp[29257] = 0; +inp[29258] = 1073735232; +inp[29259] = 0; +inp[29260] = 1073735168; +inp[29261] = 0; +inp[29262] = 1073735104; +inp[29263] = 0; +inp[29264] = 1073735040; +inp[29265] = 0; +inp[29266] = 1073734976; +inp[29267] = 0; +inp[29268] = 1073734912; +inp[29269] = 0; +inp[29270] = 1073734848; +inp[29271] = 0; +inp[29272] = 1073734784; +inp[29273] = 0; +inp[29274] = 1073734720; +inp[29275] = 0; +inp[29276] = 1073734656; +inp[29277] = 0; +inp[29278] = 1073734592; +inp[29279] = 0; +inp[29280] = 1073734528; +inp[29281] = 0; +inp[29282] = 1073734464; +inp[29283] = 0; +inp[29284] = 1073734400; +inp[29285] = 0; +inp[29286] = 1073734336; +inp[29287] = 0; +inp[29288] = 1073734272; +inp[29289] = 0; +inp[29290] = 1073734208; +inp[29291] = 0; +inp[29292] = 1073734144; +inp[29293] = 0; +inp[29294] = 1073734080; +inp[29295] = 0; +inp[29296] = 1073734016; +inp[29297] = 0; +inp[29298] = 1073733952; +inp[29299] = 0; +inp[29300] = 1073733888; +inp[29301] = 0; +inp[29302] = 1073733824; +inp[29303] = 0; +inp[29304] = 1073733760; +inp[29305] = 0; +inp[29306] = 1073733696; +inp[29307] = 0; +inp[29308] = 1073733632; +inp[29309] = 0; +inp[29310] = 1073733568; +inp[29311] = 0; +inp[29312] = 1073733504; +inp[29313] = 0; +inp[29314] = 1073733440; +inp[29315] = 0; +inp[29316] = 1073733376; +inp[29317] = 0; +inp[29318] = 1073733312; +inp[29319] = 0; +inp[29320] = 1073733248; +inp[29321] = 0; +inp[29322] = 1073733184; +inp[29323] = 0; +inp[29324] = 1073733120; +inp[29325] = 0; +inp[29326] = 1073733056; +inp[29327] = 0; +inp[29328] = 1073732992; +inp[29329] = 0; +inp[29330] = 1073732928; +inp[29331] = 0; +inp[29332] = 1073732864; +inp[29333] = 0; +inp[29334] = 1073732800; +inp[29335] = 0; +inp[29336] = 1073732736; +inp[29337] = 0; +inp[29338] = 1073732672; +inp[29339] = 0; +inp[29340] = 1073732608; +inp[29341] = 0; +inp[29342] = 1073732544; +inp[29343] = 0; +inp[29344] = 1073732480; +inp[29345] = 0; +inp[29346] = 1073732416; +inp[29347] = 0; +inp[29348] = 1073732352; +inp[29349] = 0; +inp[29350] = 1073732288; +inp[29351] = 0; +inp[29352] = 1073732224; +inp[29353] = 0; +inp[29354] = 1073732160; +inp[29355] = 0; +inp[29356] = 1073732096; +inp[29357] = 0; +inp[29358] = 1073732032; +inp[29359] = 0; +inp[29360] = 1073731968; +inp[29361] = 0; +inp[29362] = 1073731904; +inp[29363] = 0; +inp[29364] = 1073731840; +inp[29365] = 0; +inp[29366] = 1073731776; +inp[29367] = 0; +inp[29368] = 1073731712; +inp[29369] = 0; +inp[29370] = 1073731648; +inp[29371] = 0; +inp[29372] = 1073731584; +inp[29373] = 0; +inp[29374] = 1073731520; +inp[29375] = 0; +inp[29376] = 1073731456; +inp[29377] = 0; +inp[29378] = 1073731392; +inp[29379] = 0; +inp[29380] = 1073731328; +inp[29381] = 0; +inp[29382] = 1073731264; +inp[29383] = 0; +inp[29384] = 1073731200; +inp[29385] = 0; +inp[29386] = 1073731136; +inp[29387] = 0; +inp[29388] = 1073731072; +inp[29389] = 0; +inp[29390] = 1073731008; +inp[29391] = 0; +inp[29392] = 1073730944; +inp[29393] = 0; +inp[29394] = 1073730880; +inp[29395] = 0; +inp[29396] = 1073730816; +inp[29397] = 0; +inp[29398] = 1073730752; +inp[29399] = 0; +inp[29400] = 1073730688; +inp[29401] = 0; +inp[29402] = 1073730624; +inp[29403] = 0; +inp[29404] = 1073730560; +inp[29405] = 0; +inp[29406] = 1073730496; +inp[29407] = 0; +inp[29408] = 1073730432; +inp[29409] = 0; +inp[29410] = 1073730368; +inp[29411] = 0; +inp[29412] = 1073730304; +inp[29413] = 0; +inp[29414] = 1073730240; +inp[29415] = 0; +inp[29416] = 1073730176; +inp[29417] = 0; +inp[29418] = 1073730112; +inp[29419] = 0; +inp[29420] = 1073730048; +inp[29421] = 0; +inp[29422] = 1073729984; +inp[29423] = 0; +inp[29424] = 1073729920; +inp[29425] = 0; +inp[29426] = 1073729856; +inp[29427] = 0; +inp[29428] = 1073729792; +inp[29429] = 0; +inp[29430] = 1073729728; +inp[29431] = 0; +inp[29432] = 1073729664; +inp[29433] = 0; +inp[29434] = 1073729600; +inp[29435] = 0; +inp[29436] = 1073729536; +inp[29437] = 0; +inp[29438] = 1073729472; +inp[29439] = 0; +inp[29440] = 1073729408; +inp[29441] = 0; +inp[29442] = 1073729344; +inp[29443] = 0; +inp[29444] = 1073729280; +inp[29445] = 0; +inp[29446] = 1073729216; +inp[29447] = 0; +inp[29448] = 1073729152; +inp[29449] = 0; +inp[29450] = 1073729088; +inp[29451] = 0; +inp[29452] = 1073729024; +inp[29453] = 0; +inp[29454] = 1073728960; +inp[29455] = 0; +inp[29456] = 1073728896; +inp[29457] = 0; +inp[29458] = 1073728832; +inp[29459] = 0; +inp[29460] = 1073728768; +inp[29461] = 0; +inp[29462] = 1073728704; +inp[29463] = 0; +inp[29464] = 1073728640; +inp[29465] = 0; +inp[29466] = 1073728576; +inp[29467] = 0; +inp[29468] = 1073728512; +inp[29469] = 0; +inp[29470] = 1073728448; +inp[29471] = 0; +inp[29472] = 1073728384; +inp[29473] = 0; +inp[29474] = 1073728320; +inp[29475] = 0; +inp[29476] = 1073728256; +inp[29477] = 0; +inp[29478] = 1073728192; +inp[29479] = 0; +inp[29480] = 1073728128; +inp[29481] = 0; +inp[29482] = 1073728064; +inp[29483] = 0; +inp[29484] = 1073728000; +inp[29485] = 0; +inp[29486] = 1073727936; +inp[29487] = 0; +inp[29488] = 1073727872; +inp[29489] = 0; +inp[29490] = 1073727808; +inp[29491] = 0; +inp[29492] = 1073727744; +inp[29493] = 0; +inp[29494] = 1073727680; +inp[29495] = 0; +inp[29496] = 1073727616; +inp[29497] = 0; +inp[29498] = 1073727552; +inp[29499] = 0; +inp[29500] = 1073727488; +inp[29501] = 0; +inp[29502] = 1073727424; +inp[29503] = 0; +inp[29504] = 1073727360; +inp[29505] = 0; +inp[29506] = 1073727296; +inp[29507] = 0; +inp[29508] = 1073727232; +inp[29509] = 0; +inp[29510] = 1073727168; +inp[29511] = 0; +inp[29512] = 1073727104; +inp[29513] = 0; +inp[29514] = 1073727040; +inp[29515] = 0; +inp[29516] = 1073726976; +inp[29517] = 0; +inp[29518] = 1073726912; +inp[29519] = 0; +inp[29520] = 1073726848; +inp[29521] = 0; +inp[29522] = 1073726784; +inp[29523] = 0; +inp[29524] = 1073726720; +inp[29525] = 0; +inp[29526] = 1073726656; +inp[29527] = 0; +inp[29528] = 1073726592; +inp[29529] = 0; +inp[29530] = 1073726528; +inp[29531] = 0; +inp[29532] = 1073726464; +inp[29533] = 0; +inp[29534] = 1073726400; +inp[29535] = 0; +inp[29536] = 1073726336; +inp[29537] = 0; +inp[29538] = 1073726272; +inp[29539] = 0; +inp[29540] = 1073726208; +inp[29541] = 0; +inp[29542] = 1073726144; +inp[29543] = 0; +inp[29544] = 1073726080; +inp[29545] = 0; +inp[29546] = 1073726016; +inp[29547] = 0; +inp[29548] = 1073725952; +inp[29549] = 0; +inp[29550] = 1073725888; +inp[29551] = 0; +inp[29552] = 1073725824; +inp[29553] = 0; +inp[29554] = 1073725760; +inp[29555] = 0; +inp[29556] = 1073725696; +inp[29557] = 0; +inp[29558] = 1073725632; +inp[29559] = 0; +inp[29560] = 1073725568; +inp[29561] = 0; +inp[29562] = 1073725504; +inp[29563] = 0; +inp[29564] = 1073741824; +inp[29565] = 1073741824; +inp[29566] = 1073741792; +inp[29567] = 0; +inp[29568] = 1073741760; +inp[29569] = 0; +inp[29570] = 1073741728; +inp[29571] = 0; +inp[29572] = 1073741696; +inp[29573] = 0; +inp[29574] = 1073741664; +inp[29575] = 0; +inp[29576] = 1073741632; +inp[29577] = 0; +inp[29578] = 1073741600; +inp[29579] = 0; +inp[29580] = 1073741568; +inp[29581] = 0; +inp[29582] = 1073741536; +inp[29583] = 0; +inp[29584] = 1073741504; +inp[29585] = 0; +inp[29586] = 1073741472; +inp[29587] = 0; +inp[29588] = 1073741440; +inp[29589] = 0; +inp[29590] = 1073741408; +inp[29591] = 0; +inp[29592] = 1073741376; +inp[29593] = 0; +inp[29594] = 1073741344; +inp[29595] = 0; +inp[29596] = 1073741312; +inp[29597] = 0; +inp[29598] = 1073741280; +inp[29599] = 0; +inp[29600] = 1073741248; +inp[29601] = 0; +inp[29602] = 1073741216; +inp[29603] = 0; +inp[29604] = 1073741184; +inp[29605] = 0; +inp[29606] = 1073741152; +inp[29607] = 0; +inp[29608] = 1073741120; +inp[29609] = 0; +inp[29610] = 1073741088; +inp[29611] = 0; +inp[29612] = 1073741056; +inp[29613] = 0; +inp[29614] = 1073741024; +inp[29615] = 0; +inp[29616] = 1073740992; +inp[29617] = 0; +inp[29618] = 1073740960; +inp[29619] = 0; +inp[29620] = 1073740928; +inp[29621] = 0; +inp[29622] = 1073740896; +inp[29623] = 0; +inp[29624] = 1073740864; +inp[29625] = 0; +inp[29626] = 1073740832; +inp[29627] = 0; +inp[29628] = 1073740800; +inp[29629] = 0; +inp[29630] = 1073740768; +inp[29631] = 0; +inp[29632] = 1073740736; +inp[29633] = 0; +inp[29634] = 1073740704; +inp[29635] = 0; +inp[29636] = 1073740672; +inp[29637] = 0; +inp[29638] = 1073740640; +inp[29639] = 0; +inp[29640] = 1073740608; +inp[29641] = 0; +inp[29642] = 1073740576; +inp[29643] = 0; +inp[29644] = 1073740544; +inp[29645] = 0; +inp[29646] = 1073740512; +inp[29647] = 0; +inp[29648] = 1073740480; +inp[29649] = 0; +inp[29650] = 1073740448; +inp[29651] = 0; +inp[29652] = 1073740416; +inp[29653] = 0; +inp[29654] = 1073740384; +inp[29655] = 0; +inp[29656] = 1073740352; +inp[29657] = 0; +inp[29658] = 1073740320; +inp[29659] = 0; +inp[29660] = 1073740288; +inp[29661] = 0; +inp[29662] = 1073740256; +inp[29663] = 0; +inp[29664] = 1073740224; +inp[29665] = 0; +inp[29666] = 1073740192; +inp[29667] = 0; +inp[29668] = 1073740160; +inp[29669] = 0; +inp[29670] = 1073740128; +inp[29671] = 0; +inp[29672] = 1073740096; +inp[29673] = 0; +inp[29674] = 1073740064; +inp[29675] = 0; +inp[29676] = 1073740032; +inp[29677] = 0; +inp[29678] = 1073740000; +inp[29679] = 0; +inp[29680] = 1073739968; +inp[29681] = 0; +inp[29682] = 1073739936; +inp[29683] = 0; +inp[29684] = 1073739904; +inp[29685] = 0; +inp[29686] = 1073739872; +inp[29687] = 0; +inp[29688] = 1073739840; +inp[29689] = 0; +inp[29690] = 1073739808; +inp[29691] = 0; +inp[29692] = 1073739776; +inp[29693] = 0; +inp[29694] = 1073739744; +inp[29695] = 0; +inp[29696] = 1073739712; +inp[29697] = 0; +inp[29698] = 1073739680; +inp[29699] = 0; +inp[29700] = 1073739648; +inp[29701] = 0; +inp[29702] = 1073739616; +inp[29703] = 0; +inp[29704] = 1073739584; +inp[29705] = 0; +inp[29706] = 1073739552; +inp[29707] = 0; +inp[29708] = 1073739520; +inp[29709] = 0; +inp[29710] = 1073739488; +inp[29711] = 0; +inp[29712] = 1073739456; +inp[29713] = 0; +inp[29714] = 1073739424; +inp[29715] = 0; +inp[29716] = 1073739392; +inp[29717] = 0; +inp[29718] = 1073739360; +inp[29719] = 0; +inp[29720] = 1073739328; +inp[29721] = 0; +inp[29722] = 1073739296; +inp[29723] = 0; +inp[29724] = 1073739264; +inp[29725] = 0; +inp[29726] = 1073739232; +inp[29727] = 0; +inp[29728] = 1073739200; +inp[29729] = 0; +inp[29730] = 1073739168; +inp[29731] = 0; +inp[29732] = 1073739136; +inp[29733] = 0; +inp[29734] = 1073739104; +inp[29735] = 0; +inp[29736] = 1073739072; +inp[29737] = 0; +inp[29738] = 1073739040; +inp[29739] = 0; +inp[29740] = 1073739008; +inp[29741] = 0; +inp[29742] = 1073738976; +inp[29743] = 0; +inp[29744] = 1073738944; +inp[29745] = 0; +inp[29746] = 1073738912; +inp[29747] = 0; +inp[29748] = 1073738880; +inp[29749] = 0; +inp[29750] = 1073738848; +inp[29751] = 0; +inp[29752] = 1073738816; +inp[29753] = 0; +inp[29754] = 1073738784; +inp[29755] = 0; +inp[29756] = 1073738752; +inp[29757] = 0; +inp[29758] = 1073738720; +inp[29759] = 0; +inp[29760] = 1073738688; +inp[29761] = 0; +inp[29762] = 1073738656; +inp[29763] = 0; +inp[29764] = 1073738624; +inp[29765] = 0; +inp[29766] = 1073738592; +inp[29767] = 0; +inp[29768] = 1073738560; +inp[29769] = 0; +inp[29770] = 1073738528; +inp[29771] = 0; +inp[29772] = 1073738496; +inp[29773] = 0; +inp[29774] = 1073738464; +inp[29775] = 0; +inp[29776] = 1073738432; +inp[29777] = 0; +inp[29778] = 1073738400; +inp[29779] = 0; +inp[29780] = 1073738368; +inp[29781] = 0; +inp[29782] = 1073738336; +inp[29783] = 0; +inp[29784] = 1073738304; +inp[29785] = 0; +inp[29786] = 1073738272; +inp[29787] = 0; +inp[29788] = 1073738240; +inp[29789] = 0; +inp[29790] = 1073738208; +inp[29791] = 0; +inp[29792] = 1073738176; +inp[29793] = 0; +inp[29794] = 1073738144; +inp[29795] = 0; +inp[29796] = 1073738112; +inp[29797] = 0; +inp[29798] = 1073738080; +inp[29799] = 0; +inp[29800] = 1073738048; +inp[29801] = 0; +inp[29802] = 1073738016; +inp[29803] = 0; +inp[29804] = 1073737984; +inp[29805] = 0; +inp[29806] = 1073737952; +inp[29807] = 0; +inp[29808] = 1073737920; +inp[29809] = 0; +inp[29810] = 1073737888; +inp[29811] = 0; +inp[29812] = 1073737856; +inp[29813] = 0; +inp[29814] = 1073737824; +inp[29815] = 0; +inp[29816] = 1073737792; +inp[29817] = 0; +inp[29818] = 1073737760; +inp[29819] = 0; +inp[29820] = 1073737728; +inp[29821] = 0; +inp[29822] = 1073737696; +inp[29823] = 0; +inp[29824] = 1073737664; +inp[29825] = 0; +inp[29826] = 1073737632; +inp[29827] = 0; +inp[29828] = 1073737600; +inp[29829] = 0; +inp[29830] = 1073737568; +inp[29831] = 0; +inp[29832] = 1073737536; +inp[29833] = 0; +inp[29834] = 1073737504; +inp[29835] = 0; +inp[29836] = 1073737472; +inp[29837] = 0; +inp[29838] = 1073737440; +inp[29839] = 0; +inp[29840] = 1073737408; +inp[29841] = 0; +inp[29842] = 1073737376; +inp[29843] = 0; +inp[29844] = 1073737344; +inp[29845] = 0; +inp[29846] = 1073737312; +inp[29847] = 0; +inp[29848] = 1073737280; +inp[29849] = 0; +inp[29850] = 1073737248; +inp[29851] = 0; +inp[29852] = 1073737216; +inp[29853] = 0; +inp[29854] = 1073737184; +inp[29855] = 0; +inp[29856] = 1073737152; +inp[29857] = 0; +inp[29858] = 1073737120; +inp[29859] = 0; +inp[29860] = 1073737088; +inp[29861] = 0; +inp[29862] = 1073737056; +inp[29863] = 0; +inp[29864] = 1073737024; +inp[29865] = 0; +inp[29866] = 1073736992; +inp[29867] = 0; +inp[29868] = 1073736960; +inp[29869] = 0; +inp[29870] = 1073736928; +inp[29871] = 0; +inp[29872] = 1073736896; +inp[29873] = 0; +inp[29874] = 1073736864; +inp[29875] = 0; +inp[29876] = 1073736832; +inp[29877] = 0; +inp[29878] = 1073736800; +inp[29879] = 0; +inp[29880] = 1073736768; +inp[29881] = 0; +inp[29882] = 1073736736; +inp[29883] = 0; +inp[29884] = 1073736704; +inp[29885] = 0; +inp[29886] = 1073736672; +inp[29887] = 0; +inp[29888] = 1073736640; +inp[29889] = 0; +inp[29890] = 1073736608; +inp[29891] = 0; +inp[29892] = 1073736576; +inp[29893] = 0; +inp[29894] = 1073736544; +inp[29895] = 0; +inp[29896] = 1073736512; +inp[29897] = 0; +inp[29898] = 1073736480; +inp[29899] = 0; +inp[29900] = 1073736448; +inp[29901] = 0; +inp[29902] = 1073736416; +inp[29903] = 0; +inp[29904] = 1073736384; +inp[29905] = 0; +inp[29906] = 1073736352; +inp[29907] = 0; +inp[29908] = 1073736320; +inp[29909] = 0; +inp[29910] = 1073736288; +inp[29911] = 0; +inp[29912] = 1073736256; +inp[29913] = 0; +inp[29914] = 1073736224; +inp[29915] = 0; +inp[29916] = 1073736192; +inp[29917] = 0; +inp[29918] = 1073736160; +inp[29919] = 0; +inp[29920] = 1073736128; +inp[29921] = 0; +inp[29922] = 1073736096; +inp[29923] = 0; +inp[29924] = 1073736064; +inp[29925] = 0; +inp[29926] = 1073736032; +inp[29927] = 0; +inp[29928] = 1073736000; +inp[29929] = 0; +inp[29930] = 1073735968; +inp[29931] = 0; +inp[29932] = 1073735936; +inp[29933] = 0; +inp[29934] = 1073735904; +inp[29935] = 0; +inp[29936] = 1073735872; +inp[29937] = 0; +inp[29938] = 1073735840; +inp[29939] = 0; +inp[29940] = 1073735808; +inp[29941] = 0; +inp[29942] = 1073735776; +inp[29943] = 0; +inp[29944] = 1073735744; +inp[29945] = 0; +inp[29946] = 1073735712; +inp[29947] = 0; +inp[29948] = 1073735680; +inp[29949] = 0; +inp[29950] = 1073735648; +inp[29951] = 0; +inp[29952] = 1073735616; +inp[29953] = 0; +inp[29954] = 1073735584; +inp[29955] = 0; +inp[29956] = 1073735552; +inp[29957] = 0; +inp[29958] = 1073735520; +inp[29959] = 0; +inp[29960] = 1073735488; +inp[29961] = 0; +inp[29962] = 1073735456; +inp[29963] = 0; +inp[29964] = 1073735424; +inp[29965] = 0; +inp[29966] = 1073735392; +inp[29967] = 0; +inp[29968] = 1073735360; +inp[29969] = 0; +inp[29970] = 1073735328; +inp[29971] = 0; +inp[29972] = 1073735296; +inp[29973] = 0; +inp[29974] = 1073735264; +inp[29975] = 0; +inp[29976] = 1073735232; +inp[29977] = 0; +inp[29978] = 1073735200; +inp[29979] = 0; +inp[29980] = 1073735168; +inp[29981] = 0; +inp[29982] = 1073735136; +inp[29983] = 0; +inp[29984] = 1073735104; +inp[29985] = 0; +inp[29986] = 1073735072; +inp[29987] = 0; +inp[29988] = 1073735040; +inp[29989] = 0; +inp[29990] = 1073735008; +inp[29991] = 0; +inp[29992] = 1073734976; +inp[29993] = 0; +inp[29994] = 1073734944; +inp[29995] = 0; +inp[29996] = 1073734912; +inp[29997] = 0; +inp[29998] = 1073734880; +inp[29999] = 0; +inp[30000] = 1073734848; +inp[30001] = 0; +inp[30002] = 1073734816; +inp[30003] = 0; +inp[30004] = 1073734784; +inp[30005] = 0; +inp[30006] = 1073734752; +inp[30007] = 0; +inp[30008] = 1073734720; +inp[30009] = 0; +inp[30010] = 1073734688; +inp[30011] = 0; +inp[30012] = 1073734656; +inp[30013] = 0; +inp[30014] = 1073734624; +inp[30015] = 0; +inp[30016] = 1073734592; +inp[30017] = 0; +inp[30018] = 1073734560; +inp[30019] = 0; +inp[30020] = 1073734528; +inp[30021] = 0; +inp[30022] = 1073734496; +inp[30023] = 0; +inp[30024] = 1073734464; +inp[30025] = 0; +inp[30026] = 1073734432; +inp[30027] = 0; +inp[30028] = 1073734400; +inp[30029] = 0; +inp[30030] = 1073734368; +inp[30031] = 0; +inp[30032] = 1073734336; +inp[30033] = 0; +inp[30034] = 1073734304; +inp[30035] = 0; +inp[30036] = 1073734272; +inp[30037] = 0; +inp[30038] = 1073734240; +inp[30039] = 0; +inp[30040] = 1073734208; +inp[30041] = 0; +inp[30042] = 1073734176; +inp[30043] = 0; +inp[30044] = 1073734144; +inp[30045] = 0; +inp[30046] = 1073734112; +inp[30047] = 0; +inp[30048] = 1073734080; +inp[30049] = 0; +inp[30050] = 1073734048; +inp[30051] = 0; +inp[30052] = 1073734016; +inp[30053] = 0; +inp[30054] = 1073733984; +inp[30055] = 0; +inp[30056] = 1073733952; +inp[30057] = 0; +inp[30058] = 1073733920; +inp[30059] = 0; +inp[30060] = 1073733888; +inp[30061] = 0; +inp[30062] = 1073733856; +inp[30063] = 0; +inp[30064] = 1073733824; +inp[30065] = 0; +inp[30066] = 1073733792; +inp[30067] = 0; +inp[30068] = 1073733760; +inp[30069] = 0; +inp[30070] = 1073733728; +inp[30071] = 0; +inp[30072] = 1073733696; +inp[30073] = 0; +inp[30074] = 1073733664; +inp[30075] = 0; +inp[30076] = 1073741824; +inp[30077] = 1073741824; +inp[30078] = 1073741808; +inp[30079] = 0; +inp[30080] = 1073741792; +inp[30081] = 0; +inp[30082] = 1073741776; +inp[30083] = 0; +inp[30084] = 1073741760; +inp[30085] = 0; +inp[30086] = 1073741744; +inp[30087] = 0; +inp[30088] = 1073741728; +inp[30089] = 0; +inp[30090] = 1073741712; +inp[30091] = 0; +inp[30092] = 1073741696; +inp[30093] = 0; +inp[30094] = 1073741680; +inp[30095] = 0; +inp[30096] = 1073741664; +inp[30097] = 0; +inp[30098] = 1073741648; +inp[30099] = 0; +inp[30100] = 1073741632; +inp[30101] = 0; +inp[30102] = 1073741616; +inp[30103] = 0; +inp[30104] = 1073741600; +inp[30105] = 0; +inp[30106] = 1073741584; +inp[30107] = 0; +inp[30108] = 1073741568; +inp[30109] = 0; +inp[30110] = 1073741552; +inp[30111] = 0; +inp[30112] = 1073741536; +inp[30113] = 0; +inp[30114] = 1073741520; +inp[30115] = 0; +inp[30116] = 1073741504; +inp[30117] = 0; +inp[30118] = 1073741488; +inp[30119] = 0; +inp[30120] = 1073741472; +inp[30121] = 0; +inp[30122] = 1073741456; +inp[30123] = 0; +inp[30124] = 1073741440; +inp[30125] = 0; +inp[30126] = 1073741424; +inp[30127] = 0; +inp[30128] = 1073741408; +inp[30129] = 0; +inp[30130] = 1073741392; +inp[30131] = 0; +inp[30132] = 1073741376; +inp[30133] = 0; +inp[30134] = 1073741360; +inp[30135] = 0; +inp[30136] = 1073741344; +inp[30137] = 0; +inp[30138] = 1073741328; +inp[30139] = 0; +inp[30140] = 1073741312; +inp[30141] = 0; +inp[30142] = 1073741296; +inp[30143] = 0; +inp[30144] = 1073741280; +inp[30145] = 0; +inp[30146] = 1073741264; +inp[30147] = 0; +inp[30148] = 1073741248; +inp[30149] = 0; +inp[30150] = 1073741232; +inp[30151] = 0; +inp[30152] = 1073741216; +inp[30153] = 0; +inp[30154] = 1073741200; +inp[30155] = 0; +inp[30156] = 1073741184; +inp[30157] = 0; +inp[30158] = 1073741168; +inp[30159] = 0; +inp[30160] = 1073741152; +inp[30161] = 0; +inp[30162] = 1073741136; +inp[30163] = 0; +inp[30164] = 1073741120; +inp[30165] = 0; +inp[30166] = 1073741104; +inp[30167] = 0; +inp[30168] = 1073741088; +inp[30169] = 0; +inp[30170] = 1073741072; +inp[30171] = 0; +inp[30172] = 1073741056; +inp[30173] = 0; +inp[30174] = 1073741040; +inp[30175] = 0; +inp[30176] = 1073741024; +inp[30177] = 0; +inp[30178] = 1073741008; +inp[30179] = 0; +inp[30180] = 1073740992; +inp[30181] = 0; +inp[30182] = 1073740976; +inp[30183] = 0; +inp[30184] = 1073740960; +inp[30185] = 0; +inp[30186] = 1073740944; +inp[30187] = 0; +inp[30188] = 1073740928; +inp[30189] = 0; +inp[30190] = 1073740912; +inp[30191] = 0; +inp[30192] = 1073740896; +inp[30193] = 0; +inp[30194] = 1073740880; +inp[30195] = 0; +inp[30196] = 1073740864; +inp[30197] = 0; +inp[30198] = 1073740848; +inp[30199] = 0; +inp[30200] = 1073740832; +inp[30201] = 0; +inp[30202] = 1073740816; +inp[30203] = 0; +inp[30204] = 1073740800; +inp[30205] = 0; +inp[30206] = 1073740784; +inp[30207] = 0; +inp[30208] = 1073740768; +inp[30209] = 0; +inp[30210] = 1073740752; +inp[30211] = 0; +inp[30212] = 1073740736; +inp[30213] = 0; +inp[30214] = 1073740720; +inp[30215] = 0; +inp[30216] = 1073740704; +inp[30217] = 0; +inp[30218] = 1073740688; +inp[30219] = 0; +inp[30220] = 1073740672; +inp[30221] = 0; +inp[30222] = 1073740656; +inp[30223] = 0; +inp[30224] = 1073740640; +inp[30225] = 0; +inp[30226] = 1073740624; +inp[30227] = 0; +inp[30228] = 1073740608; +inp[30229] = 0; +inp[30230] = 1073740592; +inp[30231] = 0; +inp[30232] = 1073740576; +inp[30233] = 0; +inp[30234] = 1073740560; +inp[30235] = 0; +inp[30236] = 1073740544; +inp[30237] = 0; +inp[30238] = 1073740528; +inp[30239] = 0; +inp[30240] = 1073740512; +inp[30241] = 0; +inp[30242] = 1073740496; +inp[30243] = 0; +inp[30244] = 1073740480; +inp[30245] = 0; +inp[30246] = 1073740464; +inp[30247] = 0; +inp[30248] = 1073740448; +inp[30249] = 0; +inp[30250] = 1073740432; +inp[30251] = 0; +inp[30252] = 1073740416; +inp[30253] = 0; +inp[30254] = 1073740400; +inp[30255] = 0; +inp[30256] = 1073740384; +inp[30257] = 0; +inp[30258] = 1073740368; +inp[30259] = 0; +inp[30260] = 1073740352; +inp[30261] = 0; +inp[30262] = 1073740336; +inp[30263] = 0; +inp[30264] = 1073740320; +inp[30265] = 0; +inp[30266] = 1073740304; +inp[30267] = 0; +inp[30268] = 1073740288; +inp[30269] = 0; +inp[30270] = 1073740272; +inp[30271] = 0; +inp[30272] = 1073740256; +inp[30273] = 0; +inp[30274] = 1073740240; +inp[30275] = 0; +inp[30276] = 1073740224; +inp[30277] = 0; +inp[30278] = 1073740208; +inp[30279] = 0; +inp[30280] = 1073740192; +inp[30281] = 0; +inp[30282] = 1073740176; +inp[30283] = 0; +inp[30284] = 1073740160; +inp[30285] = 0; +inp[30286] = 1073740144; +inp[30287] = 0; +inp[30288] = 1073740128; +inp[30289] = 0; +inp[30290] = 1073740112; +inp[30291] = 0; +inp[30292] = 1073740096; +inp[30293] = 0; +inp[30294] = 1073740080; +inp[30295] = 0; +inp[30296] = 1073740064; +inp[30297] = 0; +inp[30298] = 1073740048; +inp[30299] = 0; +inp[30300] = 1073740032; +inp[30301] = 0; +inp[30302] = 1073740016; +inp[30303] = 0; +inp[30304] = 1073740000; +inp[30305] = 0; +inp[30306] = 1073739984; +inp[30307] = 0; +inp[30308] = 1073739968; +inp[30309] = 0; +inp[30310] = 1073739952; +inp[30311] = 0; +inp[30312] = 1073739936; +inp[30313] = 0; +inp[30314] = 1073739920; +inp[30315] = 0; +inp[30316] = 1073739904; +inp[30317] = 0; +inp[30318] = 1073739888; +inp[30319] = 0; +inp[30320] = 1073739872; +inp[30321] = 0; +inp[30322] = 1073739856; +inp[30323] = 0; +inp[30324] = 1073739840; +inp[30325] = 0; +inp[30326] = 1073739824; +inp[30327] = 0; +inp[30328] = 1073739808; +inp[30329] = 0; +inp[30330] = 1073739792; +inp[30331] = 0; +inp[30332] = 1073739776; +inp[30333] = 0; +inp[30334] = 1073739760; +inp[30335] = 0; +inp[30336] = 1073739744; +inp[30337] = 0; +inp[30338] = 1073739728; +inp[30339] = 0; +inp[30340] = 1073739712; +inp[30341] = 0; +inp[30342] = 1073739696; +inp[30343] = 0; +inp[30344] = 1073739680; +inp[30345] = 0; +inp[30346] = 1073739664; +inp[30347] = 0; +inp[30348] = 1073739648; +inp[30349] = 0; +inp[30350] = 1073739632; +inp[30351] = 0; +inp[30352] = 1073739616; +inp[30353] = 0; +inp[30354] = 1073739600; +inp[30355] = 0; +inp[30356] = 1073739584; +inp[30357] = 0; +inp[30358] = 1073739568; +inp[30359] = 0; +inp[30360] = 1073739552; +inp[30361] = 0; +inp[30362] = 1073739536; +inp[30363] = 0; +inp[30364] = 1073739520; +inp[30365] = 0; +inp[30366] = 1073739504; +inp[30367] = 0; +inp[30368] = 1073739488; +inp[30369] = 0; +inp[30370] = 1073739472; +inp[30371] = 0; +inp[30372] = 1073739456; +inp[30373] = 0; +inp[30374] = 1073739440; +inp[30375] = 0; +inp[30376] = 1073739424; +inp[30377] = 0; +inp[30378] = 1073739408; +inp[30379] = 0; +inp[30380] = 1073739392; +inp[30381] = 0; +inp[30382] = 1073739376; +inp[30383] = 0; +inp[30384] = 1073739360; +inp[30385] = 0; +inp[30386] = 1073739344; +inp[30387] = 0; +inp[30388] = 1073739328; +inp[30389] = 0; +inp[30390] = 1073739312; +inp[30391] = 0; +inp[30392] = 1073739296; +inp[30393] = 0; +inp[30394] = 1073739280; +inp[30395] = 0; +inp[30396] = 1073739264; +inp[30397] = 0; +inp[30398] = 1073739248; +inp[30399] = 0; +inp[30400] = 1073739232; +inp[30401] = 0; +inp[30402] = 1073739216; +inp[30403] = 0; +inp[30404] = 1073739200; +inp[30405] = 0; +inp[30406] = 1073739184; +inp[30407] = 0; +inp[30408] = 1073739168; +inp[30409] = 0; +inp[30410] = 1073739152; +inp[30411] = 0; +inp[30412] = 1073739136; +inp[30413] = 0; +inp[30414] = 1073739120; +inp[30415] = 0; +inp[30416] = 1073739104; +inp[30417] = 0; +inp[30418] = 1073739088; +inp[30419] = 0; +inp[30420] = 1073739072; +inp[30421] = 0; +inp[30422] = 1073739056; +inp[30423] = 0; +inp[30424] = 1073739040; +inp[30425] = 0; +inp[30426] = 1073739024; +inp[30427] = 0; +inp[30428] = 1073739008; +inp[30429] = 0; +inp[30430] = 1073738992; +inp[30431] = 0; +inp[30432] = 1073738976; +inp[30433] = 0; +inp[30434] = 1073738960; +inp[30435] = 0; +inp[30436] = 1073738944; +inp[30437] = 0; +inp[30438] = 1073738928; +inp[30439] = 0; +inp[30440] = 1073738912; +inp[30441] = 0; +inp[30442] = 1073738896; +inp[30443] = 0; +inp[30444] = 1073738880; +inp[30445] = 0; +inp[30446] = 1073738864; +inp[30447] = 0; +inp[30448] = 1073738848; +inp[30449] = 0; +inp[30450] = 1073738832; +inp[30451] = 0; +inp[30452] = 1073738816; +inp[30453] = 0; +inp[30454] = 1073738800; +inp[30455] = 0; +inp[30456] = 1073738784; +inp[30457] = 0; +inp[30458] = 1073738768; +inp[30459] = 0; +inp[30460] = 1073738752; +inp[30461] = 0; +inp[30462] = 1073738736; +inp[30463] = 0; +inp[30464] = 1073738720; +inp[30465] = 0; +inp[30466] = 1073738704; +inp[30467] = 0; +inp[30468] = 1073738688; +inp[30469] = 0; +inp[30470] = 1073738672; +inp[30471] = 0; +inp[30472] = 1073738656; +inp[30473] = 0; +inp[30474] = 1073738640; +inp[30475] = 0; +inp[30476] = 1073738624; +inp[30477] = 0; +inp[30478] = 1073738608; +inp[30479] = 0; +inp[30480] = 1073738592; +inp[30481] = 0; +inp[30482] = 1073738576; +inp[30483] = 0; +inp[30484] = 1073738560; +inp[30485] = 0; +inp[30486] = 1073738544; +inp[30487] = 0; +inp[30488] = 1073738528; +inp[30489] = 0; +inp[30490] = 1073738512; +inp[30491] = 0; +inp[30492] = 1073738496; +inp[30493] = 0; +inp[30494] = 1073738480; +inp[30495] = 0; +inp[30496] = 1073738464; +inp[30497] = 0; +inp[30498] = 1073738448; +inp[30499] = 0; +inp[30500] = 1073738432; +inp[30501] = 0; +inp[30502] = 1073738416; +inp[30503] = 0; +inp[30504] = 1073738400; +inp[30505] = 0; +inp[30506] = 1073738384; +inp[30507] = 0; +inp[30508] = 1073738368; +inp[30509] = 0; +inp[30510] = 1073738352; +inp[30511] = 0; +inp[30512] = 1073738336; +inp[30513] = 0; +inp[30514] = 1073738320; +inp[30515] = 0; +inp[30516] = 1073738304; +inp[30517] = 0; +inp[30518] = 1073738288; +inp[30519] = 0; +inp[30520] = 1073738272; +inp[30521] = 0; +inp[30522] = 1073738256; +inp[30523] = 0; +inp[30524] = 1073738240; +inp[30525] = 0; +inp[30526] = 1073738224; +inp[30527] = 0; +inp[30528] = 1073738208; +inp[30529] = 0; +inp[30530] = 1073738192; +inp[30531] = 0; +inp[30532] = 1073738176; +inp[30533] = 0; +inp[30534] = 1073738160; +inp[30535] = 0; +inp[30536] = 1073738144; +inp[30537] = 0; +inp[30538] = 1073738128; +inp[30539] = 0; +inp[30540] = 1073738112; +inp[30541] = 0; +inp[30542] = 1073738096; +inp[30543] = 0; +inp[30544] = 1073738080; +inp[30545] = 0; +inp[30546] = 1073738064; +inp[30547] = 0; +inp[30548] = 1073738048; +inp[30549] = 0; +inp[30550] = 1073738032; +inp[30551] = 0; +inp[30552] = 1073738016; +inp[30553] = 0; +inp[30554] = 1073738000; +inp[30555] = 0; +inp[30556] = 1073737984; +inp[30557] = 0; +inp[30558] = 1073737968; +inp[30559] = 0; +inp[30560] = 1073737952; +inp[30561] = 0; +inp[30562] = 1073737936; +inp[30563] = 0; +inp[30564] = 1073737920; +inp[30565] = 0; +inp[30566] = 1073737904; +inp[30567] = 0; +inp[30568] = 1073737888; +inp[30569] = 0; +inp[30570] = 1073737872; +inp[30571] = 0; +inp[30572] = 1073737856; +inp[30573] = 0; +inp[30574] = 1073737840; +inp[30575] = 0; +inp[30576] = 1073737824; +inp[30577] = 0; +inp[30578] = 1073737808; +inp[30579] = 0; +inp[30580] = 1073737792; +inp[30581] = 0; +inp[30582] = 1073737776; +inp[30583] = 0; +inp[30584] = 1073737760; +inp[30585] = 0; +inp[30586] = 1073737744; +inp[30587] = 0; +inp[30588] = 1073741824; +inp[30589] = 1073741824; +inp[30590] = 1073741816; +inp[30591] = 0; +inp[30592] = 1073741808; +inp[30593] = 0; +inp[30594] = 1073741800; +inp[30595] = 0; +inp[30596] = 1073741792; +inp[30597] = 0; +inp[30598] = 1073741784; +inp[30599] = 0; +inp[30600] = 1073741776; +inp[30601] = 0; +inp[30602] = 1073741768; +inp[30603] = 0; +inp[30604] = 1073741760; +inp[30605] = 0; +inp[30606] = 1073741752; +inp[30607] = 0; +inp[30608] = 1073741744; +inp[30609] = 0; +inp[30610] = 1073741736; +inp[30611] = 0; +inp[30612] = 1073741728; +inp[30613] = 0; +inp[30614] = 1073741720; +inp[30615] = 0; +inp[30616] = 1073741712; +inp[30617] = 0; +inp[30618] = 1073741704; +inp[30619] = 0; +inp[30620] = 1073741696; +inp[30621] = 0; +inp[30622] = 1073741688; +inp[30623] = 0; +inp[30624] = 1073741680; +inp[30625] = 0; +inp[30626] = 1073741672; +inp[30627] = 0; +inp[30628] = 1073741664; +inp[30629] = 0; +inp[30630] = 1073741656; +inp[30631] = 0; +inp[30632] = 1073741648; +inp[30633] = 0; +inp[30634] = 1073741640; +inp[30635] = 0; +inp[30636] = 1073741632; +inp[30637] = 0; +inp[30638] = 1073741624; +inp[30639] = 0; +inp[30640] = 1073741616; +inp[30641] = 0; +inp[30642] = 1073741608; +inp[30643] = 0; +inp[30644] = 1073741600; +inp[30645] = 0; +inp[30646] = 1073741592; +inp[30647] = 0; +inp[30648] = 1073741584; +inp[30649] = 0; +inp[30650] = 1073741576; +inp[30651] = 0; +inp[30652] = 1073741568; +inp[30653] = 0; +inp[30654] = 1073741560; +inp[30655] = 0; +inp[30656] = 1073741552; +inp[30657] = 0; +inp[30658] = 1073741544; +inp[30659] = 0; +inp[30660] = 1073741536; +inp[30661] = 0; +inp[30662] = 1073741528; +inp[30663] = 0; +inp[30664] = 1073741520; +inp[30665] = 0; +inp[30666] = 1073741512; +inp[30667] = 0; +inp[30668] = 1073741504; +inp[30669] = 0; +inp[30670] = 1073741496; +inp[30671] = 0; +inp[30672] = 1073741488; +inp[30673] = 0; +inp[30674] = 1073741480; +inp[30675] = 0; +inp[30676] = 1073741472; +inp[30677] = 0; +inp[30678] = 1073741464; +inp[30679] = 0; +inp[30680] = 1073741456; +inp[30681] = 0; +inp[30682] = 1073741448; +inp[30683] = 0; +inp[30684] = 1073741440; +inp[30685] = 0; +inp[30686] = 1073741432; +inp[30687] = 0; +inp[30688] = 1073741424; +inp[30689] = 0; +inp[30690] = 1073741416; +inp[30691] = 0; +inp[30692] = 1073741408; +inp[30693] = 0; +inp[30694] = 1073741400; +inp[30695] = 0; +inp[30696] = 1073741392; +inp[30697] = 0; +inp[30698] = 1073741384; +inp[30699] = 0; +inp[30700] = 1073741376; +inp[30701] = 0; +inp[30702] = 1073741368; +inp[30703] = 0; +inp[30704] = 1073741360; +inp[30705] = 0; +inp[30706] = 1073741352; +inp[30707] = 0; +inp[30708] = 1073741344; +inp[30709] = 0; +inp[30710] = 1073741336; +inp[30711] = 0; +inp[30712] = 1073741328; +inp[30713] = 0; +inp[30714] = 1073741320; +inp[30715] = 0; +inp[30716] = 1073741312; +inp[30717] = 0; +inp[30718] = 1073741304; +inp[30719] = 0; +inp[30720] = 1073741296; +inp[30721] = 0; +inp[30722] = 1073741288; +inp[30723] = 0; +inp[30724] = 1073741280; +inp[30725] = 0; +inp[30726] = 1073741272; +inp[30727] = 0; +inp[30728] = 1073741264; +inp[30729] = 0; +inp[30730] = 1073741256; +inp[30731] = 0; +inp[30732] = 1073741248; +inp[30733] = 0; +inp[30734] = 1073741240; +inp[30735] = 0; +inp[30736] = 1073741232; +inp[30737] = 0; +inp[30738] = 1073741224; +inp[30739] = 0; +inp[30740] = 1073741216; +inp[30741] = 0; +inp[30742] = 1073741208; +inp[30743] = 0; +inp[30744] = 1073741200; +inp[30745] = 0; +inp[30746] = 1073741192; +inp[30747] = 0; +inp[30748] = 1073741184; +inp[30749] = 0; +inp[30750] = 1073741176; +inp[30751] = 0; +inp[30752] = 1073741168; +inp[30753] = 0; +inp[30754] = 1073741160; +inp[30755] = 0; +inp[30756] = 1073741152; +inp[30757] = 0; +inp[30758] = 1073741144; +inp[30759] = 0; +inp[30760] = 1073741136; +inp[30761] = 0; +inp[30762] = 1073741128; +inp[30763] = 0; +inp[30764] = 1073741120; +inp[30765] = 0; +inp[30766] = 1073741112; +inp[30767] = 0; +inp[30768] = 1073741104; +inp[30769] = 0; +inp[30770] = 1073741096; +inp[30771] = 0; +inp[30772] = 1073741088; +inp[30773] = 0; +inp[30774] = 1073741080; +inp[30775] = 0; +inp[30776] = 1073741072; +inp[30777] = 0; +inp[30778] = 1073741064; +inp[30779] = 0; +inp[30780] = 1073741056; +inp[30781] = 0; +inp[30782] = 1073741048; +inp[30783] = 0; +inp[30784] = 1073741040; +inp[30785] = 0; +inp[30786] = 1073741032; +inp[30787] = 0; +inp[30788] = 1073741024; +inp[30789] = 0; +inp[30790] = 1073741016; +inp[30791] = 0; +inp[30792] = 1073741008; +inp[30793] = 0; +inp[30794] = 1073741000; +inp[30795] = 0; +inp[30796] = 1073740992; +inp[30797] = 0; +inp[30798] = 1073740984; +inp[30799] = 0; +inp[30800] = 1073740976; +inp[30801] = 0; +inp[30802] = 1073740968; +inp[30803] = 0; +inp[30804] = 1073740960; +inp[30805] = 0; +inp[30806] = 1073740952; +inp[30807] = 0; +inp[30808] = 1073740944; +inp[30809] = 0; +inp[30810] = 1073740936; +inp[30811] = 0; +inp[30812] = 1073740928; +inp[30813] = 0; +inp[30814] = 1073740920; +inp[30815] = 0; +inp[30816] = 1073740912; +inp[30817] = 0; +inp[30818] = 1073740904; +inp[30819] = 0; +inp[30820] = 1073740896; +inp[30821] = 0; +inp[30822] = 1073740888; +inp[30823] = 0; +inp[30824] = 1073740880; +inp[30825] = 0; +inp[30826] = 1073740872; +inp[30827] = 0; +inp[30828] = 1073740864; +inp[30829] = 0; +inp[30830] = 1073740856; +inp[30831] = 0; +inp[30832] = 1073740848; +inp[30833] = 0; +inp[30834] = 1073740840; +inp[30835] = 0; +inp[30836] = 1073740832; +inp[30837] = 0; +inp[30838] = 1073740824; +inp[30839] = 0; +inp[30840] = 1073740816; +inp[30841] = 0; +inp[30842] = 1073740808; +inp[30843] = 0; +inp[30844] = 1073740800; +inp[30845] = 0; +inp[30846] = 1073740792; +inp[30847] = 0; +inp[30848] = 1073740784; +inp[30849] = 0; +inp[30850] = 1073740776; +inp[30851] = 0; +inp[30852] = 1073740768; +inp[30853] = 0; +inp[30854] = 1073740760; +inp[30855] = 0; +inp[30856] = 1073740752; +inp[30857] = 0; +inp[30858] = 1073740744; +inp[30859] = 0; +inp[30860] = 1073740736; +inp[30861] = 0; +inp[30862] = 1073740728; +inp[30863] = 0; +inp[30864] = 1073740720; +inp[30865] = 0; +inp[30866] = 1073740712; +inp[30867] = 0; +inp[30868] = 1073740704; +inp[30869] = 0; +inp[30870] = 1073740696; +inp[30871] = 0; +inp[30872] = 1073740688; +inp[30873] = 0; +inp[30874] = 1073740680; +inp[30875] = 0; +inp[30876] = 1073740672; +inp[30877] = 0; +inp[30878] = 1073740664; +inp[30879] = 0; +inp[30880] = 1073740656; +inp[30881] = 0; +inp[30882] = 1073740648; +inp[30883] = 0; +inp[30884] = 1073740640; +inp[30885] = 0; +inp[30886] = 1073740632; +inp[30887] = 0; +inp[30888] = 1073740624; +inp[30889] = 0; +inp[30890] = 1073740616; +inp[30891] = 0; +inp[30892] = 1073740608; +inp[30893] = 0; +inp[30894] = 1073740600; +inp[30895] = 0; +inp[30896] = 1073740592; +inp[30897] = 0; +inp[30898] = 1073740584; +inp[30899] = 0; +inp[30900] = 1073740576; +inp[30901] = 0; +inp[30902] = 1073740568; +inp[30903] = 0; +inp[30904] = 1073740560; +inp[30905] = 0; +inp[30906] = 1073740552; +inp[30907] = 0; +inp[30908] = 1073740544; +inp[30909] = 0; +inp[30910] = 1073740536; +inp[30911] = 0; +inp[30912] = 1073740528; +inp[30913] = 0; +inp[30914] = 1073740520; +inp[30915] = 0; +inp[30916] = 1073740512; +inp[30917] = 0; +inp[30918] = 1073740504; +inp[30919] = 0; +inp[30920] = 1073740496; +inp[30921] = 0; +inp[30922] = 1073740488; +inp[30923] = 0; +inp[30924] = 1073740480; +inp[30925] = 0; +inp[30926] = 1073740472; +inp[30927] = 0; +inp[30928] = 1073740464; +inp[30929] = 0; +inp[30930] = 1073740456; +inp[30931] = 0; +inp[30932] = 1073740448; +inp[30933] = 0; +inp[30934] = 1073740440; +inp[30935] = 0; +inp[30936] = 1073740432; +inp[30937] = 0; +inp[30938] = 1073740424; +inp[30939] = 0; +inp[30940] = 1073740416; +inp[30941] = 0; +inp[30942] = 1073740408; +inp[30943] = 0; +inp[30944] = 1073740400; +inp[30945] = 0; +inp[30946] = 1073740392; +inp[30947] = 0; +inp[30948] = 1073740384; +inp[30949] = 0; +inp[30950] = 1073740376; +inp[30951] = 0; +inp[30952] = 1073740368; +inp[30953] = 0; +inp[30954] = 1073740360; +inp[30955] = 0; +inp[30956] = 1073740352; +inp[30957] = 0; +inp[30958] = 1073740344; +inp[30959] = 0; +inp[30960] = 1073740336; +inp[30961] = 0; +inp[30962] = 1073740328; +inp[30963] = 0; +inp[30964] = 1073740320; +inp[30965] = 0; +inp[30966] = 1073740312; +inp[30967] = 0; +inp[30968] = 1073740304; +inp[30969] = 0; +inp[30970] = 1073740296; +inp[30971] = 0; +inp[30972] = 1073740288; +inp[30973] = 0; +inp[30974] = 1073740280; +inp[30975] = 0; +inp[30976] = 1073740272; +inp[30977] = 0; +inp[30978] = 1073740264; +inp[30979] = 0; +inp[30980] = 1073740256; +inp[30981] = 0; +inp[30982] = 1073740248; +inp[30983] = 0; +inp[30984] = 1073740240; +inp[30985] = 0; +inp[30986] = 1073740232; +inp[30987] = 0; +inp[30988] = 1073740224; +inp[30989] = 0; +inp[30990] = 1073740216; +inp[30991] = 0; +inp[30992] = 1073740208; +inp[30993] = 0; +inp[30994] = 1073740200; +inp[30995] = 0; +inp[30996] = 1073740192; +inp[30997] = 0; +inp[30998] = 1073740184; +inp[30999] = 0; +inp[31000] = 1073740176; +inp[31001] = 0; +inp[31002] = 1073740168; +inp[31003] = 0; +inp[31004] = 1073740160; +inp[31005] = 0; +inp[31006] = 1073740152; +inp[31007] = 0; +inp[31008] = 1073740144; +inp[31009] = 0; +inp[31010] = 1073740136; +inp[31011] = 0; +inp[31012] = 1073740128; +inp[31013] = 0; +inp[31014] = 1073740120; +inp[31015] = 0; +inp[31016] = 1073740112; +inp[31017] = 0; +inp[31018] = 1073740104; +inp[31019] = 0; +inp[31020] = 1073740096; +inp[31021] = 0; +inp[31022] = 1073740088; +inp[31023] = 0; +inp[31024] = 1073740080; +inp[31025] = 0; +inp[31026] = 1073740072; +inp[31027] = 0; +inp[31028] = 1073740064; +inp[31029] = 0; +inp[31030] = 1073740056; +inp[31031] = 0; +inp[31032] = 1073740048; +inp[31033] = 0; +inp[31034] = 1073740040; +inp[31035] = 0; +inp[31036] = 1073740032; +inp[31037] = 0; +inp[31038] = 1073740024; +inp[31039] = 0; +inp[31040] = 1073740016; +inp[31041] = 0; +inp[31042] = 1073740008; +inp[31043] = 0; +inp[31044] = 1073740000; +inp[31045] = 0; +inp[31046] = 1073739992; +inp[31047] = 0; +inp[31048] = 1073739984; +inp[31049] = 0; +inp[31050] = 1073739976; +inp[31051] = 0; +inp[31052] = 1073739968; +inp[31053] = 0; +inp[31054] = 1073739960; +inp[31055] = 0; +inp[31056] = 1073739952; +inp[31057] = 0; +inp[31058] = 1073739944; +inp[31059] = 0; +inp[31060] = 1073739936; +inp[31061] = 0; +inp[31062] = 1073739928; +inp[31063] = 0; +inp[31064] = 1073739920; +inp[31065] = 0; +inp[31066] = 1073739912; +inp[31067] = 0; +inp[31068] = 1073739904; +inp[31069] = 0; +inp[31070] = 1073739896; +inp[31071] = 0; +inp[31072] = 1073739888; +inp[31073] = 0; +inp[31074] = 1073739880; +inp[31075] = 0; +inp[31076] = 1073739872; +inp[31077] = 0; +inp[31078] = 1073739864; +inp[31079] = 0; +inp[31080] = 1073739856; +inp[31081] = 0; +inp[31082] = 1073739848; +inp[31083] = 0; +inp[31084] = 1073739840; +inp[31085] = 0; +inp[31086] = 1073739832; +inp[31087] = 0; +inp[31088] = 1073739824; +inp[31089] = 0; +inp[31090] = 1073739816; +inp[31091] = 0; +inp[31092] = 1073739808; +inp[31093] = 0; +inp[31094] = 1073739800; +inp[31095] = 0; +inp[31096] = 1073739792; +inp[31097] = 0; +inp[31098] = 1073739784; +inp[31099] = 0; +inp[31100] = 1073741824; +inp[31101] = 1073741824; +inp[31102] = 1073741820; +inp[31103] = 0; +inp[31104] = 1073741816; +inp[31105] = 0; +inp[31106] = 1073741812; +inp[31107] = 0; +inp[31108] = 1073741808; +inp[31109] = 0; +inp[31110] = 1073741804; +inp[31111] = 0; +inp[31112] = 1073741800; +inp[31113] = 0; +inp[31114] = 1073741796; +inp[31115] = 0; +inp[31116] = 1073741792; +inp[31117] = 0; +inp[31118] = 1073741788; +inp[31119] = 0; +inp[31120] = 1073741784; +inp[31121] = 0; +inp[31122] = 1073741780; +inp[31123] = 0; +inp[31124] = 1073741776; +inp[31125] = 0; +inp[31126] = 1073741772; +inp[31127] = 0; +inp[31128] = 1073741768; +inp[31129] = 0; +inp[31130] = 1073741764; +inp[31131] = 0; +inp[31132] = 1073741760; +inp[31133] = 0; +inp[31134] = 1073741756; +inp[31135] = 0; +inp[31136] = 1073741752; +inp[31137] = 0; +inp[31138] = 1073741748; +inp[31139] = 0; +inp[31140] = 1073741744; +inp[31141] = 0; +inp[31142] = 1073741740; +inp[31143] = 0; +inp[31144] = 1073741736; +inp[31145] = 0; +inp[31146] = 1073741732; +inp[31147] = 0; +inp[31148] = 1073741728; +inp[31149] = 0; +inp[31150] = 1073741724; +inp[31151] = 0; +inp[31152] = 1073741720; +inp[31153] = 0; +inp[31154] = 1073741716; +inp[31155] = 0; +inp[31156] = 1073741712; +inp[31157] = 0; +inp[31158] = 1073741708; +inp[31159] = 0; +inp[31160] = 1073741704; +inp[31161] = 0; +inp[31162] = 1073741700; +inp[31163] = 0; +inp[31164] = 1073741696; +inp[31165] = 0; +inp[31166] = 1073741692; +inp[31167] = 0; +inp[31168] = 1073741688; +inp[31169] = 0; +inp[31170] = 1073741684; +inp[31171] = 0; +inp[31172] = 1073741680; +inp[31173] = 0; +inp[31174] = 1073741676; +inp[31175] = 0; +inp[31176] = 1073741672; +inp[31177] = 0; +inp[31178] = 1073741668; +inp[31179] = 0; +inp[31180] = 1073741664; +inp[31181] = 0; +inp[31182] = 1073741660; +inp[31183] = 0; +inp[31184] = 1073741656; +inp[31185] = 0; +inp[31186] = 1073741652; +inp[31187] = 0; +inp[31188] = 1073741648; +inp[31189] = 0; +inp[31190] = 1073741644; +inp[31191] = 0; +inp[31192] = 1073741640; +inp[31193] = 0; +inp[31194] = 1073741636; +inp[31195] = 0; +inp[31196] = 1073741632; +inp[31197] = 0; +inp[31198] = 1073741628; +inp[31199] = 0; +inp[31200] = 1073741624; +inp[31201] = 0; +inp[31202] = 1073741620; +inp[31203] = 0; +inp[31204] = 1073741616; +inp[31205] = 0; +inp[31206] = 1073741612; +inp[31207] = 0; +inp[31208] = 1073741608; +inp[31209] = 0; +inp[31210] = 1073741604; +inp[31211] = 0; +inp[31212] = 1073741600; +inp[31213] = 0; +inp[31214] = 1073741596; +inp[31215] = 0; +inp[31216] = 1073741592; +inp[31217] = 0; +inp[31218] = 1073741588; +inp[31219] = 0; +inp[31220] = 1073741584; +inp[31221] = 0; +inp[31222] = 1073741580; +inp[31223] = 0; +inp[31224] = 1073741576; +inp[31225] = 0; +inp[31226] = 1073741572; +inp[31227] = 0; +inp[31228] = 1073741568; +inp[31229] = 0; +inp[31230] = 1073741564; +inp[31231] = 0; +inp[31232] = 1073741560; +inp[31233] = 0; +inp[31234] = 1073741556; +inp[31235] = 0; +inp[31236] = 1073741552; +inp[31237] = 0; +inp[31238] = 1073741548; +inp[31239] = 0; +inp[31240] = 1073741544; +inp[31241] = 0; +inp[31242] = 1073741540; +inp[31243] = 0; +inp[31244] = 1073741536; +inp[31245] = 0; +inp[31246] = 1073741532; +inp[31247] = 0; +inp[31248] = 1073741528; +inp[31249] = 0; +inp[31250] = 1073741524; +inp[31251] = 0; +inp[31252] = 1073741520; +inp[31253] = 0; +inp[31254] = 1073741516; +inp[31255] = 0; +inp[31256] = 1073741512; +inp[31257] = 0; +inp[31258] = 1073741508; +inp[31259] = 0; +inp[31260] = 1073741504; +inp[31261] = 0; +inp[31262] = 1073741500; +inp[31263] = 0; +inp[31264] = 1073741496; +inp[31265] = 0; +inp[31266] = 1073741492; +inp[31267] = 0; +inp[31268] = 1073741488; +inp[31269] = 0; +inp[31270] = 1073741484; +inp[31271] = 0; +inp[31272] = 1073741480; +inp[31273] = 0; +inp[31274] = 1073741476; +inp[31275] = 0; +inp[31276] = 1073741472; +inp[31277] = 0; +inp[31278] = 1073741468; +inp[31279] = 0; +inp[31280] = 1073741464; +inp[31281] = 0; +inp[31282] = 1073741460; +inp[31283] = 0; +inp[31284] = 1073741456; +inp[31285] = 0; +inp[31286] = 1073741452; +inp[31287] = 0; +inp[31288] = 1073741448; +inp[31289] = 0; +inp[31290] = 1073741444; +inp[31291] = 0; +inp[31292] = 1073741440; +inp[31293] = 0; +inp[31294] = 1073741436; +inp[31295] = 0; +inp[31296] = 1073741432; +inp[31297] = 0; +inp[31298] = 1073741428; +inp[31299] = 0; +inp[31300] = 1073741424; +inp[31301] = 0; +inp[31302] = 1073741420; +inp[31303] = 0; +inp[31304] = 1073741416; +inp[31305] = 0; +inp[31306] = 1073741412; +inp[31307] = 0; +inp[31308] = 1073741408; +inp[31309] = 0; +inp[31310] = 1073741404; +inp[31311] = 0; +inp[31312] = 1073741400; +inp[31313] = 0; +inp[31314] = 1073741396; +inp[31315] = 0; +inp[31316] = 1073741392; +inp[31317] = 0; +inp[31318] = 1073741388; +inp[31319] = 0; +inp[31320] = 1073741384; +inp[31321] = 0; +inp[31322] = 1073741380; +inp[31323] = 0; +inp[31324] = 1073741376; +inp[31325] = 0; +inp[31326] = 1073741372; +inp[31327] = 0; +inp[31328] = 1073741368; +inp[31329] = 0; +inp[31330] = 1073741364; +inp[31331] = 0; +inp[31332] = 1073741360; +inp[31333] = 0; +inp[31334] = 1073741356; +inp[31335] = 0; +inp[31336] = 1073741352; +inp[31337] = 0; +inp[31338] = 1073741348; +inp[31339] = 0; +inp[31340] = 1073741344; +inp[31341] = 0; +inp[31342] = 1073741340; +inp[31343] = 0; +inp[31344] = 1073741336; +inp[31345] = 0; +inp[31346] = 1073741332; +inp[31347] = 0; +inp[31348] = 1073741328; +inp[31349] = 0; +inp[31350] = 1073741324; +inp[31351] = 0; +inp[31352] = 1073741320; +inp[31353] = 0; +inp[31354] = 1073741316; +inp[31355] = 0; +inp[31356] = 1073741312; +inp[31357] = 0; +inp[31358] = 1073741308; +inp[31359] = 0; +inp[31360] = 1073741304; +inp[31361] = 0; +inp[31362] = 1073741300; +inp[31363] = 0; +inp[31364] = 1073741296; +inp[31365] = 0; +inp[31366] = 1073741292; +inp[31367] = 0; +inp[31368] = 1073741288; +inp[31369] = 0; +inp[31370] = 1073741284; +inp[31371] = 0; +inp[31372] = 1073741280; +inp[31373] = 0; +inp[31374] = 1073741276; +inp[31375] = 0; +inp[31376] = 1073741272; +inp[31377] = 0; +inp[31378] = 1073741268; +inp[31379] = 0; +inp[31380] = 1073741264; +inp[31381] = 0; +inp[31382] = 1073741260; +inp[31383] = 0; +inp[31384] = 1073741256; +inp[31385] = 0; +inp[31386] = 1073741252; +inp[31387] = 0; +inp[31388] = 1073741248; +inp[31389] = 0; +inp[31390] = 1073741244; +inp[31391] = 0; +inp[31392] = 1073741240; +inp[31393] = 0; +inp[31394] = 1073741236; +inp[31395] = 0; +inp[31396] = 1073741232; +inp[31397] = 0; +inp[31398] = 1073741228; +inp[31399] = 0; +inp[31400] = 1073741224; +inp[31401] = 0; +inp[31402] = 1073741220; +inp[31403] = 0; +inp[31404] = 1073741216; +inp[31405] = 0; +inp[31406] = 1073741212; +inp[31407] = 0; +inp[31408] = 1073741208; +inp[31409] = 0; +inp[31410] = 1073741204; +inp[31411] = 0; +inp[31412] = 1073741200; +inp[31413] = 0; +inp[31414] = 1073741196; +inp[31415] = 0; +inp[31416] = 1073741192; +inp[31417] = 0; +inp[31418] = 1073741188; +inp[31419] = 0; +inp[31420] = 1073741184; +inp[31421] = 0; +inp[31422] = 1073741180; +inp[31423] = 0; +inp[31424] = 1073741176; +inp[31425] = 0; +inp[31426] = 1073741172; +inp[31427] = 0; +inp[31428] = 1073741168; +inp[31429] = 0; +inp[31430] = 1073741164; +inp[31431] = 0; +inp[31432] = 1073741160; +inp[31433] = 0; +inp[31434] = 1073741156; +inp[31435] = 0; +inp[31436] = 1073741152; +inp[31437] = 0; +inp[31438] = 1073741148; +inp[31439] = 0; +inp[31440] = 1073741144; +inp[31441] = 0; +inp[31442] = 1073741140; +inp[31443] = 0; +inp[31444] = 1073741136; +inp[31445] = 0; +inp[31446] = 1073741132; +inp[31447] = 0; +inp[31448] = 1073741128; +inp[31449] = 0; +inp[31450] = 1073741124; +inp[31451] = 0; +inp[31452] = 1073741120; +inp[31453] = 0; +inp[31454] = 1073741116; +inp[31455] = 0; +inp[31456] = 1073741112; +inp[31457] = 0; +inp[31458] = 1073741108; +inp[31459] = 0; +inp[31460] = 1073741104; +inp[31461] = 0; +inp[31462] = 1073741100; +inp[31463] = 0; +inp[31464] = 1073741096; +inp[31465] = 0; +inp[31466] = 1073741092; +inp[31467] = 0; +inp[31468] = 1073741088; +inp[31469] = 0; +inp[31470] = 1073741084; +inp[31471] = 0; +inp[31472] = 1073741080; +inp[31473] = 0; +inp[31474] = 1073741076; +inp[31475] = 0; +inp[31476] = 1073741072; +inp[31477] = 0; +inp[31478] = 1073741068; +inp[31479] = 0; +inp[31480] = 1073741064; +inp[31481] = 0; +inp[31482] = 1073741060; +inp[31483] = 0; +inp[31484] = 1073741056; +inp[31485] = 0; +inp[31486] = 1073741052; +inp[31487] = 0; +inp[31488] = 1073741048; +inp[31489] = 0; +inp[31490] = 1073741044; +inp[31491] = 0; +inp[31492] = 1073741040; +inp[31493] = 0; +inp[31494] = 1073741036; +inp[31495] = 0; +inp[31496] = 1073741032; +inp[31497] = 0; +inp[31498] = 1073741028; +inp[31499] = 0; +inp[31500] = 1073741024; +inp[31501] = 0; +inp[31502] = 1073741020; +inp[31503] = 0; +inp[31504] = 1073741016; +inp[31505] = 0; +inp[31506] = 1073741012; +inp[31507] = 0; +inp[31508] = 1073741008; +inp[31509] = 0; +inp[31510] = 1073741004; +inp[31511] = 0; +inp[31512] = 1073741000; +inp[31513] = 0; +inp[31514] = 1073740996; +inp[31515] = 0; +inp[31516] = 1073740992; +inp[31517] = 0; +inp[31518] = 1073740988; +inp[31519] = 0; +inp[31520] = 1073740984; +inp[31521] = 0; +inp[31522] = 1073740980; +inp[31523] = 0; +inp[31524] = 1073740976; +inp[31525] = 0; +inp[31526] = 1073740972; +inp[31527] = 0; +inp[31528] = 1073740968; +inp[31529] = 0; +inp[31530] = 1073740964; +inp[31531] = 0; +inp[31532] = 1073740960; +inp[31533] = 0; +inp[31534] = 1073740956; +inp[31535] = 0; +inp[31536] = 1073740952; +inp[31537] = 0; +inp[31538] = 1073740948; +inp[31539] = 0; +inp[31540] = 1073740944; +inp[31541] = 0; +inp[31542] = 1073740940; +inp[31543] = 0; +inp[31544] = 1073740936; +inp[31545] = 0; +inp[31546] = 1073740932; +inp[31547] = 0; +inp[31548] = 1073740928; +inp[31549] = 0; +inp[31550] = 1073740924; +inp[31551] = 0; +inp[31552] = 1073740920; +inp[31553] = 0; +inp[31554] = 1073740916; +inp[31555] = 0; +inp[31556] = 1073740912; +inp[31557] = 0; +inp[31558] = 1073740908; +inp[31559] = 0; +inp[31560] = 1073740904; +inp[31561] = 0; +inp[31562] = 1073740900; +inp[31563] = 0; +inp[31564] = 1073740896; +inp[31565] = 0; +inp[31566] = 1073740892; +inp[31567] = 0; +inp[31568] = 1073740888; +inp[31569] = 0; +inp[31570] = 1073740884; +inp[31571] = 0; +inp[31572] = 1073740880; +inp[31573] = 0; +inp[31574] = 1073740876; +inp[31575] = 0; +inp[31576] = 1073740872; +inp[31577] = 0; +inp[31578] = 1073740868; +inp[31579] = 0; +inp[31580] = 1073740864; +inp[31581] = 0; +inp[31582] = 1073740860; +inp[31583] = 0; +inp[31584] = 1073740856; +inp[31585] = 0; +inp[31586] = 1073740852; +inp[31587] = 0; +inp[31588] = 1073740848; +inp[31589] = 0; +inp[31590] = 1073740844; +inp[31591] = 0; +inp[31592] = 1073740840; +inp[31593] = 0; +inp[31594] = 1073740836; +inp[31595] = 0; +inp[31596] = 1073740832; +inp[31597] = 0; +inp[31598] = 1073740828; +inp[31599] = 0; +inp[31600] = 1073740824; +inp[31601] = 0; +inp[31602] = 1073740820; +inp[31603] = 0; +inp[31604] = 1073740816; +inp[31605] = 0; +inp[31606] = 1073740812; +inp[31607] = 0; +inp[31608] = 1073740808; +inp[31609] = 0; +inp[31610] = 1073740804; +inp[31611] = 0; +inp[31612] = 1073741824; +inp[31613] = 1073741824; +inp[31614] = 1073741822; +inp[31615] = 0; +inp[31616] = 1073741820; +inp[31617] = 0; +inp[31618] = 1073741818; +inp[31619] = 0; +inp[31620] = 1073741816; +inp[31621] = 0; +inp[31622] = 1073741814; +inp[31623] = 0; +inp[31624] = 1073741812; +inp[31625] = 0; +inp[31626] = 1073741810; +inp[31627] = 0; +inp[31628] = 1073741808; +inp[31629] = 0; +inp[31630] = 1073741806; +inp[31631] = 0; +inp[31632] = 1073741804; +inp[31633] = 0; +inp[31634] = 1073741802; +inp[31635] = 0; +inp[31636] = 1073741800; +inp[31637] = 0; +inp[31638] = 1073741798; +inp[31639] = 0; +inp[31640] = 1073741796; +inp[31641] = 0; +inp[31642] = 1073741794; +inp[31643] = 0; +inp[31644] = 1073741792; +inp[31645] = 0; +inp[31646] = 1073741790; +inp[31647] = 0; +inp[31648] = 1073741788; +inp[31649] = 0; +inp[31650] = 1073741786; +inp[31651] = 0; +inp[31652] = 1073741784; +inp[31653] = 0; +inp[31654] = 1073741782; +inp[31655] = 0; +inp[31656] = 1073741780; +inp[31657] = 0; +inp[31658] = 1073741778; +inp[31659] = 0; +inp[31660] = 1073741776; +inp[31661] = 0; +inp[31662] = 1073741774; +inp[31663] = 0; +inp[31664] = 1073741772; +inp[31665] = 0; +inp[31666] = 1073741770; +inp[31667] = 0; +inp[31668] = 1073741768; +inp[31669] = 0; +inp[31670] = 1073741766; +inp[31671] = 0; +inp[31672] = 1073741764; +inp[31673] = 0; +inp[31674] = 1073741762; +inp[31675] = 0; +inp[31676] = 1073741760; +inp[31677] = 0; +inp[31678] = 1073741758; +inp[31679] = 0; +inp[31680] = 1073741756; +inp[31681] = 0; +inp[31682] = 1073741754; +inp[31683] = 0; +inp[31684] = 1073741752; +inp[31685] = 0; +inp[31686] = 1073741750; +inp[31687] = 0; +inp[31688] = 1073741748; +inp[31689] = 0; +inp[31690] = 1073741746; +inp[31691] = 0; +inp[31692] = 1073741744; +inp[31693] = 0; +inp[31694] = 1073741742; +inp[31695] = 0; +inp[31696] = 1073741740; +inp[31697] = 0; +inp[31698] = 1073741738; +inp[31699] = 0; +inp[31700] = 1073741736; +inp[31701] = 0; +inp[31702] = 1073741734; +inp[31703] = 0; +inp[31704] = 1073741732; +inp[31705] = 0; +inp[31706] = 1073741730; +inp[31707] = 0; +inp[31708] = 1073741728; +inp[31709] = 0; +inp[31710] = 1073741726; +inp[31711] = 0; +inp[31712] = 1073741724; +inp[31713] = 0; +inp[31714] = 1073741722; +inp[31715] = 0; +inp[31716] = 1073741720; +inp[31717] = 0; +inp[31718] = 1073741718; +inp[31719] = 0; +inp[31720] = 1073741716; +inp[31721] = 0; +inp[31722] = 1073741714; +inp[31723] = 0; +inp[31724] = 1073741712; +inp[31725] = 0; +inp[31726] = 1073741710; +inp[31727] = 0; +inp[31728] = 1073741708; +inp[31729] = 0; +inp[31730] = 1073741706; +inp[31731] = 0; +inp[31732] = 1073741704; +inp[31733] = 0; +inp[31734] = 1073741702; +inp[31735] = 0; +inp[31736] = 1073741700; +inp[31737] = 0; +inp[31738] = 1073741698; +inp[31739] = 0; +inp[31740] = 1073741696; +inp[31741] = 0; +inp[31742] = 1073741694; +inp[31743] = 0; +inp[31744] = 1073741692; +inp[31745] = 0; +inp[31746] = 1073741690; +inp[31747] = 0; +inp[31748] = 1073741688; +inp[31749] = 0; +inp[31750] = 1073741686; +inp[31751] = 0; +inp[31752] = 1073741684; +inp[31753] = 0; +inp[31754] = 1073741682; +inp[31755] = 0; +inp[31756] = 1073741680; +inp[31757] = 0; +inp[31758] = 1073741678; +inp[31759] = 0; +inp[31760] = 1073741676; +inp[31761] = 0; +inp[31762] = 1073741674; +inp[31763] = 0; +inp[31764] = 1073741672; +inp[31765] = 0; +inp[31766] = 1073741670; +inp[31767] = 0; +inp[31768] = 1073741668; +inp[31769] = 0; +inp[31770] = 1073741666; +inp[31771] = 0; +inp[31772] = 1073741664; +inp[31773] = 0; +inp[31774] = 1073741662; +inp[31775] = 0; +inp[31776] = 1073741660; +inp[31777] = 0; +inp[31778] = 1073741658; +inp[31779] = 0; +inp[31780] = 1073741656; +inp[31781] = 0; +inp[31782] = 1073741654; +inp[31783] = 0; +inp[31784] = 1073741652; +inp[31785] = 0; +inp[31786] = 1073741650; +inp[31787] = 0; +inp[31788] = 1073741648; +inp[31789] = 0; +inp[31790] = 1073741646; +inp[31791] = 0; +inp[31792] = 1073741644; +inp[31793] = 0; +inp[31794] = 1073741642; +inp[31795] = 0; +inp[31796] = 1073741640; +inp[31797] = 0; +inp[31798] = 1073741638; +inp[31799] = 0; +inp[31800] = 1073741636; +inp[31801] = 0; +inp[31802] = 1073741634; +inp[31803] = 0; +inp[31804] = 1073741632; +inp[31805] = 0; +inp[31806] = 1073741630; +inp[31807] = 0; +inp[31808] = 1073741628; +inp[31809] = 0; +inp[31810] = 1073741626; +inp[31811] = 0; +inp[31812] = 1073741624; +inp[31813] = 0; +inp[31814] = 1073741622; +inp[31815] = 0; +inp[31816] = 1073741620; +inp[31817] = 0; +inp[31818] = 1073741618; +inp[31819] = 0; +inp[31820] = 1073741616; +inp[31821] = 0; +inp[31822] = 1073741614; +inp[31823] = 0; +inp[31824] = 1073741612; +inp[31825] = 0; +inp[31826] = 1073741610; +inp[31827] = 0; +inp[31828] = 1073741608; +inp[31829] = 0; +inp[31830] = 1073741606; +inp[31831] = 0; +inp[31832] = 1073741604; +inp[31833] = 0; +inp[31834] = 1073741602; +inp[31835] = 0; +inp[31836] = 1073741600; +inp[31837] = 0; +inp[31838] = 1073741598; +inp[31839] = 0; +inp[31840] = 1073741596; +inp[31841] = 0; +inp[31842] = 1073741594; +inp[31843] = 0; +inp[31844] = 1073741592; +inp[31845] = 0; +inp[31846] = 1073741590; +inp[31847] = 0; +inp[31848] = 1073741588; +inp[31849] = 0; +inp[31850] = 1073741586; +inp[31851] = 0; +inp[31852] = 1073741584; +inp[31853] = 0; +inp[31854] = 1073741582; +inp[31855] = 0; +inp[31856] = 1073741580; +inp[31857] = 0; +inp[31858] = 1073741578; +inp[31859] = 0; +inp[31860] = 1073741576; +inp[31861] = 0; +inp[31862] = 1073741574; +inp[31863] = 0; +inp[31864] = 1073741572; +inp[31865] = 0; +inp[31866] = 1073741570; +inp[31867] = 0; +inp[31868] = 1073741568; +inp[31869] = 0; +inp[31870] = 1073741566; +inp[31871] = 0; +inp[31872] = 1073741564; +inp[31873] = 0; +inp[31874] = 1073741562; +inp[31875] = 0; +inp[31876] = 1073741560; +inp[31877] = 0; +inp[31878] = 1073741558; +inp[31879] = 0; +inp[31880] = 1073741556; +inp[31881] = 0; +inp[31882] = 1073741554; +inp[31883] = 0; +inp[31884] = 1073741552; +inp[31885] = 0; +inp[31886] = 1073741550; +inp[31887] = 0; +inp[31888] = 1073741548; +inp[31889] = 0; +inp[31890] = 1073741546; +inp[31891] = 0; +inp[31892] = 1073741544; +inp[31893] = 0; +inp[31894] = 1073741542; +inp[31895] = 0; +inp[31896] = 1073741540; +inp[31897] = 0; +inp[31898] = 1073741538; +inp[31899] = 0; +inp[31900] = 1073741536; +inp[31901] = 0; +inp[31902] = 1073741534; +inp[31903] = 0; +inp[31904] = 1073741532; +inp[31905] = 0; +inp[31906] = 1073741530; +inp[31907] = 0; +inp[31908] = 1073741528; +inp[31909] = 0; +inp[31910] = 1073741526; +inp[31911] = 0; +inp[31912] = 1073741524; +inp[31913] = 0; +inp[31914] = 1073741522; +inp[31915] = 0; +inp[31916] = 1073741520; +inp[31917] = 0; +inp[31918] = 1073741518; +inp[31919] = 0; +inp[31920] = 1073741516; +inp[31921] = 0; +inp[31922] = 1073741514; +inp[31923] = 0; +inp[31924] = 1073741512; +inp[31925] = 0; +inp[31926] = 1073741510; +inp[31927] = 0; +inp[31928] = 1073741508; +inp[31929] = 0; +inp[31930] = 1073741506; +inp[31931] = 0; +inp[31932] = 1073741504; +inp[31933] = 0; +inp[31934] = 1073741502; +inp[31935] = 0; +inp[31936] = 1073741500; +inp[31937] = 0; +inp[31938] = 1073741498; +inp[31939] = 0; +inp[31940] = 1073741496; +inp[31941] = 0; +inp[31942] = 1073741494; +inp[31943] = 0; +inp[31944] = 1073741492; +inp[31945] = 0; +inp[31946] = 1073741490; +inp[31947] = 0; +inp[31948] = 1073741488; +inp[31949] = 0; +inp[31950] = 1073741486; +inp[31951] = 0; +inp[31952] = 1073741484; +inp[31953] = 0; +inp[31954] = 1073741482; +inp[31955] = 0; +inp[31956] = 1073741480; +inp[31957] = 0; +inp[31958] = 1073741478; +inp[31959] = 0; +inp[31960] = 1073741476; +inp[31961] = 0; +inp[31962] = 1073741474; +inp[31963] = 0; +inp[31964] = 1073741472; +inp[31965] = 0; +inp[31966] = 1073741470; +inp[31967] = 0; +inp[31968] = 1073741468; +inp[31969] = 0; +inp[31970] = 1073741466; +inp[31971] = 0; +inp[31972] = 1073741464; +inp[31973] = 0; +inp[31974] = 1073741462; +inp[31975] = 0; +inp[31976] = 1073741460; +inp[31977] = 0; +inp[31978] = 1073741458; +inp[31979] = 0; +inp[31980] = 1073741456; +inp[31981] = 0; +inp[31982] = 1073741454; +inp[31983] = 0; +inp[31984] = 1073741452; +inp[31985] = 0; +inp[31986] = 1073741450; +inp[31987] = 0; +inp[31988] = 1073741448; +inp[31989] = 0; +inp[31990] = 1073741446; +inp[31991] = 0; +inp[31992] = 1073741444; +inp[31993] = 0; +inp[31994] = 1073741442; +inp[31995] = 0; +inp[31996] = 1073741440; +inp[31997] = 0; +inp[31998] = 1073741438; +inp[31999] = 0; +inp[32000] = 1073741436; +inp[32001] = 0; +inp[32002] = 1073741434; +inp[32003] = 0; +inp[32004] = 1073741432; +inp[32005] = 0; +inp[32006] = 1073741430; +inp[32007] = 0; +inp[32008] = 1073741428; +inp[32009] = 0; +inp[32010] = 1073741426; +inp[32011] = 0; +inp[32012] = 1073741424; +inp[32013] = 0; +inp[32014] = 1073741422; +inp[32015] = 0; +inp[32016] = 1073741420; +inp[32017] = 0; +inp[32018] = 1073741418; +inp[32019] = 0; +inp[32020] = 1073741416; +inp[32021] = 0; +inp[32022] = 1073741414; +inp[32023] = 0; +inp[32024] = 1073741412; +inp[32025] = 0; +inp[32026] = 1073741410; +inp[32027] = 0; +inp[32028] = 1073741408; +inp[32029] = 0; +inp[32030] = 1073741406; +inp[32031] = 0; +inp[32032] = 1073741404; +inp[32033] = 0; +inp[32034] = 1073741402; +inp[32035] = 0; +inp[32036] = 1073741400; +inp[32037] = 0; +inp[32038] = 1073741398; +inp[32039] = 0; +inp[32040] = 1073741396; +inp[32041] = 0; +inp[32042] = 1073741394; +inp[32043] = 0; +inp[32044] = 1073741392; +inp[32045] = 0; +inp[32046] = 1073741390; +inp[32047] = 0; +inp[32048] = 1073741388; +inp[32049] = 0; +inp[32050] = 1073741386; +inp[32051] = 0; +inp[32052] = 1073741384; +inp[32053] = 0; +inp[32054] = 1073741382; +inp[32055] = 0; +inp[32056] = 1073741380; +inp[32057] = 0; +inp[32058] = 1073741378; +inp[32059] = 0; +inp[32060] = 1073741376; +inp[32061] = 0; +inp[32062] = 1073741374; +inp[32063] = 0; +inp[32064] = 1073741372; +inp[32065] = 0; +inp[32066] = 1073741370; +inp[32067] = 0; +inp[32068] = 1073741368; +inp[32069] = 0; +inp[32070] = 1073741366; +inp[32071] = 0; +inp[32072] = 1073741364; +inp[32073] = 0; +inp[32074] = 1073741362; +inp[32075] = 0; +inp[32076] = 1073741360; +inp[32077] = 0; +inp[32078] = 1073741358; +inp[32079] = 0; +inp[32080] = 1073741356; +inp[32081] = 0; +inp[32082] = 1073741354; +inp[32083] = 0; +inp[32084] = 1073741352; +inp[32085] = 0; +inp[32086] = 1073741350; +inp[32087] = 0; +inp[32088] = 1073741348; +inp[32089] = 0; +inp[32090] = 1073741346; +inp[32091] = 0; +inp[32092] = 1073741344; +inp[32093] = 0; +inp[32094] = 1073741342; +inp[32095] = 0; +inp[32096] = 1073741340; +inp[32097] = 0; +inp[32098] = 1073741338; +inp[32099] = 0; +inp[32100] = 1073741336; +inp[32101] = 0; +inp[32102] = 1073741334; +inp[32103] = 0; +inp[32104] = 1073741332; +inp[32105] = 0; +inp[32106] = 1073741330; +inp[32107] = 0; +inp[32108] = 1073741328; +inp[32109] = 0; +inp[32110] = 1073741326; +inp[32111] = 0; +inp[32112] = 1073741324; +inp[32113] = 0; +inp[32114] = 1073741322; +inp[32115] = 0; +inp[32116] = 1073741320; +inp[32117] = 0; +inp[32118] = 1073741318; +inp[32119] = 0; +inp[32120] = 1073741316; +inp[32121] = 0; +inp[32122] = 1073741314; +inp[32123] = 0; +inp[32124] = 1073741824; +inp[32125] = 1073741824; +inp[32126] = 1073741823; +inp[32127] = 0; +inp[32128] = 1073741822; +inp[32129] = 0; +inp[32130] = 1073741821; +inp[32131] = 0; +inp[32132] = 1073741820; +inp[32133] = 0; +inp[32134] = 1073741819; +inp[32135] = 0; +inp[32136] = 1073741818; +inp[32137] = 0; +inp[32138] = 1073741817; +inp[32139] = 0; +inp[32140] = 1073741816; +inp[32141] = 0; +inp[32142] = 1073741815; +inp[32143] = 0; +inp[32144] = 1073741814; +inp[32145] = 0; +inp[32146] = 1073741813; +inp[32147] = 0; +inp[32148] = 1073741812; +inp[32149] = 0; +inp[32150] = 1073741811; +inp[32151] = 0; +inp[32152] = 1073741810; +inp[32153] = 0; +inp[32154] = 1073741809; +inp[32155] = 0; +inp[32156] = 1073741808; +inp[32157] = 0; +inp[32158] = 1073741807; +inp[32159] = 0; +inp[32160] = 1073741806; +inp[32161] = 0; +inp[32162] = 1073741805; +inp[32163] = 0; +inp[32164] = 1073741804; +inp[32165] = 0; +inp[32166] = 1073741803; +inp[32167] = 0; +inp[32168] = 1073741802; +inp[32169] = 0; +inp[32170] = 1073741801; +inp[32171] = 0; +inp[32172] = 1073741800; +inp[32173] = 0; +inp[32174] = 1073741799; +inp[32175] = 0; +inp[32176] = 1073741798; +inp[32177] = 0; +inp[32178] = 1073741797; +inp[32179] = 0; +inp[32180] = 1073741796; +inp[32181] = 0; +inp[32182] = 1073741795; +inp[32183] = 0; +inp[32184] = 1073741794; +inp[32185] = 0; +inp[32186] = 1073741793; +inp[32187] = 0; +inp[32188] = 1073741792; +inp[32189] = 0; +inp[32190] = 1073741791; +inp[32191] = 0; +inp[32192] = 1073741790; +inp[32193] = 0; +inp[32194] = 1073741789; +inp[32195] = 0; +inp[32196] = 1073741788; +inp[32197] = 0; +inp[32198] = 1073741787; +inp[32199] = 0; +inp[32200] = 1073741786; +inp[32201] = 0; +inp[32202] = 1073741785; +inp[32203] = 0; +inp[32204] = 1073741784; +inp[32205] = 0; +inp[32206] = 1073741783; +inp[32207] = 0; +inp[32208] = 1073741782; +inp[32209] = 0; +inp[32210] = 1073741781; +inp[32211] = 0; +inp[32212] = 1073741780; +inp[32213] = 0; +inp[32214] = 1073741779; +inp[32215] = 0; +inp[32216] = 1073741778; +inp[32217] = 0; +inp[32218] = 1073741777; +inp[32219] = 0; +inp[32220] = 1073741776; +inp[32221] = 0; +inp[32222] = 1073741775; +inp[32223] = 0; +inp[32224] = 1073741774; +inp[32225] = 0; +inp[32226] = 1073741773; +inp[32227] = 0; +inp[32228] = 1073741772; +inp[32229] = 0; +inp[32230] = 1073741771; +inp[32231] = 0; +inp[32232] = 1073741770; +inp[32233] = 0; +inp[32234] = 1073741769; +inp[32235] = 0; +inp[32236] = 1073741768; +inp[32237] = 0; +inp[32238] = 1073741767; +inp[32239] = 0; +inp[32240] = 1073741766; +inp[32241] = 0; +inp[32242] = 1073741765; +inp[32243] = 0; +inp[32244] = 1073741764; +inp[32245] = 0; +inp[32246] = 1073741763; +inp[32247] = 0; +inp[32248] = 1073741762; +inp[32249] = 0; +inp[32250] = 1073741761; +inp[32251] = 0; +inp[32252] = 1073741760; +inp[32253] = 0; +inp[32254] = 1073741759; +inp[32255] = 0; +inp[32256] = 1073741758; +inp[32257] = 0; +inp[32258] = 1073741757; +inp[32259] = 0; +inp[32260] = 1073741756; +inp[32261] = 0; +inp[32262] = 1073741755; +inp[32263] = 0; +inp[32264] = 1073741754; +inp[32265] = 0; +inp[32266] = 1073741753; +inp[32267] = 0; +inp[32268] = 1073741752; +inp[32269] = 0; +inp[32270] = 1073741751; +inp[32271] = 0; +inp[32272] = 1073741750; +inp[32273] = 0; +inp[32274] = 1073741749; +inp[32275] = 0; +inp[32276] = 1073741748; +inp[32277] = 0; +inp[32278] = 1073741747; +inp[32279] = 0; +inp[32280] = 1073741746; +inp[32281] = 0; +inp[32282] = 1073741745; +inp[32283] = 0; +inp[32284] = 1073741744; +inp[32285] = 0; +inp[32286] = 1073741743; +inp[32287] = 0; +inp[32288] = 1073741742; +inp[32289] = 0; +inp[32290] = 1073741741; +inp[32291] = 0; +inp[32292] = 1073741740; +inp[32293] = 0; +inp[32294] = 1073741739; +inp[32295] = 0; +inp[32296] = 1073741738; +inp[32297] = 0; +inp[32298] = 1073741737; +inp[32299] = 0; +inp[32300] = 1073741736; +inp[32301] = 0; +inp[32302] = 1073741735; +inp[32303] = 0; +inp[32304] = 1073741734; +inp[32305] = 0; +inp[32306] = 1073741733; +inp[32307] = 0; +inp[32308] = 1073741732; +inp[32309] = 0; +inp[32310] = 1073741731; +inp[32311] = 0; +inp[32312] = 1073741730; +inp[32313] = 0; +inp[32314] = 1073741729; +inp[32315] = 0; +inp[32316] = 1073741728; +inp[32317] = 0; +inp[32318] = 1073741727; +inp[32319] = 0; +inp[32320] = 1073741726; +inp[32321] = 0; +inp[32322] = 1073741725; +inp[32323] = 0; +inp[32324] = 1073741724; +inp[32325] = 0; +inp[32326] = 1073741723; +inp[32327] = 0; +inp[32328] = 1073741722; +inp[32329] = 0; +inp[32330] = 1073741721; +inp[32331] = 0; +inp[32332] = 1073741720; +inp[32333] = 0; +inp[32334] = 1073741719; +inp[32335] = 0; +inp[32336] = 1073741718; +inp[32337] = 0; +inp[32338] = 1073741717; +inp[32339] = 0; +inp[32340] = 1073741716; +inp[32341] = 0; +inp[32342] = 1073741715; +inp[32343] = 0; +inp[32344] = 1073741714; +inp[32345] = 0; +inp[32346] = 1073741713; +inp[32347] = 0; +inp[32348] = 1073741712; +inp[32349] = 0; +inp[32350] = 1073741711; +inp[32351] = 0; +inp[32352] = 1073741710; +inp[32353] = 0; +inp[32354] = 1073741709; +inp[32355] = 0; +inp[32356] = 1073741708; +inp[32357] = 0; +inp[32358] = 1073741707; +inp[32359] = 0; +inp[32360] = 1073741706; +inp[32361] = 0; +inp[32362] = 1073741705; +inp[32363] = 0; +inp[32364] = 1073741704; +inp[32365] = 0; +inp[32366] = 1073741703; +inp[32367] = 0; +inp[32368] = 1073741702; +inp[32369] = 0; +inp[32370] = 1073741701; +inp[32371] = 0; +inp[32372] = 1073741700; +inp[32373] = 0; +inp[32374] = 1073741699; +inp[32375] = 0; +inp[32376] = 1073741698; +inp[32377] = 0; +inp[32378] = 1073741697; +inp[32379] = 0; +inp[32380] = 1073741696; +inp[32381] = 0; +inp[32382] = 1073741695; +inp[32383] = 0; +inp[32384] = 1073741694; +inp[32385] = 0; +inp[32386] = 1073741693; +inp[32387] = 0; +inp[32388] = 1073741692; +inp[32389] = 0; +inp[32390] = 1073741691; +inp[32391] = 0; +inp[32392] = 1073741690; +inp[32393] = 0; +inp[32394] = 1073741689; +inp[32395] = 0; +inp[32396] = 1073741688; +inp[32397] = 0; +inp[32398] = 1073741687; +inp[32399] = 0; +inp[32400] = 1073741686; +inp[32401] = 0; +inp[32402] = 1073741685; +inp[32403] = 0; +inp[32404] = 1073741684; +inp[32405] = 0; +inp[32406] = 1073741683; +inp[32407] = 0; +inp[32408] = 1073741682; +inp[32409] = 0; +inp[32410] = 1073741681; +inp[32411] = 0; +inp[32412] = 1073741680; +inp[32413] = 0; +inp[32414] = 1073741679; +inp[32415] = 0; +inp[32416] = 1073741678; +inp[32417] = 0; +inp[32418] = 1073741677; +inp[32419] = 0; +inp[32420] = 1073741676; +inp[32421] = 0; +inp[32422] = 1073741675; +inp[32423] = 0; +inp[32424] = 1073741674; +inp[32425] = 0; +inp[32426] = 1073741673; +inp[32427] = 0; +inp[32428] = 1073741672; +inp[32429] = 0; +inp[32430] = 1073741671; +inp[32431] = 0; +inp[32432] = 1073741670; +inp[32433] = 0; +inp[32434] = 1073741669; +inp[32435] = 0; +inp[32436] = 1073741668; +inp[32437] = 0; +inp[32438] = 1073741667; +inp[32439] = 0; +inp[32440] = 1073741666; +inp[32441] = 0; +inp[32442] = 1073741665; +inp[32443] = 0; +inp[32444] = 1073741664; +inp[32445] = 0; +inp[32446] = 1073741663; +inp[32447] = 0; +inp[32448] = 1073741662; +inp[32449] = 0; +inp[32450] = 1073741661; +inp[32451] = 0; +inp[32452] = 1073741660; +inp[32453] = 0; +inp[32454] = 1073741659; +inp[32455] = 0; +inp[32456] = 1073741658; +inp[32457] = 0; +inp[32458] = 1073741657; +inp[32459] = 0; +inp[32460] = 1073741656; +inp[32461] = 0; +inp[32462] = 1073741655; +inp[32463] = 0; +inp[32464] = 1073741654; +inp[32465] = 0; +inp[32466] = 1073741653; +inp[32467] = 0; +inp[32468] = 1073741652; +inp[32469] = 0; +inp[32470] = 1073741651; +inp[32471] = 0; +inp[32472] = 1073741650; +inp[32473] = 0; +inp[32474] = 1073741649; +inp[32475] = 0; +inp[32476] = 1073741648; +inp[32477] = 0; +inp[32478] = 1073741647; +inp[32479] = 0; +inp[32480] = 1073741646; +inp[32481] = 0; +inp[32482] = 1073741645; +inp[32483] = 0; +inp[32484] = 1073741644; +inp[32485] = 0; +inp[32486] = 1073741643; +inp[32487] = 0; +inp[32488] = 1073741642; +inp[32489] = 0; +inp[32490] = 1073741641; +inp[32491] = 0; +inp[32492] = 1073741640; +inp[32493] = 0; +inp[32494] = 1073741639; +inp[32495] = 0; +inp[32496] = 1073741638; +inp[32497] = 0; +inp[32498] = 1073741637; +inp[32499] = 0; +inp[32500] = 1073741636; +inp[32501] = 0; +inp[32502] = 1073741635; +inp[32503] = 0; +inp[32504] = 1073741634; +inp[32505] = 0; +inp[32506] = 1073741633; +inp[32507] = 0; +inp[32508] = 1073741632; +inp[32509] = 0; +inp[32510] = 1073741631; +inp[32511] = 0; +inp[32512] = 1073741630; +inp[32513] = 0; +inp[32514] = 1073741629; +inp[32515] = 0; +inp[32516] = 1073741628; +inp[32517] = 0; +inp[32518] = 1073741627; +inp[32519] = 0; +inp[32520] = 1073741626; +inp[32521] = 0; +inp[32522] = 1073741625; +inp[32523] = 0; +inp[32524] = 1073741624; +inp[32525] = 0; +inp[32526] = 1073741623; +inp[32527] = 0; +inp[32528] = 1073741622; +inp[32529] = 0; +inp[32530] = 1073741621; +inp[32531] = 0; +inp[32532] = 1073741620; +inp[32533] = 0; +inp[32534] = 1073741619; +inp[32535] = 0; +inp[32536] = 1073741618; +inp[32537] = 0; +inp[32538] = 1073741617; +inp[32539] = 0; +inp[32540] = 1073741616; +inp[32541] = 0; +inp[32542] = 1073741615; +inp[32543] = 0; +inp[32544] = 1073741614; +inp[32545] = 0; +inp[32546] = 1073741613; +inp[32547] = 0; +inp[32548] = 1073741612; +inp[32549] = 0; +inp[32550] = 1073741611; +inp[32551] = 0; +inp[32552] = 1073741610; +inp[32553] = 0; +inp[32554] = 1073741609; +inp[32555] = 0; +inp[32556] = 1073741608; +inp[32557] = 0; +inp[32558] = 1073741607; +inp[32559] = 0; +inp[32560] = 1073741606; +inp[32561] = 0; +inp[32562] = 1073741605; +inp[32563] = 0; +inp[32564] = 1073741604; +inp[32565] = 0; +inp[32566] = 1073741603; +inp[32567] = 0; +inp[32568] = 1073741602; +inp[32569] = 0; +inp[32570] = 1073741601; +inp[32571] = 0; +inp[32572] = 1073741600; +inp[32573] = 0; +inp[32574] = 1073741599; +inp[32575] = 0; +inp[32576] = 1073741598; +inp[32577] = 0; +inp[32578] = 1073741597; +inp[32579] = 0; +inp[32580] = 1073741596; +inp[32581] = 0; +inp[32582] = 1073741595; +inp[32583] = 0; +inp[32584] = 1073741594; +inp[32585] = 0; +inp[32586] = 1073741593; +inp[32587] = 0; +inp[32588] = 1073741592; +inp[32589] = 0; +inp[32590] = 1073741591; +inp[32591] = 0; +inp[32592] = 1073741590; +inp[32593] = 0; +inp[32594] = 1073741589; +inp[32595] = 0; +inp[32596] = 1073741588; +inp[32597] = 0; +inp[32598] = 1073741587; +inp[32599] = 0; +inp[32600] = 1073741586; +inp[32601] = 0; +inp[32602] = 1073741585; +inp[32603] = 0; +inp[32604] = 1073741584; +inp[32605] = 0; +inp[32606] = 1073741583; +inp[32607] = 0; +inp[32608] = 1073741582; +inp[32609] = 0; +inp[32610] = 1073741581; +inp[32611] = 0; +inp[32612] = 1073741580; +inp[32613] = 0; +inp[32614] = 1073741579; +inp[32615] = 0; +inp[32616] = 1073741578; +inp[32617] = 0; +inp[32618] = 1073741577; +inp[32619] = 0; +inp[32620] = 1073741576; +inp[32621] = 0; +inp[32622] = 1073741575; +inp[32623] = 0; +inp[32624] = 1073741574; +inp[32625] = 0; +inp[32626] = 1073741573; +inp[32627] = 0; +inp[32628] = 1073741572; +inp[32629] = 0; +inp[32630] = 1073741571; +inp[32631] = 0; +inp[32632] = 1073741570; +inp[32633] = 0; +inp[32634] = 1073741569; +inp[32635] = 0; +inp[32636] = 1073741824; +inp[32637] = 1073741824; +inp[32638] = 1073741823; +inp[32639] = 0; +inp[32640] = 1073741823; +inp[32641] = 0; +inp[32642] = 1073741822; +inp[32643] = 0; +inp[32644] = 1073741822; +inp[32645] = 0; +inp[32646] = 1073741821; +inp[32647] = 0; +inp[32648] = 1073741821; +inp[32649] = 0; +inp[32650] = 1073741820; +inp[32651] = 0; +inp[32652] = 1073741820; +inp[32653] = 0; +inp[32654] = 1073741819; +inp[32655] = 0; +inp[32656] = 1073741819; +inp[32657] = 0; +inp[32658] = 1073741818; +inp[32659] = 0; +inp[32660] = 1073741818; +inp[32661] = 0; +inp[32662] = 1073741817; +inp[32663] = 0; +inp[32664] = 1073741817; +inp[32665] = 0; +inp[32666] = 1073741816; +inp[32667] = 0; +inp[32668] = 1073741816; +inp[32669] = 0; +inp[32670] = 1073741815; +inp[32671] = 0; +inp[32672] = 1073741815; +inp[32673] = 0; +inp[32674] = 1073741814; +inp[32675] = 0; +inp[32676] = 1073741814; +inp[32677] = 0; +inp[32678] = 1073741813; +inp[32679] = 0; +inp[32680] = 1073741813; +inp[32681] = 0; +inp[32682] = 1073741812; +inp[32683] = 0; +inp[32684] = 1073741812; +inp[32685] = 0; +inp[32686] = 1073741811; +inp[32687] = 0; +inp[32688] = 1073741811; +inp[32689] = 0; +inp[32690] = 1073741810; +inp[32691] = 0; +inp[32692] = 1073741810; +inp[32693] = 0; +inp[32694] = 1073741809; +inp[32695] = 0; +inp[32696] = 1073741809; +inp[32697] = 0; +inp[32698] = 1073741808; +inp[32699] = 0; +inp[32700] = 1073741808; +inp[32701] = 0; +inp[32702] = 1073741807; +inp[32703] = 0; +inp[32704] = 1073741807; +inp[32705] = 0; +inp[32706] = 1073741806; +inp[32707] = 0; +inp[32708] = 1073741806; +inp[32709] = 0; +inp[32710] = 1073741805; +inp[32711] = 0; +inp[32712] = 1073741805; +inp[32713] = 0; +inp[32714] = 1073741804; +inp[32715] = 0; +inp[32716] = 1073741804; +inp[32717] = 0; +inp[32718] = 1073741803; +inp[32719] = 0; +inp[32720] = 1073741803; +inp[32721] = 0; +inp[32722] = 1073741802; +inp[32723] = 0; +inp[32724] = 1073741802; +inp[32725] = 0; +inp[32726] = 1073741801; +inp[32727] = 0; +inp[32728] = 1073741801; +inp[32729] = 0; +inp[32730] = 1073741800; +inp[32731] = 0; +inp[32732] = 1073741800; +inp[32733] = 0; +inp[32734] = 1073741799; +inp[32735] = 0; +inp[32736] = 1073741799; +inp[32737] = 0; +inp[32738] = 1073741798; +inp[32739] = 0; +inp[32740] = 1073741798; +inp[32741] = 0; +inp[32742] = 1073741797; +inp[32743] = 0; +inp[32744] = 1073741797; +inp[32745] = 0; +inp[32746] = 1073741796; +inp[32747] = 0; +inp[32748] = 1073741796; +inp[32749] = 0; +inp[32750] = 1073741795; +inp[32751] = 0; +inp[32752] = 1073741795; +inp[32753] = 0; +inp[32754] = 1073741794; +inp[32755] = 0; +inp[32756] = 1073741794; +inp[32757] = 0; +inp[32758] = 1073741793; +inp[32759] = 0; +inp[32760] = 1073741793; +inp[32761] = 0; +inp[32762] = 1073741792; +inp[32763] = 0; +inp[32764] = 1073741792; +inp[32765] = 0; +inp[32766] = 1073741791; +inp[32767] = 0; +inp[32768] = 1073741791; +inp[32769] = 0; +inp[32770] = 1073741790; +inp[32771] = 0; +inp[32772] = 1073741790; +inp[32773] = 0; +inp[32774] = 1073741789; +inp[32775] = 0; +inp[32776] = 1073741789; +inp[32777] = 0; +inp[32778] = 1073741788; +inp[32779] = 0; +inp[32780] = 1073741788; +inp[32781] = 0; +inp[32782] = 1073741787; +inp[32783] = 0; +inp[32784] = 1073741787; +inp[32785] = 0; +inp[32786] = 1073741786; +inp[32787] = 0; +inp[32788] = 1073741786; +inp[32789] = 0; +inp[32790] = 1073741785; +inp[32791] = 0; +inp[32792] = 1073741785; +inp[32793] = 0; +inp[32794] = 1073741784; +inp[32795] = 0; +inp[32796] = 1073741784; +inp[32797] = 0; +inp[32798] = 1073741783; +inp[32799] = 0; +inp[32800] = 1073741783; +inp[32801] = 0; +inp[32802] = 1073741782; +inp[32803] = 0; +inp[32804] = 1073741782; +inp[32805] = 0; +inp[32806] = 1073741781; +inp[32807] = 0; +inp[32808] = 1073741781; +inp[32809] = 0; +inp[32810] = 1073741780; +inp[32811] = 0; +inp[32812] = 1073741780; +inp[32813] = 0; +inp[32814] = 1073741779; +inp[32815] = 0; +inp[32816] = 1073741779; +inp[32817] = 0; +inp[32818] = 1073741778; +inp[32819] = 0; +inp[32820] = 1073741778; +inp[32821] = 0; +inp[32822] = 1073741777; +inp[32823] = 0; +inp[32824] = 1073741777; +inp[32825] = 0; +inp[32826] = 1073741776; +inp[32827] = 0; +inp[32828] = 1073741776; +inp[32829] = 0; +inp[32830] = 1073741775; +inp[32831] = 0; +inp[32832] = 1073741775; +inp[32833] = 0; +inp[32834] = 1073741774; +inp[32835] = 0; +inp[32836] = 1073741774; +inp[32837] = 0; +inp[32838] = 1073741773; +inp[32839] = 0; +inp[32840] = 1073741773; +inp[32841] = 0; +inp[32842] = 1073741772; +inp[32843] = 0; +inp[32844] = 1073741772; +inp[32845] = 0; +inp[32846] = 1073741771; +inp[32847] = 0; +inp[32848] = 1073741771; +inp[32849] = 0; +inp[32850] = 1073741770; +inp[32851] = 0; +inp[32852] = 1073741770; +inp[32853] = 0; +inp[32854] = 1073741769; +inp[32855] = 0; +inp[32856] = 1073741769; +inp[32857] = 0; +inp[32858] = 1073741768; +inp[32859] = 0; +inp[32860] = 1073741768; +inp[32861] = 0; +inp[32862] = 1073741767; +inp[32863] = 0; +inp[32864] = 1073741767; +inp[32865] = 0; +inp[32866] = 1073741766; +inp[32867] = 0; +inp[32868] = 1073741766; +inp[32869] = 0; +inp[32870] = 1073741765; +inp[32871] = 0; +inp[32872] = 1073741765; +inp[32873] = 0; +inp[32874] = 1073741764; +inp[32875] = 0; +inp[32876] = 1073741764; +inp[32877] = 0; +inp[32878] = 1073741763; +inp[32879] = 0; +inp[32880] = 1073741763; +inp[32881] = 0; +inp[32882] = 1073741762; +inp[32883] = 0; +inp[32884] = 1073741762; +inp[32885] = 0; +inp[32886] = 1073741761; +inp[32887] = 0; +inp[32888] = 1073741761; +inp[32889] = 0; +inp[32890] = 1073741760; +inp[32891] = 0; +inp[32892] = 1073741760; +inp[32893] = 0; +inp[32894] = 1073741759; +inp[32895] = 0; +inp[32896] = 1073741759; +inp[32897] = 0; +inp[32898] = 1073741758; +inp[32899] = 0; +inp[32900] = 1073741758; +inp[32901] = 0; +inp[32902] = 1073741757; +inp[32903] = 0; +inp[32904] = 1073741757; +inp[32905] = 0; +inp[32906] = 1073741756; +inp[32907] = 0; +inp[32908] = 1073741756; +inp[32909] = 0; +inp[32910] = 1073741755; +inp[32911] = 0; +inp[32912] = 1073741755; +inp[32913] = 0; +inp[32914] = 1073741754; +inp[32915] = 0; +inp[32916] = 1073741754; +inp[32917] = 0; +inp[32918] = 1073741753; +inp[32919] = 0; +inp[32920] = 1073741753; +inp[32921] = 0; +inp[32922] = 1073741752; +inp[32923] = 0; +inp[32924] = 1073741752; +inp[32925] = 0; +inp[32926] = 1073741751; +inp[32927] = 0; +inp[32928] = 1073741751; +inp[32929] = 0; +inp[32930] = 1073741750; +inp[32931] = 0; +inp[32932] = 1073741750; +inp[32933] = 0; +inp[32934] = 1073741749; +inp[32935] = 0; +inp[32936] = 1073741749; +inp[32937] = 0; +inp[32938] = 1073741748; +inp[32939] = 0; +inp[32940] = 1073741748; +inp[32941] = 0; +inp[32942] = 1073741747; +inp[32943] = 0; +inp[32944] = 1073741747; +inp[32945] = 0; +inp[32946] = 1073741746; +inp[32947] = 0; +inp[32948] = 1073741746; +inp[32949] = 0; +inp[32950] = 1073741745; +inp[32951] = 0; +inp[32952] = 1073741745; +inp[32953] = 0; +inp[32954] = 1073741744; +inp[32955] = 0; +inp[32956] = 1073741744; +inp[32957] = 0; +inp[32958] = 1073741743; +inp[32959] = 0; +inp[32960] = 1073741743; +inp[32961] = 0; +inp[32962] = 1073741742; +inp[32963] = 0; +inp[32964] = 1073741742; +inp[32965] = 0; +inp[32966] = 1073741741; +inp[32967] = 0; +inp[32968] = 1073741741; +inp[32969] = 0; +inp[32970] = 1073741740; +inp[32971] = 0; +inp[32972] = 1073741740; +inp[32973] = 0; +inp[32974] = 1073741739; +inp[32975] = 0; +inp[32976] = 1073741739; +inp[32977] = 0; +inp[32978] = 1073741738; +inp[32979] = 0; +inp[32980] = 1073741738; +inp[32981] = 0; +inp[32982] = 1073741737; +inp[32983] = 0; +inp[32984] = 1073741737; +inp[32985] = 0; +inp[32986] = 1073741736; +inp[32987] = 0; +inp[32988] = 1073741736; +inp[32989] = 0; +inp[32990] = 1073741735; +inp[32991] = 0; +inp[32992] = 1073741735; +inp[32993] = 0; +inp[32994] = 1073741734; +inp[32995] = 0; +inp[32996] = 1073741734; +inp[32997] = 0; +inp[32998] = 1073741733; +inp[32999] = 0; +inp[33000] = 1073741733; +inp[33001] = 0; +inp[33002] = 1073741732; +inp[33003] = 0; +inp[33004] = 1073741732; +inp[33005] = 0; +inp[33006] = 1073741731; +inp[33007] = 0; +inp[33008] = 1073741731; +inp[33009] = 0; +inp[33010] = 1073741730; +inp[33011] = 0; +inp[33012] = 1073741730; +inp[33013] = 0; +inp[33014] = 1073741729; +inp[33015] = 0; +inp[33016] = 1073741729; +inp[33017] = 0; +inp[33018] = 1073741728; +inp[33019] = 0; +inp[33020] = 1073741728; +inp[33021] = 0; +inp[33022] = 1073741727; +inp[33023] = 0; +inp[33024] = 1073741727; +inp[33025] = 0; +inp[33026] = 1073741726; +inp[33027] = 0; +inp[33028] = 1073741726; +inp[33029] = 0; +inp[33030] = 1073741725; +inp[33031] = 0; +inp[33032] = 1073741725; +inp[33033] = 0; +inp[33034] = 1073741724; +inp[33035] = 0; +inp[33036] = 1073741724; +inp[33037] = 0; +inp[33038] = 1073741723; +inp[33039] = 0; +inp[33040] = 1073741723; +inp[33041] = 0; +inp[33042] = 1073741722; +inp[33043] = 0; +inp[33044] = 1073741722; +inp[33045] = 0; +inp[33046] = 1073741721; +inp[33047] = 0; +inp[33048] = 1073741721; +inp[33049] = 0; +inp[33050] = 1073741720; +inp[33051] = 0; +inp[33052] = 1073741720; +inp[33053] = 0; +inp[33054] = 1073741719; +inp[33055] = 0; +inp[33056] = 1073741719; +inp[33057] = 0; +inp[33058] = 1073741718; +inp[33059] = 0; +inp[33060] = 1073741718; +inp[33061] = 0; +inp[33062] = 1073741717; +inp[33063] = 0; +inp[33064] = 1073741717; +inp[33065] = 0; +inp[33066] = 1073741716; +inp[33067] = 0; +inp[33068] = 1073741716; +inp[33069] = 0; +inp[33070] = 1073741715; +inp[33071] = 0; +inp[33072] = 1073741715; +inp[33073] = 0; +inp[33074] = 1073741714; +inp[33075] = 0; +inp[33076] = 1073741714; +inp[33077] = 0; +inp[33078] = 1073741713; +inp[33079] = 0; +inp[33080] = 1073741713; +inp[33081] = 0; +inp[33082] = 1073741712; +inp[33083] = 0; +inp[33084] = 1073741712; +inp[33085] = 0; +inp[33086] = 1073741711; +inp[33087] = 0; +inp[33088] = 1073741711; +inp[33089] = 0; +inp[33090] = 1073741710; +inp[33091] = 0; +inp[33092] = 1073741710; +inp[33093] = 0; +inp[33094] = 1073741709; +inp[33095] = 0; +inp[33096] = 1073741709; +inp[33097] = 0; +inp[33098] = 1073741708; +inp[33099] = 0; +inp[33100] = 1073741708; +inp[33101] = 0; +inp[33102] = 1073741707; +inp[33103] = 0; +inp[33104] = 1073741707; +inp[33105] = 0; +inp[33106] = 1073741706; +inp[33107] = 0; +inp[33108] = 1073741706; +inp[33109] = 0; +inp[33110] = 1073741705; +inp[33111] = 0; +inp[33112] = 1073741705; +inp[33113] = 0; +inp[33114] = 1073741704; +inp[33115] = 0; +inp[33116] = 1073741704; +inp[33117] = 0; +inp[33118] = 1073741703; +inp[33119] = 0; +inp[33120] = 1073741703; +inp[33121] = 0; +inp[33122] = 1073741702; +inp[33123] = 0; +inp[33124] = 1073741702; +inp[33125] = 0; +inp[33126] = 1073741701; +inp[33127] = 0; +inp[33128] = 1073741701; +inp[33129] = 0; +inp[33130] = 1073741700; +inp[33131] = 0; +inp[33132] = 1073741700; +inp[33133] = 0; +inp[33134] = 1073741699; +inp[33135] = 0; +inp[33136] = 1073741699; +inp[33137] = 0; +inp[33138] = 1073741698; +inp[33139] = 0; +inp[33140] = 1073741698; +inp[33141] = 0; +inp[33142] = 1073741697; +inp[33143] = 0; +inp[33144] = 1073741697; +inp[33145] = 0; +inp[33146] = 1073741696; +inp[33147] = 0; +inp[33148] = 1073741824; +inp[33149] = 1073741824; +inp[33150] = 1073741823; +inp[33151] = 0; +inp[33152] = 1073741823; +inp[33153] = 0; +inp[33154] = 1073741823; +inp[33155] = 0; +inp[33156] = 1073741823; +inp[33157] = 0; +inp[33158] = 1073741822; +inp[33159] = 0; +inp[33160] = 1073741822; +inp[33161] = 0; +inp[33162] = 1073741822; +inp[33163] = 0; +inp[33164] = 1073741822; +inp[33165] = 0; +inp[33166] = 1073741821; +inp[33167] = 0; +inp[33168] = 1073741821; +inp[33169] = 0; +inp[33170] = 1073741821; +inp[33171] = 0; +inp[33172] = 1073741821; +inp[33173] = 0; +inp[33174] = 1073741820; +inp[33175] = 0; +inp[33176] = 1073741820; +inp[33177] = 0; +inp[33178] = 1073741820; +inp[33179] = 0; +inp[33180] = 1073741820; +inp[33181] = 0; +inp[33182] = 1073741819; +inp[33183] = 0; +inp[33184] = 1073741819; +inp[33185] = 0; +inp[33186] = 1073741819; +inp[33187] = 0; +inp[33188] = 1073741819; +inp[33189] = 0; +inp[33190] = 1073741818; +inp[33191] = 0; +inp[33192] = 1073741818; +inp[33193] = 0; +inp[33194] = 1073741818; +inp[33195] = 0; +inp[33196] = 1073741818; +inp[33197] = 0; +inp[33198] = 1073741817; +inp[33199] = 0; +inp[33200] = 1073741817; +inp[33201] = 0; +inp[33202] = 1073741817; +inp[33203] = 0; +inp[33204] = 1073741817; +inp[33205] = 0; +inp[33206] = 1073741816; +inp[33207] = 0; +inp[33208] = 1073741816; +inp[33209] = 0; +inp[33210] = 1073741816; +inp[33211] = 0; +inp[33212] = 1073741816; +inp[33213] = 0; +inp[33214] = 1073741815; +inp[33215] = 0; +inp[33216] = 1073741815; +inp[33217] = 0; +inp[33218] = 1073741815; +inp[33219] = 0; +inp[33220] = 1073741815; +inp[33221] = 0; +inp[33222] = 1073741814; +inp[33223] = 0; +inp[33224] = 1073741814; +inp[33225] = 0; +inp[33226] = 1073741814; +inp[33227] = 0; +inp[33228] = 1073741814; +inp[33229] = 0; +inp[33230] = 1073741813; +inp[33231] = 0; +inp[33232] = 1073741813; +inp[33233] = 0; +inp[33234] = 1073741813; +inp[33235] = 0; +inp[33236] = 1073741813; +inp[33237] = 0; +inp[33238] = 1073741812; +inp[33239] = 0; +inp[33240] = 1073741812; +inp[33241] = 0; +inp[33242] = 1073741812; +inp[33243] = 0; +inp[33244] = 1073741812; +inp[33245] = 0; +inp[33246] = 1073741811; +inp[33247] = 0; +inp[33248] = 1073741811; +inp[33249] = 0; +inp[33250] = 1073741811; +inp[33251] = 0; +inp[33252] = 1073741811; +inp[33253] = 0; +inp[33254] = 1073741810; +inp[33255] = 0; +inp[33256] = 1073741810; +inp[33257] = 0; +inp[33258] = 1073741810; +inp[33259] = 0; +inp[33260] = 1073741810; +inp[33261] = 0; +inp[33262] = 1073741809; +inp[33263] = 0; +inp[33264] = 1073741809; +inp[33265] = 0; +inp[33266] = 1073741809; +inp[33267] = 0; +inp[33268] = 1073741809; +inp[33269] = 0; +inp[33270] = 1073741808; +inp[33271] = 0; +inp[33272] = 1073741808; +inp[33273] = 0; +inp[33274] = 1073741808; +inp[33275] = 0; +inp[33276] = 1073741808; +inp[33277] = 0; +inp[33278] = 1073741807; +inp[33279] = 0; +inp[33280] = 1073741807; +inp[33281] = 0; +inp[33282] = 1073741807; +inp[33283] = 0; +inp[33284] = 1073741807; +inp[33285] = 0; +inp[33286] = 1073741806; +inp[33287] = 0; +inp[33288] = 1073741806; +inp[33289] = 0; +inp[33290] = 1073741806; +inp[33291] = 0; +inp[33292] = 1073741806; +inp[33293] = 0; +inp[33294] = 1073741805; +inp[33295] = 0; +inp[33296] = 1073741805; +inp[33297] = 0; +inp[33298] = 1073741805; +inp[33299] = 0; +inp[33300] = 1073741805; +inp[33301] = 0; +inp[33302] = 1073741804; +inp[33303] = 0; +inp[33304] = 1073741804; +inp[33305] = 0; +inp[33306] = 1073741804; +inp[33307] = 0; +inp[33308] = 1073741804; +inp[33309] = 0; +inp[33310] = 1073741803; +inp[33311] = 0; +inp[33312] = 1073741803; +inp[33313] = 0; +inp[33314] = 1073741803; +inp[33315] = 0; +inp[33316] = 1073741803; +inp[33317] = 0; +inp[33318] = 1073741802; +inp[33319] = 0; +inp[33320] = 1073741802; +inp[33321] = 0; +inp[33322] = 1073741802; +inp[33323] = 0; +inp[33324] = 1073741802; +inp[33325] = 0; +inp[33326] = 1073741801; +inp[33327] = 0; +inp[33328] = 1073741801; +inp[33329] = 0; +inp[33330] = 1073741801; +inp[33331] = 0; +inp[33332] = 1073741801; +inp[33333] = 0; +inp[33334] = 1073741800; +inp[33335] = 0; +inp[33336] = 1073741800; +inp[33337] = 0; +inp[33338] = 1073741800; +inp[33339] = 0; +inp[33340] = 1073741800; +inp[33341] = 0; +inp[33342] = 1073741799; +inp[33343] = 0; +inp[33344] = 1073741799; +inp[33345] = 0; +inp[33346] = 1073741799; +inp[33347] = 0; +inp[33348] = 1073741799; +inp[33349] = 0; +inp[33350] = 1073741798; +inp[33351] = 0; +inp[33352] = 1073741798; +inp[33353] = 0; +inp[33354] = 1073741798; +inp[33355] = 0; +inp[33356] = 1073741798; +inp[33357] = 0; +inp[33358] = 1073741797; +inp[33359] = 0; +inp[33360] = 1073741797; +inp[33361] = 0; +inp[33362] = 1073741797; +inp[33363] = 0; +inp[33364] = 1073741797; +inp[33365] = 0; +inp[33366] = 1073741796; +inp[33367] = 0; +inp[33368] = 1073741796; +inp[33369] = 0; +inp[33370] = 1073741796; +inp[33371] = 0; +inp[33372] = 1073741796; +inp[33373] = 0; +inp[33374] = 1073741795; +inp[33375] = 0; +inp[33376] = 1073741795; +inp[33377] = 0; +inp[33378] = 1073741795; +inp[33379] = 0; +inp[33380] = 1073741795; +inp[33381] = 0; +inp[33382] = 1073741794; +inp[33383] = 0; +inp[33384] = 1073741794; +inp[33385] = 0; +inp[33386] = 1073741794; +inp[33387] = 0; +inp[33388] = 1073741794; +inp[33389] = 0; +inp[33390] = 1073741793; +inp[33391] = 0; +inp[33392] = 1073741793; +inp[33393] = 0; +inp[33394] = 1073741793; +inp[33395] = 0; +inp[33396] = 1073741793; +inp[33397] = 0; +inp[33398] = 1073741792; +inp[33399] = 0; +inp[33400] = 1073741792; +inp[33401] = 0; +inp[33402] = 1073741792; +inp[33403] = 0; +inp[33404] = 1073741792; +inp[33405] = 0; +inp[33406] = 1073741791; +inp[33407] = 0; +inp[33408] = 1073741791; +inp[33409] = 0; +inp[33410] = 1073741791; +inp[33411] = 0; +inp[33412] = 1073741791; +inp[33413] = 0; +inp[33414] = 1073741790; +inp[33415] = 0; +inp[33416] = 1073741790; +inp[33417] = 0; +inp[33418] = 1073741790; +inp[33419] = 0; +inp[33420] = 1073741790; +inp[33421] = 0; +inp[33422] = 1073741789; +inp[33423] = 0; +inp[33424] = 1073741789; +inp[33425] = 0; +inp[33426] = 1073741789; +inp[33427] = 0; +inp[33428] = 1073741789; +inp[33429] = 0; +inp[33430] = 1073741788; +inp[33431] = 0; +inp[33432] = 1073741788; +inp[33433] = 0; +inp[33434] = 1073741788; +inp[33435] = 0; +inp[33436] = 1073741788; +inp[33437] = 0; +inp[33438] = 1073741787; +inp[33439] = 0; +inp[33440] = 1073741787; +inp[33441] = 0; +inp[33442] = 1073741787; +inp[33443] = 0; +inp[33444] = 1073741787; +inp[33445] = 0; +inp[33446] = 1073741786; +inp[33447] = 0; +inp[33448] = 1073741786; +inp[33449] = 0; +inp[33450] = 1073741786; +inp[33451] = 0; +inp[33452] = 1073741786; +inp[33453] = 0; +inp[33454] = 1073741785; +inp[33455] = 0; +inp[33456] = 1073741785; +inp[33457] = 0; +inp[33458] = 1073741785; +inp[33459] = 0; +inp[33460] = 1073741785; +inp[33461] = 0; +inp[33462] = 1073741784; +inp[33463] = 0; +inp[33464] = 1073741784; +inp[33465] = 0; +inp[33466] = 1073741784; +inp[33467] = 0; +inp[33468] = 1073741784; +inp[33469] = 0; +inp[33470] = 1073741783; +inp[33471] = 0; +inp[33472] = 1073741783; +inp[33473] = 0; +inp[33474] = 1073741783; +inp[33475] = 0; +inp[33476] = 1073741783; +inp[33477] = 0; +inp[33478] = 1073741782; +inp[33479] = 0; +inp[33480] = 1073741782; +inp[33481] = 0; +inp[33482] = 1073741782; +inp[33483] = 0; +inp[33484] = 1073741782; +inp[33485] = 0; +inp[33486] = 1073741781; +inp[33487] = 0; +inp[33488] = 1073741781; +inp[33489] = 0; +inp[33490] = 1073741781; +inp[33491] = 0; +inp[33492] = 1073741781; +inp[33493] = 0; +inp[33494] = 1073741780; +inp[33495] = 0; +inp[33496] = 1073741780; +inp[33497] = 0; +inp[33498] = 1073741780; +inp[33499] = 0; +inp[33500] = 1073741780; +inp[33501] = 0; +inp[33502] = 1073741779; +inp[33503] = 0; +inp[33504] = 1073741779; +inp[33505] = 0; +inp[33506] = 1073741779; +inp[33507] = 0; +inp[33508] = 1073741779; +inp[33509] = 0; +inp[33510] = 1073741778; +inp[33511] = 0; +inp[33512] = 1073741778; +inp[33513] = 0; +inp[33514] = 1073741778; +inp[33515] = 0; +inp[33516] = 1073741778; +inp[33517] = 0; +inp[33518] = 1073741777; +inp[33519] = 0; +inp[33520] = 1073741777; +inp[33521] = 0; +inp[33522] = 1073741777; +inp[33523] = 0; +inp[33524] = 1073741777; +inp[33525] = 0; +inp[33526] = 1073741776; +inp[33527] = 0; +inp[33528] = 1073741776; +inp[33529] = 0; +inp[33530] = 1073741776; +inp[33531] = 0; +inp[33532] = 1073741776; +inp[33533] = 0; +inp[33534] = 1073741775; +inp[33535] = 0; +inp[33536] = 1073741775; +inp[33537] = 0; +inp[33538] = 1073741775; +inp[33539] = 0; +inp[33540] = 1073741775; +inp[33541] = 0; +inp[33542] = 1073741774; +inp[33543] = 0; +inp[33544] = 1073741774; +inp[33545] = 0; +inp[33546] = 1073741774; +inp[33547] = 0; +inp[33548] = 1073741774; +inp[33549] = 0; +inp[33550] = 1073741773; +inp[33551] = 0; +inp[33552] = 1073741773; +inp[33553] = 0; +inp[33554] = 1073741773; +inp[33555] = 0; +inp[33556] = 1073741773; +inp[33557] = 0; +inp[33558] = 1073741772; +inp[33559] = 0; +inp[33560] = 1073741772; +inp[33561] = 0; +inp[33562] = 1073741772; +inp[33563] = 0; +inp[33564] = 1073741772; +inp[33565] = 0; +inp[33566] = 1073741771; +inp[33567] = 0; +inp[33568] = 1073741771; +inp[33569] = 0; +inp[33570] = 1073741771; +inp[33571] = 0; +inp[33572] = 1073741771; +inp[33573] = 0; +inp[33574] = 1073741770; +inp[33575] = 0; +inp[33576] = 1073741770; +inp[33577] = 0; +inp[33578] = 1073741770; +inp[33579] = 0; +inp[33580] = 1073741770; +inp[33581] = 0; +inp[33582] = 1073741769; +inp[33583] = 0; +inp[33584] = 1073741769; +inp[33585] = 0; +inp[33586] = 1073741769; +inp[33587] = 0; +inp[33588] = 1073741769; +inp[33589] = 0; +inp[33590] = 1073741768; +inp[33591] = 0; +inp[33592] = 1073741768; +inp[33593] = 0; +inp[33594] = 1073741768; +inp[33595] = 0; +inp[33596] = 1073741768; +inp[33597] = 0; +inp[33598] = 1073741767; +inp[33599] = 0; +inp[33600] = 1073741767; +inp[33601] = 0; +inp[33602] = 1073741767; +inp[33603] = 0; +inp[33604] = 1073741767; +inp[33605] = 0; +inp[33606] = 1073741766; +inp[33607] = 0; +inp[33608] = 1073741766; +inp[33609] = 0; +inp[33610] = 1073741766; +inp[33611] = 0; +inp[33612] = 1073741766; +inp[33613] = 0; +inp[33614] = 1073741765; +inp[33615] = 0; +inp[33616] = 1073741765; +inp[33617] = 0; +inp[33618] = 1073741765; +inp[33619] = 0; +inp[33620] = 1073741765; +inp[33621] = 0; +inp[33622] = 1073741764; +inp[33623] = 0; +inp[33624] = 1073741764; +inp[33625] = 0; +inp[33626] = 1073741764; +inp[33627] = 0; +inp[33628] = 1073741764; +inp[33629] = 0; +inp[33630] = 1073741763; +inp[33631] = 0; +inp[33632] = 1073741763; +inp[33633] = 0; +inp[33634] = 1073741763; +inp[33635] = 0; +inp[33636] = 1073741763; +inp[33637] = 0; +inp[33638] = 1073741762; +inp[33639] = 0; +inp[33640] = 1073741762; +inp[33641] = 0; +inp[33642] = 1073741762; +inp[33643] = 0; +inp[33644] = 1073741762; +inp[33645] = 0; +inp[33646] = 1073741761; +inp[33647] = 0; +inp[33648] = 1073741761; +inp[33649] = 0; +inp[33650] = 1073741761; +inp[33651] = 0; +inp[33652] = 1073741761; +inp[33653] = 0; +inp[33654] = 1073741760; +inp[33655] = 0; +inp[33656] = 1073741760; +inp[33657] = 0; +inp[33658] = 1073741760; +inp[33659] = 0; +} + +(* <><><><><><> Auto-generated code end <><><><><><> *) + +(* <><><><><><><><>< *) +(* Library functions *) +(* <><><><><><><><>< *) + +(* All secret variables will have type int32_al and all public ones will be int32_pl. bwA will be bitwidth of variable A which is substitution *) +(* of TypeA and so on for B and C. bwTemp is the bitwidth of intermediate computation and is substitute for TypeTemp. *) + +(* x should be a power of 2 *) +def int32_pl log(int32_pl x) +{ + for i=[0:64] + { + if ((1 << i) == x) + { + return i; + }; + }; +} + +def int32_pl ceillog(int32_pl x) +{ + for i=[0:65] + { + if ((1 << i) >= x) + { + return i; + }; + }; +} + +def int32_pl ceildiv(int32_pl a, int32_pl b) +{ + int32_pl rem = a % b; + int32_pl ret = a / b; + if (((2*rem)/b) >= 1) + { + ret = ret + 1; + }; + return ret; +} + +(* If number from MSB to LSB is 00110001, then output can be 00100000 as a one-hot vector *) +def void msnzbgetvec(int32_pl NUMBITS, int32_pl batch, int32_al[batch] inp, int32_al[batch*NUMBITS] out) +{ + int32_al left; + int32_al right; + int32_al temp; + + for i=[0:batch] + { + out[i] = 0; + for j=[0:NUMBITS] + { + left = (1<<(NUMBITS-1-j)); + right = ((1<<(NUMBITS-j)) - 1); + temp = inp[i]; + out[i*NUMBITS + j] = ((temp >= left) && (temp <= right))?(1):0; + }; + }; +} + +(* If number from MSB to LSB is 00110001, then output is 5 *) +def void msnzb(int32_pl NUMBITS, int32_pl batch, int32_al[batch] inp, int32_al[batch] out) +{ + int32_al left; + int32_al right; + int32_al temp; + + for i=[0:batch] + { + out[i] = 0; + for j=[0:NUMBITS] + { + left = (1<= left) && (temp <= right))?(j+0):(out[i]); + }; + }; +} + +(* MSB to LSB. MSB at index 0 *) +def void BitDecompose(int32_pl NUMBITS, int32_pl batch, int32_al[batch] inp, int32_al[batch*NUMBITS] outBits) +{ + bool_bl muxCondition; + for i=[0:batch] + { + for j=[0:NUMBITS] + { + muxCondition = ((inp[i] & (1<<(NUMBITS-1-j))) == (1<<(NUMBITS-1-j))); + outBits[i*NUMBITS + j] = (muxCondition)?1:0; + }; + }; +} + +(* Input a linear array of 2^LUTBITS elements *) +def void LookUpTableArithmeticMUX(int32_pl LUTBITS, int32_pl batch, int32_pl[1<= m *) + int32_pl[1<<(LUTBITS+2)] LUT; + int32_pl[1<> (bwA - 2 - m)) & mMask); + (* TODO call the batched version instead *) + LookUpTableArithmeticMUX(m, 1, LUTPar0, Am, YPar0); + LookUpTableArithmeticMUX(m, 1, LUTPar1, Am, YPar1); + muxCondition = (expParity == 1); + Y = muxCondition?YPar1[0]:YPar0[0]; + (* Ideally we wanted to multiply by 2 when parity is 1, but rather we divide by 2 when parity is 0 and decrease scale by 1 simultaneously. *) + X = muxCondition?shiftedA:(shiftedA >> 1); + (* Scale of XPrev is: (bwA - 3) + (m + 1) = bwA + m - 2 *) + + XPrev = (X * Y); + (* make scale = sB *) + if ((bwA + m - 2) > sB) + { + XPrev = XPrev >> (bwA + m - 2 - sB); + } + else + { + XPrev = XPrev << (-1*(bwA + m - 2 - sB)); + }; + + BPrev = X; + (* make scale = sB *) + if ((bwA - 3) > sB) + { + BPrev = BPrev >> (bwA - 3 - sB); + } + else + { + BPrev = BPrev << (-1*(bwA - 3 - sB)); + }; + + (* scale = m *) + YPrev = Y; + + (* Run iterations now *) + for j=[0:iter] + { + YSquare = YPrev * YPrev; + if (j == 0) + { + YSquare = YSquare << (sB - (2*(m+1))); + } + else + { + YSquare = YSquare >> (sB + 2); + }; + BCur = BPrev * YSquare; + BCur = BCur >> sB; + YCur = (((1 << (sB+1))*3)/2) - BCur; + XCur = XPrev * YCur; + XCur = XCur >> (sB+1); + XPrev = XCur; + BPrev = BCur; + YPrev = YCur; + }; + + B[i] = (XCur * sqrtAdjust); + B[i] = ((B[i]) >> sqrtAdjustScale) & bMask; + }; +} + +def void div(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl sC, int32_pl bwA, int32_pl bwB, int32_pl bwC, int32_al[size] A, int32_al[size] B, int32_al[size] C) +{ + int32_pl m; + int32_pl temp; + int32_pl iter; + + if (sC <= 18) + { + m = ceildiv((sC-2), 2); + iter = 1; + } + else + { + temp = ceildiv(sC, 2); + m = ceildiv((temp-2), 2); + iter = 2; + }; + + int32_pl mMask = (1 << m) - 1; + int32_pl cMask = (1 << bwC) - 1; + int32_pl sMinusmMask = (1 << (sB-m)) - 1; + + (* Assumption: LUTBITS >= m *) + int32_pl[1<<(LUTBITS+2)] LUT; + int32_pl[1<> (sB - m)) & mMask; + + (* A0 scale = m+3 *) + (* A1 scale = 2m+2 *) + (* TODO call the batched version instead *) + LookUpTableArithmeticMUX(m, 1, LUTA0, Bm, A0); + LookUpTableArithmeticMUX(m, 1, LUTA1, Bm, A1); + + (* Q scale = sB *) + Q = B[i] & sMinusmMask; + + (* A0Q scale = m+3+sB *) + A0Q = (A0[0]) * Q; + + (* Reciprocal Approximation of B with precision sC *) + (* First make scale of A1 same as A0Q *) + Y = (((A1[0]) << (sB + 1 - m)) -_al A0Q) >> (sB + m + 3 - sC); + + e = (B[i] * Y) >> sB; + (* e0 = 2-e *) + e0 = (1 << (sC + 1)) - e; + a0 = (A[i] * Y) >> sA; + C[i] = (a0 * e0) >> sC; + C[i] = (C[i]) & cMask; + }; +} + +def void exp(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_al[size] A, int32_al[size] B) +{ + int32_pl sDemote = log(demote); + int32_pl digitSize = LUTBITS; + int32_pl numDigits = ceildiv(bwA, digitSize); + int32_pl lastDigitSize = bwA % digitSize; + int32_pl digitMask; + int32_pl m = digitSize; + int32_pl maxScale = 32; + (* Assumption: LUTBITS >= m *) + int32_pl LUTOffset = 0; + for i=[1:m] + { + LUTOffset = LUTOffset + ((maxScale+1)*(1<> (j*digitSize)) & digitMask; + Adigit[0] = Adigits[j]; + curScale = sA - (digitSize*j); + if (curScale < 0){ + negScale = 1; + } + else{ + negScale = 0; + }; + for k=[0:(1<> (30-sB); + }; + + (* TODO call the batched version instead *) + LookUpTableArithmeticMUX(m, 1, LUTA, Adigit, A0); + Adigits[j] = A0[0]; + }; + + int32_pl jvar = 1; + int32_pl kvar = 0; + + for j=[1:numDigits] + { + if (jvar < numDigits) + { + kvar = 0; + for k=[0:numDigits] + { + if ((kvar+jvar) < numDigits) + { + if ((kvar) < numDigits) + { + Adigits[kvar] = (Adigits[kvar+jvar] * Adigits[kvar]) >> sB; + }; + }; + if ((kvar) < numDigits) + { + kvar = kvar + (2*jvar); + }; + }; + jvar = jvar*2; + }; + }; + B[i] = Adigits[0] >> sDemote; + B[i] = (B[i]) & bMask; + + }; + +} + +def void SigmoidImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_al[size] A, int32_al[size] B) +{ + int32_al[size] negA; + int32_al[size] expNegA; + int32_al[size] sigNegA; + int32_al[size] den; + int32_al[size] all1; + for i=[0:(size)] + { + negA[i] = ((A[i])<0)?_bl(A[i]):((-1)*(A[i])); + }; + + exp(LUTBITS, size, sA, sB, 1, bwA, 32, negA, expNegA); + + for i=[0:(size)] + { + den[i] = ((expNegA[i]) == (1<= 0)?_bl(sigNegA[i]):(((expNegA[i]) * (sigNegA[i])) >> sB); + }; +} + +def void TanhImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_al[size] A, int32_al[size] B) +{ + int32_al[size] negA; + int32_al[size] expNeg2A; + int32_al[size] tanhNegA; + int32_al[size] den; + int32_al[size] num; + + for i=[0:(size)] + { + negA[i] = ((A[i])<0)?_bl(A[i]):((-1)*(A[i])); + }; + + exp(LUTBITS, size, sA - 1, sB, 1, bwA, bwB, negA, expNeg2A); + + for i=[0:(size)] + { + den[i] = ((expNeg2A[i]) == (1<= 0)?_bl(tanhNegA[i]):((-1) * (tanhNegA[i])); + }; +} + +(* <><><><><><><><>< *) +(* Lib functions end *) +(* <><><><><><><><>< *) + + + (**************************) def void ScaleUp(int32_pl s1, int32_al[s1] arr, int32_pl sf) { diff --git a/Athos/TFEzPCLibrary/Library32_sci.ezpc b/Athos/TFEzPCLibrary/Library32_sci.ezpc index 8d6197f7..f2510253 100644 --- a/Athos/TFEzPCLibrary/Library32_sci.ezpc +++ b/Athos/TFEzPCLibrary/Library32_sci.ezpc @@ -124,3 +124,21 @@ extern void ConvTranspose3DWrapper(int32_pl N, int32_pl DPrime, int32_pl HPrime, int32_al[N][DPrime][HPrime][WPrime][CI] inputArr, int32_al[FD][FH][FW][CO][CI] filterArr, int32_al[N][D][H][W][CO] outArr); + +extern void TanH(int32_pl one, int32_pl size, int32_pl scaleIn, int32_pl scaleOut, int32_pl bwA, int32_pl bwB, int32_al[size] A, int32_al[size] B); + +def void TanhImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_al[size] A, int32_al[size] B) { + TanH(1, size, sA, sB, bwA, bwB, A, B); +} + +extern void Sigmoid(int32_pl one, int32_pl size, int32_pl scaleIn, int32_pl scaleOut, int32_pl bwA, int32_pl bwB, int32_al[size] A, int32_al[size] B); + +def void SigmoidImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_al[size] A, int32_al[size] B) { + Sigmoid(1, size, sA, sB, bwA, bwB, A, B); +} + +extern void Sqrt(int32_pl one, int32_pl size, int32_pl scaleIn, int32_pl scaleOut, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_al[size] A, int32_al[size] B); + +def void SqrtImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_al[size] A, int32_al[size] B) { + Sqrt(1, size, sA, sB, bwA, bwB, inverse, A, B); +} diff --git a/Athos/TFEzPCLibrary/Library64_common.ezpc b/Athos/TFEzPCLibrary/Library64_common.ezpc index d276e2ad..ac86a37c 100644 --- a/Athos/TFEzPCLibrary/Library64_common.ezpc +++ b/Athos/TFEzPCLibrary/Library64_common.ezpc @@ -1599,6 +1599,11 @@ def void ArgMax3(int32_pl outs1, int32_pl outs2, int32_pl outs3, } (**************************) +def void Relu1(int32_pl s1, int64_al[s1] inArr, int64_al[s1] outArr, int32_pl sf, bool_pl doTruncation) +{ + Relu(s1, inArr, outArr, sf, doTruncation); +} + def void Relu2(int32_pl s1, int32_pl s2, int64_al[s1][s2] inArr, int64_al[s1][s2] outArr, int32_pl sf, bool_pl doTruncation) { int32_pl size = s1*s2; @@ -1939,3 +1944,223 @@ def void ScaleDown5(int32_pl s1, int32_pl s2, int32_pl s3, int32_pl s4, int32_pl ClearMemSecret1(size, reshapedArr); } + + +(* Non linear (OT only) functionalities *) + +def void Tanh1(int32_pl s1, int64_al[s1] inp, int64_al[s1] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + TanhImpl(LUTBITS, s1, sA, sB, bwA, bwB, inp, out); +} + +def void Tanh2(int32_pl s1, int32_pl s2, int64_al[s1][s2] inp, int64_al[s1][s2] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2; + int64_al[size] inpCopy; + int64_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + inpCopy[i*s1 + j] = inp[i][j]; + }; + }; + + TanhImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + out[i][j] = outCopy[i*s2 + j]; + }; + }; +} + +def void Tanh3(int32_pl s1, int32_pl s2, int32_pl s3, int64_al[s1][s2][s3] inp, int64_al[s1][s2][s3] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3; + int64_al[size] inpCopy; + int64_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + inpCopy[i*s2*s3 + j*s3 + k] = inp[i][j][k]; + }; + }; + }; + + TanhImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + out[i][j][k] = outCopy[i*s2*s3 + j*s3 + k]; + }; + }; + }; +} + +def void Tanh4(int32_pl s1, int32_pl s2, int32_pl s3, int32_pl s4, int64_al[s1][s2][s3][s4] inp, int64_al[s1][s2][s3][s4] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3 * s4; + int64_al[size] inpCopy; + int64_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l] = inp[i][j][k][l]; + }; + }; + }; + }; + + TanhImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + out[i][j][k][l] = inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l]; + }; + }; + }; + }; +} +def void Sigmoid1(int32_pl s1, int64_al[s1] inp, int64_al[s1] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + SigmoidImpl(LUTBITS, s1, sA, sB, bwA, bwB, inp, out); +} + +def void Sigmoid2(int32_pl s1, int32_pl s2, int64_al[s1][s2] inp, int64_al[s1][s2] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2; + int64_al[size] inpCopy; + int64_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + inpCopy[i*s1 + j] = inp[i][j]; + }; + }; + + SigmoidImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + out[i][j] = outCopy[i*s2 + j]; + }; + }; +} + +def void Sigmoid3(int32_pl s1, int32_pl s2, int32_pl s3, int64_al[s1][s2][s3] inp, int64_al[s1][s2][s3] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3; + int64_al[size] inpCopy; + int64_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + inpCopy[i*s2*s3 + j*s3 + k] = inp[i][j][k]; + }; + }; + }; + + SigmoidImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + out[i][j][k] = outCopy[i*s2*s3 + j*s3 + k]; + }; + }; + }; +} + +def void Sigmoid4(int32_pl s1, int32_pl s2, int32_pl s3, int32_pl s4, int64_al[s1][s2][s3][s4] inp, int64_al[s1][s2][s3][s4] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3 * s4; + int64_al[size] inpCopy; + int64_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l] = inp[i][j][k][l]; + }; + }; + }; + }; + + SigmoidImpl(LUTBITS, size, sA, sB, bwA, bwB, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + out[i][j][k][l] = inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l]; + }; + }; + }; + }; +} +def void Sqrt1(int32_pl s1, int64_al[s1] inp, int64_al[s1] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_pl LUTBITS) { + SqrtImpl(LUTBITS, s1, sA, sB, bwA, bwB, inverse, inp, out); +} + +def void Sqrt2(int32_pl s1, int32_pl s2, int64_al[s1][s2] inp, int64_al[s1][s2] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_pl LUTBITS) { + int32_pl size = s1 * s2; + int64_al[size] inpCopy; + int64_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + inpCopy[i*s1 + j] = inp[i][j]; + }; + }; + + SqrtImpl(LUTBITS, size, sA, sB, bwA, bwB, inverse, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + out[i][j] = outCopy[i*s2 + j]; + }; + }; +} + +def void Sqrt3(int32_pl s1, int32_pl s2, int32_pl s3, int64_al[s1][s2][s3] inp, int64_al[s1][s2][s3] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3; + int64_al[size] inpCopy; + int64_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + inpCopy[i*s2*s3 + j*s3 + k] = inp[i][j][k]; + }; + }; + }; + + SqrtImpl(LUTBITS, size, sA, sB, bwA, bwB, inverse, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + out[i][j][k] = outCopy[i*s2*s3 + j*s3 + k]; + }; + }; + }; +} + +def void Sqrt4(int32_pl s1, int32_pl s2, int32_pl s3, int32_pl s4, int64_al[s1][s2][s3][s4] inp, int64_al[s1][s2][s3][s4] out, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int32_pl LUTBITS) { + int32_pl size = s1 * s2 * s3 * s4; + int64_al[size] inpCopy; + int64_al[size] outCopy; + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l] = inp[i][j][k][l]; + }; + }; + }; + }; + + SqrtImpl(LUTBITS, size, sA, sB, bwA, bwB, inverse, inpCopy, outCopy); + + for i=[0:s1] { + for j=[0:s2] { + for k=[0:s3] { + for l=[0:s4] { + out[i][j][k][l] = inpCopy[i*s2*s3*s4 + j*s3*s4 + k*s4 + l]; + }; + }; + }; + }; +} diff --git a/Athos/TFEzPCLibrary/Library64_cpp_pre.ezpc b/Athos/TFEzPCLibrary/Library64_cpp_pre.ezpc index c00a6e8f..91dc7fb6 100644 --- a/Athos/TFEzPCLibrary/Library64_cpp_pre.ezpc +++ b/Athos/TFEzPCLibrary/Library64_cpp_pre.ezpc @@ -236,6 +236,36238 @@ def void ElemWiseVectorPublicDiv(int32_pl s1, int64_al[s1] arr1, int32_pl diviso }; } +(* <><><><><><><> Auto-generated code <><><><><><><> *) +def void fillLUTINVSQRT(int32_pl[1020] inp) +{ +inp[0] = 4; +inp[1] = 2; +inp[2] = 3; +inp[3] = 2; +inp[4] = 8; +inp[5] = 5; +inp[6] = 7; +inp[7] = 5; +inp[8] = 6; +inp[9] = 4; +inp[10] = 6; +inp[11] = 4; +inp[12] = 16; +inp[13] = 11; +inp[14] = 15; +inp[15] = 10; +inp[16] = 14; +inp[17] = 10; +inp[18] = 13; +inp[19] = 9; +inp[20] = 13; +inp[21] = 9; +inp[22] = 12; +inp[23] = 8; +inp[24] = 12; +inp[25] = 8; +inp[26] = 11; +inp[27] = 8; +inp[28] = 32; +inp[29] = 22; +inp[30] = 31; +inp[31] = 21; +inp[32] = 30; +inp[33] = 21; +inp[34] = 29; +inp[35] = 20; +inp[36] = 28; +inp[37] = 20; +inp[38] = 27; +inp[39] = 19; +inp[40] = 27; +inp[41] = 19; +inp[42] = 26; +inp[43] = 18; +inp[44] = 26; +inp[45] = 18; +inp[46] = 25; +inp[47] = 18; +inp[48] = 25; +inp[49] = 17; +inp[50] = 24; +inp[51] = 17; +inp[52] = 24; +inp[53] = 17; +inp[54] = 23; +inp[55] = 16; +inp[56] = 23; +inp[57] = 16; +inp[58] = 22; +inp[59] = 16; +inp[60] = 64; +inp[61] = 45; +inp[62] = 63; +inp[63] = 44; +inp[64] = 62; +inp[65] = 43; +inp[66] = 61; +inp[67] = 43; +inp[68] = 60; +inp[69] = 42; +inp[70] = 59; +inp[71] = 42; +inp[72] = 58; +inp[73] = 41; +inp[74] = 57; +inp[75] = 40; +inp[76] = 57; +inp[77] = 40; +inp[78] = 56; +inp[79] = 39; +inp[80] = 55; +inp[81] = 39; +inp[82] = 55; +inp[83] = 39; +inp[84] = 54; +inp[85] = 38; +inp[86] = 53; +inp[87] = 38; +inp[88] = 53; +inp[89] = 37; +inp[90] = 52; +inp[91] = 37; +inp[92] = 52; +inp[93] = 36; +inp[94] = 51; +inp[95] = 36; +inp[96] = 51; +inp[97] = 36; +inp[98] = 50; +inp[99] = 35; +inp[100] = 50; +inp[101] = 35; +inp[102] = 49; +inp[103] = 35; +inp[104] = 49; +inp[105] = 34; +inp[106] = 48; +inp[107] = 34; +inp[108] = 48; +inp[109] = 34; +inp[110] = 47; +inp[111] = 33; +inp[112] = 47; +inp[113] = 33; +inp[114] = 47; +inp[115] = 33; +inp[116] = 46; +inp[117] = 33; +inp[118] = 46; +inp[119] = 32; +inp[120] = 45; +inp[121] = 32; +inp[122] = 45; +inp[123] = 32; +inp[124] = 128; +inp[125] = 90; +inp[126] = 127; +inp[127] = 89; +inp[128] = 126; +inp[129] = 89; +inp[130] = 125; +inp[131] = 88; +inp[132] = 124; +inp[133] = 87; +inp[134] = 123; +inp[135] = 87; +inp[136] = 122; +inp[137] = 86; +inp[138] = 121; +inp[139] = 85; +inp[140] = 120; +inp[141] = 85; +inp[142] = 119; +inp[143] = 84; +inp[144] = 119; +inp[145] = 84; +inp[146] = 118; +inp[147] = 83; +inp[148] = 117; +inp[149] = 83; +inp[150] = 116; +inp[151] = 82; +inp[152] = 115; +inp[153] = 81; +inp[154] = 115; +inp[155] = 81; +inp[156] = 114; +inp[157] = 80; +inp[158] = 113; +inp[159] = 80; +inp[160] = 113; +inp[161] = 79; +inp[162] = 112; +inp[163] = 79; +inp[164] = 111; +inp[165] = 79; +inp[166] = 111; +inp[167] = 78; +inp[168] = 110; +inp[169] = 78; +inp[170] = 109; +inp[171] = 77; +inp[172] = 109; +inp[173] = 77; +inp[174] = 108; +inp[175] = 76; +inp[176] = 107; +inp[177] = 76; +inp[178] = 107; +inp[179] = 75; +inp[180] = 106; +inp[181] = 75; +inp[182] = 106; +inp[183] = 75; +inp[184] = 105; +inp[185] = 74; +inp[186] = 105; +inp[187] = 74; +inp[188] = 104; +inp[189] = 73; +inp[190] = 103; +inp[191] = 73; +inp[192] = 103; +inp[193] = 73; +inp[194] = 102; +inp[195] = 72; +inp[196] = 102; +inp[197] = 72; +inp[198] = 101; +inp[199] = 72; +inp[200] = 101; +inp[201] = 71; +inp[202] = 100; +inp[203] = 71; +inp[204] = 100; +inp[205] = 71; +inp[206] = 99; +inp[207] = 70; +inp[208] = 99; +inp[209] = 70; +inp[210] = 98; +inp[211] = 69; +inp[212] = 98; +inp[213] = 69; +inp[214] = 98; +inp[215] = 69; +inp[216] = 97; +inp[217] = 69; +inp[218] = 97; +inp[219] = 68; +inp[220] = 96; +inp[221] = 68; +inp[222] = 96; +inp[223] = 68; +inp[224] = 95; +inp[225] = 67; +inp[226] = 95; +inp[227] = 67; +inp[228] = 95; +inp[229] = 67; +inp[230] = 94; +inp[231] = 66; +inp[232] = 94; +inp[233] = 66; +inp[234] = 93; +inp[235] = 66; +inp[236] = 93; +inp[237] = 66; +inp[238] = 93; +inp[239] = 65; +inp[240] = 92; +inp[241] = 65; +inp[242] = 92; +inp[243] = 65; +inp[244] = 91; +inp[245] = 65; +inp[246] = 91; +inp[247] = 64; +inp[248] = 91; +inp[249] = 64; +inp[250] = 90; +inp[251] = 64; +inp[252] = 256; +inp[253] = 181; +inp[254] = 255; +inp[255] = 180; +inp[256] = 254; +inp[257] = 179; +inp[258] = 253; +inp[259] = 178; +inp[260] = 252; +inp[261] = 178; +inp[262] = 251; +inp[263] = 177; +inp[264] = 250; +inp[265] = 176; +inp[266] = 249; +inp[267] = 176; +inp[268] = 248; +inp[269] = 175; +inp[270] = 247; +inp[271] = 174; +inp[272] = 246; +inp[273] = 174; +inp[274] = 245; +inp[275] = 173; +inp[276] = 244; +inp[277] = 173; +inp[278] = 243; +inp[279] = 172; +inp[280] = 243; +inp[281] = 171; +inp[282] = 242; +inp[283] = 171; +inp[284] = 241; +inp[285] = 170; +inp[286] = 240; +inp[287] = 170; +inp[288] = 239; +inp[289] = 169; +inp[290] = 238; +inp[291] = 168; +inp[292] = 238; +inp[293] = 168; +inp[294] = 237; +inp[295] = 167; +inp[296] = 236; +inp[297] = 167; +inp[298] = 235; +inp[299] = 166; +inp[300] = 234; +inp[301] = 166; +inp[302] = 234; +inp[303] = 165; +inp[304] = 233; +inp[305] = 165; +inp[306] = 232; +inp[307] = 164; +inp[308] = 231; +inp[309] = 163; +inp[310] = 231; +inp[311] = 163; +inp[312] = 230; +inp[313] = 162; +inp[314] = 229; +inp[315] = 162; +inp[316] = 228; +inp[317] = 161; +inp[318] = 228; +inp[319] = 161; +inp[320] = 227; +inp[321] = 160; +inp[322] = 226; +inp[323] = 160; +inp[324] = 226; +inp[325] = 159; +inp[326] = 225; +inp[327] = 159; +inp[328] = 224; +inp[329] = 158; +inp[330] = 224; +inp[331] = 158; +inp[332] = 223; +inp[333] = 158; +inp[334] = 222; +inp[335] = 157; +inp[336] = 222; +inp[337] = 157; +inp[338] = 221; +inp[339] = 156; +inp[340] = 220; +inp[341] = 156; +inp[342] = 220; +inp[343] = 155; +inp[344] = 219; +inp[345] = 155; +inp[346] = 218; +inp[347] = 154; +inp[348] = 218; +inp[349] = 154; +inp[350] = 217; +inp[351] = 153; +inp[352] = 217; +inp[353] = 153; +inp[354] = 216; +inp[355] = 153; +inp[356] = 215; +inp[357] = 152; +inp[358] = 215; +inp[359] = 152; +inp[360] = 214; +inp[361] = 151; +inp[362] = 214; +inp[363] = 151; +inp[364] = 213; +inp[365] = 150; +inp[366] = 212; +inp[367] = 150; +inp[368] = 212; +inp[369] = 150; +inp[370] = 211; +inp[371] = 149; +inp[372] = 211; +inp[373] = 149; +inp[374] = 210; +inp[375] = 148; +inp[376] = 210; +inp[377] = 148; +inp[378] = 209; +inp[379] = 148; +inp[380] = 209; +inp[381] = 147; +inp[382] = 208; +inp[383] = 147; +inp[384] = 207; +inp[385] = 147; +inp[386] = 207; +inp[387] = 146; +inp[388] = 206; +inp[389] = 146; +inp[390] = 206; +inp[391] = 145; +inp[392] = 205; +inp[393] = 145; +inp[394] = 205; +inp[395] = 145; +inp[396] = 204; +inp[397] = 144; +inp[398] = 204; +inp[399] = 144; +inp[400] = 203; +inp[401] = 144; +inp[402] = 203; +inp[403] = 143; +inp[404] = 202; +inp[405] = 143; +inp[406] = 202; +inp[407] = 143; +inp[408] = 201; +inp[409] = 142; +inp[410] = 201; +inp[411] = 142; +inp[412] = 200; +inp[413] = 142; +inp[414] = 200; +inp[415] = 141; +inp[416] = 199; +inp[417] = 141; +inp[418] = 199; +inp[419] = 140; +inp[420] = 198; +inp[421] = 140; +inp[422] = 198; +inp[423] = 140; +inp[424] = 197; +inp[425] = 139; +inp[426] = 197; +inp[427] = 139; +inp[428] = 197; +inp[429] = 139; +inp[430] = 196; +inp[431] = 139; +inp[432] = 196; +inp[433] = 138; +inp[434] = 195; +inp[435] = 138; +inp[436] = 195; +inp[437] = 138; +inp[438] = 194; +inp[439] = 137; +inp[440] = 194; +inp[441] = 137; +inp[442] = 193; +inp[443] = 137; +inp[444] = 193; +inp[445] = 136; +inp[446] = 193; +inp[447] = 136; +inp[448] = 192; +inp[449] = 136; +inp[450] = 192; +inp[451] = 135; +inp[452] = 191; +inp[453] = 135; +inp[454] = 191; +inp[455] = 135; +inp[456] = 190; +inp[457] = 135; +inp[458] = 190; +inp[459] = 134; +inp[460] = 190; +inp[461] = 134; +inp[462] = 189; +inp[463] = 134; +inp[464] = 189; +inp[465] = 133; +inp[466] = 188; +inp[467] = 133; +inp[468] = 188; +inp[469] = 133; +inp[470] = 188; +inp[471] = 133; +inp[472] = 187; +inp[473] = 132; +inp[474] = 187; +inp[475] = 132; +inp[476] = 186; +inp[477] = 132; +inp[478] = 186; +inp[479] = 131; +inp[480] = 186; +inp[481] = 131; +inp[482] = 185; +inp[483] = 131; +inp[484] = 185; +inp[485] = 131; +inp[486] = 185; +inp[487] = 130; +inp[488] = 184; +inp[489] = 130; +inp[490] = 184; +inp[491] = 130; +inp[492] = 183; +inp[493] = 130; +inp[494] = 183; +inp[495] = 129; +inp[496] = 183; +inp[497] = 129; +inp[498] = 182; +inp[499] = 129; +inp[500] = 182; +inp[501] = 129; +inp[502] = 182; +inp[503] = 128; +inp[504] = 181; +inp[505] = 128; +inp[506] = 181; +inp[507] = 128; +inp[508] = 512; +inp[509] = 362; +inp[510] = 511; +inp[511] = 361; +inp[512] = 510; +inp[513] = 360; +inp[514] = 509; +inp[515] = 359; +inp[516] = 508; +inp[517] = 359; +inp[518] = 507; +inp[519] = 358; +inp[520] = 506; +inp[521] = 357; +inp[522] = 505; +inp[523] = 357; +inp[524] = 504; +inp[525] = 356; +inp[526] = 503; +inp[527] = 355; +inp[528] = 502; +inp[529] = 355; +inp[530] = 501; +inp[531] = 354; +inp[532] = 500; +inp[533] = 353; +inp[534] = 499; +inp[535] = 353; +inp[536] = 498; +inp[537] = 352; +inp[538] = 497; +inp[539] = 351; +inp[540] = 496; +inp[541] = 351; +inp[542] = 495; +inp[543] = 350; +inp[544] = 494; +inp[545] = 349; +inp[546] = 493; +inp[547] = 349; +inp[548] = 493; +inp[549] = 348; +inp[550] = 492; +inp[551] = 348; +inp[552] = 491; +inp[553] = 347; +inp[554] = 490; +inp[555] = 346; +inp[556] = 489; +inp[557] = 346; +inp[558] = 488; +inp[559] = 345; +inp[560] = 487; +inp[561] = 344; +inp[562] = 486; +inp[563] = 344; +inp[564] = 486; +inp[565] = 343; +inp[566] = 485; +inp[567] = 343; +inp[568] = 484; +inp[569] = 342; +inp[570] = 483; +inp[571] = 341; +inp[572] = 482; +inp[573] = 341; +inp[574] = 481; +inp[575] = 340; +inp[576] = 481; +inp[577] = 340; +inp[578] = 480; +inp[579] = 339; +inp[580] = 479; +inp[581] = 338; +inp[582] = 478; +inp[583] = 338; +inp[584] = 477; +inp[585] = 337; +inp[586] = 476; +inp[587] = 337; +inp[588] = 476; +inp[589] = 336; +inp[590] = 475; +inp[591] = 336; +inp[592] = 474; +inp[593] = 335; +inp[594] = 473; +inp[595] = 334; +inp[596] = 472; +inp[597] = 334; +inp[598] = 472; +inp[599] = 333; +inp[600] = 471; +inp[601] = 333; +inp[602] = 470; +inp[603] = 332; +inp[604] = 469; +inp[605] = 332; +inp[606] = 469; +inp[607] = 331; +inp[608] = 468; +inp[609] = 331; +inp[610] = 467; +inp[611] = 330; +inp[612] = 466; +inp[613] = 330; +inp[614] = 466; +inp[615] = 329; +inp[616] = 465; +inp[617] = 328; +inp[618] = 464; +inp[619] = 328; +inp[620] = 463; +inp[621] = 327; +inp[622] = 463; +inp[623] = 327; +inp[624] = 462; +inp[625] = 326; +inp[626] = 461; +inp[627] = 326; +inp[628] = 460; +inp[629] = 325; +inp[630] = 460; +inp[631] = 325; +inp[632] = 459; +inp[633] = 324; +inp[634] = 458; +inp[635] = 324; +inp[636] = 457; +inp[637] = 323; +inp[638] = 457; +inp[639] = 323; +inp[640] = 456; +inp[641] = 322; +inp[642] = 455; +inp[643] = 322; +inp[644] = 455; +inp[645] = 321; +inp[646] = 454; +inp[647] = 321; +inp[648] = 453; +inp[649] = 320; +inp[650] = 453; +inp[651] = 320; +inp[652] = 452; +inp[653] = 319; +inp[654] = 451; +inp[655] = 319; +inp[656] = 450; +inp[657] = 318; +inp[658] = 450; +inp[659] = 318; +inp[660] = 449; +inp[661] = 317; +inp[662] = 448; +inp[663] = 317; +inp[664] = 448; +inp[665] = 316; +inp[666] = 447; +inp[667] = 316; +inp[668] = 446; +inp[669] = 316; +inp[670] = 446; +inp[671] = 315; +inp[672] = 445; +inp[673] = 315; +inp[674] = 444; +inp[675] = 314; +inp[676] = 444; +inp[677] = 314; +inp[678] = 443; +inp[679] = 313; +inp[680] = 442; +inp[681] = 313; +inp[682] = 442; +inp[683] = 312; +inp[684] = 441; +inp[685] = 312; +inp[686] = 441; +inp[687] = 311; +inp[688] = 440; +inp[689] = 311; +inp[690] = 439; +inp[691] = 310; +inp[692] = 439; +inp[693] = 310; +inp[694] = 438; +inp[695] = 310; +inp[696] = 437; +inp[697] = 309; +inp[698] = 437; +inp[699] = 309; +inp[700] = 436; +inp[701] = 308; +inp[702] = 436; +inp[703] = 308; +inp[704] = 435; +inp[705] = 307; +inp[706] = 434; +inp[707] = 307; +inp[708] = 434; +inp[709] = 307; +inp[710] = 433; +inp[711] = 306; +inp[712] = 432; +inp[713] = 306; +inp[714] = 432; +inp[715] = 305; +inp[716] = 431; +inp[717] = 305; +inp[718] = 431; +inp[719] = 304; +inp[720] = 430; +inp[721] = 304; +inp[722] = 429; +inp[723] = 304; +inp[724] = 429; +inp[725] = 303; +inp[726] = 428; +inp[727] = 303; +inp[728] = 428; +inp[729] = 302; +inp[730] = 427; +inp[731] = 302; +inp[732] = 427; +inp[733] = 301; +inp[734] = 426; +inp[735] = 301; +inp[736] = 425; +inp[737] = 301; +inp[738] = 425; +inp[739] = 300; +inp[740] = 424; +inp[741] = 300; +inp[742] = 424; +inp[743] = 299; +inp[744] = 423; +inp[745] = 299; +inp[746] = 423; +inp[747] = 299; +inp[748] = 422; +inp[749] = 298; +inp[750] = 421; +inp[751] = 298; +inp[752] = 421; +inp[753] = 297; +inp[754] = 420; +inp[755] = 297; +inp[756] = 420; +inp[757] = 297; +inp[758] = 419; +inp[759] = 296; +inp[760] = 419; +inp[761] = 296; +inp[762] = 418; +inp[763] = 295; +inp[764] = 418; +inp[765] = 295; +inp[766] = 417; +inp[767] = 295; +inp[768] = 416; +inp[769] = 294; +inp[770] = 416; +inp[771] = 294; +inp[772] = 415; +inp[773] = 294; +inp[774] = 415; +inp[775] = 293; +inp[776] = 414; +inp[777] = 293; +inp[778] = 414; +inp[779] = 292; +inp[780] = 413; +inp[781] = 292; +inp[782] = 413; +inp[783] = 292; +inp[784] = 412; +inp[785] = 291; +inp[786] = 412; +inp[787] = 291; +inp[788] = 411; +inp[789] = 291; +inp[790] = 411; +inp[791] = 290; +inp[792] = 410; +inp[793] = 290; +inp[794] = 410; +inp[795] = 289; +inp[796] = 409; +inp[797] = 289; +inp[798] = 409; +inp[799] = 289; +inp[800] = 408; +inp[801] = 288; +inp[802] = 408; +inp[803] = 288; +inp[804] = 407; +inp[805] = 288; +inp[806] = 407; +inp[807] = 287; +inp[808] = 406; +inp[809] = 287; +inp[810] = 406; +inp[811] = 287; +inp[812] = 405; +inp[813] = 286; +inp[814] = 405; +inp[815] = 286; +inp[816] = 404; +inp[817] = 286; +inp[818] = 404; +inp[819] = 285; +inp[820] = 403; +inp[821] = 285; +inp[822] = 403; +inp[823] = 285; +inp[824] = 402; +inp[825] = 284; +inp[826] = 402; +inp[827] = 284; +inp[828] = 401; +inp[829] = 284; +inp[830] = 401; +inp[831] = 283; +inp[832] = 400; +inp[833] = 283; +inp[834] = 400; +inp[835] = 282; +inp[836] = 399; +inp[837] = 282; +inp[838] = 399; +inp[839] = 282; +inp[840] = 398; +inp[841] = 281; +inp[842] = 398; +inp[843] = 281; +inp[844] = 397; +inp[845] = 281; +inp[846] = 397; +inp[847] = 280; +inp[848] = 396; +inp[849] = 280; +inp[850] = 396; +inp[851] = 280; +inp[852] = 395; +inp[853] = 279; +inp[854] = 395; +inp[855] = 279; +inp[856] = 395; +inp[857] = 279; +inp[858] = 394; +inp[859] = 279; +inp[860] = 394; +inp[861] = 278; +inp[862] = 393; +inp[863] = 278; +inp[864] = 393; +inp[865] = 278; +inp[866] = 392; +inp[867] = 277; +inp[868] = 392; +inp[869] = 277; +inp[870] = 391; +inp[871] = 277; +inp[872] = 391; +inp[873] = 276; +inp[874] = 390; +inp[875] = 276; +inp[876] = 390; +inp[877] = 276; +inp[878] = 390; +inp[879] = 275; +inp[880] = 389; +inp[881] = 275; +inp[882] = 389; +inp[883] = 275; +inp[884] = 388; +inp[885] = 274; +inp[886] = 388; +inp[887] = 274; +inp[888] = 387; +inp[889] = 274; +inp[890] = 387; +inp[891] = 273; +inp[892] = 387; +inp[893] = 273; +inp[894] = 386; +inp[895] = 273; +inp[896] = 386; +inp[897] = 273; +inp[898] = 385; +inp[899] = 272; +inp[900] = 385; +inp[901] = 272; +inp[902] = 384; +inp[903] = 272; +inp[904] = 384; +inp[905] = 271; +inp[906] = 384; +inp[907] = 271; +inp[908] = 383; +inp[909] = 271; +inp[910] = 383; +inp[911] = 270; +inp[912] = 382; +inp[913] = 270; +inp[914] = 382; +inp[915] = 270; +inp[916] = 381; +inp[917] = 270; +inp[918] = 381; +inp[919] = 269; +inp[920] = 381; +inp[921] = 269; +inp[922] = 380; +inp[923] = 269; +inp[924] = 380; +inp[925] = 268; +inp[926] = 379; +inp[927] = 268; +inp[928] = 379; +inp[929] = 268; +inp[930] = 379; +inp[931] = 268; +inp[932] = 378; +inp[933] = 267; +inp[934] = 378; +inp[935] = 267; +inp[936] = 377; +inp[937] = 267; +inp[938] = 377; +inp[939] = 266; +inp[940] = 377; +inp[941] = 266; +inp[942] = 376; +inp[943] = 266; +inp[944] = 376; +inp[945] = 266; +inp[946] = 375; +inp[947] = 265; +inp[948] = 375; +inp[949] = 265; +inp[950] = 375; +inp[951] = 265; +inp[952] = 374; +inp[953] = 264; +inp[954] = 374; +inp[955] = 264; +inp[956] = 373; +inp[957] = 264; +inp[958] = 373; +inp[959] = 264; +inp[960] = 373; +inp[961] = 263; +inp[962] = 372; +inp[963] = 263; +inp[964] = 372; +inp[965] = 263; +inp[966] = 371; +inp[967] = 263; +inp[968] = 371; +inp[969] = 262; +inp[970] = 371; +inp[971] = 262; +inp[972] = 370; +inp[973] = 262; +inp[974] = 370; +inp[975] = 261; +inp[976] = 370; +inp[977] = 261; +inp[978] = 369; +inp[979] = 261; +inp[980] = 369; +inp[981] = 261; +inp[982] = 368; +inp[983] = 260; +inp[984] = 368; +inp[985] = 260; +inp[986] = 368; +inp[987] = 260; +inp[988] = 367; +inp[989] = 260; +inp[990] = 367; +inp[991] = 259; +inp[992] = 367; +inp[993] = 259; +inp[994] = 366; +inp[995] = 259; +inp[996] = 366; +inp[997] = 259; +inp[998] = 365; +inp[999] = 258; +inp[1000] = 365; +inp[1001] = 258; +inp[1002] = 365; +inp[1003] = 258; +inp[1004] = 364; +inp[1005] = 258; +inp[1006] = 364; +inp[1007] = 257; +inp[1008] = 364; +inp[1009] = 257; +inp[1010] = 363; +inp[1011] = 257; +inp[1012] = 363; +inp[1013] = 257; +inp[1014] = 363; +inp[1015] = 256; +inp[1016] = 362; +inp[1017] = 256; +inp[1018] = 362; +inp[1019] = 256; +} + +def void fillLUTDIV(int32_pl[1020] inp) +{ +inp[0] = 10; +inp[1] = 15; +inp[2] = 5; +inp[3] = 10; +inp[4] = 25; +inp[5] = 63; +inp[6] = 17; +inp[7] = 51; +inp[8] = 12; +inp[9] = 42; +inp[10] = 9; +inp[11] = 36; +inp[12] = 56; +inp[13] = 255; +inp[14] = 45; +inp[15] = 227; +inp[16] = 37; +inp[17] = 204; +inp[18] = 31; +inp[19] = 186; +inp[20] = 26; +inp[21] = 170; +inp[22] = 22; +inp[23] = 157; +inp[24] = 19; +inp[25] = 146; +inp[26] = 17; +inp[27] = 136; +inp[28] = 120; +inp[29] = 1023; +inp[30] = 107; +inp[31] = 963; +inp[32] = 95; +inp[33] = 909; +inp[34] = 86; +inp[35] = 862; +inp[36] = 78; +inp[37] = 818; +inp[38] = 70; +inp[39] = 779; +inp[40] = 64; +inp[41] = 744; +inp[42] = 59; +inp[43] = 712; +inp[44] = 54; +inp[45] = 682; +inp[46] = 50; +inp[47] = 655; +inp[48] = 46; +inp[49] = 630; +inp[50] = 43; +inp[51] = 606; +inp[52] = 40; +inp[53] = 585; +inp[54] = 37; +inp[55] = 564; +inp[56] = 35; +inp[57] = 546; +inp[58] = 33; +inp[59] = 528; +inp[60] = 248; +inp[61] = 4095; +inp[62] = 233; +inp[63] = 3971; +inp[64] = 220; +inp[65] = 3854; +inp[66] = 208; +inp[67] = 3744; +inp[68] = 196; +inp[69] = 3640; +inp[70] = 186; +inp[71] = 3542; +inp[72] = 176; +inp[73] = 3448; +inp[74] = 168; +inp[75] = 3360; +inp[76] = 159; +inp[77] = 3276; +inp[78] = 152; +inp[79] = 3196; +inp[80] = 145; +inp[81] = 3120; +inp[82] = 138; +inp[83] = 3047; +inp[84] = 132; +inp[85] = 2978; +inp[86] = 126; +inp[87] = 2912; +inp[88] = 121; +inp[89] = 2849; +inp[90] = 116; +inp[91] = 2788; +inp[92] = 111; +inp[93] = 2730; +inp[94] = 106; +inp[95] = 2674; +inp[96] = 102; +inp[97] = 2621; +inp[98] = 98; +inp[99] = 2569; +inp[100] = 95; +inp[101] = 2520; +inp[102] = 91; +inp[103] = 2472; +inp[104] = 88; +inp[105] = 2427; +inp[106] = 85; +inp[107] = 2383; +inp[108] = 82; +inp[109] = 2340; +inp[110] = 79; +inp[111] = 2299; +inp[112] = 76; +inp[113] = 2259; +inp[114] = 74; +inp[115] = 2221; +inp[116] = 71; +inp[117] = 2184; +inp[118] = 69; +inp[119] = 2148; +inp[120] = 67; +inp[121] = 2113; +inp[122] = 65; +inp[123] = 2080; +inp[124] = 504; +inp[125] = 16383; +inp[126] = 488; +inp[127] = 16131; +inp[128] = 474; +inp[129] = 15887; +inp[130] = 460; +inp[131] = 15649; +inp[132] = 446; +inp[133] = 15419; +inp[134] = 434; +inp[135] = 15196; +inp[136] = 421; +inp[137] = 14979; +inp[138] = 410; +inp[139] = 14768; +inp[140] = 399; +inp[141] = 14563; +inp[142] = 388; +inp[143] = 14363; +inp[144] = 377; +inp[145] = 14169; +inp[146] = 367; +inp[147] = 13980; +inp[148] = 358; +inp[149] = 13796; +inp[150] = 349; +inp[151] = 13617; +inp[152] = 340; +inp[153] = 13443; +inp[154] = 331; +inp[155] = 13272; +inp[156] = 323; +inp[157] = 13106; +inp[158] = 315; +inp[159] = 12945; +inp[160] = 308; +inp[161] = 12787; +inp[162] = 300; +inp[163] = 12633; +inp[164] = 293; +inp[165] = 12482; +inp[166] = 286; +inp[167] = 12335; +inp[168] = 280; +inp[169] = 12192; +inp[170] = 273; +inp[171] = 12052; +inp[172] = 267; +inp[173] = 11915; +inp[174] = 261; +inp[175] = 11781; +inp[176] = 256; +inp[177] = 11650; +inp[178] = 250; +inp[179] = 11522; +inp[180] = 245; +inp[181] = 11397; +inp[182] = 239; +inp[183] = 11274; +inp[184] = 234; +inp[185] = 11154; +inp[186] = 229; +inp[187] = 11037; +inp[188] = 225; +inp[189] = 10922; +inp[190] = 220; +inp[191] = 10809; +inp[192] = 216; +inp[193] = 10699; +inp[194] = 211; +inp[195] = 10591; +inp[196] = 207; +inp[197] = 10485; +inp[198] = 203; +inp[199] = 10381; +inp[200] = 199; +inp[201] = 10280; +inp[202] = 195; +inp[203] = 10180; +inp[204] = 192; +inp[205] = 10082; +inp[206] = 188; +inp[207] = 9986; +inp[208] = 184; +inp[209] = 9892; +inp[210] = 181; +inp[211] = 9799; +inp[212] = 178; +inp[213] = 9708; +inp[214] = 174; +inp[215] = 9619; +inp[216] = 171; +inp[217] = 9532; +inp[218] = 168; +inp[219] = 9446; +inp[220] = 165; +inp[221] = 9362; +inp[222] = 162; +inp[223] = 9279; +inp[224] = 159; +inp[225] = 9197; +inp[226] = 157; +inp[227] = 9117; +inp[228] = 154; +inp[229] = 9039; +inp[230] = 151; +inp[231] = 8962; +inp[232] = 149; +inp[233] = 8886; +inp[234] = 146; +inp[235] = 8811; +inp[236] = 144; +inp[237] = 8738; +inp[238] = 142; +inp[239] = 8665; +inp[240] = 139; +inp[241] = 8594; +inp[242] = 137; +inp[243] = 8524; +inp[244] = 135; +inp[245] = 8456; +inp[246] = 133; +inp[247] = 8388; +inp[248] = 131; +inp[249] = 8321; +inp[250] = 129; +inp[251] = 8256; +inp[252] = 1016; +inp[253] = 65535; +inp[254] = 1000; +inp[255] = 65027; +inp[256] = 985; +inp[257] = 64527; +inp[258] = 970; +inp[259] = 64034; +inp[260] = 955; +inp[261] = 63549; +inp[262] = 941; +inp[263] = 63071; +inp[264] = 927; +inp[265] = 62601; +inp[266] = 913; +inp[267] = 62137; +inp[268] = 900; +inp[269] = 61680; +inp[270] = 887; +inp[271] = 61230; +inp[272] = 874; +inp[273] = 60786; +inp[274] = 862; +inp[275] = 60349; +inp[276] = 849; +inp[277] = 59918; +inp[278] = 837; +inp[279] = 59493; +inp[280] = 826; +inp[281] = 59074; +inp[282] = 814; +inp[283] = 58661; +inp[284] = 803; +inp[285] = 58253; +inp[286] = 792; +inp[287] = 57852; +inp[288] = 781; +inp[289] = 57455; +inp[290] = 771; +inp[291] = 57065; +inp[292] = 760; +inp[293] = 56679; +inp[294] = 750; +inp[295] = 56299; +inp[296] = 740; +inp[297] = 55923; +inp[298] = 730; +inp[299] = 55553; +inp[300] = 721; +inp[301] = 55187; +inp[302] = 712; +inp[303] = 54827; +inp[304] = 702; +inp[305] = 54471; +inp[306] = 693; +inp[307] = 54119; +inp[308] = 685; +inp[309] = 53772; +inp[310] = 676; +inp[311] = 53430; +inp[312] = 667; +inp[313] = 53092; +inp[314] = 659; +inp[315] = 52758; +inp[316] = 651; +inp[317] = 52428; +inp[318] = 643; +inp[319] = 52102; +inp[320] = 635; +inp[321] = 51781; +inp[322] = 627; +inp[323] = 51463; +inp[324] = 620; +inp[325] = 51149; +inp[326] = 612; +inp[327] = 50839; +inp[328] = 605; +inp[329] = 50533; +inp[330] = 597; +inp[331] = 50230; +inp[332] = 590; +inp[333] = 49931; +inp[334] = 583; +inp[335] = 49636; +inp[336] = 577; +inp[337] = 49344; +inp[338] = 570; +inp[339] = 49055; +inp[340] = 563; +inp[341] = 48770; +inp[342] = 557; +inp[343] = 48488; +inp[344] = 550; +inp[345] = 48210; +inp[346] = 544; +inp[347] = 47934; +inp[348] = 538; +inp[349] = 47662; +inp[350] = 532; +inp[351] = 47393; +inp[352] = 526; +inp[353] = 47126; +inp[354] = 520; +inp[355] = 46863; +inp[356] = 514; +inp[357] = 46603; +inp[358] = 509; +inp[359] = 46345; +inp[360] = 503; +inp[361] = 46091; +inp[362] = 498; +inp[363] = 45839; +inp[364] = 492; +inp[365] = 45590; +inp[366] = 487; +inp[367] = 45343; +inp[368] = 482; +inp[369] = 45099; +inp[370] = 477; +inp[371] = 44858; +inp[372] = 472; +inp[373] = 44620; +inp[374] = 467; +inp[375] = 44384; +inp[376] = 462; +inp[377] = 44150; +inp[378] = 457; +inp[379] = 43919; +inp[380] = 452; +inp[381] = 43690; +inp[382] = 448; +inp[383] = 43464; +inp[384] = 443; +inp[385] = 43240; +inp[386] = 438; +inp[387] = 43018; +inp[388] = 434; +inp[389] = 42798; +inp[390] = 430; +inp[391] = 42581; +inp[392] = 425; +inp[393] = 42366; +inp[394] = 421; +inp[395] = 42153; +inp[396] = 417; +inp[397] = 41942; +inp[398] = 413; +inp[399] = 41734; +inp[400] = 409; +inp[401] = 41527; +inp[402] = 405; +inp[403] = 41323; +inp[404] = 401; +inp[405] = 41120; +inp[406] = 397; +inp[407] = 40919; +inp[408] = 393; +inp[409] = 40721; +inp[410] = 389; +inp[411] = 40524; +inp[412] = 385; +inp[413] = 40329; +inp[414] = 382; +inp[415] = 40136; +inp[416] = 378; +inp[417] = 39945; +inp[418] = 375; +inp[419] = 39756; +inp[420] = 371; +inp[421] = 39568; +inp[422] = 368; +inp[423] = 39383; +inp[424] = 364; +inp[425] = 39198; +inp[426] = 361; +inp[427] = 39016; +inp[428] = 357; +inp[429] = 38836; +inp[430] = 354; +inp[431] = 38657; +inp[432] = 351; +inp[433] = 38479; +inp[434] = 348; +inp[435] = 38304; +inp[436] = 345; +inp[437] = 38129; +inp[438] = 341; +inp[439] = 37957; +inp[440] = 338; +inp[441] = 37786; +inp[442] = 335; +inp[443] = 37616; +inp[444] = 332; +inp[445] = 37449; +inp[446] = 329; +inp[447] = 37282; +inp[448] = 327; +inp[449] = 37117; +inp[450] = 324; +inp[451] = 36954; +inp[452] = 321; +inp[453] = 36792; +inp[454] = 318; +inp[455] = 36631; +inp[456] = 315; +inp[457] = 36472; +inp[458] = 313; +inp[459] = 36314; +inp[460] = 310; +inp[461] = 36157; +inp[462] = 307; +inp[463] = 36002; +inp[464] = 305; +inp[465] = 35848; +inp[466] = 302; +inp[467] = 35696; +inp[468] = 299; +inp[469] = 35544; +inp[470] = 297; +inp[471] = 35394; +inp[472] = 294; +inp[473] = 35246; +inp[474] = 292; +inp[475] = 35098; +inp[476] = 290; +inp[477] = 34952; +inp[478] = 287; +inp[479] = 34807; +inp[480] = 285; +inp[481] = 34663; +inp[482] = 282; +inp[483] = 34520; +inp[484] = 280; +inp[485] = 34379; +inp[486] = 278; +inp[487] = 34239; +inp[488] = 276; +inp[489] = 34099; +inp[490] = 273; +inp[491] = 33961; +inp[492] = 271; +inp[493] = 33824; +inp[494] = 269; +inp[495] = 33689; +inp[496] = 267; +inp[497] = 33554; +inp[498] = 265; +inp[499] = 33420; +inp[500] = 263; +inp[501] = 33288; +inp[502] = 261; +inp[503] = 33156; +inp[504] = 259; +inp[505] = 33025; +inp[506] = 257; +inp[507] = 32896; +inp[508] = 2040; +inp[509] = 262143; +inp[510] = 2024; +inp[511] = 261123; +inp[512] = 2008; +inp[513] = 260111; +inp[514] = 1993; +inp[515] = 259107; +inp[516] = 1977; +inp[517] = 258110; +inp[518] = 1962; +inp[519] = 257121; +inp[520] = 1947; +inp[521] = 256140; +inp[522] = 1933; +inp[523] = 255166; +inp[524] = 1918; +inp[525] = 254199; +inp[526] = 1904; +inp[527] = 253240; +inp[528] = 1889; +inp[529] = 252288; +inp[530] = 1875; +inp[531] = 251343; +inp[532] = 1861; +inp[533] = 250405; +inp[534] = 1847; +inp[535] = 249474; +inp[536] = 1834; +inp[537] = 248550; +inp[538] = 1820; +inp[539] = 247633; +inp[540] = 1807; +inp[541] = 246723; +inp[542] = 1794; +inp[543] = 245819; +inp[544] = 1781; +inp[545] = 244922; +inp[546] = 1768; +inp[547] = 244031; +inp[548] = 1755; +inp[549] = 243147; +inp[550] = 1742; +inp[551] = 242269; +inp[552] = 1730; +inp[553] = 241398; +inp[554] = 1718; +inp[555] = 240533; +inp[556] = 1705; +inp[557] = 239674; +inp[558] = 1693; +inp[559] = 238821; +inp[560] = 1681; +inp[561] = 237974; +inp[562] = 1669; +inp[563] = 237133; +inp[564] = 1658; +inp[565] = 236298; +inp[566] = 1646; +inp[567] = 235469; +inp[568] = 1635; +inp[569] = 234646; +inp[570] = 1623; +inp[571] = 233828; +inp[572] = 1612; +inp[573] = 233016; +inp[574] = 1601; +inp[575] = 232210; +inp[576] = 1590; +inp[577] = 231409; +inp[578] = 1579; +inp[579] = 230614; +inp[580] = 1568; +inp[581] = 229824; +inp[582] = 1558; +inp[583] = 229040; +inp[584] = 1547; +inp[585] = 228261; +inp[586] = 1537; +inp[587] = 227487; +inp[588] = 1526; +inp[589] = 226718; +inp[590] = 1516; +inp[591] = 225955; +inp[592] = 1506; +inp[593] = 225197; +inp[594] = 1496; +inp[595] = 224444; +inp[596] = 1486; +inp[597] = 223695; +inp[598] = 1476; +inp[599] = 222952; +inp[600] = 1466; +inp[601] = 222214; +inp[602] = 1457; +inp[603] = 221481; +inp[604] = 1447; +inp[605] = 220752; +inp[606] = 1438; +inp[607] = 220028; +inp[608] = 1428; +inp[609] = 219309; +inp[610] = 1419; +inp[611] = 218595; +inp[612] = 1410; +inp[613] = 217885; +inp[614] = 1401; +inp[615] = 217180; +inp[616] = 1392; +inp[617] = 216479; +inp[618] = 1383; +inp[619] = 215783; +inp[620] = 1374; +inp[621] = 215092; +inp[622] = 1365; +inp[623] = 214405; +inp[624] = 1356; +inp[625] = 213722; +inp[626] = 1348; +inp[627] = 213043; +inp[628] = 1339; +inp[629] = 212369; +inp[630] = 1331; +inp[631] = 211699; +inp[632] = 1323; +inp[633] = 211033; +inp[634] = 1314; +inp[635] = 210372; +inp[636] = 1306; +inp[637] = 209714; +inp[638] = 1298; +inp[639] = 209061; +inp[640] = 1290; +inp[641] = 208412; +inp[642] = 1282; +inp[643] = 207767; +inp[644] = 1274; +inp[645] = 207125; +inp[646] = 1266; +inp[647] = 206488; +inp[648] = 1259; +inp[649] = 205855; +inp[650] = 1251; +inp[651] = 205225; +inp[652] = 1243; +inp[653] = 204599; +inp[654] = 1236; +inp[655] = 203978; +inp[656] = 1228; +inp[657] = 203359; +inp[658] = 1221; +inp[659] = 202745; +inp[660] = 1214; +inp[661] = 202134; +inp[662] = 1206; +inp[663] = 201527; +inp[664] = 1199; +inp[665] = 200924; +inp[666] = 1192; +inp[667] = 200324; +inp[668] = 1185; +inp[669] = 199728; +inp[670] = 1178; +inp[671] = 199135; +inp[672] = 1171; +inp[673] = 198546; +inp[674] = 1164; +inp[675] = 197961; +inp[676] = 1157; +inp[677] = 197378; +inp[678] = 1150; +inp[679] = 196799; +inp[680] = 1144; +inp[681] = 196224; +inp[682] = 1137; +inp[683] = 195652; +inp[684] = 1130; +inp[685] = 195083; +inp[686] = 1124; +inp[687] = 194518; +inp[688] = 1117; +inp[689] = 193956; +inp[690] = 1111; +inp[691] = 193397; +inp[692] = 1105; +inp[693] = 192841; +inp[694] = 1098; +inp[695] = 192288; +inp[696] = 1092; +inp[697] = 191739; +inp[698] = 1086; +inp[699] = 191193; +inp[700] = 1080; +inp[701] = 190649; +inp[702] = 1074; +inp[703] = 190109; +inp[704] = 1068; +inp[705] = 189572; +inp[706] = 1062; +inp[707] = 189038; +inp[708] = 1056; +inp[709] = 188507; +inp[710] = 1050; +inp[711] = 187979; +inp[712] = 1044; +inp[713] = 187454; +inp[714] = 1038; +inp[715] = 186932; +inp[716] = 1032; +inp[717] = 186413; +inp[718] = 1027; +inp[719] = 185896; +inp[720] = 1021; +inp[721] = 185383; +inp[722] = 1015; +inp[723] = 184872; +inp[724] = 1010; +inp[725] = 184364; +inp[726] = 1004; +inp[727] = 183859; +inp[728] = 999; +inp[729] = 183357; +inp[730] = 993; +inp[731] = 182857; +inp[732] = 988; +inp[733] = 182360; +inp[734] = 983; +inp[735] = 181866; +inp[736] = 977; +inp[737] = 181375; +inp[738] = 972; +inp[739] = 180886; +inp[740] = 967; +inp[741] = 180400; +inp[742] = 962; +inp[743] = 179916; +inp[744] = 956; +inp[745] = 179435; +inp[746] = 951; +inp[747] = 178956; +inp[748] = 946; +inp[749] = 178480; +inp[750] = 941; +inp[751] = 178007; +inp[752] = 936; +inp[753] = 177536; +inp[754] = 931; +inp[755] = 177068; +inp[756] = 927; +inp[757] = 176602; +inp[758] = 922; +inp[759] = 176138; +inp[760] = 917; +inp[761] = 175677; +inp[762] = 912; +inp[763] = 175218; +inp[764] = 907; +inp[765] = 174762; +inp[766] = 903; +inp[767] = 174308; +inp[768] = 898; +inp[769] = 173857; +inp[770] = 893; +inp[771] = 173407; +inp[772] = 889; +inp[773] = 172960; +inp[774] = 884; +inp[775] = 172516; +inp[776] = 880; +inp[777] = 172073; +inp[778] = 875; +inp[779] = 171633; +inp[780] = 871; +inp[781] = 171195; +inp[782] = 866; +inp[783] = 170760; +inp[784] = 862; +inp[785] = 170326; +inp[786] = 858; +inp[787] = 169895; +inp[788] = 853; +inp[789] = 169466; +inp[790] = 849; +inp[791] = 169039; +inp[792] = 845; +inp[793] = 168615; +inp[794] = 840; +inp[795] = 168192; +inp[796] = 836; +inp[797] = 167772; +inp[798] = 832; +inp[799] = 167353; +inp[800] = 828; +inp[801] = 166937; +inp[802] = 824; +inp[803] = 166523; +inp[804] = 820; +inp[805] = 166110; +inp[806] = 816; +inp[807] = 165700; +inp[808] = 812; +inp[809] = 165292; +inp[810] = 808; +inp[811] = 164886; +inp[812] = 804; +inp[813] = 164482; +inp[814] = 800; +inp[815] = 164080; +inp[816] = 796; +inp[817] = 163680; +inp[818] = 792; +inp[819] = 163281; +inp[820] = 788; +inp[821] = 162885; +inp[822] = 784; +inp[823] = 162491; +inp[824] = 781; +inp[825] = 162098; +inp[826] = 777; +inp[827] = 161707; +inp[828] = 773; +inp[829] = 161319; +inp[830] = 770; +inp[831] = 160932; +inp[832] = 766; +inp[833] = 160547; +inp[834] = 762; +inp[835] = 160164; +inp[836] = 759; +inp[837] = 159782; +inp[838] = 755; +inp[839] = 159403; +inp[840] = 751; +inp[841] = 159025; +inp[842] = 748; +inp[843] = 158649; +inp[844] = 744; +inp[845] = 158275; +inp[846] = 741; +inp[847] = 157903; +inp[848] = 737; +inp[849] = 157532; +inp[850] = 734; +inp[851] = 157163; +inp[852] = 730; +inp[853] = 156796; +inp[854] = 727; +inp[855] = 156430; +inp[856] = 724; +inp[857] = 156067; +inp[858] = 720; +inp[859] = 155704; +inp[860] = 717; +inp[861] = 155344; +inp[862] = 714; +inp[863] = 154985; +inp[864] = 710; +inp[865] = 154628; +inp[866] = 707; +inp[867] = 154273; +inp[868] = 704; +inp[869] = 153919; +inp[870] = 701; +inp[871] = 153567; +inp[872] = 698; +inp[873] = 153216; +inp[874] = 694; +inp[875] = 152867; +inp[876] = 691; +inp[877] = 152520; +inp[878] = 688; +inp[879] = 152174; +inp[880] = 685; +inp[881] = 151829; +inp[882] = 682; +inp[883] = 151487; +inp[884] = 679; +inp[885] = 151145; +inp[886] = 676; +inp[887] = 150806; +inp[888] = 673; +inp[889] = 150468; +inp[890] = 670; +inp[891] = 150131; +inp[892] = 667; +inp[893] = 149796; +inp[894] = 664; +inp[895] = 149462; +inp[896] = 661; +inp[897] = 149130; +inp[898] = 658; +inp[899] = 148800; +inp[900] = 655; +inp[901] = 148470; +inp[902] = 652; +inp[903] = 148143; +inp[904] = 649; +inp[905] = 147816; +inp[906] = 646; +inp[907] = 147491; +inp[908] = 644; +inp[909] = 147168; +inp[910] = 641; +inp[911] = 146846; +inp[912] = 638; +inp[913] = 146525; +inp[914] = 635; +inp[915] = 146206; +inp[916] = 632; +inp[917] = 145888; +inp[918] = 630; +inp[919] = 145572; +inp[920] = 627; +inp[921] = 145257; +inp[922] = 624; +inp[923] = 144943; +inp[924] = 622; +inp[925] = 144631; +inp[926] = 619; +inp[927] = 144320; +inp[928] = 616; +inp[929] = 144010; +inp[930] = 614; +inp[931] = 143701; +inp[932] = 611; +inp[933] = 143394; +inp[934] = 608; +inp[935] = 143089; +inp[936] = 606; +inp[937] = 142784; +inp[938] = 603; +inp[939] = 142481; +inp[940] = 601; +inp[941] = 142179; +inp[942] = 598; +inp[943] = 141879; +inp[944] = 596; +inp[945] = 141579; +inp[946] = 593; +inp[947] = 141281; +inp[948] = 591; +inp[949] = 140984; +inp[950] = 588; +inp[951] = 140689; +inp[952] = 586; +inp[953] = 140395; +inp[954] = 583; +inp[955] = 140101; +inp[956] = 581; +inp[957] = 139810; +inp[958] = 578; +inp[959] = 139519; +inp[960] = 576; +inp[961] = 139229; +inp[962] = 574; +inp[963] = 138941; +inp[964] = 571; +inp[965] = 138654; +inp[966] = 569; +inp[967] = 138368; +inp[968] = 567; +inp[969] = 138084; +inp[970] = 564; +inp[971] = 137800; +inp[972] = 562; +inp[973] = 137518; +inp[974] = 560; +inp[975] = 137236; +inp[976] = 557; +inp[977] = 136956; +inp[978] = 555; +inp[979] = 136677; +inp[980] = 553; +inp[981] = 136400; +inp[982] = 551; +inp[983] = 136123; +inp[984] = 548; +inp[985] = 135847; +inp[986] = 546; +inp[987] = 135573; +inp[988] = 544; +inp[989] = 135300; +inp[990] = 542; +inp[991] = 135027; +inp[992] = 540; +inp[993] = 134756; +inp[994] = 537; +inp[995] = 134486; +inp[996] = 535; +inp[997] = 134217; +inp[998] = 533; +inp[999] = 133949; +inp[1000] = 531; +inp[1001] = 133682; +inp[1002] = 529; +inp[1003] = 133417; +inp[1004] = 527; +inp[1005] = 133152; +inp[1006] = 525; +inp[1007] = 132888; +inp[1008] = 523; +inp[1009] = 132626; +inp[1010] = 521; +inp[1011] = 132364; +inp[1012] = 519; +inp[1013] = 132103; +inp[1014] = 517; +inp[1015] = 131844; +inp[1016] = 515; +inp[1017] = 131585; +inp[1018] = 513; +inp[1019] = 131328; +} + +def void fillLUTNEGEXP(int32_pl[33660] inp) +{ +inp[0] = 1073741824; +inp[1] = 1073741824; +inp[2] = 395007542; +inp[3] = 395007542; +inp[4] = 1073741824; +inp[5] = 1073741824; +inp[6] = 651257336; +inp[7] = 145315153; +inp[8] = 1073741824; +inp[9] = 1073741824; +inp[10] = 836230973; +inp[11] = 19666267; +inp[12] = 1073741824; +inp[13] = 1073741824; +inp[14] = 947573833; +inp[15] = 360200; +inp[16] = 1073741824; +inp[17] = 1073741824; +inp[18] = 1008687095; +inp[19] = 120; +inp[20] = 1073741824; +inp[21] = 1073741824; +inp[22] = 1040706261; +inp[23] = 0; +inp[24] = 1073741824; +inp[25] = 1073741824; +inp[26] = 1057094999; +inp[27] = 0; +inp[28] = 1073741824; +inp[29] = 1073741824; +inp[30] = 1065385898; +inp[31] = 0; +inp[32] = 1073741824; +inp[33] = 1073741824; +inp[34] = 1069555701; +inp[35] = 0; +inp[36] = 1073741824; +inp[37] = 1073741824; +inp[38] = 1071646718; +inp[39] = 0; +inp[40] = 1073741824; +inp[41] = 1073741824; +inp[42] = 1072693759; +inp[43] = 0; +inp[44] = 1073741824; +inp[45] = 1073741824; +inp[46] = 1073217663; +inp[47] = 0; +inp[48] = 1073741824; +inp[49] = 1073741824; +inp[50] = 1073479711; +inp[51] = 0; +inp[52] = 1073741824; +inp[53] = 1073741824; +inp[54] = 1073610759; +inp[55] = 0; +inp[56] = 1073741824; +inp[57] = 1073741824; +inp[58] = 1073676289; +inp[59] = 0; +inp[60] = 1073741824; +inp[61] = 1073741824; +inp[62] = 1073709056; +inp[63] = 0; +inp[64] = 1073741824; +inp[65] = 1073741824; +inp[66] = 1073725440; +inp[67] = 0; +inp[68] = 1073741824; +inp[69] = 1073741824; +inp[70] = 1073733632; +inp[71] = 0; +inp[72] = 1073741824; +inp[73] = 1073741824; +inp[74] = 1073737728; +inp[75] = 0; +inp[76] = 1073741824; +inp[77] = 1073741824; +inp[78] = 1073739776; +inp[79] = 0; +inp[80] = 1073741824; +inp[81] = 1073741824; +inp[82] = 1073740800; +inp[83] = 0; +inp[84] = 1073741824; +inp[85] = 1073741824; +inp[86] = 1073741312; +inp[87] = 0; +inp[88] = 1073741824; +inp[89] = 1073741824; +inp[90] = 1073741568; +inp[91] = 0; +inp[92] = 1073741824; +inp[93] = 1073741824; +inp[94] = 1073741696; +inp[95] = 0; +inp[96] = 1073741824; +inp[97] = 1073741824; +inp[98] = 1073741760; +inp[99] = 0; +inp[100] = 1073741824; +inp[101] = 1073741824; +inp[102] = 1073741792; +inp[103] = 0; +inp[104] = 1073741824; +inp[105] = 1073741824; +inp[106] = 1073741808; +inp[107] = 0; +inp[108] = 1073741824; +inp[109] = 1073741824; +inp[110] = 1073741816; +inp[111] = 0; +inp[112] = 1073741824; +inp[113] = 1073741824; +inp[114] = 1073741820; +inp[115] = 0; +inp[116] = 1073741824; +inp[117] = 1073741824; +inp[118] = 1073741822; +inp[119] = 0; +inp[120] = 1073741824; +inp[121] = 1073741824; +inp[122] = 1073741823; +inp[123] = 0; +inp[124] = 1073741824; +inp[125] = 1073741824; +inp[126] = 1073741823; +inp[127] = 0; +inp[128] = 1073741824; +inp[129] = 1073741824; +inp[130] = 1073741823; +inp[131] = 0; +inp[132] = 1073741824; +inp[133] = 1073741824; +inp[134] = 395007542; +inp[135] = 395007542; +inp[136] = 145315153; +inp[137] = 145315153; +inp[138] = 53458457; +inp[139] = 53458457; +inp[140] = 1073741824; +inp[141] = 1073741824; +inp[142] = 651257336; +inp[143] = 145315153; +inp[144] = 395007542; +inp[145] = 19666267; +inp[146] = 239584185; +inp[147] = 2661539; +inp[148] = 1073741824; +inp[149] = 1073741824; +inp[150] = 836230973; +inp[151] = 19666267; +inp[152] = 651257336; +inp[153] = 360200; +inp[154] = 507199723; +inp[155] = 6597; +inp[156] = 1073741824; +inp[157] = 1073741824; +inp[158] = 947573833; +inp[159] = 360200; +inp[160] = 836230973; +inp[161] = 120; +inp[162] = 737971243; +inp[163] = 0; +inp[164] = 1073741824; +inp[165] = 1073741824; +inp[166] = 1008687095; +inp[167] = 120; +inp[168] = 947573833; +inp[169] = 0; +inp[170] = 890163237; +inp[171] = 0; +inp[172] = 1073741824; +inp[173] = 1073741824; +inp[174] = 1040706261; +inp[175] = 0; +inp[176] = 1008687095; +inp[177] = 0; +inp[178] = 977653056; +inp[179] = 0; +inp[180] = 1073741824; +inp[181] = 1073741824; +inp[182] = 1057094999; +inp[183] = 0; +inp[184] = 1040706261; +inp[185] = 0; +inp[186] = 1024571605; +inp[187] = 0; +inp[188] = 1073741824; +inp[189] = 1073741824; +inp[190] = 1065385898; +inp[191] = 0; +inp[192] = 1057094999; +inp[193] = 0; +inp[194] = 1048868621; +inp[195] = 0; +inp[196] = 1073741824; +inp[197] = 1073741824; +inp[198] = 1069555701; +inp[199] = 0; +inp[200] = 1065385898; +inp[201] = 0; +inp[202] = 1061232352; +inp[203] = 0; +inp[204] = 1073741824; +inp[205] = 1073741824; +inp[206] = 1071646718; +inp[207] = 0; +inp[208] = 1069555701; +inp[209] = 0; +inp[210] = 1067468764; +inp[211] = 0; +inp[212] = 1073741824; +inp[213] = 1073741824; +inp[214] = 1072693759; +inp[215] = 0; +inp[216] = 1071646718; +inp[217] = 0; +inp[218] = 1070600699; +inp[219] = 0; +inp[220] = 1073741824; +inp[221] = 1073741824; +inp[222] = 1073217663; +inp[223] = 0; +inp[224] = 1072693759; +inp[225] = 0; +inp[226] = 1072170111; +inp[227] = 0; +inp[228] = 1073741824; +inp[229] = 1073741824; +inp[230] = 1073479711; +inp[231] = 0; +inp[232] = 1073217663; +inp[233] = 0; +inp[234] = 1072955679; +inp[235] = 0; +inp[236] = 1073741824; +inp[237] = 1073741824; +inp[238] = 1073610759; +inp[239] = 0; +inp[240] = 1073479711; +inp[241] = 0; +inp[242] = 1073348679; +inp[243] = 0; +inp[244] = 1073741824; +inp[245] = 1073741824; +inp[246] = 1073676289; +inp[247] = 0; +inp[248] = 1073610759; +inp[249] = 0; +inp[250] = 1073545233; +inp[251] = 0; +inp[252] = 1073741824; +inp[253] = 1073741824; +inp[254] = 1073709056; +inp[255] = 0; +inp[256] = 1073676289; +inp[257] = 0; +inp[258] = 1073643524; +inp[259] = 0; +inp[260] = 1073741824; +inp[261] = 1073741824; +inp[262] = 1073725440; +inp[263] = 0; +inp[264] = 1073709056; +inp[265] = 0; +inp[266] = 1073692673; +inp[267] = 0; +inp[268] = 1073741824; +inp[269] = 1073741824; +inp[270] = 1073733632; +inp[271] = 0; +inp[272] = 1073725440; +inp[273] = 0; +inp[274] = 1073717248; +inp[275] = 0; +inp[276] = 1073741824; +inp[277] = 1073741824; +inp[278] = 1073737728; +inp[279] = 0; +inp[280] = 1073733632; +inp[281] = 0; +inp[282] = 1073729536; +inp[283] = 0; +inp[284] = 1073741824; +inp[285] = 1073741824; +inp[286] = 1073739776; +inp[287] = 0; +inp[288] = 1073737728; +inp[289] = 0; +inp[290] = 1073735680; +inp[291] = 0; +inp[292] = 1073741824; +inp[293] = 1073741824; +inp[294] = 1073740800; +inp[295] = 0; +inp[296] = 1073739776; +inp[297] = 0; +inp[298] = 1073738752; +inp[299] = 0; +inp[300] = 1073741824; +inp[301] = 1073741824; +inp[302] = 1073741312; +inp[303] = 0; +inp[304] = 1073740800; +inp[305] = 0; +inp[306] = 1073740288; +inp[307] = 0; +inp[308] = 1073741824; +inp[309] = 1073741824; +inp[310] = 1073741568; +inp[311] = 0; +inp[312] = 1073741312; +inp[313] = 0; +inp[314] = 1073741056; +inp[315] = 0; +inp[316] = 1073741824; +inp[317] = 1073741824; +inp[318] = 1073741696; +inp[319] = 0; +inp[320] = 1073741568; +inp[321] = 0; +inp[322] = 1073741440; +inp[323] = 0; +inp[324] = 1073741824; +inp[325] = 1073741824; +inp[326] = 1073741760; +inp[327] = 0; +inp[328] = 1073741696; +inp[329] = 0; +inp[330] = 1073741632; +inp[331] = 0; +inp[332] = 1073741824; +inp[333] = 1073741824; +inp[334] = 1073741792; +inp[335] = 0; +inp[336] = 1073741760; +inp[337] = 0; +inp[338] = 1073741728; +inp[339] = 0; +inp[340] = 1073741824; +inp[341] = 1073741824; +inp[342] = 1073741808; +inp[343] = 0; +inp[344] = 1073741792; +inp[345] = 0; +inp[346] = 1073741776; +inp[347] = 0; +inp[348] = 1073741824; +inp[349] = 1073741824; +inp[350] = 1073741816; +inp[351] = 0; +inp[352] = 1073741808; +inp[353] = 0; +inp[354] = 1073741800; +inp[355] = 0; +inp[356] = 1073741824; +inp[357] = 1073741824; +inp[358] = 1073741820; +inp[359] = 0; +inp[360] = 1073741816; +inp[361] = 0; +inp[362] = 1073741812; +inp[363] = 0; +inp[364] = 1073741824; +inp[365] = 1073741824; +inp[366] = 1073741822; +inp[367] = 0; +inp[368] = 1073741820; +inp[369] = 0; +inp[370] = 1073741818; +inp[371] = 0; +inp[372] = 1073741824; +inp[373] = 1073741824; +inp[374] = 1073741823; +inp[375] = 0; +inp[376] = 1073741822; +inp[377] = 0; +inp[378] = 1073741821; +inp[379] = 0; +inp[380] = 1073741824; +inp[381] = 1073741824; +inp[382] = 1073741823; +inp[383] = 0; +inp[384] = 1073741823; +inp[385] = 0; +inp[386] = 1073741822; +inp[387] = 0; +inp[388] = 1073741824; +inp[389] = 1073741824; +inp[390] = 1073741823; +inp[391] = 0; +inp[392] = 1073741823; +inp[393] = 0; +inp[394] = 1073741823; +inp[395] = 0; +inp[396] = 1073741824; +inp[397] = 1073741824; +inp[398] = 395007542; +inp[399] = 395007542; +inp[400] = 145315153; +inp[401] = 145315153; +inp[402] = 53458457; +inp[403] = 53458457; +inp[404] = 19666267; +inp[405] = 19666267; +inp[406] = 7234815; +inp[407] = 7234815; +inp[408] = 2661539; +inp[409] = 2661539; +inp[410] = 979125; +inp[411] = 979125; +inp[412] = 1073741824; +inp[413] = 1073741824; +inp[414] = 651257336; +inp[415] = 145315153; +inp[416] = 395007542; +inp[417] = 19666267; +inp[418] = 239584185; +inp[419] = 2661539; +inp[420] = 145315153; +inp[421] = 360200; +inp[422] = 88138096; +inp[423] = 48747; +inp[424] = 53458457; +inp[425] = 6597; +inp[426] = 32424193; +inp[427] = 892; +inp[428] = 1073741824; +inp[429] = 1073741824; +inp[430] = 836230973; +inp[431] = 19666267; +inp[432] = 651257336; +inp[433] = 360200; +inp[434] = 507199723; +inp[435] = 6597; +inp[436] = 395007542; +inp[437] = 120; +inp[438] = 307632183; +inp[439] = 2; +inp[440] = 239584185; +inp[441] = 0; +inp[442] = 186588351; +inp[443] = 0; +inp[444] = 1073741824; +inp[445] = 1073741824; +inp[446] = 947573833; +inp[447] = 360200; +inp[448] = 836230973; +inp[449] = 120; +inp[450] = 737971243; +inp[451] = 0; +inp[452] = 651257336; +inp[453] = 0; +inp[454] = 574732582; +inp[455] = 0; +inp[456] = 507199723; +inp[457] = 0; +inp[458] = 447602185; +inp[459] = 0; +inp[460] = 1073741824; +inp[461] = 1073741824; +inp[462] = 1008687095; +inp[463] = 120; +inp[464] = 947573833; +inp[465] = 0; +inp[466] = 890163237; +inp[467] = 0; +inp[468] = 836230973; +inp[469] = 0; +inp[470] = 785566299; +inp[471] = 0; +inp[472] = 737971243; +inp[473] = 0; +inp[474] = 693259826; +inp[475] = 0; +inp[476] = 1073741824; +inp[477] = 1073741824; +inp[478] = 1040706261; +inp[479] = 0; +inp[480] = 1008687095; +inp[481] = 0; +inp[482] = 977653056; +inp[483] = 0; +inp[484] = 947573833; +inp[485] = 0; +inp[486] = 918420051; +inp[487] = 0; +inp[488] = 890163237; +inp[489] = 0; +inp[490] = 862775793; +inp[491] = 0; +inp[492] = 1073741824; +inp[493] = 1073741824; +inp[494] = 1057094999; +inp[495] = 0; +inp[496] = 1040706261; +inp[497] = 0; +inp[498] = 1024571605; +inp[499] = 0; +inp[500] = 1008687095; +inp[501] = 0; +inp[502] = 993048851; +inp[503] = 0; +inp[504] = 977653056; +inp[505] = 0; +inp[506] = 962495950; +inp[507] = 0; +inp[508] = 1073741824; +inp[509] = 1073741824; +inp[510] = 1065385898; +inp[511] = 0; +inp[512] = 1057094999; +inp[513] = 0; +inp[514] = 1048868621; +inp[515] = 0; +inp[516] = 1040706261; +inp[517] = 0; +inp[518] = 1032607420; +inp[519] = 0; +inp[520] = 1024571605; +inp[521] = 0; +inp[522] = 1016598326; +inp[523] = 0; +inp[524] = 1073741824; +inp[525] = 1073741824; +inp[526] = 1069555701; +inp[527] = 0; +inp[528] = 1065385898; +inp[529] = 0; +inp[530] = 1061232352; +inp[531] = 0; +inp[532] = 1057094999; +inp[533] = 0; +inp[534] = 1052973777; +inp[535] = 0; +inp[536] = 1048868621; +inp[537] = 0; +inp[538] = 1044779470; +inp[539] = 0; +inp[540] = 1073741824; +inp[541] = 1073741824; +inp[542] = 1071646718; +inp[543] = 0; +inp[544] = 1069555701; +inp[545] = 0; +inp[546] = 1067468764; +inp[547] = 0; +inp[548] = 1065385898; +inp[549] = 0; +inp[550] = 1063307097; +inp[551] = 0; +inp[552] = 1061232352; +inp[553] = 0; +inp[554] = 1059161656; +inp[555] = 0; +inp[556] = 1073741824; +inp[557] = 1073741824; +inp[558] = 1072693759; +inp[559] = 0; +inp[560] = 1071646718; +inp[561] = 0; +inp[562] = 1070600699; +inp[563] = 0; +inp[564] = 1069555701; +inp[565] = 0; +inp[566] = 1068511723; +inp[567] = 0; +inp[568] = 1067468764; +inp[569] = 0; +inp[570] = 1066426822; +inp[571] = 0; +inp[572] = 1073741824; +inp[573] = 1073741824; +inp[574] = 1073217663; +inp[575] = 0; +inp[576] = 1072693759; +inp[577] = 0; +inp[578] = 1072170111; +inp[579] = 0; +inp[580] = 1071646718; +inp[581] = 0; +inp[582] = 1071123581; +inp[583] = 0; +inp[584] = 1070600699; +inp[585] = 0; +inp[586] = 1070078072; +inp[587] = 0; +inp[588] = 1073741824; +inp[589] = 1073741824; +inp[590] = 1073479711; +inp[591] = 0; +inp[592] = 1073217663; +inp[593] = 0; +inp[594] = 1072955679; +inp[595] = 0; +inp[596] = 1072693759; +inp[597] = 0; +inp[598] = 1072431903; +inp[599] = 0; +inp[600] = 1072170111; +inp[601] = 0; +inp[602] = 1071908383; +inp[603] = 0; +inp[604] = 1073741824; +inp[605] = 1073741824; +inp[606] = 1073610759; +inp[607] = 0; +inp[608] = 1073479711; +inp[609] = 0; +inp[610] = 1073348679; +inp[611] = 0; +inp[612] = 1073217663; +inp[613] = 0; +inp[614] = 1073086663; +inp[615] = 0; +inp[616] = 1072955679; +inp[617] = 0; +inp[618] = 1072824711; +inp[619] = 0; +inp[620] = 1073741824; +inp[621] = 1073741824; +inp[622] = 1073676289; +inp[623] = 0; +inp[624] = 1073610759; +inp[625] = 0; +inp[626] = 1073545233; +inp[627] = 0; +inp[628] = 1073479711; +inp[629] = 0; +inp[630] = 1073414193; +inp[631] = 0; +inp[632] = 1073348679; +inp[633] = 0; +inp[634] = 1073283169; +inp[635] = 0; +inp[636] = 1073741824; +inp[637] = 1073741824; +inp[638] = 1073709056; +inp[639] = 0; +inp[640] = 1073676289; +inp[641] = 0; +inp[642] = 1073643524; +inp[643] = 0; +inp[644] = 1073610759; +inp[645] = 0; +inp[646] = 1073577996; +inp[647] = 0; +inp[648] = 1073545233; +inp[649] = 0; +inp[650] = 1073512472; +inp[651] = 0; +inp[652] = 1073741824; +inp[653] = 1073741824; +inp[654] = 1073725440; +inp[655] = 0; +inp[656] = 1073709056; +inp[657] = 0; +inp[658] = 1073692673; +inp[659] = 0; +inp[660] = 1073676289; +inp[661] = 0; +inp[662] = 1073659907; +inp[663] = 0; +inp[664] = 1073643524; +inp[665] = 0; +inp[666] = 1073627142; +inp[667] = 0; +inp[668] = 1073741824; +inp[669] = 1073741824; +inp[670] = 1073733632; +inp[671] = 0; +inp[672] = 1073725440; +inp[673] = 0; +inp[674] = 1073717248; +inp[675] = 0; +inp[676] = 1073709056; +inp[677] = 0; +inp[678] = 1073700864; +inp[679] = 0; +inp[680] = 1073692673; +inp[681] = 0; +inp[682] = 1073684481; +inp[683] = 0; +inp[684] = 1073741824; +inp[685] = 1073741824; +inp[686] = 1073737728; +inp[687] = 0; +inp[688] = 1073733632; +inp[689] = 0; +inp[690] = 1073729536; +inp[691] = 0; +inp[692] = 1073725440; +inp[693] = 0; +inp[694] = 1073721344; +inp[695] = 0; +inp[696] = 1073717248; +inp[697] = 0; +inp[698] = 1073713152; +inp[699] = 0; +inp[700] = 1073741824; +inp[701] = 1073741824; +inp[702] = 1073739776; +inp[703] = 0; +inp[704] = 1073737728; +inp[705] = 0; +inp[706] = 1073735680; +inp[707] = 0; +inp[708] = 1073733632; +inp[709] = 0; +inp[710] = 1073731584; +inp[711] = 0; +inp[712] = 1073729536; +inp[713] = 0; +inp[714] = 1073727488; +inp[715] = 0; +inp[716] = 1073741824; +inp[717] = 1073741824; +inp[718] = 1073740800; +inp[719] = 0; +inp[720] = 1073739776; +inp[721] = 0; +inp[722] = 1073738752; +inp[723] = 0; +inp[724] = 1073737728; +inp[725] = 0; +inp[726] = 1073736704; +inp[727] = 0; +inp[728] = 1073735680; +inp[729] = 0; +inp[730] = 1073734656; +inp[731] = 0; +inp[732] = 1073741824; +inp[733] = 1073741824; +inp[734] = 1073741312; +inp[735] = 0; +inp[736] = 1073740800; +inp[737] = 0; +inp[738] = 1073740288; +inp[739] = 0; +inp[740] = 1073739776; +inp[741] = 0; +inp[742] = 1073739264; +inp[743] = 0; +inp[744] = 1073738752; +inp[745] = 0; +inp[746] = 1073738240; +inp[747] = 0; +inp[748] = 1073741824; +inp[749] = 1073741824; +inp[750] = 1073741568; +inp[751] = 0; +inp[752] = 1073741312; +inp[753] = 0; +inp[754] = 1073741056; +inp[755] = 0; +inp[756] = 1073740800; +inp[757] = 0; +inp[758] = 1073740544; +inp[759] = 0; +inp[760] = 1073740288; +inp[761] = 0; +inp[762] = 1073740032; +inp[763] = 0; +inp[764] = 1073741824; +inp[765] = 1073741824; +inp[766] = 1073741696; +inp[767] = 0; +inp[768] = 1073741568; +inp[769] = 0; +inp[770] = 1073741440; +inp[771] = 0; +inp[772] = 1073741312; +inp[773] = 0; +inp[774] = 1073741184; +inp[775] = 0; +inp[776] = 1073741056; +inp[777] = 0; +inp[778] = 1073740928; +inp[779] = 0; +inp[780] = 1073741824; +inp[781] = 1073741824; +inp[782] = 1073741760; +inp[783] = 0; +inp[784] = 1073741696; +inp[785] = 0; +inp[786] = 1073741632; +inp[787] = 0; +inp[788] = 1073741568; +inp[789] = 0; +inp[790] = 1073741504; +inp[791] = 0; +inp[792] = 1073741440; +inp[793] = 0; +inp[794] = 1073741376; +inp[795] = 0; +inp[796] = 1073741824; +inp[797] = 1073741824; +inp[798] = 1073741792; +inp[799] = 0; +inp[800] = 1073741760; +inp[801] = 0; +inp[802] = 1073741728; +inp[803] = 0; +inp[804] = 1073741696; +inp[805] = 0; +inp[806] = 1073741664; +inp[807] = 0; +inp[808] = 1073741632; +inp[809] = 0; +inp[810] = 1073741600; +inp[811] = 0; +inp[812] = 1073741824; +inp[813] = 1073741824; +inp[814] = 1073741808; +inp[815] = 0; +inp[816] = 1073741792; +inp[817] = 0; +inp[818] = 1073741776; +inp[819] = 0; +inp[820] = 1073741760; +inp[821] = 0; +inp[822] = 1073741744; +inp[823] = 0; +inp[824] = 1073741728; +inp[825] = 0; +inp[826] = 1073741712; +inp[827] = 0; +inp[828] = 1073741824; +inp[829] = 1073741824; +inp[830] = 1073741816; +inp[831] = 0; +inp[832] = 1073741808; +inp[833] = 0; +inp[834] = 1073741800; +inp[835] = 0; +inp[836] = 1073741792; +inp[837] = 0; +inp[838] = 1073741784; +inp[839] = 0; +inp[840] = 1073741776; +inp[841] = 0; +inp[842] = 1073741768; +inp[843] = 0; +inp[844] = 1073741824; +inp[845] = 1073741824; +inp[846] = 1073741820; +inp[847] = 0; +inp[848] = 1073741816; +inp[849] = 0; +inp[850] = 1073741812; +inp[851] = 0; +inp[852] = 1073741808; +inp[853] = 0; +inp[854] = 1073741804; +inp[855] = 0; +inp[856] = 1073741800; +inp[857] = 0; +inp[858] = 1073741796; +inp[859] = 0; +inp[860] = 1073741824; +inp[861] = 1073741824; +inp[862] = 1073741822; +inp[863] = 0; +inp[864] = 1073741820; +inp[865] = 0; +inp[866] = 1073741818; +inp[867] = 0; +inp[868] = 1073741816; +inp[869] = 0; +inp[870] = 1073741814; +inp[871] = 0; +inp[872] = 1073741812; +inp[873] = 0; +inp[874] = 1073741810; +inp[875] = 0; +inp[876] = 1073741824; +inp[877] = 1073741824; +inp[878] = 1073741823; +inp[879] = 0; +inp[880] = 1073741822; +inp[881] = 0; +inp[882] = 1073741821; +inp[883] = 0; +inp[884] = 1073741820; +inp[885] = 0; +inp[886] = 1073741819; +inp[887] = 0; +inp[888] = 1073741818; +inp[889] = 0; +inp[890] = 1073741817; +inp[891] = 0; +inp[892] = 1073741824; +inp[893] = 1073741824; +inp[894] = 1073741823; +inp[895] = 0; +inp[896] = 1073741823; +inp[897] = 0; +inp[898] = 1073741822; +inp[899] = 0; +inp[900] = 1073741822; +inp[901] = 0; +inp[902] = 1073741821; +inp[903] = 0; +inp[904] = 1073741821; +inp[905] = 0; +inp[906] = 1073741820; +inp[907] = 0; +inp[908] = 1073741824; +inp[909] = 1073741824; +inp[910] = 1073741823; +inp[911] = 0; +inp[912] = 1073741823; +inp[913] = 0; +inp[914] = 1073741823; +inp[915] = 0; +inp[916] = 1073741823; +inp[917] = 0; +inp[918] = 1073741822; +inp[919] = 0; +inp[920] = 1073741822; +inp[921] = 0; +inp[922] = 1073741822; +inp[923] = 0; +inp[924] = 1073741824; +inp[925] = 1073741824; +inp[926] = 395007542; +inp[927] = 395007542; +inp[928] = 145315153; +inp[929] = 145315153; +inp[930] = 53458457; +inp[931] = 53458457; +inp[932] = 19666267; +inp[933] = 19666267; +inp[934] = 7234815; +inp[935] = 7234815; +inp[936] = 2661539; +inp[937] = 2661539; +inp[938] = 979125; +inp[939] = 979125; +inp[940] = 360200; +inp[941] = 360200; +inp[942] = 132510; +inp[943] = 132510; +inp[944] = 48747; +inp[945] = 48747; +inp[946] = 17933; +inp[947] = 17933; +inp[948] = 6597; +inp[949] = 6597; +inp[950] = 2427; +inp[951] = 2427; +inp[952] = 892; +inp[953] = 892; +inp[954] = 328; +inp[955] = 328; +inp[956] = 1073741824; +inp[957] = 1073741824; +inp[958] = 651257336; +inp[959] = 145315153; +inp[960] = 395007542; +inp[961] = 19666267; +inp[962] = 239584185; +inp[963] = 2661539; +inp[964] = 145315153; +inp[965] = 360200; +inp[966] = 88138096; +inp[967] = 48747; +inp[968] = 53458457; +inp[969] = 6597; +inp[970] = 32424193; +inp[971] = 892; +inp[972] = 19666267; +inp[973] = 120; +inp[974] = 11928194; +inp[975] = 16; +inp[976] = 7234815; +inp[977] = 2; +inp[978] = 4388137; +inp[979] = 0; +inp[980] = 2661539; +inp[981] = 0; +inp[982] = 1614305; +inp[983] = 0; +inp[984] = 979125; +inp[985] = 0; +inp[986] = 593869; +inp[987] = 0; +inp[988] = 1073741824; +inp[989] = 1073741824; +inp[990] = 836230973; +inp[991] = 19666267; +inp[992] = 651257336; +inp[993] = 360200; +inp[994] = 507199723; +inp[995] = 6597; +inp[996] = 395007542; +inp[997] = 120; +inp[998] = 307632183; +inp[999] = 2; +inp[1000] = 239584185; +inp[1001] = 0; +inp[1002] = 186588351; +inp[1003] = 0; +inp[1004] = 145315153; +inp[1005] = 0; +inp[1006] = 113171555; +inp[1007] = 0; +inp[1008] = 88138096; +inp[1009] = 0; +inp[1010] = 68642018; +inp[1011] = 0; +inp[1012] = 53458457; +inp[1013] = 0; +inp[1014] = 41633488; +inp[1015] = 0; +inp[1016] = 32424193; +inp[1017] = 0; +inp[1018] = 25251987; +inp[1019] = 0; +inp[1020] = 1073741824; +inp[1021] = 1073741824; +inp[1022] = 947573833; +inp[1023] = 360200; +inp[1024] = 836230973; +inp[1025] = 120; +inp[1026] = 737971243; +inp[1027] = 0; +inp[1028] = 651257336; +inp[1029] = 0; +inp[1030] = 574732582; +inp[1031] = 0; +inp[1032] = 507199723; +inp[1033] = 0; +inp[1034] = 447602185; +inp[1035] = 0; +inp[1036] = 395007542; +inp[1037] = 0; +inp[1038] = 348592932; +inp[1039] = 0; +inp[1040] = 307632183; +inp[1041] = 0; +inp[1042] = 271484448; +inp[1043] = 0; +inp[1044] = 239584185; +inp[1045] = 0; +inp[1046] = 211432301; +inp[1047] = 0; +inp[1048] = 186588351; +inp[1049] = 0; +inp[1050] = 164663641; +inp[1051] = 0; +inp[1052] = 1073741824; +inp[1053] = 1073741824; +inp[1054] = 1008687095; +inp[1055] = 120; +inp[1056] = 947573833; +inp[1057] = 0; +inp[1058] = 890163237; +inp[1059] = 0; +inp[1060] = 836230973; +inp[1061] = 0; +inp[1062] = 785566299; +inp[1063] = 0; +inp[1064] = 737971243; +inp[1065] = 0; +inp[1066] = 693259826; +inp[1067] = 0; +inp[1068] = 651257336; +inp[1069] = 0; +inp[1070] = 611799649; +inp[1071] = 0; +inp[1072] = 574732582; +inp[1073] = 0; +inp[1074] = 539911295; +inp[1075] = 0; +inp[1076] = 507199723; +inp[1077] = 0; +inp[1078] = 476470046; +inp[1079] = 0; +inp[1080] = 447602185; +inp[1081] = 0; +inp[1082] = 420483339; +inp[1083] = 0; +inp[1084] = 1073741824; +inp[1085] = 1073741824; +inp[1086] = 1040706261; +inp[1087] = 0; +inp[1088] = 1008687095; +inp[1089] = 0; +inp[1090] = 977653056; +inp[1091] = 0; +inp[1092] = 947573833; +inp[1093] = 0; +inp[1094] = 918420051; +inp[1095] = 0; +inp[1096] = 890163237; +inp[1097] = 0; +inp[1098] = 862775793; +inp[1099] = 0; +inp[1100] = 836230973; +inp[1101] = 0; +inp[1102] = 810502851; +inp[1103] = 0; +inp[1104] = 785566299; +inp[1105] = 0; +inp[1106] = 761396965; +inp[1107] = 0; +inp[1108] = 737971243; +inp[1109] = 0; +inp[1110] = 715266255; +inp[1111] = 0; +inp[1112] = 693259826; +inp[1113] = 0; +inp[1114] = 671930463; +inp[1115] = 0; +inp[1116] = 1073741824; +inp[1117] = 1073741824; +inp[1118] = 1057094999; +inp[1119] = 0; +inp[1120] = 1040706261; +inp[1121] = 0; +inp[1122] = 1024571605; +inp[1123] = 0; +inp[1124] = 1008687095; +inp[1125] = 0; +inp[1126] = 993048851; +inp[1127] = 0; +inp[1128] = 977653056; +inp[1129] = 0; +inp[1130] = 962495950; +inp[1131] = 0; +inp[1132] = 947573833; +inp[1133] = 0; +inp[1134] = 932883063; +inp[1135] = 0; +inp[1136] = 918420051; +inp[1137] = 0; +inp[1138] = 904181268; +inp[1139] = 0; +inp[1140] = 890163237; +inp[1141] = 0; +inp[1142] = 876362535; +inp[1143] = 0; +inp[1144] = 862775793; +inp[1145] = 0; +inp[1146] = 849399695; +inp[1147] = 0; +inp[1148] = 1073741824; +inp[1149] = 1073741824; +inp[1150] = 1065385898; +inp[1151] = 0; +inp[1152] = 1057094999; +inp[1153] = 0; +inp[1154] = 1048868621; +inp[1155] = 0; +inp[1156] = 1040706261; +inp[1157] = 0; +inp[1158] = 1032607420; +inp[1159] = 0; +inp[1160] = 1024571605; +inp[1161] = 0; +inp[1162] = 1016598326; +inp[1163] = 0; +inp[1164] = 1008687095; +inp[1165] = 0; +inp[1166] = 1000837430; +inp[1167] = 0; +inp[1168] = 993048851; +inp[1169] = 0; +inp[1170] = 985320884; +inp[1171] = 0; +inp[1172] = 977653056; +inp[1173] = 0; +inp[1174] = 970044899; +inp[1175] = 0; +inp[1176] = 962495950; +inp[1177] = 0; +inp[1178] = 955005747; +inp[1179] = 0; +inp[1180] = 1073741824; +inp[1181] = 1073741824; +inp[1182] = 1069555701; +inp[1183] = 0; +inp[1184] = 1065385898; +inp[1185] = 0; +inp[1186] = 1061232352; +inp[1187] = 0; +inp[1188] = 1057094999; +inp[1189] = 0; +inp[1190] = 1052973777; +inp[1191] = 0; +inp[1192] = 1048868621; +inp[1193] = 0; +inp[1194] = 1044779470; +inp[1195] = 0; +inp[1196] = 1040706261; +inp[1197] = 0; +inp[1198] = 1036648931; +inp[1199] = 0; +inp[1200] = 1032607420; +inp[1201] = 0; +inp[1202] = 1028581665; +inp[1203] = 0; +inp[1204] = 1024571605; +inp[1205] = 0; +inp[1206] = 1020577179; +inp[1207] = 0; +inp[1208] = 1016598326; +inp[1209] = 0; +inp[1210] = 1012634985; +inp[1211] = 0; +inp[1212] = 1073741824; +inp[1213] = 1073741824; +inp[1214] = 1071646718; +inp[1215] = 0; +inp[1216] = 1069555701; +inp[1217] = 0; +inp[1218] = 1067468764; +inp[1219] = 0; +inp[1220] = 1065385898; +inp[1221] = 0; +inp[1222] = 1063307097; +inp[1223] = 0; +inp[1224] = 1061232352; +inp[1225] = 0; +inp[1226] = 1059161656; +inp[1227] = 0; +inp[1228] = 1057094999; +inp[1229] = 0; +inp[1230] = 1055032376; +inp[1231] = 0; +inp[1232] = 1052973777; +inp[1233] = 0; +inp[1234] = 1050919194; +inp[1235] = 0; +inp[1236] = 1048868621; +inp[1237] = 0; +inp[1238] = 1046822049; +inp[1239] = 0; +inp[1240] = 1044779470; +inp[1241] = 0; +inp[1242] = 1042740876; +inp[1243] = 0; +inp[1244] = 1073741824; +inp[1245] = 1073741824; +inp[1246] = 1072693759; +inp[1247] = 0; +inp[1248] = 1071646718; +inp[1249] = 0; +inp[1250] = 1070600699; +inp[1251] = 0; +inp[1252] = 1069555701; +inp[1253] = 0; +inp[1254] = 1068511723; +inp[1255] = 0; +inp[1256] = 1067468764; +inp[1257] = 0; +inp[1258] = 1066426822; +inp[1259] = 0; +inp[1260] = 1065385898; +inp[1261] = 0; +inp[1262] = 1064345990; +inp[1263] = 0; +inp[1264] = 1063307097; +inp[1265] = 0; +inp[1266] = 1062269218; +inp[1267] = 0; +inp[1268] = 1061232352; +inp[1269] = 0; +inp[1270] = 1060196498; +inp[1271] = 0; +inp[1272] = 1059161656; +inp[1273] = 0; +inp[1274] = 1058127823; +inp[1275] = 0; +inp[1276] = 1073741824; +inp[1277] = 1073741824; +inp[1278] = 1073217663; +inp[1279] = 0; +inp[1280] = 1072693759; +inp[1281] = 0; +inp[1282] = 1072170111; +inp[1283] = 0; +inp[1284] = 1071646718; +inp[1285] = 0; +inp[1286] = 1071123581; +inp[1287] = 0; +inp[1288] = 1070600699; +inp[1289] = 0; +inp[1290] = 1070078072; +inp[1291] = 0; +inp[1292] = 1069555701; +inp[1293] = 0; +inp[1294] = 1069033584; +inp[1295] = 0; +inp[1296] = 1068511723; +inp[1297] = 0; +inp[1298] = 1067990116; +inp[1299] = 0; +inp[1300] = 1067468764; +inp[1301] = 0; +inp[1302] = 1066947666; +inp[1303] = 0; +inp[1304] = 1066426822; +inp[1305] = 0; +inp[1306] = 1065906233; +inp[1307] = 0; +inp[1308] = 1073741824; +inp[1309] = 1073741824; +inp[1310] = 1073479711; +inp[1311] = 0; +inp[1312] = 1073217663; +inp[1313] = 0; +inp[1314] = 1072955679; +inp[1315] = 0; +inp[1316] = 1072693759; +inp[1317] = 0; +inp[1318] = 1072431903; +inp[1319] = 0; +inp[1320] = 1072170111; +inp[1321] = 0; +inp[1322] = 1071908383; +inp[1323] = 0; +inp[1324] = 1071646718; +inp[1325] = 0; +inp[1326] = 1071385118; +inp[1327] = 0; +inp[1328] = 1071123581; +inp[1329] = 0; +inp[1330] = 1070862108; +inp[1331] = 0; +inp[1332] = 1070600699; +inp[1333] = 0; +inp[1334] = 1070339354; +inp[1335] = 0; +inp[1336] = 1070078072; +inp[1337] = 0; +inp[1338] = 1069816855; +inp[1339] = 0; +inp[1340] = 1073741824; +inp[1341] = 1073741824; +inp[1342] = 1073610759; +inp[1343] = 0; +inp[1344] = 1073479711; +inp[1345] = 0; +inp[1346] = 1073348679; +inp[1347] = 0; +inp[1348] = 1073217663; +inp[1349] = 0; +inp[1350] = 1073086663; +inp[1351] = 0; +inp[1352] = 1072955679; +inp[1353] = 0; +inp[1354] = 1072824711; +inp[1355] = 0; +inp[1356] = 1072693759; +inp[1357] = 0; +inp[1358] = 1072562823; +inp[1359] = 0; +inp[1360] = 1072431903; +inp[1361] = 0; +inp[1362] = 1072300999; +inp[1363] = 0; +inp[1364] = 1072170111; +inp[1365] = 0; +inp[1366] = 1072039239; +inp[1367] = 0; +inp[1368] = 1071908383; +inp[1369] = 0; +inp[1370] = 1071777542; +inp[1371] = 0; +inp[1372] = 1073741824; +inp[1373] = 1073741824; +inp[1374] = 1073676289; +inp[1375] = 0; +inp[1376] = 1073610759; +inp[1377] = 0; +inp[1378] = 1073545233; +inp[1379] = 0; +inp[1380] = 1073479711; +inp[1381] = 0; +inp[1382] = 1073414193; +inp[1383] = 0; +inp[1384] = 1073348679; +inp[1385] = 0; +inp[1386] = 1073283169; +inp[1387] = 0; +inp[1388] = 1073217663; +inp[1389] = 0; +inp[1390] = 1073152161; +inp[1391] = 0; +inp[1392] = 1073086663; +inp[1393] = 0; +inp[1394] = 1073021169; +inp[1395] = 0; +inp[1396] = 1072955679; +inp[1397] = 0; +inp[1398] = 1072890193; +inp[1399] = 0; +inp[1400] = 1072824711; +inp[1401] = 0; +inp[1402] = 1072759233; +inp[1403] = 0; +inp[1404] = 1073741824; +inp[1405] = 1073741824; +inp[1406] = 1073709056; +inp[1407] = 0; +inp[1408] = 1073676289; +inp[1409] = 0; +inp[1410] = 1073643524; +inp[1411] = 0; +inp[1412] = 1073610759; +inp[1413] = 0; +inp[1414] = 1073577996; +inp[1415] = 0; +inp[1416] = 1073545233; +inp[1417] = 0; +inp[1418] = 1073512472; +inp[1419] = 0; +inp[1420] = 1073479711; +inp[1421] = 0; +inp[1422] = 1073446952; +inp[1423] = 0; +inp[1424] = 1073414193; +inp[1425] = 0; +inp[1426] = 1073381436; +inp[1427] = 0; +inp[1428] = 1073348679; +inp[1429] = 0; +inp[1430] = 1073315924; +inp[1431] = 0; +inp[1432] = 1073283169; +inp[1433] = 0; +inp[1434] = 1073250416; +inp[1435] = 0; +inp[1436] = 1073741824; +inp[1437] = 1073741824; +inp[1438] = 1073725440; +inp[1439] = 0; +inp[1440] = 1073709056; +inp[1441] = 0; +inp[1442] = 1073692673; +inp[1443] = 0; +inp[1444] = 1073676289; +inp[1445] = 0; +inp[1446] = 1073659907; +inp[1447] = 0; +inp[1448] = 1073643524; +inp[1449] = 0; +inp[1450] = 1073627142; +inp[1451] = 0; +inp[1452] = 1073610759; +inp[1453] = 0; +inp[1454] = 1073594378; +inp[1455] = 0; +inp[1456] = 1073577996; +inp[1457] = 0; +inp[1458] = 1073561615; +inp[1459] = 0; +inp[1460] = 1073545233; +inp[1461] = 0; +inp[1462] = 1073528853; +inp[1463] = 0; +inp[1464] = 1073512472; +inp[1465] = 0; +inp[1466] = 1073496092; +inp[1467] = 0; +inp[1468] = 1073741824; +inp[1469] = 1073741824; +inp[1470] = 1073733632; +inp[1471] = 0; +inp[1472] = 1073725440; +inp[1473] = 0; +inp[1474] = 1073717248; +inp[1475] = 0; +inp[1476] = 1073709056; +inp[1477] = 0; +inp[1478] = 1073700864; +inp[1479] = 0; +inp[1480] = 1073692673; +inp[1481] = 0; +inp[1482] = 1073684481; +inp[1483] = 0; +inp[1484] = 1073676289; +inp[1485] = 0; +inp[1486] = 1073668098; +inp[1487] = 0; +inp[1488] = 1073659907; +inp[1489] = 0; +inp[1490] = 1073651715; +inp[1491] = 0; +inp[1492] = 1073643524; +inp[1493] = 0; +inp[1494] = 1073635333; +inp[1495] = 0; +inp[1496] = 1073627142; +inp[1497] = 0; +inp[1498] = 1073618951; +inp[1499] = 0; +inp[1500] = 1073741824; +inp[1501] = 1073741824; +inp[1502] = 1073737728; +inp[1503] = 0; +inp[1504] = 1073733632; +inp[1505] = 0; +inp[1506] = 1073729536; +inp[1507] = 0; +inp[1508] = 1073725440; +inp[1509] = 0; +inp[1510] = 1073721344; +inp[1511] = 0; +inp[1512] = 1073717248; +inp[1513] = 0; +inp[1514] = 1073713152; +inp[1515] = 0; +inp[1516] = 1073709056; +inp[1517] = 0; +inp[1518] = 1073704960; +inp[1519] = 0; +inp[1520] = 1073700864; +inp[1521] = 0; +inp[1522] = 1073696768; +inp[1523] = 0; +inp[1524] = 1073692673; +inp[1525] = 0; +inp[1526] = 1073688577; +inp[1527] = 0; +inp[1528] = 1073684481; +inp[1529] = 0; +inp[1530] = 1073680385; +inp[1531] = 0; +inp[1532] = 1073741824; +inp[1533] = 1073741824; +inp[1534] = 1073739776; +inp[1535] = 0; +inp[1536] = 1073737728; +inp[1537] = 0; +inp[1538] = 1073735680; +inp[1539] = 0; +inp[1540] = 1073733632; +inp[1541] = 0; +inp[1542] = 1073731584; +inp[1543] = 0; +inp[1544] = 1073729536; +inp[1545] = 0; +inp[1546] = 1073727488; +inp[1547] = 0; +inp[1548] = 1073725440; +inp[1549] = 0; +inp[1550] = 1073723392; +inp[1551] = 0; +inp[1552] = 1073721344; +inp[1553] = 0; +inp[1554] = 1073719296; +inp[1555] = 0; +inp[1556] = 1073717248; +inp[1557] = 0; +inp[1558] = 1073715200; +inp[1559] = 0; +inp[1560] = 1073713152; +inp[1561] = 0; +inp[1562] = 1073711104; +inp[1563] = 0; +inp[1564] = 1073741824; +inp[1565] = 1073741824; +inp[1566] = 1073740800; +inp[1567] = 0; +inp[1568] = 1073739776; +inp[1569] = 0; +inp[1570] = 1073738752; +inp[1571] = 0; +inp[1572] = 1073737728; +inp[1573] = 0; +inp[1574] = 1073736704; +inp[1575] = 0; +inp[1576] = 1073735680; +inp[1577] = 0; +inp[1578] = 1073734656; +inp[1579] = 0; +inp[1580] = 1073733632; +inp[1581] = 0; +inp[1582] = 1073732608; +inp[1583] = 0; +inp[1584] = 1073731584; +inp[1585] = 0; +inp[1586] = 1073730560; +inp[1587] = 0; +inp[1588] = 1073729536; +inp[1589] = 0; +inp[1590] = 1073728512; +inp[1591] = 0; +inp[1592] = 1073727488; +inp[1593] = 0; +inp[1594] = 1073726464; +inp[1595] = 0; +inp[1596] = 1073741824; +inp[1597] = 1073741824; +inp[1598] = 1073741312; +inp[1599] = 0; +inp[1600] = 1073740800; +inp[1601] = 0; +inp[1602] = 1073740288; +inp[1603] = 0; +inp[1604] = 1073739776; +inp[1605] = 0; +inp[1606] = 1073739264; +inp[1607] = 0; +inp[1608] = 1073738752; +inp[1609] = 0; +inp[1610] = 1073738240; +inp[1611] = 0; +inp[1612] = 1073737728; +inp[1613] = 0; +inp[1614] = 1073737216; +inp[1615] = 0; +inp[1616] = 1073736704; +inp[1617] = 0; +inp[1618] = 1073736192; +inp[1619] = 0; +inp[1620] = 1073735680; +inp[1621] = 0; +inp[1622] = 1073735168; +inp[1623] = 0; +inp[1624] = 1073734656; +inp[1625] = 0; +inp[1626] = 1073734144; +inp[1627] = 0; +inp[1628] = 1073741824; +inp[1629] = 1073741824; +inp[1630] = 1073741568; +inp[1631] = 0; +inp[1632] = 1073741312; +inp[1633] = 0; +inp[1634] = 1073741056; +inp[1635] = 0; +inp[1636] = 1073740800; +inp[1637] = 0; +inp[1638] = 1073740544; +inp[1639] = 0; +inp[1640] = 1073740288; +inp[1641] = 0; +inp[1642] = 1073740032; +inp[1643] = 0; +inp[1644] = 1073739776; +inp[1645] = 0; +inp[1646] = 1073739520; +inp[1647] = 0; +inp[1648] = 1073739264; +inp[1649] = 0; +inp[1650] = 1073739008; +inp[1651] = 0; +inp[1652] = 1073738752; +inp[1653] = 0; +inp[1654] = 1073738496; +inp[1655] = 0; +inp[1656] = 1073738240; +inp[1657] = 0; +inp[1658] = 1073737984; +inp[1659] = 0; +inp[1660] = 1073741824; +inp[1661] = 1073741824; +inp[1662] = 1073741696; +inp[1663] = 0; +inp[1664] = 1073741568; +inp[1665] = 0; +inp[1666] = 1073741440; +inp[1667] = 0; +inp[1668] = 1073741312; +inp[1669] = 0; +inp[1670] = 1073741184; +inp[1671] = 0; +inp[1672] = 1073741056; +inp[1673] = 0; +inp[1674] = 1073740928; +inp[1675] = 0; +inp[1676] = 1073740800; +inp[1677] = 0; +inp[1678] = 1073740672; +inp[1679] = 0; +inp[1680] = 1073740544; +inp[1681] = 0; +inp[1682] = 1073740416; +inp[1683] = 0; +inp[1684] = 1073740288; +inp[1685] = 0; +inp[1686] = 1073740160; +inp[1687] = 0; +inp[1688] = 1073740032; +inp[1689] = 0; +inp[1690] = 1073739904; +inp[1691] = 0; +inp[1692] = 1073741824; +inp[1693] = 1073741824; +inp[1694] = 1073741760; +inp[1695] = 0; +inp[1696] = 1073741696; +inp[1697] = 0; +inp[1698] = 1073741632; +inp[1699] = 0; +inp[1700] = 1073741568; +inp[1701] = 0; +inp[1702] = 1073741504; +inp[1703] = 0; +inp[1704] = 1073741440; +inp[1705] = 0; +inp[1706] = 1073741376; +inp[1707] = 0; +inp[1708] = 1073741312; +inp[1709] = 0; +inp[1710] = 1073741248; +inp[1711] = 0; +inp[1712] = 1073741184; +inp[1713] = 0; +inp[1714] = 1073741120; +inp[1715] = 0; +inp[1716] = 1073741056; +inp[1717] = 0; +inp[1718] = 1073740992; +inp[1719] = 0; +inp[1720] = 1073740928; +inp[1721] = 0; +inp[1722] = 1073740864; +inp[1723] = 0; +inp[1724] = 1073741824; +inp[1725] = 1073741824; +inp[1726] = 1073741792; +inp[1727] = 0; +inp[1728] = 1073741760; +inp[1729] = 0; +inp[1730] = 1073741728; +inp[1731] = 0; +inp[1732] = 1073741696; +inp[1733] = 0; +inp[1734] = 1073741664; +inp[1735] = 0; +inp[1736] = 1073741632; +inp[1737] = 0; +inp[1738] = 1073741600; +inp[1739] = 0; +inp[1740] = 1073741568; +inp[1741] = 0; +inp[1742] = 1073741536; +inp[1743] = 0; +inp[1744] = 1073741504; +inp[1745] = 0; +inp[1746] = 1073741472; +inp[1747] = 0; +inp[1748] = 1073741440; +inp[1749] = 0; +inp[1750] = 1073741408; +inp[1751] = 0; +inp[1752] = 1073741376; +inp[1753] = 0; +inp[1754] = 1073741344; +inp[1755] = 0; +inp[1756] = 1073741824; +inp[1757] = 1073741824; +inp[1758] = 1073741808; +inp[1759] = 0; +inp[1760] = 1073741792; +inp[1761] = 0; +inp[1762] = 1073741776; +inp[1763] = 0; +inp[1764] = 1073741760; +inp[1765] = 0; +inp[1766] = 1073741744; +inp[1767] = 0; +inp[1768] = 1073741728; +inp[1769] = 0; +inp[1770] = 1073741712; +inp[1771] = 0; +inp[1772] = 1073741696; +inp[1773] = 0; +inp[1774] = 1073741680; +inp[1775] = 0; +inp[1776] = 1073741664; +inp[1777] = 0; +inp[1778] = 1073741648; +inp[1779] = 0; +inp[1780] = 1073741632; +inp[1781] = 0; +inp[1782] = 1073741616; +inp[1783] = 0; +inp[1784] = 1073741600; +inp[1785] = 0; +inp[1786] = 1073741584; +inp[1787] = 0; +inp[1788] = 1073741824; +inp[1789] = 1073741824; +inp[1790] = 1073741816; +inp[1791] = 0; +inp[1792] = 1073741808; +inp[1793] = 0; +inp[1794] = 1073741800; +inp[1795] = 0; +inp[1796] = 1073741792; +inp[1797] = 0; +inp[1798] = 1073741784; +inp[1799] = 0; +inp[1800] = 1073741776; +inp[1801] = 0; +inp[1802] = 1073741768; +inp[1803] = 0; +inp[1804] = 1073741760; +inp[1805] = 0; +inp[1806] = 1073741752; +inp[1807] = 0; +inp[1808] = 1073741744; +inp[1809] = 0; +inp[1810] = 1073741736; +inp[1811] = 0; +inp[1812] = 1073741728; +inp[1813] = 0; +inp[1814] = 1073741720; +inp[1815] = 0; +inp[1816] = 1073741712; +inp[1817] = 0; +inp[1818] = 1073741704; +inp[1819] = 0; +inp[1820] = 1073741824; +inp[1821] = 1073741824; +inp[1822] = 1073741820; +inp[1823] = 0; +inp[1824] = 1073741816; +inp[1825] = 0; +inp[1826] = 1073741812; +inp[1827] = 0; +inp[1828] = 1073741808; +inp[1829] = 0; +inp[1830] = 1073741804; +inp[1831] = 0; +inp[1832] = 1073741800; +inp[1833] = 0; +inp[1834] = 1073741796; +inp[1835] = 0; +inp[1836] = 1073741792; +inp[1837] = 0; +inp[1838] = 1073741788; +inp[1839] = 0; +inp[1840] = 1073741784; +inp[1841] = 0; +inp[1842] = 1073741780; +inp[1843] = 0; +inp[1844] = 1073741776; +inp[1845] = 0; +inp[1846] = 1073741772; +inp[1847] = 0; +inp[1848] = 1073741768; +inp[1849] = 0; +inp[1850] = 1073741764; +inp[1851] = 0; +inp[1852] = 1073741824; +inp[1853] = 1073741824; +inp[1854] = 1073741822; +inp[1855] = 0; +inp[1856] = 1073741820; +inp[1857] = 0; +inp[1858] = 1073741818; +inp[1859] = 0; +inp[1860] = 1073741816; +inp[1861] = 0; +inp[1862] = 1073741814; +inp[1863] = 0; +inp[1864] = 1073741812; +inp[1865] = 0; +inp[1866] = 1073741810; +inp[1867] = 0; +inp[1868] = 1073741808; +inp[1869] = 0; +inp[1870] = 1073741806; +inp[1871] = 0; +inp[1872] = 1073741804; +inp[1873] = 0; +inp[1874] = 1073741802; +inp[1875] = 0; +inp[1876] = 1073741800; +inp[1877] = 0; +inp[1878] = 1073741798; +inp[1879] = 0; +inp[1880] = 1073741796; +inp[1881] = 0; +inp[1882] = 1073741794; +inp[1883] = 0; +inp[1884] = 1073741824; +inp[1885] = 1073741824; +inp[1886] = 1073741823; +inp[1887] = 0; +inp[1888] = 1073741822; +inp[1889] = 0; +inp[1890] = 1073741821; +inp[1891] = 0; +inp[1892] = 1073741820; +inp[1893] = 0; +inp[1894] = 1073741819; +inp[1895] = 0; +inp[1896] = 1073741818; +inp[1897] = 0; +inp[1898] = 1073741817; +inp[1899] = 0; +inp[1900] = 1073741816; +inp[1901] = 0; +inp[1902] = 1073741815; +inp[1903] = 0; +inp[1904] = 1073741814; +inp[1905] = 0; +inp[1906] = 1073741813; +inp[1907] = 0; +inp[1908] = 1073741812; +inp[1909] = 0; +inp[1910] = 1073741811; +inp[1911] = 0; +inp[1912] = 1073741810; +inp[1913] = 0; +inp[1914] = 1073741809; +inp[1915] = 0; +inp[1916] = 1073741824; +inp[1917] = 1073741824; +inp[1918] = 1073741823; +inp[1919] = 0; +inp[1920] = 1073741823; +inp[1921] = 0; +inp[1922] = 1073741822; +inp[1923] = 0; +inp[1924] = 1073741822; +inp[1925] = 0; +inp[1926] = 1073741821; +inp[1927] = 0; +inp[1928] = 1073741821; +inp[1929] = 0; +inp[1930] = 1073741820; +inp[1931] = 0; +inp[1932] = 1073741820; +inp[1933] = 0; +inp[1934] = 1073741819; +inp[1935] = 0; +inp[1936] = 1073741819; +inp[1937] = 0; +inp[1938] = 1073741818; +inp[1939] = 0; +inp[1940] = 1073741818; +inp[1941] = 0; +inp[1942] = 1073741817; +inp[1943] = 0; +inp[1944] = 1073741817; +inp[1945] = 0; +inp[1946] = 1073741816; +inp[1947] = 0; +inp[1948] = 1073741824; +inp[1949] = 1073741824; +inp[1950] = 1073741823; +inp[1951] = 0; +inp[1952] = 1073741823; +inp[1953] = 0; +inp[1954] = 1073741823; +inp[1955] = 0; +inp[1956] = 1073741823; +inp[1957] = 0; +inp[1958] = 1073741822; +inp[1959] = 0; +inp[1960] = 1073741822; +inp[1961] = 0; +inp[1962] = 1073741822; +inp[1963] = 0; +inp[1964] = 1073741822; +inp[1965] = 0; +inp[1966] = 1073741821; +inp[1967] = 0; +inp[1968] = 1073741821; +inp[1969] = 0; +inp[1970] = 1073741821; +inp[1971] = 0; +inp[1972] = 1073741821; +inp[1973] = 0; +inp[1974] = 1073741820; +inp[1975] = 0; +inp[1976] = 1073741820; +inp[1977] = 0; +inp[1978] = 1073741820; +inp[1979] = 0; +inp[1980] = 1073741824; +inp[1981] = 1073741824; +inp[1982] = 395007542; +inp[1983] = 395007542; +inp[1984] = 145315153; +inp[1985] = 145315153; +inp[1986] = 53458457; +inp[1987] = 53458457; +inp[1988] = 19666267; +inp[1989] = 19666267; +inp[1990] = 7234815; +inp[1991] = 7234815; +inp[1992] = 2661539; +inp[1993] = 2661539; +inp[1994] = 979125; +inp[1995] = 979125; +inp[1996] = 360200; +inp[1997] = 360200; +inp[1998] = 132510; +inp[1999] = 132510; +inp[2000] = 48747; +inp[2001] = 48747; +inp[2002] = 17933; +inp[2003] = 17933; +inp[2004] = 6597; +inp[2005] = 6597; +inp[2006] = 2427; +inp[2007] = 2427; +inp[2008] = 892; +inp[2009] = 892; +inp[2010] = 328; +inp[2011] = 328; +inp[2012] = 120; +inp[2013] = 120; +inp[2014] = 44; +inp[2015] = 44; +inp[2016] = 16; +inp[2017] = 16; +inp[2018] = 6; +inp[2019] = 6; +inp[2020] = 2; +inp[2021] = 2; +inp[2022] = 0; +inp[2023] = 0; +inp[2024] = 0; +inp[2025] = 0; +inp[2026] = 0; +inp[2027] = 0; +inp[2028] = 0; +inp[2029] = 0; +inp[2030] = 0; +inp[2031] = 0; +inp[2032] = 0; +inp[2033] = 0; +inp[2034] = 0; +inp[2035] = 0; +inp[2036] = 0; +inp[2037] = 0; +inp[2038] = 0; +inp[2039] = 0; +inp[2040] = 0; +inp[2041] = 0; +inp[2042] = 0; +inp[2043] = 0; +inp[2044] = 1073741824; +inp[2045] = 1073741824; +inp[2046] = 651257336; +inp[2047] = 145315153; +inp[2048] = 395007542; +inp[2049] = 19666267; +inp[2050] = 239584185; +inp[2051] = 2661539; +inp[2052] = 145315153; +inp[2053] = 360200; +inp[2054] = 88138096; +inp[2055] = 48747; +inp[2056] = 53458457; +inp[2057] = 6597; +inp[2058] = 32424193; +inp[2059] = 892; +inp[2060] = 19666267; +inp[2061] = 120; +inp[2062] = 11928194; +inp[2063] = 16; +inp[2064] = 7234815; +inp[2065] = 2; +inp[2066] = 4388137; +inp[2067] = 0; +inp[2068] = 2661539; +inp[2069] = 0; +inp[2070] = 1614305; +inp[2071] = 0; +inp[2072] = 979125; +inp[2073] = 0; +inp[2074] = 593869; +inp[2075] = 0; +inp[2076] = 360200; +inp[2077] = 0; +inp[2078] = 218472; +inp[2079] = 0; +inp[2080] = 132510; +inp[2081] = 0; +inp[2082] = 80371; +inp[2083] = 0; +inp[2084] = 48747; +inp[2085] = 0; +inp[2086] = 29567; +inp[2087] = 0; +inp[2088] = 17933; +inp[2089] = 0; +inp[2090] = 10877; +inp[2091] = 0; +inp[2092] = 6597; +inp[2093] = 0; +inp[2094] = 4001; +inp[2095] = 0; +inp[2096] = 2427; +inp[2097] = 0; +inp[2098] = 1472; +inp[2099] = 0; +inp[2100] = 892; +inp[2101] = 0; +inp[2102] = 541; +inp[2103] = 0; +inp[2104] = 328; +inp[2105] = 0; +inp[2106] = 199; +inp[2107] = 0; +inp[2108] = 1073741824; +inp[2109] = 1073741824; +inp[2110] = 836230973; +inp[2111] = 19666267; +inp[2112] = 651257336; +inp[2113] = 360200; +inp[2114] = 507199723; +inp[2115] = 6597; +inp[2116] = 395007542; +inp[2117] = 120; +inp[2118] = 307632183; +inp[2119] = 2; +inp[2120] = 239584185; +inp[2121] = 0; +inp[2122] = 186588351; +inp[2123] = 0; +inp[2124] = 145315153; +inp[2125] = 0; +inp[2126] = 113171555; +inp[2127] = 0; +inp[2128] = 88138096; +inp[2129] = 0; +inp[2130] = 68642018; +inp[2131] = 0; +inp[2132] = 53458457; +inp[2133] = 0; +inp[2134] = 41633488; +inp[2135] = 0; +inp[2136] = 32424193; +inp[2137] = 0; +inp[2138] = 25251987; +inp[2139] = 0; +inp[2140] = 19666267; +inp[2141] = 0; +inp[2142] = 15316104; +inp[2143] = 0; +inp[2144] = 11928194; +inp[2145] = 0; +inp[2146] = 9289686; +inp[2147] = 0; +inp[2148] = 7234815; +inp[2149] = 0; +inp[2150] = 5634479; +inp[2151] = 0; +inp[2152] = 4388137; +inp[2153] = 0; +inp[2154] = 3417484; +inp[2155] = 0; +inp[2156] = 2661539; +inp[2157] = 0; +inp[2158] = 2072809; +inp[2159] = 0; +inp[2160] = 1614305; +inp[2161] = 0; +inp[2162] = 1257222; +inp[2163] = 0; +inp[2164] = 979125; +inp[2165] = 0; +inp[2166] = 762543; +inp[2167] = 0; +inp[2168] = 593869; +inp[2169] = 0; +inp[2170] = 462506; +inp[2171] = 0; +inp[2172] = 1073741824; +inp[2173] = 1073741824; +inp[2174] = 947573833; +inp[2175] = 360200; +inp[2176] = 836230973; +inp[2177] = 120; +inp[2178] = 737971243; +inp[2179] = 0; +inp[2180] = 651257336; +inp[2181] = 0; +inp[2182] = 574732582; +inp[2183] = 0; +inp[2184] = 507199723; +inp[2185] = 0; +inp[2186] = 447602185; +inp[2187] = 0; +inp[2188] = 395007542; +inp[2189] = 0; +inp[2190] = 348592932; +inp[2191] = 0; +inp[2192] = 307632183; +inp[2193] = 0; +inp[2194] = 271484448; +inp[2195] = 0; +inp[2196] = 239584185; +inp[2197] = 0; +inp[2198] = 211432301; +inp[2199] = 0; +inp[2200] = 186588351; +inp[2201] = 0; +inp[2202] = 164663641; +inp[2203] = 0; +inp[2204] = 145315153; +inp[2205] = 0; +inp[2206] = 128240173; +inp[2207] = 0; +inp[2208] = 113171555; +inp[2209] = 0; +inp[2210] = 99873547; +inp[2211] = 0; +inp[2212] = 88138096; +inp[2213] = 0; +inp[2214] = 77781596; +inp[2215] = 0; +inp[2216] = 68642018; +inp[2217] = 0; +inp[2218] = 60576368; +inp[2219] = 0; +inp[2220] = 53458457; +inp[2221] = 0; +inp[2222] = 47176923; +inp[2223] = 0; +inp[2224] = 41633488; +inp[2225] = 0; +inp[2226] = 36741424; +inp[2227] = 0; +inp[2228] = 32424193; +inp[2229] = 0; +inp[2230] = 28614250; +inp[2231] = 0; +inp[2232] = 25251987; +inp[2233] = 0; +inp[2234] = 22284800; +inp[2235] = 0; +inp[2236] = 1073741824; +inp[2237] = 1073741824; +inp[2238] = 1008687095; +inp[2239] = 120; +inp[2240] = 947573833; +inp[2241] = 0; +inp[2242] = 890163237; +inp[2243] = 0; +inp[2244] = 836230973; +inp[2245] = 0; +inp[2246] = 785566299; +inp[2247] = 0; +inp[2248] = 737971243; +inp[2249] = 0; +inp[2250] = 693259826; +inp[2251] = 0; +inp[2252] = 651257336; +inp[2253] = 0; +inp[2254] = 611799649; +inp[2255] = 0; +inp[2256] = 574732582; +inp[2257] = 0; +inp[2258] = 539911295; +inp[2259] = 0; +inp[2260] = 507199723; +inp[2261] = 0; +inp[2262] = 476470046; +inp[2263] = 0; +inp[2264] = 447602185; +inp[2265] = 0; +inp[2266] = 420483339; +inp[2267] = 0; +inp[2268] = 395007542; +inp[2269] = 0; +inp[2270] = 371075245; +inp[2271] = 0; +inp[2272] = 348592932; +inp[2273] = 0; +inp[2274] = 327472754; +inp[2275] = 0; +inp[2276] = 307632183; +inp[2277] = 0; +inp[2278] = 288993691; +inp[2279] = 0; +inp[2280] = 271484448; +inp[2281] = 0; +inp[2282] = 255036037; +inp[2283] = 0; +inp[2284] = 239584185; +inp[2285] = 0; +inp[2286] = 225068513; +inp[2287] = 0; +inp[2288] = 211432301; +inp[2289] = 0; +inp[2290] = 198622265; +inp[2291] = 0; +inp[2292] = 186588351; +inp[2293] = 0; +inp[2294] = 175283534; +inp[2295] = 0; +inp[2296] = 164663641; +inp[2297] = 0; +inp[2298] = 154687176; +inp[2299] = 0; +inp[2300] = 1073741824; +inp[2301] = 1073741824; +inp[2302] = 1040706261; +inp[2303] = 0; +inp[2304] = 1008687095; +inp[2305] = 0; +inp[2306] = 977653056; +inp[2307] = 0; +inp[2308] = 947573833; +inp[2309] = 0; +inp[2310] = 918420051; +inp[2311] = 0; +inp[2312] = 890163237; +inp[2313] = 0; +inp[2314] = 862775793; +inp[2315] = 0; +inp[2316] = 836230973; +inp[2317] = 0; +inp[2318] = 810502851; +inp[2319] = 0; +inp[2320] = 785566299; +inp[2321] = 0; +inp[2322] = 761396965; +inp[2323] = 0; +inp[2324] = 737971243; +inp[2325] = 0; +inp[2326] = 715266255; +inp[2327] = 0; +inp[2328] = 693259826; +inp[2329] = 0; +inp[2330] = 671930463; +inp[2331] = 0; +inp[2332] = 651257336; +inp[2333] = 0; +inp[2334] = 631220255; +inp[2335] = 0; +inp[2336] = 611799649; +inp[2337] = 0; +inp[2338] = 592976553; +inp[2339] = 0; +inp[2340] = 574732582; +inp[2341] = 0; +inp[2342] = 557049919; +inp[2343] = 0; +inp[2344] = 539911295; +inp[2345] = 0; +inp[2346] = 523299971; +inp[2347] = 0; +inp[2348] = 507199723; +inp[2349] = 0; +inp[2350] = 491594828; +inp[2351] = 0; +inp[2352] = 476470046; +inp[2353] = 0; +inp[2354] = 461810603; +inp[2355] = 0; +inp[2356] = 447602185; +inp[2357] = 0; +inp[2358] = 433830913; +inp[2359] = 0; +inp[2360] = 420483339; +inp[2361] = 0; +inp[2362] = 407546427; +inp[2363] = 0; +inp[2364] = 1073741824; +inp[2365] = 1073741824; +inp[2366] = 1057094999; +inp[2367] = 0; +inp[2368] = 1040706261; +inp[2369] = 0; +inp[2370] = 1024571605; +inp[2371] = 0; +inp[2372] = 1008687095; +inp[2373] = 0; +inp[2374] = 993048851; +inp[2375] = 0; +inp[2376] = 977653056; +inp[2377] = 0; +inp[2378] = 962495950; +inp[2379] = 0; +inp[2380] = 947573833; +inp[2381] = 0; +inp[2382] = 932883063; +inp[2383] = 0; +inp[2384] = 918420051; +inp[2385] = 0; +inp[2386] = 904181268; +inp[2387] = 0; +inp[2388] = 890163237; +inp[2389] = 0; +inp[2390] = 876362535; +inp[2391] = 0; +inp[2392] = 862775793; +inp[2393] = 0; +inp[2394] = 849399695; +inp[2395] = 0; +inp[2396] = 836230973; +inp[2397] = 0; +inp[2398] = 823266413; +inp[2399] = 0; +inp[2400] = 810502851; +inp[2401] = 0; +inp[2402] = 797937169; +inp[2403] = 0; +inp[2404] = 785566299; +inp[2405] = 0; +inp[2406] = 773387223; +inp[2407] = 0; +inp[2408] = 761396965; +inp[2409] = 0; +inp[2410] = 749592599; +inp[2411] = 0; +inp[2412] = 737971243; +inp[2413] = 0; +inp[2414] = 726530060; +inp[2415] = 0; +inp[2416] = 715266255; +inp[2417] = 0; +inp[2418] = 704177080; +inp[2419] = 0; +inp[2420] = 693259826; +inp[2421] = 0; +inp[2422] = 682511829; +inp[2423] = 0; +inp[2424] = 671930463; +inp[2425] = 0; +inp[2426] = 661513147; +inp[2427] = 0; +inp[2428] = 1073741824; +inp[2429] = 1073741824; +inp[2430] = 1065385898; +inp[2431] = 0; +inp[2432] = 1057094999; +inp[2433] = 0; +inp[2434] = 1048868621; +inp[2435] = 0; +inp[2436] = 1040706261; +inp[2437] = 0; +inp[2438] = 1032607420; +inp[2439] = 0; +inp[2440] = 1024571605; +inp[2441] = 0; +inp[2442] = 1016598326; +inp[2443] = 0; +inp[2444] = 1008687095; +inp[2445] = 0; +inp[2446] = 1000837430; +inp[2447] = 0; +inp[2448] = 993048851; +inp[2449] = 0; +inp[2450] = 985320884; +inp[2451] = 0; +inp[2452] = 977653056; +inp[2453] = 0; +inp[2454] = 970044899; +inp[2455] = 0; +inp[2456] = 962495950; +inp[2457] = 0; +inp[2458] = 955005747; +inp[2459] = 0; +inp[2460] = 947573833; +inp[2461] = 0; +inp[2462] = 940199755; +inp[2463] = 0; +inp[2464] = 932883063; +inp[2465] = 0; +inp[2466] = 925623309; +inp[2467] = 0; +inp[2468] = 918420051; +inp[2469] = 0; +inp[2470] = 911272850; +inp[2471] = 0; +inp[2472] = 904181268; +inp[2473] = 0; +inp[2474] = 897144874; +inp[2475] = 0; +inp[2476] = 890163237; +inp[2477] = 0; +inp[2478] = 883235932; +inp[2479] = 0; +inp[2480] = 876362535; +inp[2481] = 0; +inp[2482] = 869542628; +inp[2483] = 0; +inp[2484] = 862775793; +inp[2485] = 0; +inp[2486] = 856061619; +inp[2487] = 0; +inp[2488] = 849399695; +inp[2489] = 0; +inp[2490] = 842789614; +inp[2491] = 0; +inp[2492] = 1073741824; +inp[2493] = 1073741824; +inp[2494] = 1069555701; +inp[2495] = 0; +inp[2496] = 1065385898; +inp[2497] = 0; +inp[2498] = 1061232352; +inp[2499] = 0; +inp[2500] = 1057094999; +inp[2501] = 0; +inp[2502] = 1052973777; +inp[2503] = 0; +inp[2504] = 1048868621; +inp[2505] = 0; +inp[2506] = 1044779470; +inp[2507] = 0; +inp[2508] = 1040706261; +inp[2509] = 0; +inp[2510] = 1036648931; +inp[2511] = 0; +inp[2512] = 1032607420; +inp[2513] = 0; +inp[2514] = 1028581665; +inp[2515] = 0; +inp[2516] = 1024571605; +inp[2517] = 0; +inp[2518] = 1020577179; +inp[2519] = 0; +inp[2520] = 1016598326; +inp[2521] = 0; +inp[2522] = 1012634985; +inp[2523] = 0; +inp[2524] = 1008687095; +inp[2525] = 0; +inp[2526] = 1004754597; +inp[2527] = 0; +inp[2528] = 1000837430; +inp[2529] = 0; +inp[2530] = 996935534; +inp[2531] = 0; +inp[2532] = 993048851; +inp[2533] = 0; +inp[2534] = 989177321; +inp[2535] = 0; +inp[2536] = 985320884; +inp[2537] = 0; +inp[2538] = 981479482; +inp[2539] = 0; +inp[2540] = 977653056; +inp[2541] = 0; +inp[2542] = 973841548; +inp[2543] = 0; +inp[2544] = 970044899; +inp[2545] = 0; +inp[2546] = 966263053; +inp[2547] = 0; +inp[2548] = 962495950; +inp[2549] = 0; +inp[2550] = 958743534; +inp[2551] = 0; +inp[2552] = 955005747; +inp[2553] = 0; +inp[2554] = 951282532; +inp[2555] = 0; +inp[2556] = 1073741824; +inp[2557] = 1073741824; +inp[2558] = 1071646718; +inp[2559] = 0; +inp[2560] = 1069555701; +inp[2561] = 0; +inp[2562] = 1067468764; +inp[2563] = 0; +inp[2564] = 1065385898; +inp[2565] = 0; +inp[2566] = 1063307097; +inp[2567] = 0; +inp[2568] = 1061232352; +inp[2569] = 0; +inp[2570] = 1059161656; +inp[2571] = 0; +inp[2572] = 1057094999; +inp[2573] = 0; +inp[2574] = 1055032376; +inp[2575] = 0; +inp[2576] = 1052973777; +inp[2577] = 0; +inp[2578] = 1050919194; +inp[2579] = 0; +inp[2580] = 1048868621; +inp[2581] = 0; +inp[2582] = 1046822049; +inp[2583] = 0; +inp[2584] = 1044779470; +inp[2585] = 0; +inp[2586] = 1042740876; +inp[2587] = 0; +inp[2588] = 1040706261; +inp[2589] = 0; +inp[2590] = 1038675615; +inp[2591] = 0; +inp[2592] = 1036648931; +inp[2593] = 0; +inp[2594] = 1034626202; +inp[2595] = 0; +inp[2596] = 1032607420; +inp[2597] = 0; +inp[2598] = 1030592577; +inp[2599] = 0; +inp[2600] = 1028581665; +inp[2601] = 0; +inp[2602] = 1026574677; +inp[2603] = 0; +inp[2604] = 1024571605; +inp[2605] = 0; +inp[2606] = 1022572442; +inp[2607] = 0; +inp[2608] = 1020577179; +inp[2609] = 0; +inp[2610] = 1018585810; +inp[2611] = 0; +inp[2612] = 1016598326; +inp[2613] = 0; +inp[2614] = 1014614720; +inp[2615] = 0; +inp[2616] = 1012634985; +inp[2617] = 0; +inp[2618] = 1010659112; +inp[2619] = 0; +inp[2620] = 1073741824; +inp[2621] = 1073741824; +inp[2622] = 1072693759; +inp[2623] = 0; +inp[2624] = 1071646718; +inp[2625] = 0; +inp[2626] = 1070600699; +inp[2627] = 0; +inp[2628] = 1069555701; +inp[2629] = 0; +inp[2630] = 1068511723; +inp[2631] = 0; +inp[2632] = 1067468764; +inp[2633] = 0; +inp[2634] = 1066426822; +inp[2635] = 0; +inp[2636] = 1065385898; +inp[2637] = 0; +inp[2638] = 1064345990; +inp[2639] = 0; +inp[2640] = 1063307097; +inp[2641] = 0; +inp[2642] = 1062269218; +inp[2643] = 0; +inp[2644] = 1061232352; +inp[2645] = 0; +inp[2646] = 1060196498; +inp[2647] = 0; +inp[2648] = 1059161656; +inp[2649] = 0; +inp[2650] = 1058127823; +inp[2651] = 0; +inp[2652] = 1057094999; +inp[2653] = 0; +inp[2654] = 1056063184; +inp[2655] = 0; +inp[2656] = 1055032376; +inp[2657] = 0; +inp[2658] = 1054002574; +inp[2659] = 0; +inp[2660] = 1052973777; +inp[2661] = 0; +inp[2662] = 1051945984; +inp[2663] = 0; +inp[2664] = 1050919194; +inp[2665] = 0; +inp[2666] = 1049893407; +inp[2667] = 0; +inp[2668] = 1048868621; +inp[2669] = 0; +inp[2670] = 1047844835; +inp[2671] = 0; +inp[2672] = 1046822049; +inp[2673] = 0; +inp[2674] = 1045800261; +inp[2675] = 0; +inp[2676] = 1044779470; +inp[2677] = 0; +inp[2678] = 1043759675; +inp[2679] = 0; +inp[2680] = 1042740876; +inp[2681] = 0; +inp[2682] = 1041723072; +inp[2683] = 0; +inp[2684] = 1073741824; +inp[2685] = 1073741824; +inp[2686] = 1073217663; +inp[2687] = 0; +inp[2688] = 1072693759; +inp[2689] = 0; +inp[2690] = 1072170111; +inp[2691] = 0; +inp[2692] = 1071646718; +inp[2693] = 0; +inp[2694] = 1071123581; +inp[2695] = 0; +inp[2696] = 1070600699; +inp[2697] = 0; +inp[2698] = 1070078072; +inp[2699] = 0; +inp[2700] = 1069555701; +inp[2701] = 0; +inp[2702] = 1069033584; +inp[2703] = 0; +inp[2704] = 1068511723; +inp[2705] = 0; +inp[2706] = 1067990116; +inp[2707] = 0; +inp[2708] = 1067468764; +inp[2709] = 0; +inp[2710] = 1066947666; +inp[2711] = 0; +inp[2712] = 1066426822; +inp[2713] = 0; +inp[2714] = 1065906233; +inp[2715] = 0; +inp[2716] = 1065385898; +inp[2717] = 0; +inp[2718] = 1064865817; +inp[2719] = 0; +inp[2720] = 1064345990; +inp[2721] = 0; +inp[2722] = 1063826417; +inp[2723] = 0; +inp[2724] = 1063307097; +inp[2725] = 0; +inp[2726] = 1062788031; +inp[2727] = 0; +inp[2728] = 1062269218; +inp[2729] = 0; +inp[2730] = 1061750659; +inp[2731] = 0; +inp[2732] = 1061232352; +inp[2733] = 0; +inp[2734] = 1060714299; +inp[2735] = 0; +inp[2736] = 1060196498; +inp[2737] = 0; +inp[2738] = 1059678951; +inp[2739] = 0; +inp[2740] = 1059161656; +inp[2741] = 0; +inp[2742] = 1058644613; +inp[2743] = 0; +inp[2744] = 1058127823; +inp[2745] = 0; +inp[2746] = 1057611285; +inp[2747] = 0; +inp[2748] = 1073741824; +inp[2749] = 1073741824; +inp[2750] = 1073479711; +inp[2751] = 0; +inp[2752] = 1073217663; +inp[2753] = 0; +inp[2754] = 1072955679; +inp[2755] = 0; +inp[2756] = 1072693759; +inp[2757] = 0; +inp[2758] = 1072431903; +inp[2759] = 0; +inp[2760] = 1072170111; +inp[2761] = 0; +inp[2762] = 1071908383; +inp[2763] = 0; +inp[2764] = 1071646718; +inp[2765] = 0; +inp[2766] = 1071385118; +inp[2767] = 0; +inp[2768] = 1071123581; +inp[2769] = 0; +inp[2770] = 1070862108; +inp[2771] = 0; +inp[2772] = 1070600699; +inp[2773] = 0; +inp[2774] = 1070339354; +inp[2775] = 0; +inp[2776] = 1070078072; +inp[2777] = 0; +inp[2778] = 1069816855; +inp[2779] = 0; +inp[2780] = 1069555701; +inp[2781] = 0; +inp[2782] = 1069294611; +inp[2783] = 0; +inp[2784] = 1069033584; +inp[2785] = 0; +inp[2786] = 1068772622; +inp[2787] = 0; +inp[2788] = 1068511723; +inp[2789] = 0; +inp[2790] = 1068250887; +inp[2791] = 0; +inp[2792] = 1067990116; +inp[2793] = 0; +inp[2794] = 1067729408; +inp[2795] = 0; +inp[2796] = 1067468764; +inp[2797] = 0; +inp[2798] = 1067208183; +inp[2799] = 0; +inp[2800] = 1066947666; +inp[2801] = 0; +inp[2802] = 1066687212; +inp[2803] = 0; +inp[2804] = 1066426822; +inp[2805] = 0; +inp[2806] = 1066166496; +inp[2807] = 0; +inp[2808] = 1065906233; +inp[2809] = 0; +inp[2810] = 1065646034; +inp[2811] = 0; +inp[2812] = 1073741824; +inp[2813] = 1073741824; +inp[2814] = 1073610759; +inp[2815] = 0; +inp[2816] = 1073479711; +inp[2817] = 0; +inp[2818] = 1073348679; +inp[2819] = 0; +inp[2820] = 1073217663; +inp[2821] = 0; +inp[2822] = 1073086663; +inp[2823] = 0; +inp[2824] = 1072955679; +inp[2825] = 0; +inp[2826] = 1072824711; +inp[2827] = 0; +inp[2828] = 1072693759; +inp[2829] = 0; +inp[2830] = 1072562823; +inp[2831] = 0; +inp[2832] = 1072431903; +inp[2833] = 0; +inp[2834] = 1072300999; +inp[2835] = 0; +inp[2836] = 1072170111; +inp[2837] = 0; +inp[2838] = 1072039239; +inp[2839] = 0; +inp[2840] = 1071908383; +inp[2841] = 0; +inp[2842] = 1071777542; +inp[2843] = 0; +inp[2844] = 1071646718; +inp[2845] = 0; +inp[2846] = 1071515910; +inp[2847] = 0; +inp[2848] = 1071385118; +inp[2849] = 0; +inp[2850] = 1071254341; +inp[2851] = 0; +inp[2852] = 1071123581; +inp[2853] = 0; +inp[2854] = 1070992836; +inp[2855] = 0; +inp[2856] = 1070862108; +inp[2857] = 0; +inp[2858] = 1070731396; +inp[2859] = 0; +inp[2860] = 1070600699; +inp[2861] = 0; +inp[2862] = 1070470018; +inp[2863] = 0; +inp[2864] = 1070339354; +inp[2865] = 0; +inp[2866] = 1070208705; +inp[2867] = 0; +inp[2868] = 1070078072; +inp[2869] = 0; +inp[2870] = 1069947456; +inp[2871] = 0; +inp[2872] = 1069816855; +inp[2873] = 0; +inp[2874] = 1069686270; +inp[2875] = 0; +inp[2876] = 1073741824; +inp[2877] = 1073741824; +inp[2878] = 1073676289; +inp[2879] = 0; +inp[2880] = 1073610759; +inp[2881] = 0; +inp[2882] = 1073545233; +inp[2883] = 0; +inp[2884] = 1073479711; +inp[2885] = 0; +inp[2886] = 1073414193; +inp[2887] = 0; +inp[2888] = 1073348679; +inp[2889] = 0; +inp[2890] = 1073283169; +inp[2891] = 0; +inp[2892] = 1073217663; +inp[2893] = 0; +inp[2894] = 1073152161; +inp[2895] = 0; +inp[2896] = 1073086663; +inp[2897] = 0; +inp[2898] = 1073021169; +inp[2899] = 0; +inp[2900] = 1072955679; +inp[2901] = 0; +inp[2902] = 1072890193; +inp[2903] = 0; +inp[2904] = 1072824711; +inp[2905] = 0; +inp[2906] = 1072759233; +inp[2907] = 0; +inp[2908] = 1072693759; +inp[2909] = 0; +inp[2910] = 1072628289; +inp[2911] = 0; +inp[2912] = 1072562823; +inp[2913] = 0; +inp[2914] = 1072497361; +inp[2915] = 0; +inp[2916] = 1072431903; +inp[2917] = 0; +inp[2918] = 1072366449; +inp[2919] = 0; +inp[2920] = 1072300999; +inp[2921] = 0; +inp[2922] = 1072235553; +inp[2923] = 0; +inp[2924] = 1072170111; +inp[2925] = 0; +inp[2926] = 1072104673; +inp[2927] = 0; +inp[2928] = 1072039239; +inp[2929] = 0; +inp[2930] = 1071973809; +inp[2931] = 0; +inp[2932] = 1071908383; +inp[2933] = 0; +inp[2934] = 1071842961; +inp[2935] = 0; +inp[2936] = 1071777542; +inp[2937] = 0; +inp[2938] = 1071712128; +inp[2939] = 0; +inp[2940] = 1073741824; +inp[2941] = 1073741824; +inp[2942] = 1073709056; +inp[2943] = 0; +inp[2944] = 1073676289; +inp[2945] = 0; +inp[2946] = 1073643524; +inp[2947] = 0; +inp[2948] = 1073610759; +inp[2949] = 0; +inp[2950] = 1073577996; +inp[2951] = 0; +inp[2952] = 1073545233; +inp[2953] = 0; +inp[2954] = 1073512472; +inp[2955] = 0; +inp[2956] = 1073479711; +inp[2957] = 0; +inp[2958] = 1073446952; +inp[2959] = 0; +inp[2960] = 1073414193; +inp[2961] = 0; +inp[2962] = 1073381436; +inp[2963] = 0; +inp[2964] = 1073348679; +inp[2965] = 0; +inp[2966] = 1073315924; +inp[2967] = 0; +inp[2968] = 1073283169; +inp[2969] = 0; +inp[2970] = 1073250416; +inp[2971] = 0; +inp[2972] = 1073217663; +inp[2973] = 0; +inp[2974] = 1073184912; +inp[2975] = 0; +inp[2976] = 1073152161; +inp[2977] = 0; +inp[2978] = 1073119412; +inp[2979] = 0; +inp[2980] = 1073086663; +inp[2981] = 0; +inp[2982] = 1073053916; +inp[2983] = 0; +inp[2984] = 1073021169; +inp[2985] = 0; +inp[2986] = 1072988424; +inp[2987] = 0; +inp[2988] = 1072955679; +inp[2989] = 0; +inp[2990] = 1072922936; +inp[2991] = 0; +inp[2992] = 1072890193; +inp[2993] = 0; +inp[2994] = 1072857452; +inp[2995] = 0; +inp[2996] = 1072824711; +inp[2997] = 0; +inp[2998] = 1072791972; +inp[2999] = 0; +inp[3000] = 1072759233; +inp[3001] = 0; +inp[3002] = 1072726496; +inp[3003] = 0; +inp[3004] = 1073741824; +inp[3005] = 1073741824; +inp[3006] = 1073725440; +inp[3007] = 0; +inp[3008] = 1073709056; +inp[3009] = 0; +inp[3010] = 1073692673; +inp[3011] = 0; +inp[3012] = 1073676289; +inp[3013] = 0; +inp[3014] = 1073659907; +inp[3015] = 0; +inp[3016] = 1073643524; +inp[3017] = 0; +inp[3018] = 1073627142; +inp[3019] = 0; +inp[3020] = 1073610759; +inp[3021] = 0; +inp[3022] = 1073594378; +inp[3023] = 0; +inp[3024] = 1073577996; +inp[3025] = 0; +inp[3026] = 1073561615; +inp[3027] = 0; +inp[3028] = 1073545233; +inp[3029] = 0; +inp[3030] = 1073528853; +inp[3031] = 0; +inp[3032] = 1073512472; +inp[3033] = 0; +inp[3034] = 1073496092; +inp[3035] = 0; +inp[3036] = 1073479711; +inp[3037] = 0; +inp[3038] = 1073463332; +inp[3039] = 0; +inp[3040] = 1073446952; +inp[3041] = 0; +inp[3042] = 1073430573; +inp[3043] = 0; +inp[3044] = 1073414193; +inp[3045] = 0; +inp[3046] = 1073397815; +inp[3047] = 0; +inp[3048] = 1073381436; +inp[3049] = 0; +inp[3050] = 1073365058; +inp[3051] = 0; +inp[3052] = 1073348679; +inp[3053] = 0; +inp[3054] = 1073332302; +inp[3055] = 0; +inp[3056] = 1073315924; +inp[3057] = 0; +inp[3058] = 1073299547; +inp[3059] = 0; +inp[3060] = 1073283169; +inp[3061] = 0; +inp[3062] = 1073266793; +inp[3063] = 0; +inp[3064] = 1073250416; +inp[3065] = 0; +inp[3066] = 1073234040; +inp[3067] = 0; +inp[3068] = 1073741824; +inp[3069] = 1073741824; +inp[3070] = 1073733632; +inp[3071] = 0; +inp[3072] = 1073725440; +inp[3073] = 0; +inp[3074] = 1073717248; +inp[3075] = 0; +inp[3076] = 1073709056; +inp[3077] = 0; +inp[3078] = 1073700864; +inp[3079] = 0; +inp[3080] = 1073692673; +inp[3081] = 0; +inp[3082] = 1073684481; +inp[3083] = 0; +inp[3084] = 1073676289; +inp[3085] = 0; +inp[3086] = 1073668098; +inp[3087] = 0; +inp[3088] = 1073659907; +inp[3089] = 0; +inp[3090] = 1073651715; +inp[3091] = 0; +inp[3092] = 1073643524; +inp[3093] = 0; +inp[3094] = 1073635333; +inp[3095] = 0; +inp[3096] = 1073627142; +inp[3097] = 0; +inp[3098] = 1073618951; +inp[3099] = 0; +inp[3100] = 1073610759; +inp[3101] = 0; +inp[3102] = 1073602569; +inp[3103] = 0; +inp[3104] = 1073594378; +inp[3105] = 0; +inp[3106] = 1073586187; +inp[3107] = 0; +inp[3108] = 1073577996; +inp[3109] = 0; +inp[3110] = 1073569805; +inp[3111] = 0; +inp[3112] = 1073561615; +inp[3113] = 0; +inp[3114] = 1073553424; +inp[3115] = 0; +inp[3116] = 1073545233; +inp[3117] = 0; +inp[3118] = 1073537043; +inp[3119] = 0; +inp[3120] = 1073528853; +inp[3121] = 0; +inp[3122] = 1073520662; +inp[3123] = 0; +inp[3124] = 1073512472; +inp[3125] = 0; +inp[3126] = 1073504282; +inp[3127] = 0; +inp[3128] = 1073496092; +inp[3129] = 0; +inp[3130] = 1073487902; +inp[3131] = 0; +inp[3132] = 1073741824; +inp[3133] = 1073741824; +inp[3134] = 1073737728; +inp[3135] = 0; +inp[3136] = 1073733632; +inp[3137] = 0; +inp[3138] = 1073729536; +inp[3139] = 0; +inp[3140] = 1073725440; +inp[3141] = 0; +inp[3142] = 1073721344; +inp[3143] = 0; +inp[3144] = 1073717248; +inp[3145] = 0; +inp[3146] = 1073713152; +inp[3147] = 0; +inp[3148] = 1073709056; +inp[3149] = 0; +inp[3150] = 1073704960; +inp[3151] = 0; +inp[3152] = 1073700864; +inp[3153] = 0; +inp[3154] = 1073696768; +inp[3155] = 0; +inp[3156] = 1073692673; +inp[3157] = 0; +inp[3158] = 1073688577; +inp[3159] = 0; +inp[3160] = 1073684481; +inp[3161] = 0; +inp[3162] = 1073680385; +inp[3163] = 0; +inp[3164] = 1073676289; +inp[3165] = 0; +inp[3166] = 1073672194; +inp[3167] = 0; +inp[3168] = 1073668098; +inp[3169] = 0; +inp[3170] = 1073664002; +inp[3171] = 0; +inp[3172] = 1073659907; +inp[3173] = 0; +inp[3174] = 1073655811; +inp[3175] = 0; +inp[3176] = 1073651715; +inp[3177] = 0; +inp[3178] = 1073647620; +inp[3179] = 0; +inp[3180] = 1073643524; +inp[3181] = 0; +inp[3182] = 1073639428; +inp[3183] = 0; +inp[3184] = 1073635333; +inp[3185] = 0; +inp[3186] = 1073631237; +inp[3187] = 0; +inp[3188] = 1073627142; +inp[3189] = 0; +inp[3190] = 1073623046; +inp[3191] = 0; +inp[3192] = 1073618951; +inp[3193] = 0; +inp[3194] = 1073614855; +inp[3195] = 0; +inp[3196] = 1073741824; +inp[3197] = 1073741824; +inp[3198] = 1073739776; +inp[3199] = 0; +inp[3200] = 1073737728; +inp[3201] = 0; +inp[3202] = 1073735680; +inp[3203] = 0; +inp[3204] = 1073733632; +inp[3205] = 0; +inp[3206] = 1073731584; +inp[3207] = 0; +inp[3208] = 1073729536; +inp[3209] = 0; +inp[3210] = 1073727488; +inp[3211] = 0; +inp[3212] = 1073725440; +inp[3213] = 0; +inp[3214] = 1073723392; +inp[3215] = 0; +inp[3216] = 1073721344; +inp[3217] = 0; +inp[3218] = 1073719296; +inp[3219] = 0; +inp[3220] = 1073717248; +inp[3221] = 0; +inp[3222] = 1073715200; +inp[3223] = 0; +inp[3224] = 1073713152; +inp[3225] = 0; +inp[3226] = 1073711104; +inp[3227] = 0; +inp[3228] = 1073709056; +inp[3229] = 0; +inp[3230] = 1073707008; +inp[3231] = 0; +inp[3232] = 1073704960; +inp[3233] = 0; +inp[3234] = 1073702912; +inp[3235] = 0; +inp[3236] = 1073700864; +inp[3237] = 0; +inp[3238] = 1073698816; +inp[3239] = 0; +inp[3240] = 1073696768; +inp[3241] = 0; +inp[3242] = 1073694721; +inp[3243] = 0; +inp[3244] = 1073692673; +inp[3245] = 0; +inp[3246] = 1073690625; +inp[3247] = 0; +inp[3248] = 1073688577; +inp[3249] = 0; +inp[3250] = 1073686529; +inp[3251] = 0; +inp[3252] = 1073684481; +inp[3253] = 0; +inp[3254] = 1073682433; +inp[3255] = 0; +inp[3256] = 1073680385; +inp[3257] = 0; +inp[3258] = 1073678337; +inp[3259] = 0; +inp[3260] = 1073741824; +inp[3261] = 1073741824; +inp[3262] = 1073740800; +inp[3263] = 0; +inp[3264] = 1073739776; +inp[3265] = 0; +inp[3266] = 1073738752; +inp[3267] = 0; +inp[3268] = 1073737728; +inp[3269] = 0; +inp[3270] = 1073736704; +inp[3271] = 0; +inp[3272] = 1073735680; +inp[3273] = 0; +inp[3274] = 1073734656; +inp[3275] = 0; +inp[3276] = 1073733632; +inp[3277] = 0; +inp[3278] = 1073732608; +inp[3279] = 0; +inp[3280] = 1073731584; +inp[3281] = 0; +inp[3282] = 1073730560; +inp[3283] = 0; +inp[3284] = 1073729536; +inp[3285] = 0; +inp[3286] = 1073728512; +inp[3287] = 0; +inp[3288] = 1073727488; +inp[3289] = 0; +inp[3290] = 1073726464; +inp[3291] = 0; +inp[3292] = 1073725440; +inp[3293] = 0; +inp[3294] = 1073724416; +inp[3295] = 0; +inp[3296] = 1073723392; +inp[3297] = 0; +inp[3298] = 1073722368; +inp[3299] = 0; +inp[3300] = 1073721344; +inp[3301] = 0; +inp[3302] = 1073720320; +inp[3303] = 0; +inp[3304] = 1073719296; +inp[3305] = 0; +inp[3306] = 1073718272; +inp[3307] = 0; +inp[3308] = 1073717248; +inp[3309] = 0; +inp[3310] = 1073716224; +inp[3311] = 0; +inp[3312] = 1073715200; +inp[3313] = 0; +inp[3314] = 1073714176; +inp[3315] = 0; +inp[3316] = 1073713152; +inp[3317] = 0; +inp[3318] = 1073712128; +inp[3319] = 0; +inp[3320] = 1073711104; +inp[3321] = 0; +inp[3322] = 1073710080; +inp[3323] = 0; +inp[3324] = 1073741824; +inp[3325] = 1073741824; +inp[3326] = 1073741312; +inp[3327] = 0; +inp[3328] = 1073740800; +inp[3329] = 0; +inp[3330] = 1073740288; +inp[3331] = 0; +inp[3332] = 1073739776; +inp[3333] = 0; +inp[3334] = 1073739264; +inp[3335] = 0; +inp[3336] = 1073738752; +inp[3337] = 0; +inp[3338] = 1073738240; +inp[3339] = 0; +inp[3340] = 1073737728; +inp[3341] = 0; +inp[3342] = 1073737216; +inp[3343] = 0; +inp[3344] = 1073736704; +inp[3345] = 0; +inp[3346] = 1073736192; +inp[3347] = 0; +inp[3348] = 1073735680; +inp[3349] = 0; +inp[3350] = 1073735168; +inp[3351] = 0; +inp[3352] = 1073734656; +inp[3353] = 0; +inp[3354] = 1073734144; +inp[3355] = 0; +inp[3356] = 1073733632; +inp[3357] = 0; +inp[3358] = 1073733120; +inp[3359] = 0; +inp[3360] = 1073732608; +inp[3361] = 0; +inp[3362] = 1073732096; +inp[3363] = 0; +inp[3364] = 1073731584; +inp[3365] = 0; +inp[3366] = 1073731072; +inp[3367] = 0; +inp[3368] = 1073730560; +inp[3369] = 0; +inp[3370] = 1073730048; +inp[3371] = 0; +inp[3372] = 1073729536; +inp[3373] = 0; +inp[3374] = 1073729024; +inp[3375] = 0; +inp[3376] = 1073728512; +inp[3377] = 0; +inp[3378] = 1073728000; +inp[3379] = 0; +inp[3380] = 1073727488; +inp[3381] = 0; +inp[3382] = 1073726976; +inp[3383] = 0; +inp[3384] = 1073726464; +inp[3385] = 0; +inp[3386] = 1073725952; +inp[3387] = 0; +inp[3388] = 1073741824; +inp[3389] = 1073741824; +inp[3390] = 1073741568; +inp[3391] = 0; +inp[3392] = 1073741312; +inp[3393] = 0; +inp[3394] = 1073741056; +inp[3395] = 0; +inp[3396] = 1073740800; +inp[3397] = 0; +inp[3398] = 1073740544; +inp[3399] = 0; +inp[3400] = 1073740288; +inp[3401] = 0; +inp[3402] = 1073740032; +inp[3403] = 0; +inp[3404] = 1073739776; +inp[3405] = 0; +inp[3406] = 1073739520; +inp[3407] = 0; +inp[3408] = 1073739264; +inp[3409] = 0; +inp[3410] = 1073739008; +inp[3411] = 0; +inp[3412] = 1073738752; +inp[3413] = 0; +inp[3414] = 1073738496; +inp[3415] = 0; +inp[3416] = 1073738240; +inp[3417] = 0; +inp[3418] = 1073737984; +inp[3419] = 0; +inp[3420] = 1073737728; +inp[3421] = 0; +inp[3422] = 1073737472; +inp[3423] = 0; +inp[3424] = 1073737216; +inp[3425] = 0; +inp[3426] = 1073736960; +inp[3427] = 0; +inp[3428] = 1073736704; +inp[3429] = 0; +inp[3430] = 1073736448; +inp[3431] = 0; +inp[3432] = 1073736192; +inp[3433] = 0; +inp[3434] = 1073735936; +inp[3435] = 0; +inp[3436] = 1073735680; +inp[3437] = 0; +inp[3438] = 1073735424; +inp[3439] = 0; +inp[3440] = 1073735168; +inp[3441] = 0; +inp[3442] = 1073734912; +inp[3443] = 0; +inp[3444] = 1073734656; +inp[3445] = 0; +inp[3446] = 1073734400; +inp[3447] = 0; +inp[3448] = 1073734144; +inp[3449] = 0; +inp[3450] = 1073733888; +inp[3451] = 0; +inp[3452] = 1073741824; +inp[3453] = 1073741824; +inp[3454] = 1073741696; +inp[3455] = 0; +inp[3456] = 1073741568; +inp[3457] = 0; +inp[3458] = 1073741440; +inp[3459] = 0; +inp[3460] = 1073741312; +inp[3461] = 0; +inp[3462] = 1073741184; +inp[3463] = 0; +inp[3464] = 1073741056; +inp[3465] = 0; +inp[3466] = 1073740928; +inp[3467] = 0; +inp[3468] = 1073740800; +inp[3469] = 0; +inp[3470] = 1073740672; +inp[3471] = 0; +inp[3472] = 1073740544; +inp[3473] = 0; +inp[3474] = 1073740416; +inp[3475] = 0; +inp[3476] = 1073740288; +inp[3477] = 0; +inp[3478] = 1073740160; +inp[3479] = 0; +inp[3480] = 1073740032; +inp[3481] = 0; +inp[3482] = 1073739904; +inp[3483] = 0; +inp[3484] = 1073739776; +inp[3485] = 0; +inp[3486] = 1073739648; +inp[3487] = 0; +inp[3488] = 1073739520; +inp[3489] = 0; +inp[3490] = 1073739392; +inp[3491] = 0; +inp[3492] = 1073739264; +inp[3493] = 0; +inp[3494] = 1073739136; +inp[3495] = 0; +inp[3496] = 1073739008; +inp[3497] = 0; +inp[3498] = 1073738880; +inp[3499] = 0; +inp[3500] = 1073738752; +inp[3501] = 0; +inp[3502] = 1073738624; +inp[3503] = 0; +inp[3504] = 1073738496; +inp[3505] = 0; +inp[3506] = 1073738368; +inp[3507] = 0; +inp[3508] = 1073738240; +inp[3509] = 0; +inp[3510] = 1073738112; +inp[3511] = 0; +inp[3512] = 1073737984; +inp[3513] = 0; +inp[3514] = 1073737856; +inp[3515] = 0; +inp[3516] = 1073741824; +inp[3517] = 1073741824; +inp[3518] = 1073741760; +inp[3519] = 0; +inp[3520] = 1073741696; +inp[3521] = 0; +inp[3522] = 1073741632; +inp[3523] = 0; +inp[3524] = 1073741568; +inp[3525] = 0; +inp[3526] = 1073741504; +inp[3527] = 0; +inp[3528] = 1073741440; +inp[3529] = 0; +inp[3530] = 1073741376; +inp[3531] = 0; +inp[3532] = 1073741312; +inp[3533] = 0; +inp[3534] = 1073741248; +inp[3535] = 0; +inp[3536] = 1073741184; +inp[3537] = 0; +inp[3538] = 1073741120; +inp[3539] = 0; +inp[3540] = 1073741056; +inp[3541] = 0; +inp[3542] = 1073740992; +inp[3543] = 0; +inp[3544] = 1073740928; +inp[3545] = 0; +inp[3546] = 1073740864; +inp[3547] = 0; +inp[3548] = 1073740800; +inp[3549] = 0; +inp[3550] = 1073740736; +inp[3551] = 0; +inp[3552] = 1073740672; +inp[3553] = 0; +inp[3554] = 1073740608; +inp[3555] = 0; +inp[3556] = 1073740544; +inp[3557] = 0; +inp[3558] = 1073740480; +inp[3559] = 0; +inp[3560] = 1073740416; +inp[3561] = 0; +inp[3562] = 1073740352; +inp[3563] = 0; +inp[3564] = 1073740288; +inp[3565] = 0; +inp[3566] = 1073740224; +inp[3567] = 0; +inp[3568] = 1073740160; +inp[3569] = 0; +inp[3570] = 1073740096; +inp[3571] = 0; +inp[3572] = 1073740032; +inp[3573] = 0; +inp[3574] = 1073739968; +inp[3575] = 0; +inp[3576] = 1073739904; +inp[3577] = 0; +inp[3578] = 1073739840; +inp[3579] = 0; +inp[3580] = 1073741824; +inp[3581] = 1073741824; +inp[3582] = 1073741792; +inp[3583] = 0; +inp[3584] = 1073741760; +inp[3585] = 0; +inp[3586] = 1073741728; +inp[3587] = 0; +inp[3588] = 1073741696; +inp[3589] = 0; +inp[3590] = 1073741664; +inp[3591] = 0; +inp[3592] = 1073741632; +inp[3593] = 0; +inp[3594] = 1073741600; +inp[3595] = 0; +inp[3596] = 1073741568; +inp[3597] = 0; +inp[3598] = 1073741536; +inp[3599] = 0; +inp[3600] = 1073741504; +inp[3601] = 0; +inp[3602] = 1073741472; +inp[3603] = 0; +inp[3604] = 1073741440; +inp[3605] = 0; +inp[3606] = 1073741408; +inp[3607] = 0; +inp[3608] = 1073741376; +inp[3609] = 0; +inp[3610] = 1073741344; +inp[3611] = 0; +inp[3612] = 1073741312; +inp[3613] = 0; +inp[3614] = 1073741280; +inp[3615] = 0; +inp[3616] = 1073741248; +inp[3617] = 0; +inp[3618] = 1073741216; +inp[3619] = 0; +inp[3620] = 1073741184; +inp[3621] = 0; +inp[3622] = 1073741152; +inp[3623] = 0; +inp[3624] = 1073741120; +inp[3625] = 0; +inp[3626] = 1073741088; +inp[3627] = 0; +inp[3628] = 1073741056; +inp[3629] = 0; +inp[3630] = 1073741024; +inp[3631] = 0; +inp[3632] = 1073740992; +inp[3633] = 0; +inp[3634] = 1073740960; +inp[3635] = 0; +inp[3636] = 1073740928; +inp[3637] = 0; +inp[3638] = 1073740896; +inp[3639] = 0; +inp[3640] = 1073740864; +inp[3641] = 0; +inp[3642] = 1073740832; +inp[3643] = 0; +inp[3644] = 1073741824; +inp[3645] = 1073741824; +inp[3646] = 1073741808; +inp[3647] = 0; +inp[3648] = 1073741792; +inp[3649] = 0; +inp[3650] = 1073741776; +inp[3651] = 0; +inp[3652] = 1073741760; +inp[3653] = 0; +inp[3654] = 1073741744; +inp[3655] = 0; +inp[3656] = 1073741728; +inp[3657] = 0; +inp[3658] = 1073741712; +inp[3659] = 0; +inp[3660] = 1073741696; +inp[3661] = 0; +inp[3662] = 1073741680; +inp[3663] = 0; +inp[3664] = 1073741664; +inp[3665] = 0; +inp[3666] = 1073741648; +inp[3667] = 0; +inp[3668] = 1073741632; +inp[3669] = 0; +inp[3670] = 1073741616; +inp[3671] = 0; +inp[3672] = 1073741600; +inp[3673] = 0; +inp[3674] = 1073741584; +inp[3675] = 0; +inp[3676] = 1073741568; +inp[3677] = 0; +inp[3678] = 1073741552; +inp[3679] = 0; +inp[3680] = 1073741536; +inp[3681] = 0; +inp[3682] = 1073741520; +inp[3683] = 0; +inp[3684] = 1073741504; +inp[3685] = 0; +inp[3686] = 1073741488; +inp[3687] = 0; +inp[3688] = 1073741472; +inp[3689] = 0; +inp[3690] = 1073741456; +inp[3691] = 0; +inp[3692] = 1073741440; +inp[3693] = 0; +inp[3694] = 1073741424; +inp[3695] = 0; +inp[3696] = 1073741408; +inp[3697] = 0; +inp[3698] = 1073741392; +inp[3699] = 0; +inp[3700] = 1073741376; +inp[3701] = 0; +inp[3702] = 1073741360; +inp[3703] = 0; +inp[3704] = 1073741344; +inp[3705] = 0; +inp[3706] = 1073741328; +inp[3707] = 0; +inp[3708] = 1073741824; +inp[3709] = 1073741824; +inp[3710] = 1073741816; +inp[3711] = 0; +inp[3712] = 1073741808; +inp[3713] = 0; +inp[3714] = 1073741800; +inp[3715] = 0; +inp[3716] = 1073741792; +inp[3717] = 0; +inp[3718] = 1073741784; +inp[3719] = 0; +inp[3720] = 1073741776; +inp[3721] = 0; +inp[3722] = 1073741768; +inp[3723] = 0; +inp[3724] = 1073741760; +inp[3725] = 0; +inp[3726] = 1073741752; +inp[3727] = 0; +inp[3728] = 1073741744; +inp[3729] = 0; +inp[3730] = 1073741736; +inp[3731] = 0; +inp[3732] = 1073741728; +inp[3733] = 0; +inp[3734] = 1073741720; +inp[3735] = 0; +inp[3736] = 1073741712; +inp[3737] = 0; +inp[3738] = 1073741704; +inp[3739] = 0; +inp[3740] = 1073741696; +inp[3741] = 0; +inp[3742] = 1073741688; +inp[3743] = 0; +inp[3744] = 1073741680; +inp[3745] = 0; +inp[3746] = 1073741672; +inp[3747] = 0; +inp[3748] = 1073741664; +inp[3749] = 0; +inp[3750] = 1073741656; +inp[3751] = 0; +inp[3752] = 1073741648; +inp[3753] = 0; +inp[3754] = 1073741640; +inp[3755] = 0; +inp[3756] = 1073741632; +inp[3757] = 0; +inp[3758] = 1073741624; +inp[3759] = 0; +inp[3760] = 1073741616; +inp[3761] = 0; +inp[3762] = 1073741608; +inp[3763] = 0; +inp[3764] = 1073741600; +inp[3765] = 0; +inp[3766] = 1073741592; +inp[3767] = 0; +inp[3768] = 1073741584; +inp[3769] = 0; +inp[3770] = 1073741576; +inp[3771] = 0; +inp[3772] = 1073741824; +inp[3773] = 1073741824; +inp[3774] = 1073741820; +inp[3775] = 0; +inp[3776] = 1073741816; +inp[3777] = 0; +inp[3778] = 1073741812; +inp[3779] = 0; +inp[3780] = 1073741808; +inp[3781] = 0; +inp[3782] = 1073741804; +inp[3783] = 0; +inp[3784] = 1073741800; +inp[3785] = 0; +inp[3786] = 1073741796; +inp[3787] = 0; +inp[3788] = 1073741792; +inp[3789] = 0; +inp[3790] = 1073741788; +inp[3791] = 0; +inp[3792] = 1073741784; +inp[3793] = 0; +inp[3794] = 1073741780; +inp[3795] = 0; +inp[3796] = 1073741776; +inp[3797] = 0; +inp[3798] = 1073741772; +inp[3799] = 0; +inp[3800] = 1073741768; +inp[3801] = 0; +inp[3802] = 1073741764; +inp[3803] = 0; +inp[3804] = 1073741760; +inp[3805] = 0; +inp[3806] = 1073741756; +inp[3807] = 0; +inp[3808] = 1073741752; +inp[3809] = 0; +inp[3810] = 1073741748; +inp[3811] = 0; +inp[3812] = 1073741744; +inp[3813] = 0; +inp[3814] = 1073741740; +inp[3815] = 0; +inp[3816] = 1073741736; +inp[3817] = 0; +inp[3818] = 1073741732; +inp[3819] = 0; +inp[3820] = 1073741728; +inp[3821] = 0; +inp[3822] = 1073741724; +inp[3823] = 0; +inp[3824] = 1073741720; +inp[3825] = 0; +inp[3826] = 1073741716; +inp[3827] = 0; +inp[3828] = 1073741712; +inp[3829] = 0; +inp[3830] = 1073741708; +inp[3831] = 0; +inp[3832] = 1073741704; +inp[3833] = 0; +inp[3834] = 1073741700; +inp[3835] = 0; +inp[3836] = 1073741824; +inp[3837] = 1073741824; +inp[3838] = 1073741822; +inp[3839] = 0; +inp[3840] = 1073741820; +inp[3841] = 0; +inp[3842] = 1073741818; +inp[3843] = 0; +inp[3844] = 1073741816; +inp[3845] = 0; +inp[3846] = 1073741814; +inp[3847] = 0; +inp[3848] = 1073741812; +inp[3849] = 0; +inp[3850] = 1073741810; +inp[3851] = 0; +inp[3852] = 1073741808; +inp[3853] = 0; +inp[3854] = 1073741806; +inp[3855] = 0; +inp[3856] = 1073741804; +inp[3857] = 0; +inp[3858] = 1073741802; +inp[3859] = 0; +inp[3860] = 1073741800; +inp[3861] = 0; +inp[3862] = 1073741798; +inp[3863] = 0; +inp[3864] = 1073741796; +inp[3865] = 0; +inp[3866] = 1073741794; +inp[3867] = 0; +inp[3868] = 1073741792; +inp[3869] = 0; +inp[3870] = 1073741790; +inp[3871] = 0; +inp[3872] = 1073741788; +inp[3873] = 0; +inp[3874] = 1073741786; +inp[3875] = 0; +inp[3876] = 1073741784; +inp[3877] = 0; +inp[3878] = 1073741782; +inp[3879] = 0; +inp[3880] = 1073741780; +inp[3881] = 0; +inp[3882] = 1073741778; +inp[3883] = 0; +inp[3884] = 1073741776; +inp[3885] = 0; +inp[3886] = 1073741774; +inp[3887] = 0; +inp[3888] = 1073741772; +inp[3889] = 0; +inp[3890] = 1073741770; +inp[3891] = 0; +inp[3892] = 1073741768; +inp[3893] = 0; +inp[3894] = 1073741766; +inp[3895] = 0; +inp[3896] = 1073741764; +inp[3897] = 0; +inp[3898] = 1073741762; +inp[3899] = 0; +inp[3900] = 1073741824; +inp[3901] = 1073741824; +inp[3902] = 1073741823; +inp[3903] = 0; +inp[3904] = 1073741822; +inp[3905] = 0; +inp[3906] = 1073741821; +inp[3907] = 0; +inp[3908] = 1073741820; +inp[3909] = 0; +inp[3910] = 1073741819; +inp[3911] = 0; +inp[3912] = 1073741818; +inp[3913] = 0; +inp[3914] = 1073741817; +inp[3915] = 0; +inp[3916] = 1073741816; +inp[3917] = 0; +inp[3918] = 1073741815; +inp[3919] = 0; +inp[3920] = 1073741814; +inp[3921] = 0; +inp[3922] = 1073741813; +inp[3923] = 0; +inp[3924] = 1073741812; +inp[3925] = 0; +inp[3926] = 1073741811; +inp[3927] = 0; +inp[3928] = 1073741810; +inp[3929] = 0; +inp[3930] = 1073741809; +inp[3931] = 0; +inp[3932] = 1073741808; +inp[3933] = 0; +inp[3934] = 1073741807; +inp[3935] = 0; +inp[3936] = 1073741806; +inp[3937] = 0; +inp[3938] = 1073741805; +inp[3939] = 0; +inp[3940] = 1073741804; +inp[3941] = 0; +inp[3942] = 1073741803; +inp[3943] = 0; +inp[3944] = 1073741802; +inp[3945] = 0; +inp[3946] = 1073741801; +inp[3947] = 0; +inp[3948] = 1073741800; +inp[3949] = 0; +inp[3950] = 1073741799; +inp[3951] = 0; +inp[3952] = 1073741798; +inp[3953] = 0; +inp[3954] = 1073741797; +inp[3955] = 0; +inp[3956] = 1073741796; +inp[3957] = 0; +inp[3958] = 1073741795; +inp[3959] = 0; +inp[3960] = 1073741794; +inp[3961] = 0; +inp[3962] = 1073741793; +inp[3963] = 0; +inp[3964] = 1073741824; +inp[3965] = 1073741824; +inp[3966] = 1073741823; +inp[3967] = 0; +inp[3968] = 1073741823; +inp[3969] = 0; +inp[3970] = 1073741822; +inp[3971] = 0; +inp[3972] = 1073741822; +inp[3973] = 0; +inp[3974] = 1073741821; +inp[3975] = 0; +inp[3976] = 1073741821; +inp[3977] = 0; +inp[3978] = 1073741820; +inp[3979] = 0; +inp[3980] = 1073741820; +inp[3981] = 0; +inp[3982] = 1073741819; +inp[3983] = 0; +inp[3984] = 1073741819; +inp[3985] = 0; +inp[3986] = 1073741818; +inp[3987] = 0; +inp[3988] = 1073741818; +inp[3989] = 0; +inp[3990] = 1073741817; +inp[3991] = 0; +inp[3992] = 1073741817; +inp[3993] = 0; +inp[3994] = 1073741816; +inp[3995] = 0; +inp[3996] = 1073741816; +inp[3997] = 0; +inp[3998] = 1073741815; +inp[3999] = 0; +inp[4000] = 1073741815; +inp[4001] = 0; +inp[4002] = 1073741814; +inp[4003] = 0; +inp[4004] = 1073741814; +inp[4005] = 0; +inp[4006] = 1073741813; +inp[4007] = 0; +inp[4008] = 1073741813; +inp[4009] = 0; +inp[4010] = 1073741812; +inp[4011] = 0; +inp[4012] = 1073741812; +inp[4013] = 0; +inp[4014] = 1073741811; +inp[4015] = 0; +inp[4016] = 1073741811; +inp[4017] = 0; +inp[4018] = 1073741810; +inp[4019] = 0; +inp[4020] = 1073741810; +inp[4021] = 0; +inp[4022] = 1073741809; +inp[4023] = 0; +inp[4024] = 1073741809; +inp[4025] = 0; +inp[4026] = 1073741808; +inp[4027] = 0; +inp[4028] = 1073741824; +inp[4029] = 1073741824; +inp[4030] = 1073741823; +inp[4031] = 0; +inp[4032] = 1073741823; +inp[4033] = 0; +inp[4034] = 1073741823; +inp[4035] = 0; +inp[4036] = 1073741823; +inp[4037] = 0; +inp[4038] = 1073741822; +inp[4039] = 0; +inp[4040] = 1073741822; +inp[4041] = 0; +inp[4042] = 1073741822; +inp[4043] = 0; +inp[4044] = 1073741822; +inp[4045] = 0; +inp[4046] = 1073741821; +inp[4047] = 0; +inp[4048] = 1073741821; +inp[4049] = 0; +inp[4050] = 1073741821; +inp[4051] = 0; +inp[4052] = 1073741821; +inp[4053] = 0; +inp[4054] = 1073741820; +inp[4055] = 0; +inp[4056] = 1073741820; +inp[4057] = 0; +inp[4058] = 1073741820; +inp[4059] = 0; +inp[4060] = 1073741820; +inp[4061] = 0; +inp[4062] = 1073741819; +inp[4063] = 0; +inp[4064] = 1073741819; +inp[4065] = 0; +inp[4066] = 1073741819; +inp[4067] = 0; +inp[4068] = 1073741819; +inp[4069] = 0; +inp[4070] = 1073741818; +inp[4071] = 0; +inp[4072] = 1073741818; +inp[4073] = 0; +inp[4074] = 1073741818; +inp[4075] = 0; +inp[4076] = 1073741818; +inp[4077] = 0; +inp[4078] = 1073741817; +inp[4079] = 0; +inp[4080] = 1073741817; +inp[4081] = 0; +inp[4082] = 1073741817; +inp[4083] = 0; +inp[4084] = 1073741817; +inp[4085] = 0; +inp[4086] = 1073741816; +inp[4087] = 0; +inp[4088] = 1073741816; +inp[4089] = 0; +inp[4090] = 1073741816; +inp[4091] = 0; +inp[4092] = 1073741824; +inp[4093] = 1073741824; +inp[4094] = 395007542; +inp[4095] = 395007542; +inp[4096] = 145315153; +inp[4097] = 145315153; +inp[4098] = 53458457; +inp[4099] = 53458457; +inp[4100] = 19666267; +inp[4101] = 19666267; +inp[4102] = 7234815; +inp[4103] = 7234815; +inp[4104] = 2661539; +inp[4105] = 2661539; +inp[4106] = 979125; +inp[4107] = 979125; +inp[4108] = 360200; +inp[4109] = 360200; +inp[4110] = 132510; +inp[4111] = 132510; +inp[4112] = 48747; +inp[4113] = 48747; +inp[4114] = 17933; +inp[4115] = 17933; +inp[4116] = 6597; +inp[4117] = 6597; +inp[4118] = 2427; +inp[4119] = 2427; +inp[4120] = 892; +inp[4121] = 892; +inp[4122] = 328; +inp[4123] = 328; +inp[4124] = 120; +inp[4125] = 120; +inp[4126] = 44; +inp[4127] = 44; +inp[4128] = 16; +inp[4129] = 16; +inp[4130] = 6; +inp[4131] = 6; +inp[4132] = 2; +inp[4133] = 2; +inp[4134] = 0; +inp[4135] = 0; +inp[4136] = 0; +inp[4137] = 0; +inp[4138] = 0; +inp[4139] = 0; +inp[4140] = 0; +inp[4141] = 0; +inp[4142] = 0; +inp[4143] = 0; +inp[4144] = 0; +inp[4145] = 0; +inp[4146] = 0; +inp[4147] = 0; +inp[4148] = 0; +inp[4149] = 0; +inp[4150] = 0; +inp[4151] = 0; +inp[4152] = 0; +inp[4153] = 0; +inp[4154] = 0; +inp[4155] = 0; +inp[4156] = 0; +inp[4157] = 0; +inp[4158] = 0; +inp[4159] = 0; +inp[4160] = 0; +inp[4161] = 0; +inp[4162] = 0; +inp[4163] = 0; +inp[4164] = 0; +inp[4165] = 0; +inp[4166] = 0; +inp[4167] = 0; +inp[4168] = 0; +inp[4169] = 0; +inp[4170] = 0; +inp[4171] = 0; +inp[4172] = 0; +inp[4173] = 0; +inp[4174] = 0; +inp[4175] = 0; +inp[4176] = 0; +inp[4177] = 0; +inp[4178] = 0; +inp[4179] = 0; +inp[4180] = 0; +inp[4181] = 0; +inp[4182] = 0; +inp[4183] = 0; +inp[4184] = 0; +inp[4185] = 0; +inp[4186] = 0; +inp[4187] = 0; +inp[4188] = 0; +inp[4189] = 0; +inp[4190] = 0; +inp[4191] = 0; +inp[4192] = 0; +inp[4193] = 0; +inp[4194] = 0; +inp[4195] = 0; +inp[4196] = 0; +inp[4197] = 0; +inp[4198] = 0; +inp[4199] = 0; +inp[4200] = 0; +inp[4201] = 0; +inp[4202] = 0; +inp[4203] = 0; +inp[4204] = 0; +inp[4205] = 0; +inp[4206] = 0; +inp[4207] = 0; +inp[4208] = 0; +inp[4209] = 0; +inp[4210] = 0; +inp[4211] = 0; +inp[4212] = 0; +inp[4213] = 0; +inp[4214] = 0; +inp[4215] = 0; +inp[4216] = 0; +inp[4217] = 0; +inp[4218] = 0; +inp[4219] = 0; +inp[4220] = 1073741824; +inp[4221] = 1073741824; +inp[4222] = 651257336; +inp[4223] = 145315153; +inp[4224] = 395007542; +inp[4225] = 19666267; +inp[4226] = 239584185; +inp[4227] = 2661539; +inp[4228] = 145315153; +inp[4229] = 360200; +inp[4230] = 88138096; +inp[4231] = 48747; +inp[4232] = 53458457; +inp[4233] = 6597; +inp[4234] = 32424193; +inp[4235] = 892; +inp[4236] = 19666267; +inp[4237] = 120; +inp[4238] = 11928194; +inp[4239] = 16; +inp[4240] = 7234815; +inp[4241] = 2; +inp[4242] = 4388137; +inp[4243] = 0; +inp[4244] = 2661539; +inp[4245] = 0; +inp[4246] = 1614305; +inp[4247] = 0; +inp[4248] = 979125; +inp[4249] = 0; +inp[4250] = 593869; +inp[4251] = 0; +inp[4252] = 360200; +inp[4253] = 0; +inp[4254] = 218472; +inp[4255] = 0; +inp[4256] = 132510; +inp[4257] = 0; +inp[4258] = 80371; +inp[4259] = 0; +inp[4260] = 48747; +inp[4261] = 0; +inp[4262] = 29567; +inp[4263] = 0; +inp[4264] = 17933; +inp[4265] = 0; +inp[4266] = 10877; +inp[4267] = 0; +inp[4268] = 6597; +inp[4269] = 0; +inp[4270] = 4001; +inp[4271] = 0; +inp[4272] = 2427; +inp[4273] = 0; +inp[4274] = 1472; +inp[4275] = 0; +inp[4276] = 892; +inp[4277] = 0; +inp[4278] = 541; +inp[4279] = 0; +inp[4280] = 328; +inp[4281] = 0; +inp[4282] = 199; +inp[4283] = 0; +inp[4284] = 120; +inp[4285] = 0; +inp[4286] = 73; +inp[4287] = 0; +inp[4288] = 44; +inp[4289] = 0; +inp[4290] = 26; +inp[4291] = 0; +inp[4292] = 16; +inp[4293] = 0; +inp[4294] = 9; +inp[4295] = 0; +inp[4296] = 6; +inp[4297] = 0; +inp[4298] = 3; +inp[4299] = 0; +inp[4300] = 2; +inp[4301] = 0; +inp[4302] = 1; +inp[4303] = 0; +inp[4304] = 0; +inp[4305] = 0; +inp[4306] = 0; +inp[4307] = 0; +inp[4308] = 0; +inp[4309] = 0; +inp[4310] = 0; +inp[4311] = 0; +inp[4312] = 0; +inp[4313] = 0; +inp[4314] = 0; +inp[4315] = 0; +inp[4316] = 0; +inp[4317] = 0; +inp[4318] = 0; +inp[4319] = 0; +inp[4320] = 0; +inp[4321] = 0; +inp[4322] = 0; +inp[4323] = 0; +inp[4324] = 0; +inp[4325] = 0; +inp[4326] = 0; +inp[4327] = 0; +inp[4328] = 0; +inp[4329] = 0; +inp[4330] = 0; +inp[4331] = 0; +inp[4332] = 0; +inp[4333] = 0; +inp[4334] = 0; +inp[4335] = 0; +inp[4336] = 0; +inp[4337] = 0; +inp[4338] = 0; +inp[4339] = 0; +inp[4340] = 0; +inp[4341] = 0; +inp[4342] = 0; +inp[4343] = 0; +inp[4344] = 0; +inp[4345] = 0; +inp[4346] = 0; +inp[4347] = 0; +inp[4348] = 1073741824; +inp[4349] = 1073741824; +inp[4350] = 836230973; +inp[4351] = 19666267; +inp[4352] = 651257336; +inp[4353] = 360200; +inp[4354] = 507199723; +inp[4355] = 6597; +inp[4356] = 395007542; +inp[4357] = 120; +inp[4358] = 307632183; +inp[4359] = 2; +inp[4360] = 239584185; +inp[4361] = 0; +inp[4362] = 186588351; +inp[4363] = 0; +inp[4364] = 145315153; +inp[4365] = 0; +inp[4366] = 113171555; +inp[4367] = 0; +inp[4368] = 88138096; +inp[4369] = 0; +inp[4370] = 68642018; +inp[4371] = 0; +inp[4372] = 53458457; +inp[4373] = 0; +inp[4374] = 41633488; +inp[4375] = 0; +inp[4376] = 32424193; +inp[4377] = 0; +inp[4378] = 25251987; +inp[4379] = 0; +inp[4380] = 19666267; +inp[4381] = 0; +inp[4382] = 15316104; +inp[4383] = 0; +inp[4384] = 11928194; +inp[4385] = 0; +inp[4386] = 9289686; +inp[4387] = 0; +inp[4388] = 7234815; +inp[4389] = 0; +inp[4390] = 5634479; +inp[4391] = 0; +inp[4392] = 4388137; +inp[4393] = 0; +inp[4394] = 3417484; +inp[4395] = 0; +inp[4396] = 2661539; +inp[4397] = 0; +inp[4398] = 2072809; +inp[4399] = 0; +inp[4400] = 1614305; +inp[4401] = 0; +inp[4402] = 1257222; +inp[4403] = 0; +inp[4404] = 979125; +inp[4405] = 0; +inp[4406] = 762543; +inp[4407] = 0; +inp[4408] = 593869; +inp[4409] = 0; +inp[4410] = 462506; +inp[4411] = 0; +inp[4412] = 360200; +inp[4413] = 0; +inp[4414] = 280524; +inp[4415] = 0; +inp[4416] = 218472; +inp[4417] = 0; +inp[4418] = 170146; +inp[4419] = 0; +inp[4420] = 132510; +inp[4421] = 0; +inp[4422] = 103199; +inp[4423] = 0; +inp[4424] = 80371; +inp[4425] = 0; +inp[4426] = 62593; +inp[4427] = 0; +inp[4428] = 48747; +inp[4429] = 0; +inp[4430] = 37964; +inp[4431] = 0; +inp[4432] = 29567; +inp[4433] = 0; +inp[4434] = 23026; +inp[4435] = 0; +inp[4436] = 17933; +inp[4437] = 0; +inp[4438] = 13966; +inp[4439] = 0; +inp[4440] = 10877; +inp[4441] = 0; +inp[4442] = 8471; +inp[4443] = 0; +inp[4444] = 6597; +inp[4445] = 0; +inp[4446] = 5137; +inp[4447] = 0; +inp[4448] = 4001; +inp[4449] = 0; +inp[4450] = 3116; +inp[4451] = 0; +inp[4452] = 2427; +inp[4453] = 0; +inp[4454] = 1890; +inp[4455] = 0; +inp[4456] = 1472; +inp[4457] = 0; +inp[4458] = 1146; +inp[4459] = 0; +inp[4460] = 892; +inp[4461] = 0; +inp[4462] = 695; +inp[4463] = 0; +inp[4464] = 541; +inp[4465] = 0; +inp[4466] = 421; +inp[4467] = 0; +inp[4468] = 328; +inp[4469] = 0; +inp[4470] = 255; +inp[4471] = 0; +inp[4472] = 199; +inp[4473] = 0; +inp[4474] = 155; +inp[4475] = 0; +inp[4476] = 1073741824; +inp[4477] = 1073741824; +inp[4478] = 947573833; +inp[4479] = 360200; +inp[4480] = 836230973; +inp[4481] = 120; +inp[4482] = 737971243; +inp[4483] = 0; +inp[4484] = 651257336; +inp[4485] = 0; +inp[4486] = 574732582; +inp[4487] = 0; +inp[4488] = 507199723; +inp[4489] = 0; +inp[4490] = 447602185; +inp[4491] = 0; +inp[4492] = 395007542; +inp[4493] = 0; +inp[4494] = 348592932; +inp[4495] = 0; +inp[4496] = 307632183; +inp[4497] = 0; +inp[4498] = 271484448; +inp[4499] = 0; +inp[4500] = 239584185; +inp[4501] = 0; +inp[4502] = 211432301; +inp[4503] = 0; +inp[4504] = 186588351; +inp[4505] = 0; +inp[4506] = 164663641; +inp[4507] = 0; +inp[4508] = 145315153; +inp[4509] = 0; +inp[4510] = 128240173; +inp[4511] = 0; +inp[4512] = 113171555; +inp[4513] = 0; +inp[4514] = 99873547; +inp[4515] = 0; +inp[4516] = 88138096; +inp[4517] = 0; +inp[4518] = 77781596; +inp[4519] = 0; +inp[4520] = 68642018; +inp[4521] = 0; +inp[4522] = 60576368; +inp[4523] = 0; +inp[4524] = 53458457; +inp[4525] = 0; +inp[4526] = 47176923; +inp[4527] = 0; +inp[4528] = 41633488; +inp[4529] = 0; +inp[4530] = 36741424; +inp[4531] = 0; +inp[4532] = 32424193; +inp[4533] = 0; +inp[4534] = 28614250; +inp[4535] = 0; +inp[4536] = 25251987; +inp[4537] = 0; +inp[4538] = 22284800; +inp[4539] = 0; +inp[4540] = 19666267; +inp[4541] = 0; +inp[4542] = 17355420; +inp[4543] = 0; +inp[4544] = 15316104; +inp[4545] = 0; +inp[4546] = 13516414; +inp[4547] = 0; +inp[4548] = 11928194; +inp[4549] = 0; +inp[4550] = 10526594; +inp[4551] = 0; +inp[4552] = 9289686; +inp[4553] = 0; +inp[4554] = 8198119; +inp[4555] = 0; +inp[4556] = 7234815; +inp[4557] = 0; +inp[4558] = 6384702; +inp[4559] = 0; +inp[4560] = 5634479; +inp[4561] = 0; +inp[4562] = 4972411; +inp[4563] = 0; +inp[4564] = 4388137; +inp[4565] = 0; +inp[4566] = 3872517; +inp[4567] = 0; +inp[4568] = 3417484; +inp[4569] = 0; +inp[4570] = 3015919; +inp[4571] = 0; +inp[4572] = 2661539; +inp[4573] = 0; +inp[4574] = 2348800; +inp[4575] = 0; +inp[4576] = 2072809; +inp[4577] = 0; +inp[4578] = 1829247; +inp[4579] = 0; +inp[4580] = 1614305; +inp[4581] = 0; +inp[4582] = 1424619; +inp[4583] = 0; +inp[4584] = 1257222; +inp[4585] = 0; +inp[4586] = 1109494; +inp[4587] = 0; +inp[4588] = 979125; +inp[4589] = 0; +inp[4590] = 864075; +inp[4591] = 0; +inp[4592] = 762543; +inp[4593] = 0; +inp[4594] = 672942; +inp[4595] = 0; +inp[4596] = 593869; +inp[4597] = 0; +inp[4598] = 524088; +inp[4599] = 0; +inp[4600] = 462506; +inp[4601] = 0; +inp[4602] = 408160; +inp[4603] = 0; +inp[4604] = 1073741824; +inp[4605] = 1073741824; +inp[4606] = 1008687095; +inp[4607] = 120; +inp[4608] = 947573833; +inp[4609] = 0; +inp[4610] = 890163237; +inp[4611] = 0; +inp[4612] = 836230973; +inp[4613] = 0; +inp[4614] = 785566299; +inp[4615] = 0; +inp[4616] = 737971243; +inp[4617] = 0; +inp[4618] = 693259826; +inp[4619] = 0; +inp[4620] = 651257336; +inp[4621] = 0; +inp[4622] = 611799649; +inp[4623] = 0; +inp[4624] = 574732582; +inp[4625] = 0; +inp[4626] = 539911295; +inp[4627] = 0; +inp[4628] = 507199723; +inp[4629] = 0; +inp[4630] = 476470046; +inp[4631] = 0; +inp[4632] = 447602185; +inp[4633] = 0; +inp[4634] = 420483339; +inp[4635] = 0; +inp[4636] = 395007542; +inp[4637] = 0; +inp[4638] = 371075245; +inp[4639] = 0; +inp[4640] = 348592932; +inp[4641] = 0; +inp[4642] = 327472754; +inp[4643] = 0; +inp[4644] = 307632183; +inp[4645] = 0; +inp[4646] = 288993691; +inp[4647] = 0; +inp[4648] = 271484448; +inp[4649] = 0; +inp[4650] = 255036037; +inp[4651] = 0; +inp[4652] = 239584185; +inp[4653] = 0; +inp[4654] = 225068513; +inp[4655] = 0; +inp[4656] = 211432301; +inp[4657] = 0; +inp[4658] = 198622265; +inp[4659] = 0; +inp[4660] = 186588351; +inp[4661] = 0; +inp[4662] = 175283534; +inp[4663] = 0; +inp[4664] = 164663641; +inp[4665] = 0; +inp[4666] = 154687176; +inp[4667] = 0; +inp[4668] = 145315153; +inp[4669] = 0; +inp[4670] = 136510953; +inp[4671] = 0; +inp[4672] = 128240173; +inp[4673] = 0; +inp[4674] = 120470493; +inp[4675] = 0; +inp[4676] = 113171555; +inp[4677] = 0; +inp[4678] = 106314837; +inp[4679] = 0; +inp[4680] = 99873547; +inp[4681] = 0; +inp[4682] = 93822514; +inp[4683] = 0; +inp[4684] = 88138096; +inp[4685] = 0; +inp[4686] = 82798078; +inp[4687] = 0; +inp[4688] = 77781596; +inp[4689] = 0; +inp[4690] = 73069048; +inp[4691] = 0; +inp[4692] = 68642018; +inp[4693] = 0; +inp[4694] = 64483208; +inp[4695] = 0; +inp[4696] = 60576368; +inp[4697] = 0; +inp[4698] = 56906231; +inp[4699] = 0; +inp[4700] = 53458457; +inp[4701] = 0; +inp[4702] = 50219573; +inp[4703] = 0; +inp[4704] = 47176923; +inp[4705] = 0; +inp[4706] = 44318617; +inp[4707] = 0; +inp[4708] = 41633488; +inp[4709] = 0; +inp[4710] = 39111043; +inp[4711] = 0; +inp[4712] = 36741424; +inp[4713] = 0; +inp[4714] = 34515374; +inp[4715] = 0; +inp[4716] = 32424193; +inp[4717] = 0; +inp[4718] = 30459710; +inp[4719] = 0; +inp[4720] = 28614250; +inp[4721] = 0; +inp[4722] = 26880600; +inp[4723] = 0; +inp[4724] = 25251987; +inp[4725] = 0; +inp[4726] = 23722046; +inp[4727] = 0; +inp[4728] = 22284800; +inp[4729] = 0; +inp[4730] = 20934632; +inp[4731] = 0; +inp[4732] = 1073741824; +inp[4733] = 1073741824; +inp[4734] = 1040706261; +inp[4735] = 0; +inp[4736] = 1008687095; +inp[4737] = 0; +inp[4738] = 977653056; +inp[4739] = 0; +inp[4740] = 947573833; +inp[4741] = 0; +inp[4742] = 918420051; +inp[4743] = 0; +inp[4744] = 890163237; +inp[4745] = 0; +inp[4746] = 862775793; +inp[4747] = 0; +inp[4748] = 836230973; +inp[4749] = 0; +inp[4750] = 810502851; +inp[4751] = 0; +inp[4752] = 785566299; +inp[4753] = 0; +inp[4754] = 761396965; +inp[4755] = 0; +inp[4756] = 737971243; +inp[4757] = 0; +inp[4758] = 715266255; +inp[4759] = 0; +inp[4760] = 693259826; +inp[4761] = 0; +inp[4762] = 671930463; +inp[4763] = 0; +inp[4764] = 651257336; +inp[4765] = 0; +inp[4766] = 631220255; +inp[4767] = 0; +inp[4768] = 611799649; +inp[4769] = 0; +inp[4770] = 592976553; +inp[4771] = 0; +inp[4772] = 574732582; +inp[4773] = 0; +inp[4774] = 557049919; +inp[4775] = 0; +inp[4776] = 539911295; +inp[4777] = 0; +inp[4778] = 523299971; +inp[4779] = 0; +inp[4780] = 507199723; +inp[4781] = 0; +inp[4782] = 491594828; +inp[4783] = 0; +inp[4784] = 476470046; +inp[4785] = 0; +inp[4786] = 461810603; +inp[4787] = 0; +inp[4788] = 447602185; +inp[4789] = 0; +inp[4790] = 433830913; +inp[4791] = 0; +inp[4792] = 420483339; +inp[4793] = 0; +inp[4794] = 407546427; +inp[4795] = 0; +inp[4796] = 395007542; +inp[4797] = 0; +inp[4798] = 382854437; +inp[4799] = 0; +inp[4800] = 371075245; +inp[4801] = 0; +inp[4802] = 359658459; +inp[4803] = 0; +inp[4804] = 348592932; +inp[4805] = 0; +inp[4806] = 337867855; +inp[4807] = 0; +inp[4808] = 327472754; +inp[4809] = 0; +inp[4810] = 317397476; +inp[4811] = 0; +inp[4812] = 307632183; +inp[4813] = 0; +inp[4814] = 298167335; +inp[4815] = 0; +inp[4816] = 288993691; +inp[4817] = 0; +inp[4818] = 280102290; +inp[4819] = 0; +inp[4820] = 271484448; +inp[4821] = 0; +inp[4822] = 263131750; +inp[4823] = 0; +inp[4824] = 255036037; +inp[4825] = 0; +inp[4826] = 247189403; +inp[4827] = 0; +inp[4828] = 239584185; +inp[4829] = 0; +inp[4830] = 232212954; +inp[4831] = 0; +inp[4832] = 225068513; +inp[4833] = 0; +inp[4834] = 218143882; +inp[4835] = 0; +inp[4836] = 211432301; +inp[4837] = 0; +inp[4838] = 204927213; +inp[4839] = 0; +inp[4840] = 198622265; +inp[4841] = 0; +inp[4842] = 192511301; +inp[4843] = 0; +inp[4844] = 186588351; +inp[4845] = 0; +inp[4846] = 180847630; +inp[4847] = 0; +inp[4848] = 175283534; +inp[4849] = 0; +inp[4850] = 169890626; +inp[4851] = 0; +inp[4852] = 164663641; +inp[4853] = 0; +inp[4854] = 159597474; +inp[4855] = 0; +inp[4856] = 154687176; +inp[4857] = 0; +inp[4858] = 149927952; +inp[4859] = 0; +inp[4860] = 1073741824; +inp[4861] = 1073741824; +inp[4862] = 1057094999; +inp[4863] = 0; +inp[4864] = 1040706261; +inp[4865] = 0; +inp[4866] = 1024571605; +inp[4867] = 0; +inp[4868] = 1008687095; +inp[4869] = 0; +inp[4870] = 993048851; +inp[4871] = 0; +inp[4872] = 977653056; +inp[4873] = 0; +inp[4874] = 962495950; +inp[4875] = 0; +inp[4876] = 947573833; +inp[4877] = 0; +inp[4878] = 932883063; +inp[4879] = 0; +inp[4880] = 918420051; +inp[4881] = 0; +inp[4882] = 904181268; +inp[4883] = 0; +inp[4884] = 890163237; +inp[4885] = 0; +inp[4886] = 876362535; +inp[4887] = 0; +inp[4888] = 862775793; +inp[4889] = 0; +inp[4890] = 849399695; +inp[4891] = 0; +inp[4892] = 836230973; +inp[4893] = 0; +inp[4894] = 823266413; +inp[4895] = 0; +inp[4896] = 810502851; +inp[4897] = 0; +inp[4898] = 797937169; +inp[4899] = 0; +inp[4900] = 785566299; +inp[4901] = 0; +inp[4902] = 773387223; +inp[4903] = 0; +inp[4904] = 761396965; +inp[4905] = 0; +inp[4906] = 749592599; +inp[4907] = 0; +inp[4908] = 737971243; +inp[4909] = 0; +inp[4910] = 726530060; +inp[4911] = 0; +inp[4912] = 715266255; +inp[4913] = 0; +inp[4914] = 704177080; +inp[4915] = 0; +inp[4916] = 693259826; +inp[4917] = 0; +inp[4918] = 682511829; +inp[4919] = 0; +inp[4920] = 671930463; +inp[4921] = 0; +inp[4922] = 661513147; +inp[4923] = 0; +inp[4924] = 651257336; +inp[4925] = 0; +inp[4926] = 641160527; +inp[4927] = 0; +inp[4928] = 631220255; +inp[4929] = 0; +inp[4930] = 621434092; +inp[4931] = 0; +inp[4932] = 611799649; +inp[4933] = 0; +inp[4934] = 602314575; +inp[4935] = 0; +inp[4936] = 592976553; +inp[4937] = 0; +inp[4938] = 583783303; +inp[4939] = 0; +inp[4940] = 574732582; +inp[4941] = 0; +inp[4942] = 565822179; +inp[4943] = 0; +inp[4944] = 557049919; +inp[4945] = 0; +inp[4946] = 548413661; +inp[4947] = 0; +inp[4948] = 539911295; +inp[4949] = 0; +inp[4950] = 531540746; +inp[4951] = 0; +inp[4952] = 523299971; +inp[4953] = 0; +inp[4954] = 515186957; +inp[4955] = 0; +inp[4956] = 507199723; +inp[4957] = 0; +inp[4958] = 499336321; +inp[4959] = 0; +inp[4960] = 491594828; +inp[4961] = 0; +inp[4962] = 483973357; +inp[4963] = 0; +inp[4964] = 476470046; +inp[4965] = 0; +inp[4966] = 469083062; +inp[4967] = 0; +inp[4968] = 461810603; +inp[4969] = 0; +inp[4970] = 454650894; +inp[4971] = 0; +inp[4972] = 447602185; +inp[4973] = 0; +inp[4974] = 440662756; +inp[4975] = 0; +inp[4976] = 433830913; +inp[4977] = 0; +inp[4978] = 427104988; +inp[4979] = 0; +inp[4980] = 420483339; +inp[4981] = 0; +inp[4982] = 413964349; +inp[4983] = 0; +inp[4984] = 407546427; +inp[4985] = 0; +inp[4986] = 401228005; +inp[4987] = 0; +inp[4988] = 1073741824; +inp[4989] = 1073741824; +inp[4990] = 1065385898; +inp[4991] = 0; +inp[4992] = 1057094999; +inp[4993] = 0; +inp[4994] = 1048868621; +inp[4995] = 0; +inp[4996] = 1040706261; +inp[4997] = 0; +inp[4998] = 1032607420; +inp[4999] = 0; +inp[5000] = 1024571605; +inp[5001] = 0; +inp[5002] = 1016598326; +inp[5003] = 0; +inp[5004] = 1008687095; +inp[5005] = 0; +inp[5006] = 1000837430; +inp[5007] = 0; +inp[5008] = 993048851; +inp[5009] = 0; +inp[5010] = 985320884; +inp[5011] = 0; +inp[5012] = 977653056; +inp[5013] = 0; +inp[5014] = 970044899; +inp[5015] = 0; +inp[5016] = 962495950; +inp[5017] = 0; +inp[5018] = 955005747; +inp[5019] = 0; +inp[5020] = 947573833; +inp[5021] = 0; +inp[5022] = 940199755; +inp[5023] = 0; +inp[5024] = 932883063; +inp[5025] = 0; +inp[5026] = 925623309; +inp[5027] = 0; +inp[5028] = 918420051; +inp[5029] = 0; +inp[5030] = 911272850; +inp[5031] = 0; +inp[5032] = 904181268; +inp[5033] = 0; +inp[5034] = 897144874; +inp[5035] = 0; +inp[5036] = 890163237; +inp[5037] = 0; +inp[5038] = 883235932; +inp[5039] = 0; +inp[5040] = 876362535; +inp[5041] = 0; +inp[5042] = 869542628; +inp[5043] = 0; +inp[5044] = 862775793; +inp[5045] = 0; +inp[5046] = 856061619; +inp[5047] = 0; +inp[5048] = 849399695; +inp[5049] = 0; +inp[5050] = 842789614; +inp[5051] = 0; +inp[5052] = 836230973; +inp[5053] = 0; +inp[5054] = 829723372; +inp[5055] = 0; +inp[5056] = 823266413; +inp[5057] = 0; +inp[5058] = 816859703; +inp[5059] = 0; +inp[5060] = 810502851; +inp[5061] = 0; +inp[5062] = 804195467; +inp[5063] = 0; +inp[5064] = 797937169; +inp[5065] = 0; +inp[5066] = 791727572; +inp[5067] = 0; +inp[5068] = 785566299; +inp[5069] = 0; +inp[5070] = 779452974; +inp[5071] = 0; +inp[5072] = 773387223; +inp[5073] = 0; +inp[5074] = 767368676; +inp[5075] = 0; +inp[5076] = 761396965; +inp[5077] = 0; +inp[5078] = 755471727; +inp[5079] = 0; +inp[5080] = 749592599; +inp[5081] = 0; +inp[5082] = 743759224; +inp[5083] = 0; +inp[5084] = 737971243; +inp[5085] = 0; +inp[5086] = 732228306; +inp[5087] = 0; +inp[5088] = 726530060; +inp[5089] = 0; +inp[5090] = 720876158; +inp[5091] = 0; +inp[5092] = 715266255; +inp[5093] = 0; +inp[5094] = 709700009; +inp[5095] = 0; +inp[5096] = 704177080; +inp[5097] = 0; +inp[5098] = 698697130; +inp[5099] = 0; +inp[5100] = 693259826; +inp[5101] = 0; +inp[5102] = 687864835; +inp[5103] = 0; +inp[5104] = 682511829; +inp[5105] = 0; +inp[5106] = 677200479; +inp[5107] = 0; +inp[5108] = 671930463; +inp[5109] = 0; +inp[5110] = 666701459; +inp[5111] = 0; +inp[5112] = 661513147; +inp[5113] = 0; +inp[5114] = 656365211; +inp[5115] = 0; +inp[5116] = 1073741824; +inp[5117] = 1073741824; +inp[5118] = 1069555701; +inp[5119] = 0; +inp[5120] = 1065385898; +inp[5121] = 0; +inp[5122] = 1061232352; +inp[5123] = 0; +inp[5124] = 1057094999; +inp[5125] = 0; +inp[5126] = 1052973777; +inp[5127] = 0; +inp[5128] = 1048868621; +inp[5129] = 0; +inp[5130] = 1044779470; +inp[5131] = 0; +inp[5132] = 1040706261; +inp[5133] = 0; +inp[5134] = 1036648931; +inp[5135] = 0; +inp[5136] = 1032607420; +inp[5137] = 0; +inp[5138] = 1028581665; +inp[5139] = 0; +inp[5140] = 1024571605; +inp[5141] = 0; +inp[5142] = 1020577179; +inp[5143] = 0; +inp[5144] = 1016598326; +inp[5145] = 0; +inp[5146] = 1012634985; +inp[5147] = 0; +inp[5148] = 1008687095; +inp[5149] = 0; +inp[5150] = 1004754597; +inp[5151] = 0; +inp[5152] = 1000837430; +inp[5153] = 0; +inp[5154] = 996935534; +inp[5155] = 0; +inp[5156] = 993048851; +inp[5157] = 0; +inp[5158] = 989177321; +inp[5159] = 0; +inp[5160] = 985320884; +inp[5161] = 0; +inp[5162] = 981479482; +inp[5163] = 0; +inp[5164] = 977653056; +inp[5165] = 0; +inp[5166] = 973841548; +inp[5167] = 0; +inp[5168] = 970044899; +inp[5169] = 0; +inp[5170] = 966263053; +inp[5171] = 0; +inp[5172] = 962495950; +inp[5173] = 0; +inp[5174] = 958743534; +inp[5175] = 0; +inp[5176] = 955005747; +inp[5177] = 0; +inp[5178] = 951282532; +inp[5179] = 0; +inp[5180] = 947573833; +inp[5181] = 0; +inp[5182] = 943879593; +inp[5183] = 0; +inp[5184] = 940199755; +inp[5185] = 0; +inp[5186] = 936534264; +inp[5187] = 0; +inp[5188] = 932883063; +inp[5189] = 0; +inp[5190] = 929246096; +inp[5191] = 0; +inp[5192] = 925623309; +inp[5193] = 0; +inp[5194] = 922014646; +inp[5195] = 0; +inp[5196] = 918420051; +inp[5197] = 0; +inp[5198] = 914839471; +inp[5199] = 0; +inp[5200] = 911272850; +inp[5201] = 0; +inp[5202] = 907720134; +inp[5203] = 0; +inp[5204] = 904181268; +inp[5205] = 0; +inp[5206] = 900656200; +inp[5207] = 0; +inp[5208] = 897144874; +inp[5209] = 0; +inp[5210] = 893647237; +inp[5211] = 0; +inp[5212] = 890163237; +inp[5213] = 0; +inp[5214] = 886692819; +inp[5215] = 0; +inp[5216] = 883235932; +inp[5217] = 0; +inp[5218] = 879792521; +inp[5219] = 0; +inp[5220] = 876362535; +inp[5221] = 0; +inp[5222] = 872945921; +inp[5223] = 0; +inp[5224] = 869542628; +inp[5225] = 0; +inp[5226] = 866152602; +inp[5227] = 0; +inp[5228] = 862775793; +inp[5229] = 0; +inp[5230] = 859412149; +inp[5231] = 0; +inp[5232] = 856061619; +inp[5233] = 0; +inp[5234] = 852724151; +inp[5235] = 0; +inp[5236] = 849399695; +inp[5237] = 0; +inp[5238] = 846088199; +inp[5239] = 0; +inp[5240] = 842789614; +inp[5241] = 0; +inp[5242] = 839503888; +inp[5243] = 0; +inp[5244] = 1073741824; +inp[5245] = 1073741824; +inp[5246] = 1071646718; +inp[5247] = 0; +inp[5248] = 1069555701; +inp[5249] = 0; +inp[5250] = 1067468764; +inp[5251] = 0; +inp[5252] = 1065385898; +inp[5253] = 0; +inp[5254] = 1063307097; +inp[5255] = 0; +inp[5256] = 1061232352; +inp[5257] = 0; +inp[5258] = 1059161656; +inp[5259] = 0; +inp[5260] = 1057094999; +inp[5261] = 0; +inp[5262] = 1055032376; +inp[5263] = 0; +inp[5264] = 1052973777; +inp[5265] = 0; +inp[5266] = 1050919194; +inp[5267] = 0; +inp[5268] = 1048868621; +inp[5269] = 0; +inp[5270] = 1046822049; +inp[5271] = 0; +inp[5272] = 1044779470; +inp[5273] = 0; +inp[5274] = 1042740876; +inp[5275] = 0; +inp[5276] = 1040706261; +inp[5277] = 0; +inp[5278] = 1038675615; +inp[5279] = 0; +inp[5280] = 1036648931; +inp[5281] = 0; +inp[5282] = 1034626202; +inp[5283] = 0; +inp[5284] = 1032607420; +inp[5285] = 0; +inp[5286] = 1030592577; +inp[5287] = 0; +inp[5288] = 1028581665; +inp[5289] = 0; +inp[5290] = 1026574677; +inp[5291] = 0; +inp[5292] = 1024571605; +inp[5293] = 0; +inp[5294] = 1022572442; +inp[5295] = 0; +inp[5296] = 1020577179; +inp[5297] = 0; +inp[5298] = 1018585810; +inp[5299] = 0; +inp[5300] = 1016598326; +inp[5301] = 0; +inp[5302] = 1014614720; +inp[5303] = 0; +inp[5304] = 1012634985; +inp[5305] = 0; +inp[5306] = 1010659112; +inp[5307] = 0; +inp[5308] = 1008687095; +inp[5309] = 0; +inp[5310] = 1006718926; +inp[5311] = 0; +inp[5312] = 1004754597; +inp[5313] = 0; +inp[5314] = 1002794101; +inp[5315] = 0; +inp[5316] = 1000837430; +inp[5317] = 0; +inp[5318] = 998884577; +inp[5319] = 0; +inp[5320] = 996935534; +inp[5321] = 0; +inp[5322] = 994990295; +inp[5323] = 0; +inp[5324] = 993048851; +inp[5325] = 0; +inp[5326] = 991111195; +inp[5327] = 0; +inp[5328] = 989177321; +inp[5329] = 0; +inp[5330] = 987247219; +inp[5331] = 0; +inp[5332] = 985320884; +inp[5333] = 0; +inp[5334] = 983398307; +inp[5335] = 0; +inp[5336] = 981479482; +inp[5337] = 0; +inp[5338] = 979564400; +inp[5339] = 0; +inp[5340] = 977653056; +inp[5341] = 0; +inp[5342] = 975745441; +inp[5343] = 0; +inp[5344] = 973841548; +inp[5345] = 0; +inp[5346] = 971941370; +inp[5347] = 0; +inp[5348] = 970044899; +inp[5349] = 0; +inp[5350] = 968152129; +inp[5351] = 0; +inp[5352] = 966263053; +inp[5353] = 0; +inp[5354] = 964377662; +inp[5355] = 0; +inp[5356] = 962495950; +inp[5357] = 0; +inp[5358] = 960617910; +inp[5359] = 0; +inp[5360] = 958743534; +inp[5361] = 0; +inp[5362] = 956872815; +inp[5363] = 0; +inp[5364] = 955005747; +inp[5365] = 0; +inp[5366] = 953142322; +inp[5367] = 0; +inp[5368] = 951282532; +inp[5369] = 0; +inp[5370] = 949426372; +inp[5371] = 0; +inp[5372] = 1073741824; +inp[5373] = 1073741824; +inp[5374] = 1072693759; +inp[5375] = 0; +inp[5376] = 1071646718; +inp[5377] = 0; +inp[5378] = 1070600699; +inp[5379] = 0; +inp[5380] = 1069555701; +inp[5381] = 0; +inp[5382] = 1068511723; +inp[5383] = 0; +inp[5384] = 1067468764; +inp[5385] = 0; +inp[5386] = 1066426822; +inp[5387] = 0; +inp[5388] = 1065385898; +inp[5389] = 0; +inp[5390] = 1064345990; +inp[5391] = 0; +inp[5392] = 1063307097; +inp[5393] = 0; +inp[5394] = 1062269218; +inp[5395] = 0; +inp[5396] = 1061232352; +inp[5397] = 0; +inp[5398] = 1060196498; +inp[5399] = 0; +inp[5400] = 1059161656; +inp[5401] = 0; +inp[5402] = 1058127823; +inp[5403] = 0; +inp[5404] = 1057094999; +inp[5405] = 0; +inp[5406] = 1056063184; +inp[5407] = 0; +inp[5408] = 1055032376; +inp[5409] = 0; +inp[5410] = 1054002574; +inp[5411] = 0; +inp[5412] = 1052973777; +inp[5413] = 0; +inp[5414] = 1051945984; +inp[5415] = 0; +inp[5416] = 1050919194; +inp[5417] = 0; +inp[5418] = 1049893407; +inp[5419] = 0; +inp[5420] = 1048868621; +inp[5421] = 0; +inp[5422] = 1047844835; +inp[5423] = 0; +inp[5424] = 1046822049; +inp[5425] = 0; +inp[5426] = 1045800261; +inp[5427] = 0; +inp[5428] = 1044779470; +inp[5429] = 0; +inp[5430] = 1043759675; +inp[5431] = 0; +inp[5432] = 1042740876; +inp[5433] = 0; +inp[5434] = 1041723072; +inp[5435] = 0; +inp[5436] = 1040706261; +inp[5437] = 0; +inp[5438] = 1039690442; +inp[5439] = 0; +inp[5440] = 1038675615; +inp[5441] = 0; +inp[5442] = 1037661778; +inp[5443] = 0; +inp[5444] = 1036648931; +inp[5445] = 0; +inp[5446] = 1035637073; +inp[5447] = 0; +inp[5448] = 1034626202; +inp[5449] = 0; +inp[5450] = 1033616318; +inp[5451] = 0; +inp[5452] = 1032607420; +inp[5453] = 0; +inp[5454] = 1031599507; +inp[5455] = 0; +inp[5456] = 1030592577; +inp[5457] = 0; +inp[5458] = 1029586630; +inp[5459] = 0; +inp[5460] = 1028581665; +inp[5461] = 0; +inp[5462] = 1027577681; +inp[5463] = 0; +inp[5464] = 1026574677; +inp[5465] = 0; +inp[5466] = 1025572652; +inp[5467] = 0; +inp[5468] = 1024571605; +inp[5469] = 0; +inp[5470] = 1023571536; +inp[5471] = 0; +inp[5472] = 1022572442; +inp[5473] = 0; +inp[5474] = 1021574324; +inp[5475] = 0; +inp[5476] = 1020577179; +inp[5477] = 0; +inp[5478] = 1019581008; +inp[5479] = 0; +inp[5480] = 1018585810; +inp[5481] = 0; +inp[5482] = 1017591583; +inp[5483] = 0; +inp[5484] = 1016598326; +inp[5485] = 0; +inp[5486] = 1015606039; +inp[5487] = 0; +inp[5488] = 1014614720; +inp[5489] = 0; +inp[5490] = 1013624369; +inp[5491] = 0; +inp[5492] = 1012634985; +inp[5493] = 0; +inp[5494] = 1011646566; +inp[5495] = 0; +inp[5496] = 1010659112; +inp[5497] = 0; +inp[5498] = 1009672622; +inp[5499] = 0; +inp[5500] = 1073741824; +inp[5501] = 1073741824; +inp[5502] = 1073217663; +inp[5503] = 0; +inp[5504] = 1072693759; +inp[5505] = 0; +inp[5506] = 1072170111; +inp[5507] = 0; +inp[5508] = 1071646718; +inp[5509] = 0; +inp[5510] = 1071123581; +inp[5511] = 0; +inp[5512] = 1070600699; +inp[5513] = 0; +inp[5514] = 1070078072; +inp[5515] = 0; +inp[5516] = 1069555701; +inp[5517] = 0; +inp[5518] = 1069033584; +inp[5519] = 0; +inp[5520] = 1068511723; +inp[5521] = 0; +inp[5522] = 1067990116; +inp[5523] = 0; +inp[5524] = 1067468764; +inp[5525] = 0; +inp[5526] = 1066947666; +inp[5527] = 0; +inp[5528] = 1066426822; +inp[5529] = 0; +inp[5530] = 1065906233; +inp[5531] = 0; +inp[5532] = 1065385898; +inp[5533] = 0; +inp[5534] = 1064865817; +inp[5535] = 0; +inp[5536] = 1064345990; +inp[5537] = 0; +inp[5538] = 1063826417; +inp[5539] = 0; +inp[5540] = 1063307097; +inp[5541] = 0; +inp[5542] = 1062788031; +inp[5543] = 0; +inp[5544] = 1062269218; +inp[5545] = 0; +inp[5546] = 1061750659; +inp[5547] = 0; +inp[5548] = 1061232352; +inp[5549] = 0; +inp[5550] = 1060714299; +inp[5551] = 0; +inp[5552] = 1060196498; +inp[5553] = 0; +inp[5554] = 1059678951; +inp[5555] = 0; +inp[5556] = 1059161656; +inp[5557] = 0; +inp[5558] = 1058644613; +inp[5559] = 0; +inp[5560] = 1058127823; +inp[5561] = 0; +inp[5562] = 1057611285; +inp[5563] = 0; +inp[5564] = 1057094999; +inp[5565] = 0; +inp[5566] = 1056578966; +inp[5567] = 0; +inp[5568] = 1056063184; +inp[5569] = 0; +inp[5570] = 1055547654; +inp[5571] = 0; +inp[5572] = 1055032376; +inp[5573] = 0; +inp[5574] = 1054517349; +inp[5575] = 0; +inp[5576] = 1054002574; +inp[5577] = 0; +inp[5578] = 1053488050; +inp[5579] = 0; +inp[5580] = 1052973777; +inp[5581] = 0; +inp[5582] = 1052459755; +inp[5583] = 0; +inp[5584] = 1051945984; +inp[5585] = 0; +inp[5586] = 1051432464; +inp[5587] = 0; +inp[5588] = 1050919194; +inp[5589] = 0; +inp[5590] = 1050406175; +inp[5591] = 0; +inp[5592] = 1049893407; +inp[5593] = 0; +inp[5594] = 1049380889; +inp[5595] = 0; +inp[5596] = 1048868621; +inp[5597] = 0; +inp[5598] = 1048356603; +inp[5599] = 0; +inp[5600] = 1047844835; +inp[5601] = 0; +inp[5602] = 1047333317; +inp[5603] = 0; +inp[5604] = 1046822049; +inp[5605] = 0; +inp[5606] = 1046311030; +inp[5607] = 0; +inp[5608] = 1045800261; +inp[5609] = 0; +inp[5610] = 1045289741; +inp[5611] = 0; +inp[5612] = 1044779470; +inp[5613] = 0; +inp[5614] = 1044269448; +inp[5615] = 0; +inp[5616] = 1043759675; +inp[5617] = 0; +inp[5618] = 1043250151; +inp[5619] = 0; +inp[5620] = 1042740876; +inp[5621] = 0; +inp[5622] = 1042231850; +inp[5623] = 0; +inp[5624] = 1041723072; +inp[5625] = 0; +inp[5626] = 1041214542; +inp[5627] = 0; +inp[5628] = 1073741824; +inp[5629] = 1073741824; +inp[5630] = 1073479711; +inp[5631] = 0; +inp[5632] = 1073217663; +inp[5633] = 0; +inp[5634] = 1072955679; +inp[5635] = 0; +inp[5636] = 1072693759; +inp[5637] = 0; +inp[5638] = 1072431903; +inp[5639] = 0; +inp[5640] = 1072170111; +inp[5641] = 0; +inp[5642] = 1071908383; +inp[5643] = 0; +inp[5644] = 1071646718; +inp[5645] = 0; +inp[5646] = 1071385118; +inp[5647] = 0; +inp[5648] = 1071123581; +inp[5649] = 0; +inp[5650] = 1070862108; +inp[5651] = 0; +inp[5652] = 1070600699; +inp[5653] = 0; +inp[5654] = 1070339354; +inp[5655] = 0; +inp[5656] = 1070078072; +inp[5657] = 0; +inp[5658] = 1069816855; +inp[5659] = 0; +inp[5660] = 1069555701; +inp[5661] = 0; +inp[5662] = 1069294611; +inp[5663] = 0; +inp[5664] = 1069033584; +inp[5665] = 0; +inp[5666] = 1068772622; +inp[5667] = 0; +inp[5668] = 1068511723; +inp[5669] = 0; +inp[5670] = 1068250887; +inp[5671] = 0; +inp[5672] = 1067990116; +inp[5673] = 0; +inp[5674] = 1067729408; +inp[5675] = 0; +inp[5676] = 1067468764; +inp[5677] = 0; +inp[5678] = 1067208183; +inp[5679] = 0; +inp[5680] = 1066947666; +inp[5681] = 0; +inp[5682] = 1066687212; +inp[5683] = 0; +inp[5684] = 1066426822; +inp[5685] = 0; +inp[5686] = 1066166496; +inp[5687] = 0; +inp[5688] = 1065906233; +inp[5689] = 0; +inp[5690] = 1065646034; +inp[5691] = 0; +inp[5692] = 1065385898; +inp[5693] = 0; +inp[5694] = 1065125826; +inp[5695] = 0; +inp[5696] = 1064865817; +inp[5697] = 0; +inp[5698] = 1064605872; +inp[5699] = 0; +inp[5700] = 1064345990; +inp[5701] = 0; +inp[5702] = 1064086172; +inp[5703] = 0; +inp[5704] = 1063826417; +inp[5705] = 0; +inp[5706] = 1063566725; +inp[5707] = 0; +inp[5708] = 1063307097; +inp[5709] = 0; +inp[5710] = 1063047532; +inp[5711] = 0; +inp[5712] = 1062788031; +inp[5713] = 0; +inp[5714] = 1062528593; +inp[5715] = 0; +inp[5716] = 1062269218; +inp[5717] = 0; +inp[5718] = 1062009907; +inp[5719] = 0; +inp[5720] = 1061750659; +inp[5721] = 0; +inp[5722] = 1061491474; +inp[5723] = 0; +inp[5724] = 1061232352; +inp[5725] = 0; +inp[5726] = 1060973294; +inp[5727] = 0; +inp[5728] = 1060714299; +inp[5729] = 0; +inp[5730] = 1060455367; +inp[5731] = 0; +inp[5732] = 1060196498; +inp[5733] = 0; +inp[5734] = 1059937693; +inp[5735] = 0; +inp[5736] = 1059678951; +inp[5737] = 0; +inp[5738] = 1059420272; +inp[5739] = 0; +inp[5740] = 1059161656; +inp[5741] = 0; +inp[5742] = 1058903103; +inp[5743] = 0; +inp[5744] = 1058644613; +inp[5745] = 0; +inp[5746] = 1058386187; +inp[5747] = 0; +inp[5748] = 1058127823; +inp[5749] = 0; +inp[5750] = 1057869523; +inp[5751] = 0; +inp[5752] = 1057611285; +inp[5753] = 0; +inp[5754] = 1057353111; +inp[5755] = 0; +inp[5756] = 1073741824; +inp[5757] = 1073741824; +inp[5758] = 1073610759; +inp[5759] = 0; +inp[5760] = 1073479711; +inp[5761] = 0; +inp[5762] = 1073348679; +inp[5763] = 0; +inp[5764] = 1073217663; +inp[5765] = 0; +inp[5766] = 1073086663; +inp[5767] = 0; +inp[5768] = 1072955679; +inp[5769] = 0; +inp[5770] = 1072824711; +inp[5771] = 0; +inp[5772] = 1072693759; +inp[5773] = 0; +inp[5774] = 1072562823; +inp[5775] = 0; +inp[5776] = 1072431903; +inp[5777] = 0; +inp[5778] = 1072300999; +inp[5779] = 0; +inp[5780] = 1072170111; +inp[5781] = 0; +inp[5782] = 1072039239; +inp[5783] = 0; +inp[5784] = 1071908383; +inp[5785] = 0; +inp[5786] = 1071777542; +inp[5787] = 0; +inp[5788] = 1071646718; +inp[5789] = 0; +inp[5790] = 1071515910; +inp[5791] = 0; +inp[5792] = 1071385118; +inp[5793] = 0; +inp[5794] = 1071254341; +inp[5795] = 0; +inp[5796] = 1071123581; +inp[5797] = 0; +inp[5798] = 1070992836; +inp[5799] = 0; +inp[5800] = 1070862108; +inp[5801] = 0; +inp[5802] = 1070731396; +inp[5803] = 0; +inp[5804] = 1070600699; +inp[5805] = 0; +inp[5806] = 1070470018; +inp[5807] = 0; +inp[5808] = 1070339354; +inp[5809] = 0; +inp[5810] = 1070208705; +inp[5811] = 0; +inp[5812] = 1070078072; +inp[5813] = 0; +inp[5814] = 1069947456; +inp[5815] = 0; +inp[5816] = 1069816855; +inp[5817] = 0; +inp[5818] = 1069686270; +inp[5819] = 0; +inp[5820] = 1069555701; +inp[5821] = 0; +inp[5822] = 1069425148; +inp[5823] = 0; +inp[5824] = 1069294611; +inp[5825] = 0; +inp[5826] = 1069164090; +inp[5827] = 0; +inp[5828] = 1069033584; +inp[5829] = 0; +inp[5830] = 1068903095; +inp[5831] = 0; +inp[5832] = 1068772622; +inp[5833] = 0; +inp[5834] = 1068642164; +inp[5835] = 0; +inp[5836] = 1068511723; +inp[5837] = 0; +inp[5838] = 1068381297; +inp[5839] = 0; +inp[5840] = 1068250887; +inp[5841] = 0; +inp[5842] = 1068120494; +inp[5843] = 0; +inp[5844] = 1067990116; +inp[5845] = 0; +inp[5846] = 1067859754; +inp[5847] = 0; +inp[5848] = 1067729408; +inp[5849] = 0; +inp[5850] = 1067599078; +inp[5851] = 0; +inp[5852] = 1067468764; +inp[5853] = 0; +inp[5854] = 1067338465; +inp[5855] = 0; +inp[5856] = 1067208183; +inp[5857] = 0; +inp[5858] = 1067077916; +inp[5859] = 0; +inp[5860] = 1066947666; +inp[5861] = 0; +inp[5862] = 1066817431; +inp[5863] = 0; +inp[5864] = 1066687212; +inp[5865] = 0; +inp[5866] = 1066557009; +inp[5867] = 0; +inp[5868] = 1066426822; +inp[5869] = 0; +inp[5870] = 1066296651; +inp[5871] = 0; +inp[5872] = 1066166496; +inp[5873] = 0; +inp[5874] = 1066036357; +inp[5875] = 0; +inp[5876] = 1065906233; +inp[5877] = 0; +inp[5878] = 1065776126; +inp[5879] = 0; +inp[5880] = 1065646034; +inp[5881] = 0; +inp[5882] = 1065515958; +inp[5883] = 0; +inp[5884] = 1073741824; +inp[5885] = 1073741824; +inp[5886] = 1073676289; +inp[5887] = 0; +inp[5888] = 1073610759; +inp[5889] = 0; +inp[5890] = 1073545233; +inp[5891] = 0; +inp[5892] = 1073479711; +inp[5893] = 0; +inp[5894] = 1073414193; +inp[5895] = 0; +inp[5896] = 1073348679; +inp[5897] = 0; +inp[5898] = 1073283169; +inp[5899] = 0; +inp[5900] = 1073217663; +inp[5901] = 0; +inp[5902] = 1073152161; +inp[5903] = 0; +inp[5904] = 1073086663; +inp[5905] = 0; +inp[5906] = 1073021169; +inp[5907] = 0; +inp[5908] = 1072955679; +inp[5909] = 0; +inp[5910] = 1072890193; +inp[5911] = 0; +inp[5912] = 1072824711; +inp[5913] = 0; +inp[5914] = 1072759233; +inp[5915] = 0; +inp[5916] = 1072693759; +inp[5917] = 0; +inp[5918] = 1072628289; +inp[5919] = 0; +inp[5920] = 1072562823; +inp[5921] = 0; +inp[5922] = 1072497361; +inp[5923] = 0; +inp[5924] = 1072431903; +inp[5925] = 0; +inp[5926] = 1072366449; +inp[5927] = 0; +inp[5928] = 1072300999; +inp[5929] = 0; +inp[5930] = 1072235553; +inp[5931] = 0; +inp[5932] = 1072170111; +inp[5933] = 0; +inp[5934] = 1072104673; +inp[5935] = 0; +inp[5936] = 1072039239; +inp[5937] = 0; +inp[5938] = 1071973809; +inp[5939] = 0; +inp[5940] = 1071908383; +inp[5941] = 0; +inp[5942] = 1071842961; +inp[5943] = 0; +inp[5944] = 1071777542; +inp[5945] = 0; +inp[5946] = 1071712128; +inp[5947] = 0; +inp[5948] = 1071646718; +inp[5949] = 0; +inp[5950] = 1071581312; +inp[5951] = 0; +inp[5952] = 1071515910; +inp[5953] = 0; +inp[5954] = 1071450512; +inp[5955] = 0; +inp[5956] = 1071385118; +inp[5957] = 0; +inp[5958] = 1071319727; +inp[5959] = 0; +inp[5960] = 1071254341; +inp[5961] = 0; +inp[5962] = 1071188959; +inp[5963] = 0; +inp[5964] = 1071123581; +inp[5965] = 0; +inp[5966] = 1071058207; +inp[5967] = 0; +inp[5968] = 1070992836; +inp[5969] = 0; +inp[5970] = 1070927470; +inp[5971] = 0; +inp[5972] = 1070862108; +inp[5973] = 0; +inp[5974] = 1070796750; +inp[5975] = 0; +inp[5976] = 1070731396; +inp[5977] = 0; +inp[5978] = 1070666045; +inp[5979] = 0; +inp[5980] = 1070600699; +inp[5981] = 0; +inp[5982] = 1070535357; +inp[5983] = 0; +inp[5984] = 1070470018; +inp[5985] = 0; +inp[5986] = 1070404684; +inp[5987] = 0; +inp[5988] = 1070339354; +inp[5989] = 0; +inp[5990] = 1070274027; +inp[5991] = 0; +inp[5992] = 1070208705; +inp[5993] = 0; +inp[5994] = 1070143387; +inp[5995] = 0; +inp[5996] = 1070078072; +inp[5997] = 0; +inp[5998] = 1070012762; +inp[5999] = 0; +inp[6000] = 1069947456; +inp[6001] = 0; +inp[6002] = 1069882153; +inp[6003] = 0; +inp[6004] = 1069816855; +inp[6005] = 0; +inp[6006] = 1069751560; +inp[6007] = 0; +inp[6008] = 1069686270; +inp[6009] = 0; +inp[6010] = 1069620983; +inp[6011] = 0; +inp[6012] = 1073741824; +inp[6013] = 1073741824; +inp[6014] = 1073709056; +inp[6015] = 0; +inp[6016] = 1073676289; +inp[6017] = 0; +inp[6018] = 1073643524; +inp[6019] = 0; +inp[6020] = 1073610759; +inp[6021] = 0; +inp[6022] = 1073577996; +inp[6023] = 0; +inp[6024] = 1073545233; +inp[6025] = 0; +inp[6026] = 1073512472; +inp[6027] = 0; +inp[6028] = 1073479711; +inp[6029] = 0; +inp[6030] = 1073446952; +inp[6031] = 0; +inp[6032] = 1073414193; +inp[6033] = 0; +inp[6034] = 1073381436; +inp[6035] = 0; +inp[6036] = 1073348679; +inp[6037] = 0; +inp[6038] = 1073315924; +inp[6039] = 0; +inp[6040] = 1073283169; +inp[6041] = 0; +inp[6042] = 1073250416; +inp[6043] = 0; +inp[6044] = 1073217663; +inp[6045] = 0; +inp[6046] = 1073184912; +inp[6047] = 0; +inp[6048] = 1073152161; +inp[6049] = 0; +inp[6050] = 1073119412; +inp[6051] = 0; +inp[6052] = 1073086663; +inp[6053] = 0; +inp[6054] = 1073053916; +inp[6055] = 0; +inp[6056] = 1073021169; +inp[6057] = 0; +inp[6058] = 1072988424; +inp[6059] = 0; +inp[6060] = 1072955679; +inp[6061] = 0; +inp[6062] = 1072922936; +inp[6063] = 0; +inp[6064] = 1072890193; +inp[6065] = 0; +inp[6066] = 1072857452; +inp[6067] = 0; +inp[6068] = 1072824711; +inp[6069] = 0; +inp[6070] = 1072791972; +inp[6071] = 0; +inp[6072] = 1072759233; +inp[6073] = 0; +inp[6074] = 1072726496; +inp[6075] = 0; +inp[6076] = 1072693759; +inp[6077] = 0; +inp[6078] = 1072661024; +inp[6079] = 0; +inp[6080] = 1072628289; +inp[6081] = 0; +inp[6082] = 1072595556; +inp[6083] = 0; +inp[6084] = 1072562823; +inp[6085] = 0; +inp[6086] = 1072530092; +inp[6087] = 0; +inp[6088] = 1072497361; +inp[6089] = 0; +inp[6090] = 1072464632; +inp[6091] = 0; +inp[6092] = 1072431903; +inp[6093] = 0; +inp[6094] = 1072399176; +inp[6095] = 0; +inp[6096] = 1072366449; +inp[6097] = 0; +inp[6098] = 1072333724; +inp[6099] = 0; +inp[6100] = 1072300999; +inp[6101] = 0; +inp[6102] = 1072268276; +inp[6103] = 0; +inp[6104] = 1072235553; +inp[6105] = 0; +inp[6106] = 1072202831; +inp[6107] = 0; +inp[6108] = 1072170111; +inp[6109] = 0; +inp[6110] = 1072137391; +inp[6111] = 0; +inp[6112] = 1072104673; +inp[6113] = 0; +inp[6114] = 1072071955; +inp[6115] = 0; +inp[6116] = 1072039239; +inp[6117] = 0; +inp[6118] = 1072006523; +inp[6119] = 0; +inp[6120] = 1071973809; +inp[6121] = 0; +inp[6122] = 1071941095; +inp[6123] = 0; +inp[6124] = 1071908383; +inp[6125] = 0; +inp[6126] = 1071875671; +inp[6127] = 0; +inp[6128] = 1071842961; +inp[6129] = 0; +inp[6130] = 1071810251; +inp[6131] = 0; +inp[6132] = 1071777542; +inp[6133] = 0; +inp[6134] = 1071744835; +inp[6135] = 0; +inp[6136] = 1071712128; +inp[6137] = 0; +inp[6138] = 1071679423; +inp[6139] = 0; +inp[6140] = 1073741824; +inp[6141] = 1073741824; +inp[6142] = 1073725440; +inp[6143] = 0; +inp[6144] = 1073709056; +inp[6145] = 0; +inp[6146] = 1073692673; +inp[6147] = 0; +inp[6148] = 1073676289; +inp[6149] = 0; +inp[6150] = 1073659907; +inp[6151] = 0; +inp[6152] = 1073643524; +inp[6153] = 0; +inp[6154] = 1073627142; +inp[6155] = 0; +inp[6156] = 1073610759; +inp[6157] = 0; +inp[6158] = 1073594378; +inp[6159] = 0; +inp[6160] = 1073577996; +inp[6161] = 0; +inp[6162] = 1073561615; +inp[6163] = 0; +inp[6164] = 1073545233; +inp[6165] = 0; +inp[6166] = 1073528853; +inp[6167] = 0; +inp[6168] = 1073512472; +inp[6169] = 0; +inp[6170] = 1073496092; +inp[6171] = 0; +inp[6172] = 1073479711; +inp[6173] = 0; +inp[6174] = 1073463332; +inp[6175] = 0; +inp[6176] = 1073446952; +inp[6177] = 0; +inp[6178] = 1073430573; +inp[6179] = 0; +inp[6180] = 1073414193; +inp[6181] = 0; +inp[6182] = 1073397815; +inp[6183] = 0; +inp[6184] = 1073381436; +inp[6185] = 0; +inp[6186] = 1073365058; +inp[6187] = 0; +inp[6188] = 1073348679; +inp[6189] = 0; +inp[6190] = 1073332302; +inp[6191] = 0; +inp[6192] = 1073315924; +inp[6193] = 0; +inp[6194] = 1073299547; +inp[6195] = 0; +inp[6196] = 1073283169; +inp[6197] = 0; +inp[6198] = 1073266793; +inp[6199] = 0; +inp[6200] = 1073250416; +inp[6201] = 0; +inp[6202] = 1073234040; +inp[6203] = 0; +inp[6204] = 1073217663; +inp[6205] = 0; +inp[6206] = 1073201288; +inp[6207] = 0; +inp[6208] = 1073184912; +inp[6209] = 0; +inp[6210] = 1073168537; +inp[6211] = 0; +inp[6212] = 1073152161; +inp[6213] = 0; +inp[6214] = 1073135787; +inp[6215] = 0; +inp[6216] = 1073119412; +inp[6217] = 0; +inp[6218] = 1073103038; +inp[6219] = 0; +inp[6220] = 1073086663; +inp[6221] = 0; +inp[6222] = 1073070290; +inp[6223] = 0; +inp[6224] = 1073053916; +inp[6225] = 0; +inp[6226] = 1073037543; +inp[6227] = 0; +inp[6228] = 1073021169; +inp[6229] = 0; +inp[6230] = 1073004797; +inp[6231] = 0; +inp[6232] = 1072988424; +inp[6233] = 0; +inp[6234] = 1072972052; +inp[6235] = 0; +inp[6236] = 1072955679; +inp[6237] = 0; +inp[6238] = 1072939308; +inp[6239] = 0; +inp[6240] = 1072922936; +inp[6241] = 0; +inp[6242] = 1072906565; +inp[6243] = 0; +inp[6244] = 1072890193; +inp[6245] = 0; +inp[6246] = 1072873823; +inp[6247] = 0; +inp[6248] = 1072857452; +inp[6249] = 0; +inp[6250] = 1072841082; +inp[6251] = 0; +inp[6252] = 1072824711; +inp[6253] = 0; +inp[6254] = 1072808342; +inp[6255] = 0; +inp[6256] = 1072791972; +inp[6257] = 0; +inp[6258] = 1072775602; +inp[6259] = 0; +inp[6260] = 1072759233; +inp[6261] = 0; +inp[6262] = 1072742864; +inp[6263] = 0; +inp[6264] = 1072726496; +inp[6265] = 0; +inp[6266] = 1072710127; +inp[6267] = 0; +inp[6268] = 1073741824; +inp[6269] = 1073741824; +inp[6270] = 1073733632; +inp[6271] = 0; +inp[6272] = 1073725440; +inp[6273] = 0; +inp[6274] = 1073717248; +inp[6275] = 0; +inp[6276] = 1073709056; +inp[6277] = 0; +inp[6278] = 1073700864; +inp[6279] = 0; +inp[6280] = 1073692673; +inp[6281] = 0; +inp[6282] = 1073684481; +inp[6283] = 0; +inp[6284] = 1073676289; +inp[6285] = 0; +inp[6286] = 1073668098; +inp[6287] = 0; +inp[6288] = 1073659907; +inp[6289] = 0; +inp[6290] = 1073651715; +inp[6291] = 0; +inp[6292] = 1073643524; +inp[6293] = 0; +inp[6294] = 1073635333; +inp[6295] = 0; +inp[6296] = 1073627142; +inp[6297] = 0; +inp[6298] = 1073618951; +inp[6299] = 0; +inp[6300] = 1073610759; +inp[6301] = 0; +inp[6302] = 1073602569; +inp[6303] = 0; +inp[6304] = 1073594378; +inp[6305] = 0; +inp[6306] = 1073586187; +inp[6307] = 0; +inp[6308] = 1073577996; +inp[6309] = 0; +inp[6310] = 1073569805; +inp[6311] = 0; +inp[6312] = 1073561615; +inp[6313] = 0; +inp[6314] = 1073553424; +inp[6315] = 0; +inp[6316] = 1073545233; +inp[6317] = 0; +inp[6318] = 1073537043; +inp[6319] = 0; +inp[6320] = 1073528853; +inp[6321] = 0; +inp[6322] = 1073520662; +inp[6323] = 0; +inp[6324] = 1073512472; +inp[6325] = 0; +inp[6326] = 1073504282; +inp[6327] = 0; +inp[6328] = 1073496092; +inp[6329] = 0; +inp[6330] = 1073487902; +inp[6331] = 0; +inp[6332] = 1073479711; +inp[6333] = 0; +inp[6334] = 1073471522; +inp[6335] = 0; +inp[6336] = 1073463332; +inp[6337] = 0; +inp[6338] = 1073455142; +inp[6339] = 0; +inp[6340] = 1073446952; +inp[6341] = 0; +inp[6342] = 1073438762; +inp[6343] = 0; +inp[6344] = 1073430573; +inp[6345] = 0; +inp[6346] = 1073422383; +inp[6347] = 0; +inp[6348] = 1073414193; +inp[6349] = 0; +inp[6350] = 1073406004; +inp[6351] = 0; +inp[6352] = 1073397815; +inp[6353] = 0; +inp[6354] = 1073389625; +inp[6355] = 0; +inp[6356] = 1073381436; +inp[6357] = 0; +inp[6358] = 1073373247; +inp[6359] = 0; +inp[6360] = 1073365058; +inp[6361] = 0; +inp[6362] = 1073356869; +inp[6363] = 0; +inp[6364] = 1073348679; +inp[6365] = 0; +inp[6366] = 1073340491; +inp[6367] = 0; +inp[6368] = 1073332302; +inp[6369] = 0; +inp[6370] = 1073324113; +inp[6371] = 0; +inp[6372] = 1073315924; +inp[6373] = 0; +inp[6374] = 1073307735; +inp[6375] = 0; +inp[6376] = 1073299547; +inp[6377] = 0; +inp[6378] = 1073291358; +inp[6379] = 0; +inp[6380] = 1073283169; +inp[6381] = 0; +inp[6382] = 1073274981; +inp[6383] = 0; +inp[6384] = 1073266793; +inp[6385] = 0; +inp[6386] = 1073258604; +inp[6387] = 0; +inp[6388] = 1073250416; +inp[6389] = 0; +inp[6390] = 1073242228; +inp[6391] = 0; +inp[6392] = 1073234040; +inp[6393] = 0; +inp[6394] = 1073225852; +inp[6395] = 0; +inp[6396] = 1073741824; +inp[6397] = 1073741824; +inp[6398] = 1073737728; +inp[6399] = 0; +inp[6400] = 1073733632; +inp[6401] = 0; +inp[6402] = 1073729536; +inp[6403] = 0; +inp[6404] = 1073725440; +inp[6405] = 0; +inp[6406] = 1073721344; +inp[6407] = 0; +inp[6408] = 1073717248; +inp[6409] = 0; +inp[6410] = 1073713152; +inp[6411] = 0; +inp[6412] = 1073709056; +inp[6413] = 0; +inp[6414] = 1073704960; +inp[6415] = 0; +inp[6416] = 1073700864; +inp[6417] = 0; +inp[6418] = 1073696768; +inp[6419] = 0; +inp[6420] = 1073692673; +inp[6421] = 0; +inp[6422] = 1073688577; +inp[6423] = 0; +inp[6424] = 1073684481; +inp[6425] = 0; +inp[6426] = 1073680385; +inp[6427] = 0; +inp[6428] = 1073676289; +inp[6429] = 0; +inp[6430] = 1073672194; +inp[6431] = 0; +inp[6432] = 1073668098; +inp[6433] = 0; +inp[6434] = 1073664002; +inp[6435] = 0; +inp[6436] = 1073659907; +inp[6437] = 0; +inp[6438] = 1073655811; +inp[6439] = 0; +inp[6440] = 1073651715; +inp[6441] = 0; +inp[6442] = 1073647620; +inp[6443] = 0; +inp[6444] = 1073643524; +inp[6445] = 0; +inp[6446] = 1073639428; +inp[6447] = 0; +inp[6448] = 1073635333; +inp[6449] = 0; +inp[6450] = 1073631237; +inp[6451] = 0; +inp[6452] = 1073627142; +inp[6453] = 0; +inp[6454] = 1073623046; +inp[6455] = 0; +inp[6456] = 1073618951; +inp[6457] = 0; +inp[6458] = 1073614855; +inp[6459] = 0; +inp[6460] = 1073610759; +inp[6461] = 0; +inp[6462] = 1073606664; +inp[6463] = 0; +inp[6464] = 1073602569; +inp[6465] = 0; +inp[6466] = 1073598473; +inp[6467] = 0; +inp[6468] = 1073594378; +inp[6469] = 0; +inp[6470] = 1073590282; +inp[6471] = 0; +inp[6472] = 1073586187; +inp[6473] = 0; +inp[6474] = 1073582091; +inp[6475] = 0; +inp[6476] = 1073577996; +inp[6477] = 0; +inp[6478] = 1073573901; +inp[6479] = 0; +inp[6480] = 1073569805; +inp[6481] = 0; +inp[6482] = 1073565710; +inp[6483] = 0; +inp[6484] = 1073561615; +inp[6485] = 0; +inp[6486] = 1073557519; +inp[6487] = 0; +inp[6488] = 1073553424; +inp[6489] = 0; +inp[6490] = 1073549329; +inp[6491] = 0; +inp[6492] = 1073545233; +inp[6493] = 0; +inp[6494] = 1073541138; +inp[6495] = 0; +inp[6496] = 1073537043; +inp[6497] = 0; +inp[6498] = 1073532948; +inp[6499] = 0; +inp[6500] = 1073528853; +inp[6501] = 0; +inp[6502] = 1073524757; +inp[6503] = 0; +inp[6504] = 1073520662; +inp[6505] = 0; +inp[6506] = 1073516567; +inp[6507] = 0; +inp[6508] = 1073512472; +inp[6509] = 0; +inp[6510] = 1073508377; +inp[6511] = 0; +inp[6512] = 1073504282; +inp[6513] = 0; +inp[6514] = 1073500187; +inp[6515] = 0; +inp[6516] = 1073496092; +inp[6517] = 0; +inp[6518] = 1073491997; +inp[6519] = 0; +inp[6520] = 1073487902; +inp[6521] = 0; +inp[6522] = 1073483807; +inp[6523] = 0; +inp[6524] = 1073741824; +inp[6525] = 1073741824; +inp[6526] = 1073739776; +inp[6527] = 0; +inp[6528] = 1073737728; +inp[6529] = 0; +inp[6530] = 1073735680; +inp[6531] = 0; +inp[6532] = 1073733632; +inp[6533] = 0; +inp[6534] = 1073731584; +inp[6535] = 0; +inp[6536] = 1073729536; +inp[6537] = 0; +inp[6538] = 1073727488; +inp[6539] = 0; +inp[6540] = 1073725440; +inp[6541] = 0; +inp[6542] = 1073723392; +inp[6543] = 0; +inp[6544] = 1073721344; +inp[6545] = 0; +inp[6546] = 1073719296; +inp[6547] = 0; +inp[6548] = 1073717248; +inp[6549] = 0; +inp[6550] = 1073715200; +inp[6551] = 0; +inp[6552] = 1073713152; +inp[6553] = 0; +inp[6554] = 1073711104; +inp[6555] = 0; +inp[6556] = 1073709056; +inp[6557] = 0; +inp[6558] = 1073707008; +inp[6559] = 0; +inp[6560] = 1073704960; +inp[6561] = 0; +inp[6562] = 1073702912; +inp[6563] = 0; +inp[6564] = 1073700864; +inp[6565] = 0; +inp[6566] = 1073698816; +inp[6567] = 0; +inp[6568] = 1073696768; +inp[6569] = 0; +inp[6570] = 1073694721; +inp[6571] = 0; +inp[6572] = 1073692673; +inp[6573] = 0; +inp[6574] = 1073690625; +inp[6575] = 0; +inp[6576] = 1073688577; +inp[6577] = 0; +inp[6578] = 1073686529; +inp[6579] = 0; +inp[6580] = 1073684481; +inp[6581] = 0; +inp[6582] = 1073682433; +inp[6583] = 0; +inp[6584] = 1073680385; +inp[6585] = 0; +inp[6586] = 1073678337; +inp[6587] = 0; +inp[6588] = 1073676289; +inp[6589] = 0; +inp[6590] = 1073674242; +inp[6591] = 0; +inp[6592] = 1073672194; +inp[6593] = 0; +inp[6594] = 1073670146; +inp[6595] = 0; +inp[6596] = 1073668098; +inp[6597] = 0; +inp[6598] = 1073666050; +inp[6599] = 0; +inp[6600] = 1073664002; +inp[6601] = 0; +inp[6602] = 1073661954; +inp[6603] = 0; +inp[6604] = 1073659907; +inp[6605] = 0; +inp[6606] = 1073657859; +inp[6607] = 0; +inp[6608] = 1073655811; +inp[6609] = 0; +inp[6610] = 1073653763; +inp[6611] = 0; +inp[6612] = 1073651715; +inp[6613] = 0; +inp[6614] = 1073649667; +inp[6615] = 0; +inp[6616] = 1073647620; +inp[6617] = 0; +inp[6618] = 1073645572; +inp[6619] = 0; +inp[6620] = 1073643524; +inp[6621] = 0; +inp[6622] = 1073641476; +inp[6623] = 0; +inp[6624] = 1073639428; +inp[6625] = 0; +inp[6626] = 1073637381; +inp[6627] = 0; +inp[6628] = 1073635333; +inp[6629] = 0; +inp[6630] = 1073633285; +inp[6631] = 0; +inp[6632] = 1073631237; +inp[6633] = 0; +inp[6634] = 1073629189; +inp[6635] = 0; +inp[6636] = 1073627142; +inp[6637] = 0; +inp[6638] = 1073625094; +inp[6639] = 0; +inp[6640] = 1073623046; +inp[6641] = 0; +inp[6642] = 1073620998; +inp[6643] = 0; +inp[6644] = 1073618951; +inp[6645] = 0; +inp[6646] = 1073616903; +inp[6647] = 0; +inp[6648] = 1073614855; +inp[6649] = 0; +inp[6650] = 1073612807; +inp[6651] = 0; +inp[6652] = 1073741824; +inp[6653] = 1073741824; +inp[6654] = 1073740800; +inp[6655] = 0; +inp[6656] = 1073739776; +inp[6657] = 0; +inp[6658] = 1073738752; +inp[6659] = 0; +inp[6660] = 1073737728; +inp[6661] = 0; +inp[6662] = 1073736704; +inp[6663] = 0; +inp[6664] = 1073735680; +inp[6665] = 0; +inp[6666] = 1073734656; +inp[6667] = 0; +inp[6668] = 1073733632; +inp[6669] = 0; +inp[6670] = 1073732608; +inp[6671] = 0; +inp[6672] = 1073731584; +inp[6673] = 0; +inp[6674] = 1073730560; +inp[6675] = 0; +inp[6676] = 1073729536; +inp[6677] = 0; +inp[6678] = 1073728512; +inp[6679] = 0; +inp[6680] = 1073727488; +inp[6681] = 0; +inp[6682] = 1073726464; +inp[6683] = 0; +inp[6684] = 1073725440; +inp[6685] = 0; +inp[6686] = 1073724416; +inp[6687] = 0; +inp[6688] = 1073723392; +inp[6689] = 0; +inp[6690] = 1073722368; +inp[6691] = 0; +inp[6692] = 1073721344; +inp[6693] = 0; +inp[6694] = 1073720320; +inp[6695] = 0; +inp[6696] = 1073719296; +inp[6697] = 0; +inp[6698] = 1073718272; +inp[6699] = 0; +inp[6700] = 1073717248; +inp[6701] = 0; +inp[6702] = 1073716224; +inp[6703] = 0; +inp[6704] = 1073715200; +inp[6705] = 0; +inp[6706] = 1073714176; +inp[6707] = 0; +inp[6708] = 1073713152; +inp[6709] = 0; +inp[6710] = 1073712128; +inp[6711] = 0; +inp[6712] = 1073711104; +inp[6713] = 0; +inp[6714] = 1073710080; +inp[6715] = 0; +inp[6716] = 1073709056; +inp[6717] = 0; +inp[6718] = 1073708032; +inp[6719] = 0; +inp[6720] = 1073707008; +inp[6721] = 0; +inp[6722] = 1073705984; +inp[6723] = 0; +inp[6724] = 1073704960; +inp[6725] = 0; +inp[6726] = 1073703936; +inp[6727] = 0; +inp[6728] = 1073702912; +inp[6729] = 0; +inp[6730] = 1073701888; +inp[6731] = 0; +inp[6732] = 1073700864; +inp[6733] = 0; +inp[6734] = 1073699840; +inp[6735] = 0; +inp[6736] = 1073698816; +inp[6737] = 0; +inp[6738] = 1073697792; +inp[6739] = 0; +inp[6740] = 1073696768; +inp[6741] = 0; +inp[6742] = 1073695744; +inp[6743] = 0; +inp[6744] = 1073694721; +inp[6745] = 0; +inp[6746] = 1073693697; +inp[6747] = 0; +inp[6748] = 1073692673; +inp[6749] = 0; +inp[6750] = 1073691649; +inp[6751] = 0; +inp[6752] = 1073690625; +inp[6753] = 0; +inp[6754] = 1073689601; +inp[6755] = 0; +inp[6756] = 1073688577; +inp[6757] = 0; +inp[6758] = 1073687553; +inp[6759] = 0; +inp[6760] = 1073686529; +inp[6761] = 0; +inp[6762] = 1073685505; +inp[6763] = 0; +inp[6764] = 1073684481; +inp[6765] = 0; +inp[6766] = 1073683457; +inp[6767] = 0; +inp[6768] = 1073682433; +inp[6769] = 0; +inp[6770] = 1073681409; +inp[6771] = 0; +inp[6772] = 1073680385; +inp[6773] = 0; +inp[6774] = 1073679361; +inp[6775] = 0; +inp[6776] = 1073678337; +inp[6777] = 0; +inp[6778] = 1073677313; +inp[6779] = 0; +inp[6780] = 1073741824; +inp[6781] = 1073741824; +inp[6782] = 1073741312; +inp[6783] = 0; +inp[6784] = 1073740800; +inp[6785] = 0; +inp[6786] = 1073740288; +inp[6787] = 0; +inp[6788] = 1073739776; +inp[6789] = 0; +inp[6790] = 1073739264; +inp[6791] = 0; +inp[6792] = 1073738752; +inp[6793] = 0; +inp[6794] = 1073738240; +inp[6795] = 0; +inp[6796] = 1073737728; +inp[6797] = 0; +inp[6798] = 1073737216; +inp[6799] = 0; +inp[6800] = 1073736704; +inp[6801] = 0; +inp[6802] = 1073736192; +inp[6803] = 0; +inp[6804] = 1073735680; +inp[6805] = 0; +inp[6806] = 1073735168; +inp[6807] = 0; +inp[6808] = 1073734656; +inp[6809] = 0; +inp[6810] = 1073734144; +inp[6811] = 0; +inp[6812] = 1073733632; +inp[6813] = 0; +inp[6814] = 1073733120; +inp[6815] = 0; +inp[6816] = 1073732608; +inp[6817] = 0; +inp[6818] = 1073732096; +inp[6819] = 0; +inp[6820] = 1073731584; +inp[6821] = 0; +inp[6822] = 1073731072; +inp[6823] = 0; +inp[6824] = 1073730560; +inp[6825] = 0; +inp[6826] = 1073730048; +inp[6827] = 0; +inp[6828] = 1073729536; +inp[6829] = 0; +inp[6830] = 1073729024; +inp[6831] = 0; +inp[6832] = 1073728512; +inp[6833] = 0; +inp[6834] = 1073728000; +inp[6835] = 0; +inp[6836] = 1073727488; +inp[6837] = 0; +inp[6838] = 1073726976; +inp[6839] = 0; +inp[6840] = 1073726464; +inp[6841] = 0; +inp[6842] = 1073725952; +inp[6843] = 0; +inp[6844] = 1073725440; +inp[6845] = 0; +inp[6846] = 1073724928; +inp[6847] = 0; +inp[6848] = 1073724416; +inp[6849] = 0; +inp[6850] = 1073723904; +inp[6851] = 0; +inp[6852] = 1073723392; +inp[6853] = 0; +inp[6854] = 1073722880; +inp[6855] = 0; +inp[6856] = 1073722368; +inp[6857] = 0; +inp[6858] = 1073721856; +inp[6859] = 0; +inp[6860] = 1073721344; +inp[6861] = 0; +inp[6862] = 1073720832; +inp[6863] = 0; +inp[6864] = 1073720320; +inp[6865] = 0; +inp[6866] = 1073719808; +inp[6867] = 0; +inp[6868] = 1073719296; +inp[6869] = 0; +inp[6870] = 1073718784; +inp[6871] = 0; +inp[6872] = 1073718272; +inp[6873] = 0; +inp[6874] = 1073717760; +inp[6875] = 0; +inp[6876] = 1073717248; +inp[6877] = 0; +inp[6878] = 1073716736; +inp[6879] = 0; +inp[6880] = 1073716224; +inp[6881] = 0; +inp[6882] = 1073715712; +inp[6883] = 0; +inp[6884] = 1073715200; +inp[6885] = 0; +inp[6886] = 1073714688; +inp[6887] = 0; +inp[6888] = 1073714176; +inp[6889] = 0; +inp[6890] = 1073713664; +inp[6891] = 0; +inp[6892] = 1073713152; +inp[6893] = 0; +inp[6894] = 1073712640; +inp[6895] = 0; +inp[6896] = 1073712128; +inp[6897] = 0; +inp[6898] = 1073711616; +inp[6899] = 0; +inp[6900] = 1073711104; +inp[6901] = 0; +inp[6902] = 1073710592; +inp[6903] = 0; +inp[6904] = 1073710080; +inp[6905] = 0; +inp[6906] = 1073709568; +inp[6907] = 0; +inp[6908] = 1073741824; +inp[6909] = 1073741824; +inp[6910] = 1073741568; +inp[6911] = 0; +inp[6912] = 1073741312; +inp[6913] = 0; +inp[6914] = 1073741056; +inp[6915] = 0; +inp[6916] = 1073740800; +inp[6917] = 0; +inp[6918] = 1073740544; +inp[6919] = 0; +inp[6920] = 1073740288; +inp[6921] = 0; +inp[6922] = 1073740032; +inp[6923] = 0; +inp[6924] = 1073739776; +inp[6925] = 0; +inp[6926] = 1073739520; +inp[6927] = 0; +inp[6928] = 1073739264; +inp[6929] = 0; +inp[6930] = 1073739008; +inp[6931] = 0; +inp[6932] = 1073738752; +inp[6933] = 0; +inp[6934] = 1073738496; +inp[6935] = 0; +inp[6936] = 1073738240; +inp[6937] = 0; +inp[6938] = 1073737984; +inp[6939] = 0; +inp[6940] = 1073737728; +inp[6941] = 0; +inp[6942] = 1073737472; +inp[6943] = 0; +inp[6944] = 1073737216; +inp[6945] = 0; +inp[6946] = 1073736960; +inp[6947] = 0; +inp[6948] = 1073736704; +inp[6949] = 0; +inp[6950] = 1073736448; +inp[6951] = 0; +inp[6952] = 1073736192; +inp[6953] = 0; +inp[6954] = 1073735936; +inp[6955] = 0; +inp[6956] = 1073735680; +inp[6957] = 0; +inp[6958] = 1073735424; +inp[6959] = 0; +inp[6960] = 1073735168; +inp[6961] = 0; +inp[6962] = 1073734912; +inp[6963] = 0; +inp[6964] = 1073734656; +inp[6965] = 0; +inp[6966] = 1073734400; +inp[6967] = 0; +inp[6968] = 1073734144; +inp[6969] = 0; +inp[6970] = 1073733888; +inp[6971] = 0; +inp[6972] = 1073733632; +inp[6973] = 0; +inp[6974] = 1073733376; +inp[6975] = 0; +inp[6976] = 1073733120; +inp[6977] = 0; +inp[6978] = 1073732864; +inp[6979] = 0; +inp[6980] = 1073732608; +inp[6981] = 0; +inp[6982] = 1073732352; +inp[6983] = 0; +inp[6984] = 1073732096; +inp[6985] = 0; +inp[6986] = 1073731840; +inp[6987] = 0; +inp[6988] = 1073731584; +inp[6989] = 0; +inp[6990] = 1073731328; +inp[6991] = 0; +inp[6992] = 1073731072; +inp[6993] = 0; +inp[6994] = 1073730816; +inp[6995] = 0; +inp[6996] = 1073730560; +inp[6997] = 0; +inp[6998] = 1073730304; +inp[6999] = 0; +inp[7000] = 1073730048; +inp[7001] = 0; +inp[7002] = 1073729792; +inp[7003] = 0; +inp[7004] = 1073729536; +inp[7005] = 0; +inp[7006] = 1073729280; +inp[7007] = 0; +inp[7008] = 1073729024; +inp[7009] = 0; +inp[7010] = 1073728768; +inp[7011] = 0; +inp[7012] = 1073728512; +inp[7013] = 0; +inp[7014] = 1073728256; +inp[7015] = 0; +inp[7016] = 1073728000; +inp[7017] = 0; +inp[7018] = 1073727744; +inp[7019] = 0; +inp[7020] = 1073727488; +inp[7021] = 0; +inp[7022] = 1073727232; +inp[7023] = 0; +inp[7024] = 1073726976; +inp[7025] = 0; +inp[7026] = 1073726720; +inp[7027] = 0; +inp[7028] = 1073726464; +inp[7029] = 0; +inp[7030] = 1073726208; +inp[7031] = 0; +inp[7032] = 1073725952; +inp[7033] = 0; +inp[7034] = 1073725696; +inp[7035] = 0; +inp[7036] = 1073741824; +inp[7037] = 1073741824; +inp[7038] = 1073741696; +inp[7039] = 0; +inp[7040] = 1073741568; +inp[7041] = 0; +inp[7042] = 1073741440; +inp[7043] = 0; +inp[7044] = 1073741312; +inp[7045] = 0; +inp[7046] = 1073741184; +inp[7047] = 0; +inp[7048] = 1073741056; +inp[7049] = 0; +inp[7050] = 1073740928; +inp[7051] = 0; +inp[7052] = 1073740800; +inp[7053] = 0; +inp[7054] = 1073740672; +inp[7055] = 0; +inp[7056] = 1073740544; +inp[7057] = 0; +inp[7058] = 1073740416; +inp[7059] = 0; +inp[7060] = 1073740288; +inp[7061] = 0; +inp[7062] = 1073740160; +inp[7063] = 0; +inp[7064] = 1073740032; +inp[7065] = 0; +inp[7066] = 1073739904; +inp[7067] = 0; +inp[7068] = 1073739776; +inp[7069] = 0; +inp[7070] = 1073739648; +inp[7071] = 0; +inp[7072] = 1073739520; +inp[7073] = 0; +inp[7074] = 1073739392; +inp[7075] = 0; +inp[7076] = 1073739264; +inp[7077] = 0; +inp[7078] = 1073739136; +inp[7079] = 0; +inp[7080] = 1073739008; +inp[7081] = 0; +inp[7082] = 1073738880; +inp[7083] = 0; +inp[7084] = 1073738752; +inp[7085] = 0; +inp[7086] = 1073738624; +inp[7087] = 0; +inp[7088] = 1073738496; +inp[7089] = 0; +inp[7090] = 1073738368; +inp[7091] = 0; +inp[7092] = 1073738240; +inp[7093] = 0; +inp[7094] = 1073738112; +inp[7095] = 0; +inp[7096] = 1073737984; +inp[7097] = 0; +inp[7098] = 1073737856; +inp[7099] = 0; +inp[7100] = 1073737728; +inp[7101] = 0; +inp[7102] = 1073737600; +inp[7103] = 0; +inp[7104] = 1073737472; +inp[7105] = 0; +inp[7106] = 1073737344; +inp[7107] = 0; +inp[7108] = 1073737216; +inp[7109] = 0; +inp[7110] = 1073737088; +inp[7111] = 0; +inp[7112] = 1073736960; +inp[7113] = 0; +inp[7114] = 1073736832; +inp[7115] = 0; +inp[7116] = 1073736704; +inp[7117] = 0; +inp[7118] = 1073736576; +inp[7119] = 0; +inp[7120] = 1073736448; +inp[7121] = 0; +inp[7122] = 1073736320; +inp[7123] = 0; +inp[7124] = 1073736192; +inp[7125] = 0; +inp[7126] = 1073736064; +inp[7127] = 0; +inp[7128] = 1073735936; +inp[7129] = 0; +inp[7130] = 1073735808; +inp[7131] = 0; +inp[7132] = 1073735680; +inp[7133] = 0; +inp[7134] = 1073735552; +inp[7135] = 0; +inp[7136] = 1073735424; +inp[7137] = 0; +inp[7138] = 1073735296; +inp[7139] = 0; +inp[7140] = 1073735168; +inp[7141] = 0; +inp[7142] = 1073735040; +inp[7143] = 0; +inp[7144] = 1073734912; +inp[7145] = 0; +inp[7146] = 1073734784; +inp[7147] = 0; +inp[7148] = 1073734656; +inp[7149] = 0; +inp[7150] = 1073734528; +inp[7151] = 0; +inp[7152] = 1073734400; +inp[7153] = 0; +inp[7154] = 1073734272; +inp[7155] = 0; +inp[7156] = 1073734144; +inp[7157] = 0; +inp[7158] = 1073734016; +inp[7159] = 0; +inp[7160] = 1073733888; +inp[7161] = 0; +inp[7162] = 1073733760; +inp[7163] = 0; +inp[7164] = 1073741824; +inp[7165] = 1073741824; +inp[7166] = 1073741760; +inp[7167] = 0; +inp[7168] = 1073741696; +inp[7169] = 0; +inp[7170] = 1073741632; +inp[7171] = 0; +inp[7172] = 1073741568; +inp[7173] = 0; +inp[7174] = 1073741504; +inp[7175] = 0; +inp[7176] = 1073741440; +inp[7177] = 0; +inp[7178] = 1073741376; +inp[7179] = 0; +inp[7180] = 1073741312; +inp[7181] = 0; +inp[7182] = 1073741248; +inp[7183] = 0; +inp[7184] = 1073741184; +inp[7185] = 0; +inp[7186] = 1073741120; +inp[7187] = 0; +inp[7188] = 1073741056; +inp[7189] = 0; +inp[7190] = 1073740992; +inp[7191] = 0; +inp[7192] = 1073740928; +inp[7193] = 0; +inp[7194] = 1073740864; +inp[7195] = 0; +inp[7196] = 1073740800; +inp[7197] = 0; +inp[7198] = 1073740736; +inp[7199] = 0; +inp[7200] = 1073740672; +inp[7201] = 0; +inp[7202] = 1073740608; +inp[7203] = 0; +inp[7204] = 1073740544; +inp[7205] = 0; +inp[7206] = 1073740480; +inp[7207] = 0; +inp[7208] = 1073740416; +inp[7209] = 0; +inp[7210] = 1073740352; +inp[7211] = 0; +inp[7212] = 1073740288; +inp[7213] = 0; +inp[7214] = 1073740224; +inp[7215] = 0; +inp[7216] = 1073740160; +inp[7217] = 0; +inp[7218] = 1073740096; +inp[7219] = 0; +inp[7220] = 1073740032; +inp[7221] = 0; +inp[7222] = 1073739968; +inp[7223] = 0; +inp[7224] = 1073739904; +inp[7225] = 0; +inp[7226] = 1073739840; +inp[7227] = 0; +inp[7228] = 1073739776; +inp[7229] = 0; +inp[7230] = 1073739712; +inp[7231] = 0; +inp[7232] = 1073739648; +inp[7233] = 0; +inp[7234] = 1073739584; +inp[7235] = 0; +inp[7236] = 1073739520; +inp[7237] = 0; +inp[7238] = 1073739456; +inp[7239] = 0; +inp[7240] = 1073739392; +inp[7241] = 0; +inp[7242] = 1073739328; +inp[7243] = 0; +inp[7244] = 1073739264; +inp[7245] = 0; +inp[7246] = 1073739200; +inp[7247] = 0; +inp[7248] = 1073739136; +inp[7249] = 0; +inp[7250] = 1073739072; +inp[7251] = 0; +inp[7252] = 1073739008; +inp[7253] = 0; +inp[7254] = 1073738944; +inp[7255] = 0; +inp[7256] = 1073738880; +inp[7257] = 0; +inp[7258] = 1073738816; +inp[7259] = 0; +inp[7260] = 1073738752; +inp[7261] = 0; +inp[7262] = 1073738688; +inp[7263] = 0; +inp[7264] = 1073738624; +inp[7265] = 0; +inp[7266] = 1073738560; +inp[7267] = 0; +inp[7268] = 1073738496; +inp[7269] = 0; +inp[7270] = 1073738432; +inp[7271] = 0; +inp[7272] = 1073738368; +inp[7273] = 0; +inp[7274] = 1073738304; +inp[7275] = 0; +inp[7276] = 1073738240; +inp[7277] = 0; +inp[7278] = 1073738176; +inp[7279] = 0; +inp[7280] = 1073738112; +inp[7281] = 0; +inp[7282] = 1073738048; +inp[7283] = 0; +inp[7284] = 1073737984; +inp[7285] = 0; +inp[7286] = 1073737920; +inp[7287] = 0; +inp[7288] = 1073737856; +inp[7289] = 0; +inp[7290] = 1073737792; +inp[7291] = 0; +inp[7292] = 1073741824; +inp[7293] = 1073741824; +inp[7294] = 1073741792; +inp[7295] = 0; +inp[7296] = 1073741760; +inp[7297] = 0; +inp[7298] = 1073741728; +inp[7299] = 0; +inp[7300] = 1073741696; +inp[7301] = 0; +inp[7302] = 1073741664; +inp[7303] = 0; +inp[7304] = 1073741632; +inp[7305] = 0; +inp[7306] = 1073741600; +inp[7307] = 0; +inp[7308] = 1073741568; +inp[7309] = 0; +inp[7310] = 1073741536; +inp[7311] = 0; +inp[7312] = 1073741504; +inp[7313] = 0; +inp[7314] = 1073741472; +inp[7315] = 0; +inp[7316] = 1073741440; +inp[7317] = 0; +inp[7318] = 1073741408; +inp[7319] = 0; +inp[7320] = 1073741376; +inp[7321] = 0; +inp[7322] = 1073741344; +inp[7323] = 0; +inp[7324] = 1073741312; +inp[7325] = 0; +inp[7326] = 1073741280; +inp[7327] = 0; +inp[7328] = 1073741248; +inp[7329] = 0; +inp[7330] = 1073741216; +inp[7331] = 0; +inp[7332] = 1073741184; +inp[7333] = 0; +inp[7334] = 1073741152; +inp[7335] = 0; +inp[7336] = 1073741120; +inp[7337] = 0; +inp[7338] = 1073741088; +inp[7339] = 0; +inp[7340] = 1073741056; +inp[7341] = 0; +inp[7342] = 1073741024; +inp[7343] = 0; +inp[7344] = 1073740992; +inp[7345] = 0; +inp[7346] = 1073740960; +inp[7347] = 0; +inp[7348] = 1073740928; +inp[7349] = 0; +inp[7350] = 1073740896; +inp[7351] = 0; +inp[7352] = 1073740864; +inp[7353] = 0; +inp[7354] = 1073740832; +inp[7355] = 0; +inp[7356] = 1073740800; +inp[7357] = 0; +inp[7358] = 1073740768; +inp[7359] = 0; +inp[7360] = 1073740736; +inp[7361] = 0; +inp[7362] = 1073740704; +inp[7363] = 0; +inp[7364] = 1073740672; +inp[7365] = 0; +inp[7366] = 1073740640; +inp[7367] = 0; +inp[7368] = 1073740608; +inp[7369] = 0; +inp[7370] = 1073740576; +inp[7371] = 0; +inp[7372] = 1073740544; +inp[7373] = 0; +inp[7374] = 1073740512; +inp[7375] = 0; +inp[7376] = 1073740480; +inp[7377] = 0; +inp[7378] = 1073740448; +inp[7379] = 0; +inp[7380] = 1073740416; +inp[7381] = 0; +inp[7382] = 1073740384; +inp[7383] = 0; +inp[7384] = 1073740352; +inp[7385] = 0; +inp[7386] = 1073740320; +inp[7387] = 0; +inp[7388] = 1073740288; +inp[7389] = 0; +inp[7390] = 1073740256; +inp[7391] = 0; +inp[7392] = 1073740224; +inp[7393] = 0; +inp[7394] = 1073740192; +inp[7395] = 0; +inp[7396] = 1073740160; +inp[7397] = 0; +inp[7398] = 1073740128; +inp[7399] = 0; +inp[7400] = 1073740096; +inp[7401] = 0; +inp[7402] = 1073740064; +inp[7403] = 0; +inp[7404] = 1073740032; +inp[7405] = 0; +inp[7406] = 1073740000; +inp[7407] = 0; +inp[7408] = 1073739968; +inp[7409] = 0; +inp[7410] = 1073739936; +inp[7411] = 0; +inp[7412] = 1073739904; +inp[7413] = 0; +inp[7414] = 1073739872; +inp[7415] = 0; +inp[7416] = 1073739840; +inp[7417] = 0; +inp[7418] = 1073739808; +inp[7419] = 0; +inp[7420] = 1073741824; +inp[7421] = 1073741824; +inp[7422] = 1073741808; +inp[7423] = 0; +inp[7424] = 1073741792; +inp[7425] = 0; +inp[7426] = 1073741776; +inp[7427] = 0; +inp[7428] = 1073741760; +inp[7429] = 0; +inp[7430] = 1073741744; +inp[7431] = 0; +inp[7432] = 1073741728; +inp[7433] = 0; +inp[7434] = 1073741712; +inp[7435] = 0; +inp[7436] = 1073741696; +inp[7437] = 0; +inp[7438] = 1073741680; +inp[7439] = 0; +inp[7440] = 1073741664; +inp[7441] = 0; +inp[7442] = 1073741648; +inp[7443] = 0; +inp[7444] = 1073741632; +inp[7445] = 0; +inp[7446] = 1073741616; +inp[7447] = 0; +inp[7448] = 1073741600; +inp[7449] = 0; +inp[7450] = 1073741584; +inp[7451] = 0; +inp[7452] = 1073741568; +inp[7453] = 0; +inp[7454] = 1073741552; +inp[7455] = 0; +inp[7456] = 1073741536; +inp[7457] = 0; +inp[7458] = 1073741520; +inp[7459] = 0; +inp[7460] = 1073741504; +inp[7461] = 0; +inp[7462] = 1073741488; +inp[7463] = 0; +inp[7464] = 1073741472; +inp[7465] = 0; +inp[7466] = 1073741456; +inp[7467] = 0; +inp[7468] = 1073741440; +inp[7469] = 0; +inp[7470] = 1073741424; +inp[7471] = 0; +inp[7472] = 1073741408; +inp[7473] = 0; +inp[7474] = 1073741392; +inp[7475] = 0; +inp[7476] = 1073741376; +inp[7477] = 0; +inp[7478] = 1073741360; +inp[7479] = 0; +inp[7480] = 1073741344; +inp[7481] = 0; +inp[7482] = 1073741328; +inp[7483] = 0; +inp[7484] = 1073741312; +inp[7485] = 0; +inp[7486] = 1073741296; +inp[7487] = 0; +inp[7488] = 1073741280; +inp[7489] = 0; +inp[7490] = 1073741264; +inp[7491] = 0; +inp[7492] = 1073741248; +inp[7493] = 0; +inp[7494] = 1073741232; +inp[7495] = 0; +inp[7496] = 1073741216; +inp[7497] = 0; +inp[7498] = 1073741200; +inp[7499] = 0; +inp[7500] = 1073741184; +inp[7501] = 0; +inp[7502] = 1073741168; +inp[7503] = 0; +inp[7504] = 1073741152; +inp[7505] = 0; +inp[7506] = 1073741136; +inp[7507] = 0; +inp[7508] = 1073741120; +inp[7509] = 0; +inp[7510] = 1073741104; +inp[7511] = 0; +inp[7512] = 1073741088; +inp[7513] = 0; +inp[7514] = 1073741072; +inp[7515] = 0; +inp[7516] = 1073741056; +inp[7517] = 0; +inp[7518] = 1073741040; +inp[7519] = 0; +inp[7520] = 1073741024; +inp[7521] = 0; +inp[7522] = 1073741008; +inp[7523] = 0; +inp[7524] = 1073740992; +inp[7525] = 0; +inp[7526] = 1073740976; +inp[7527] = 0; +inp[7528] = 1073740960; +inp[7529] = 0; +inp[7530] = 1073740944; +inp[7531] = 0; +inp[7532] = 1073740928; +inp[7533] = 0; +inp[7534] = 1073740912; +inp[7535] = 0; +inp[7536] = 1073740896; +inp[7537] = 0; +inp[7538] = 1073740880; +inp[7539] = 0; +inp[7540] = 1073740864; +inp[7541] = 0; +inp[7542] = 1073740848; +inp[7543] = 0; +inp[7544] = 1073740832; +inp[7545] = 0; +inp[7546] = 1073740816; +inp[7547] = 0; +inp[7548] = 1073741824; +inp[7549] = 1073741824; +inp[7550] = 1073741816; +inp[7551] = 0; +inp[7552] = 1073741808; +inp[7553] = 0; +inp[7554] = 1073741800; +inp[7555] = 0; +inp[7556] = 1073741792; +inp[7557] = 0; +inp[7558] = 1073741784; +inp[7559] = 0; +inp[7560] = 1073741776; +inp[7561] = 0; +inp[7562] = 1073741768; +inp[7563] = 0; +inp[7564] = 1073741760; +inp[7565] = 0; +inp[7566] = 1073741752; +inp[7567] = 0; +inp[7568] = 1073741744; +inp[7569] = 0; +inp[7570] = 1073741736; +inp[7571] = 0; +inp[7572] = 1073741728; +inp[7573] = 0; +inp[7574] = 1073741720; +inp[7575] = 0; +inp[7576] = 1073741712; +inp[7577] = 0; +inp[7578] = 1073741704; +inp[7579] = 0; +inp[7580] = 1073741696; +inp[7581] = 0; +inp[7582] = 1073741688; +inp[7583] = 0; +inp[7584] = 1073741680; +inp[7585] = 0; +inp[7586] = 1073741672; +inp[7587] = 0; +inp[7588] = 1073741664; +inp[7589] = 0; +inp[7590] = 1073741656; +inp[7591] = 0; +inp[7592] = 1073741648; +inp[7593] = 0; +inp[7594] = 1073741640; +inp[7595] = 0; +inp[7596] = 1073741632; +inp[7597] = 0; +inp[7598] = 1073741624; +inp[7599] = 0; +inp[7600] = 1073741616; +inp[7601] = 0; +inp[7602] = 1073741608; +inp[7603] = 0; +inp[7604] = 1073741600; +inp[7605] = 0; +inp[7606] = 1073741592; +inp[7607] = 0; +inp[7608] = 1073741584; +inp[7609] = 0; +inp[7610] = 1073741576; +inp[7611] = 0; +inp[7612] = 1073741568; +inp[7613] = 0; +inp[7614] = 1073741560; +inp[7615] = 0; +inp[7616] = 1073741552; +inp[7617] = 0; +inp[7618] = 1073741544; +inp[7619] = 0; +inp[7620] = 1073741536; +inp[7621] = 0; +inp[7622] = 1073741528; +inp[7623] = 0; +inp[7624] = 1073741520; +inp[7625] = 0; +inp[7626] = 1073741512; +inp[7627] = 0; +inp[7628] = 1073741504; +inp[7629] = 0; +inp[7630] = 1073741496; +inp[7631] = 0; +inp[7632] = 1073741488; +inp[7633] = 0; +inp[7634] = 1073741480; +inp[7635] = 0; +inp[7636] = 1073741472; +inp[7637] = 0; +inp[7638] = 1073741464; +inp[7639] = 0; +inp[7640] = 1073741456; +inp[7641] = 0; +inp[7642] = 1073741448; +inp[7643] = 0; +inp[7644] = 1073741440; +inp[7645] = 0; +inp[7646] = 1073741432; +inp[7647] = 0; +inp[7648] = 1073741424; +inp[7649] = 0; +inp[7650] = 1073741416; +inp[7651] = 0; +inp[7652] = 1073741408; +inp[7653] = 0; +inp[7654] = 1073741400; +inp[7655] = 0; +inp[7656] = 1073741392; +inp[7657] = 0; +inp[7658] = 1073741384; +inp[7659] = 0; +inp[7660] = 1073741376; +inp[7661] = 0; +inp[7662] = 1073741368; +inp[7663] = 0; +inp[7664] = 1073741360; +inp[7665] = 0; +inp[7666] = 1073741352; +inp[7667] = 0; +inp[7668] = 1073741344; +inp[7669] = 0; +inp[7670] = 1073741336; +inp[7671] = 0; +inp[7672] = 1073741328; +inp[7673] = 0; +inp[7674] = 1073741320; +inp[7675] = 0; +inp[7676] = 1073741824; +inp[7677] = 1073741824; +inp[7678] = 1073741820; +inp[7679] = 0; +inp[7680] = 1073741816; +inp[7681] = 0; +inp[7682] = 1073741812; +inp[7683] = 0; +inp[7684] = 1073741808; +inp[7685] = 0; +inp[7686] = 1073741804; +inp[7687] = 0; +inp[7688] = 1073741800; +inp[7689] = 0; +inp[7690] = 1073741796; +inp[7691] = 0; +inp[7692] = 1073741792; +inp[7693] = 0; +inp[7694] = 1073741788; +inp[7695] = 0; +inp[7696] = 1073741784; +inp[7697] = 0; +inp[7698] = 1073741780; +inp[7699] = 0; +inp[7700] = 1073741776; +inp[7701] = 0; +inp[7702] = 1073741772; +inp[7703] = 0; +inp[7704] = 1073741768; +inp[7705] = 0; +inp[7706] = 1073741764; +inp[7707] = 0; +inp[7708] = 1073741760; +inp[7709] = 0; +inp[7710] = 1073741756; +inp[7711] = 0; +inp[7712] = 1073741752; +inp[7713] = 0; +inp[7714] = 1073741748; +inp[7715] = 0; +inp[7716] = 1073741744; +inp[7717] = 0; +inp[7718] = 1073741740; +inp[7719] = 0; +inp[7720] = 1073741736; +inp[7721] = 0; +inp[7722] = 1073741732; +inp[7723] = 0; +inp[7724] = 1073741728; +inp[7725] = 0; +inp[7726] = 1073741724; +inp[7727] = 0; +inp[7728] = 1073741720; +inp[7729] = 0; +inp[7730] = 1073741716; +inp[7731] = 0; +inp[7732] = 1073741712; +inp[7733] = 0; +inp[7734] = 1073741708; +inp[7735] = 0; +inp[7736] = 1073741704; +inp[7737] = 0; +inp[7738] = 1073741700; +inp[7739] = 0; +inp[7740] = 1073741696; +inp[7741] = 0; +inp[7742] = 1073741692; +inp[7743] = 0; +inp[7744] = 1073741688; +inp[7745] = 0; +inp[7746] = 1073741684; +inp[7747] = 0; +inp[7748] = 1073741680; +inp[7749] = 0; +inp[7750] = 1073741676; +inp[7751] = 0; +inp[7752] = 1073741672; +inp[7753] = 0; +inp[7754] = 1073741668; +inp[7755] = 0; +inp[7756] = 1073741664; +inp[7757] = 0; +inp[7758] = 1073741660; +inp[7759] = 0; +inp[7760] = 1073741656; +inp[7761] = 0; +inp[7762] = 1073741652; +inp[7763] = 0; +inp[7764] = 1073741648; +inp[7765] = 0; +inp[7766] = 1073741644; +inp[7767] = 0; +inp[7768] = 1073741640; +inp[7769] = 0; +inp[7770] = 1073741636; +inp[7771] = 0; +inp[7772] = 1073741632; +inp[7773] = 0; +inp[7774] = 1073741628; +inp[7775] = 0; +inp[7776] = 1073741624; +inp[7777] = 0; +inp[7778] = 1073741620; +inp[7779] = 0; +inp[7780] = 1073741616; +inp[7781] = 0; +inp[7782] = 1073741612; +inp[7783] = 0; +inp[7784] = 1073741608; +inp[7785] = 0; +inp[7786] = 1073741604; +inp[7787] = 0; +inp[7788] = 1073741600; +inp[7789] = 0; +inp[7790] = 1073741596; +inp[7791] = 0; +inp[7792] = 1073741592; +inp[7793] = 0; +inp[7794] = 1073741588; +inp[7795] = 0; +inp[7796] = 1073741584; +inp[7797] = 0; +inp[7798] = 1073741580; +inp[7799] = 0; +inp[7800] = 1073741576; +inp[7801] = 0; +inp[7802] = 1073741572; +inp[7803] = 0; +inp[7804] = 1073741824; +inp[7805] = 1073741824; +inp[7806] = 1073741822; +inp[7807] = 0; +inp[7808] = 1073741820; +inp[7809] = 0; +inp[7810] = 1073741818; +inp[7811] = 0; +inp[7812] = 1073741816; +inp[7813] = 0; +inp[7814] = 1073741814; +inp[7815] = 0; +inp[7816] = 1073741812; +inp[7817] = 0; +inp[7818] = 1073741810; +inp[7819] = 0; +inp[7820] = 1073741808; +inp[7821] = 0; +inp[7822] = 1073741806; +inp[7823] = 0; +inp[7824] = 1073741804; +inp[7825] = 0; +inp[7826] = 1073741802; +inp[7827] = 0; +inp[7828] = 1073741800; +inp[7829] = 0; +inp[7830] = 1073741798; +inp[7831] = 0; +inp[7832] = 1073741796; +inp[7833] = 0; +inp[7834] = 1073741794; +inp[7835] = 0; +inp[7836] = 1073741792; +inp[7837] = 0; +inp[7838] = 1073741790; +inp[7839] = 0; +inp[7840] = 1073741788; +inp[7841] = 0; +inp[7842] = 1073741786; +inp[7843] = 0; +inp[7844] = 1073741784; +inp[7845] = 0; +inp[7846] = 1073741782; +inp[7847] = 0; +inp[7848] = 1073741780; +inp[7849] = 0; +inp[7850] = 1073741778; +inp[7851] = 0; +inp[7852] = 1073741776; +inp[7853] = 0; +inp[7854] = 1073741774; +inp[7855] = 0; +inp[7856] = 1073741772; +inp[7857] = 0; +inp[7858] = 1073741770; +inp[7859] = 0; +inp[7860] = 1073741768; +inp[7861] = 0; +inp[7862] = 1073741766; +inp[7863] = 0; +inp[7864] = 1073741764; +inp[7865] = 0; +inp[7866] = 1073741762; +inp[7867] = 0; +inp[7868] = 1073741760; +inp[7869] = 0; +inp[7870] = 1073741758; +inp[7871] = 0; +inp[7872] = 1073741756; +inp[7873] = 0; +inp[7874] = 1073741754; +inp[7875] = 0; +inp[7876] = 1073741752; +inp[7877] = 0; +inp[7878] = 1073741750; +inp[7879] = 0; +inp[7880] = 1073741748; +inp[7881] = 0; +inp[7882] = 1073741746; +inp[7883] = 0; +inp[7884] = 1073741744; +inp[7885] = 0; +inp[7886] = 1073741742; +inp[7887] = 0; +inp[7888] = 1073741740; +inp[7889] = 0; +inp[7890] = 1073741738; +inp[7891] = 0; +inp[7892] = 1073741736; +inp[7893] = 0; +inp[7894] = 1073741734; +inp[7895] = 0; +inp[7896] = 1073741732; +inp[7897] = 0; +inp[7898] = 1073741730; +inp[7899] = 0; +inp[7900] = 1073741728; +inp[7901] = 0; +inp[7902] = 1073741726; +inp[7903] = 0; +inp[7904] = 1073741724; +inp[7905] = 0; +inp[7906] = 1073741722; +inp[7907] = 0; +inp[7908] = 1073741720; +inp[7909] = 0; +inp[7910] = 1073741718; +inp[7911] = 0; +inp[7912] = 1073741716; +inp[7913] = 0; +inp[7914] = 1073741714; +inp[7915] = 0; +inp[7916] = 1073741712; +inp[7917] = 0; +inp[7918] = 1073741710; +inp[7919] = 0; +inp[7920] = 1073741708; +inp[7921] = 0; +inp[7922] = 1073741706; +inp[7923] = 0; +inp[7924] = 1073741704; +inp[7925] = 0; +inp[7926] = 1073741702; +inp[7927] = 0; +inp[7928] = 1073741700; +inp[7929] = 0; +inp[7930] = 1073741698; +inp[7931] = 0; +inp[7932] = 1073741824; +inp[7933] = 1073741824; +inp[7934] = 1073741823; +inp[7935] = 0; +inp[7936] = 1073741822; +inp[7937] = 0; +inp[7938] = 1073741821; +inp[7939] = 0; +inp[7940] = 1073741820; +inp[7941] = 0; +inp[7942] = 1073741819; +inp[7943] = 0; +inp[7944] = 1073741818; +inp[7945] = 0; +inp[7946] = 1073741817; +inp[7947] = 0; +inp[7948] = 1073741816; +inp[7949] = 0; +inp[7950] = 1073741815; +inp[7951] = 0; +inp[7952] = 1073741814; +inp[7953] = 0; +inp[7954] = 1073741813; +inp[7955] = 0; +inp[7956] = 1073741812; +inp[7957] = 0; +inp[7958] = 1073741811; +inp[7959] = 0; +inp[7960] = 1073741810; +inp[7961] = 0; +inp[7962] = 1073741809; +inp[7963] = 0; +inp[7964] = 1073741808; +inp[7965] = 0; +inp[7966] = 1073741807; +inp[7967] = 0; +inp[7968] = 1073741806; +inp[7969] = 0; +inp[7970] = 1073741805; +inp[7971] = 0; +inp[7972] = 1073741804; +inp[7973] = 0; +inp[7974] = 1073741803; +inp[7975] = 0; +inp[7976] = 1073741802; +inp[7977] = 0; +inp[7978] = 1073741801; +inp[7979] = 0; +inp[7980] = 1073741800; +inp[7981] = 0; +inp[7982] = 1073741799; +inp[7983] = 0; +inp[7984] = 1073741798; +inp[7985] = 0; +inp[7986] = 1073741797; +inp[7987] = 0; +inp[7988] = 1073741796; +inp[7989] = 0; +inp[7990] = 1073741795; +inp[7991] = 0; +inp[7992] = 1073741794; +inp[7993] = 0; +inp[7994] = 1073741793; +inp[7995] = 0; +inp[7996] = 1073741792; +inp[7997] = 0; +inp[7998] = 1073741791; +inp[7999] = 0; +inp[8000] = 1073741790; +inp[8001] = 0; +inp[8002] = 1073741789; +inp[8003] = 0; +inp[8004] = 1073741788; +inp[8005] = 0; +inp[8006] = 1073741787; +inp[8007] = 0; +inp[8008] = 1073741786; +inp[8009] = 0; +inp[8010] = 1073741785; +inp[8011] = 0; +inp[8012] = 1073741784; +inp[8013] = 0; +inp[8014] = 1073741783; +inp[8015] = 0; +inp[8016] = 1073741782; +inp[8017] = 0; +inp[8018] = 1073741781; +inp[8019] = 0; +inp[8020] = 1073741780; +inp[8021] = 0; +inp[8022] = 1073741779; +inp[8023] = 0; +inp[8024] = 1073741778; +inp[8025] = 0; +inp[8026] = 1073741777; +inp[8027] = 0; +inp[8028] = 1073741776; +inp[8029] = 0; +inp[8030] = 1073741775; +inp[8031] = 0; +inp[8032] = 1073741774; +inp[8033] = 0; +inp[8034] = 1073741773; +inp[8035] = 0; +inp[8036] = 1073741772; +inp[8037] = 0; +inp[8038] = 1073741771; +inp[8039] = 0; +inp[8040] = 1073741770; +inp[8041] = 0; +inp[8042] = 1073741769; +inp[8043] = 0; +inp[8044] = 1073741768; +inp[8045] = 0; +inp[8046] = 1073741767; +inp[8047] = 0; +inp[8048] = 1073741766; +inp[8049] = 0; +inp[8050] = 1073741765; +inp[8051] = 0; +inp[8052] = 1073741764; +inp[8053] = 0; +inp[8054] = 1073741763; +inp[8055] = 0; +inp[8056] = 1073741762; +inp[8057] = 0; +inp[8058] = 1073741761; +inp[8059] = 0; +inp[8060] = 1073741824; +inp[8061] = 1073741824; +inp[8062] = 1073741823; +inp[8063] = 0; +inp[8064] = 1073741823; +inp[8065] = 0; +inp[8066] = 1073741822; +inp[8067] = 0; +inp[8068] = 1073741822; +inp[8069] = 0; +inp[8070] = 1073741821; +inp[8071] = 0; +inp[8072] = 1073741821; +inp[8073] = 0; +inp[8074] = 1073741820; +inp[8075] = 0; +inp[8076] = 1073741820; +inp[8077] = 0; +inp[8078] = 1073741819; +inp[8079] = 0; +inp[8080] = 1073741819; +inp[8081] = 0; +inp[8082] = 1073741818; +inp[8083] = 0; +inp[8084] = 1073741818; +inp[8085] = 0; +inp[8086] = 1073741817; +inp[8087] = 0; +inp[8088] = 1073741817; +inp[8089] = 0; +inp[8090] = 1073741816; +inp[8091] = 0; +inp[8092] = 1073741816; +inp[8093] = 0; +inp[8094] = 1073741815; +inp[8095] = 0; +inp[8096] = 1073741815; +inp[8097] = 0; +inp[8098] = 1073741814; +inp[8099] = 0; +inp[8100] = 1073741814; +inp[8101] = 0; +inp[8102] = 1073741813; +inp[8103] = 0; +inp[8104] = 1073741813; +inp[8105] = 0; +inp[8106] = 1073741812; +inp[8107] = 0; +inp[8108] = 1073741812; +inp[8109] = 0; +inp[8110] = 1073741811; +inp[8111] = 0; +inp[8112] = 1073741811; +inp[8113] = 0; +inp[8114] = 1073741810; +inp[8115] = 0; +inp[8116] = 1073741810; +inp[8117] = 0; +inp[8118] = 1073741809; +inp[8119] = 0; +inp[8120] = 1073741809; +inp[8121] = 0; +inp[8122] = 1073741808; +inp[8123] = 0; +inp[8124] = 1073741808; +inp[8125] = 0; +inp[8126] = 1073741807; +inp[8127] = 0; +inp[8128] = 1073741807; +inp[8129] = 0; +inp[8130] = 1073741806; +inp[8131] = 0; +inp[8132] = 1073741806; +inp[8133] = 0; +inp[8134] = 1073741805; +inp[8135] = 0; +inp[8136] = 1073741805; +inp[8137] = 0; +inp[8138] = 1073741804; +inp[8139] = 0; +inp[8140] = 1073741804; +inp[8141] = 0; +inp[8142] = 1073741803; +inp[8143] = 0; +inp[8144] = 1073741803; +inp[8145] = 0; +inp[8146] = 1073741802; +inp[8147] = 0; +inp[8148] = 1073741802; +inp[8149] = 0; +inp[8150] = 1073741801; +inp[8151] = 0; +inp[8152] = 1073741801; +inp[8153] = 0; +inp[8154] = 1073741800; +inp[8155] = 0; +inp[8156] = 1073741800; +inp[8157] = 0; +inp[8158] = 1073741799; +inp[8159] = 0; +inp[8160] = 1073741799; +inp[8161] = 0; +inp[8162] = 1073741798; +inp[8163] = 0; +inp[8164] = 1073741798; +inp[8165] = 0; +inp[8166] = 1073741797; +inp[8167] = 0; +inp[8168] = 1073741797; +inp[8169] = 0; +inp[8170] = 1073741796; +inp[8171] = 0; +inp[8172] = 1073741796; +inp[8173] = 0; +inp[8174] = 1073741795; +inp[8175] = 0; +inp[8176] = 1073741795; +inp[8177] = 0; +inp[8178] = 1073741794; +inp[8179] = 0; +inp[8180] = 1073741794; +inp[8181] = 0; +inp[8182] = 1073741793; +inp[8183] = 0; +inp[8184] = 1073741793; +inp[8185] = 0; +inp[8186] = 1073741792; +inp[8187] = 0; +inp[8188] = 1073741824; +inp[8189] = 1073741824; +inp[8190] = 1073741823; +inp[8191] = 0; +inp[8192] = 1073741823; +inp[8193] = 0; +inp[8194] = 1073741823; +inp[8195] = 0; +inp[8196] = 1073741823; +inp[8197] = 0; +inp[8198] = 1073741822; +inp[8199] = 0; +inp[8200] = 1073741822; +inp[8201] = 0; +inp[8202] = 1073741822; +inp[8203] = 0; +inp[8204] = 1073741822; +inp[8205] = 0; +inp[8206] = 1073741821; +inp[8207] = 0; +inp[8208] = 1073741821; +inp[8209] = 0; +inp[8210] = 1073741821; +inp[8211] = 0; +inp[8212] = 1073741821; +inp[8213] = 0; +inp[8214] = 1073741820; +inp[8215] = 0; +inp[8216] = 1073741820; +inp[8217] = 0; +inp[8218] = 1073741820; +inp[8219] = 0; +inp[8220] = 1073741820; +inp[8221] = 0; +inp[8222] = 1073741819; +inp[8223] = 0; +inp[8224] = 1073741819; +inp[8225] = 0; +inp[8226] = 1073741819; +inp[8227] = 0; +inp[8228] = 1073741819; +inp[8229] = 0; +inp[8230] = 1073741818; +inp[8231] = 0; +inp[8232] = 1073741818; +inp[8233] = 0; +inp[8234] = 1073741818; +inp[8235] = 0; +inp[8236] = 1073741818; +inp[8237] = 0; +inp[8238] = 1073741817; +inp[8239] = 0; +inp[8240] = 1073741817; +inp[8241] = 0; +inp[8242] = 1073741817; +inp[8243] = 0; +inp[8244] = 1073741817; +inp[8245] = 0; +inp[8246] = 1073741816; +inp[8247] = 0; +inp[8248] = 1073741816; +inp[8249] = 0; +inp[8250] = 1073741816; +inp[8251] = 0; +inp[8252] = 1073741816; +inp[8253] = 0; +inp[8254] = 1073741815; +inp[8255] = 0; +inp[8256] = 1073741815; +inp[8257] = 0; +inp[8258] = 1073741815; +inp[8259] = 0; +inp[8260] = 1073741815; +inp[8261] = 0; +inp[8262] = 1073741814; +inp[8263] = 0; +inp[8264] = 1073741814; +inp[8265] = 0; +inp[8266] = 1073741814; +inp[8267] = 0; +inp[8268] = 1073741814; +inp[8269] = 0; +inp[8270] = 1073741813; +inp[8271] = 0; +inp[8272] = 1073741813; +inp[8273] = 0; +inp[8274] = 1073741813; +inp[8275] = 0; +inp[8276] = 1073741813; +inp[8277] = 0; +inp[8278] = 1073741812; +inp[8279] = 0; +inp[8280] = 1073741812; +inp[8281] = 0; +inp[8282] = 1073741812; +inp[8283] = 0; +inp[8284] = 1073741812; +inp[8285] = 0; +inp[8286] = 1073741811; +inp[8287] = 0; +inp[8288] = 1073741811; +inp[8289] = 0; +inp[8290] = 1073741811; +inp[8291] = 0; +inp[8292] = 1073741811; +inp[8293] = 0; +inp[8294] = 1073741810; +inp[8295] = 0; +inp[8296] = 1073741810; +inp[8297] = 0; +inp[8298] = 1073741810; +inp[8299] = 0; +inp[8300] = 1073741810; +inp[8301] = 0; +inp[8302] = 1073741809; +inp[8303] = 0; +inp[8304] = 1073741809; +inp[8305] = 0; +inp[8306] = 1073741809; +inp[8307] = 0; +inp[8308] = 1073741809; +inp[8309] = 0; +inp[8310] = 1073741808; +inp[8311] = 0; +inp[8312] = 1073741808; +inp[8313] = 0; +inp[8314] = 1073741808; +inp[8315] = 0; +inp[8316] = 1073741824; +inp[8317] = 1073741824; +inp[8318] = 395007542; +inp[8319] = 395007542; +inp[8320] = 145315153; +inp[8321] = 145315153; +inp[8322] = 53458457; +inp[8323] = 53458457; +inp[8324] = 19666267; +inp[8325] = 19666267; +inp[8326] = 7234815; +inp[8327] = 7234815; +inp[8328] = 2661539; +inp[8329] = 2661539; +inp[8330] = 979125; +inp[8331] = 979125; +inp[8332] = 360200; +inp[8333] = 360200; +inp[8334] = 132510; +inp[8335] = 132510; +inp[8336] = 48747; +inp[8337] = 48747; +inp[8338] = 17933; +inp[8339] = 17933; +inp[8340] = 6597; +inp[8341] = 6597; +inp[8342] = 2427; +inp[8343] = 2427; +inp[8344] = 892; +inp[8345] = 892; +inp[8346] = 328; +inp[8347] = 328; +inp[8348] = 120; +inp[8349] = 120; +inp[8350] = 44; +inp[8351] = 44; +inp[8352] = 16; +inp[8353] = 16; +inp[8354] = 6; +inp[8355] = 6; +inp[8356] = 2; +inp[8357] = 2; +inp[8358] = 0; +inp[8359] = 0; +inp[8360] = 0; +inp[8361] = 0; +inp[8362] = 0; +inp[8363] = 0; +inp[8364] = 0; +inp[8365] = 0; +inp[8366] = 0; +inp[8367] = 0; +inp[8368] = 0; +inp[8369] = 0; +inp[8370] = 0; +inp[8371] = 0; +inp[8372] = 0; +inp[8373] = 0; +inp[8374] = 0; +inp[8375] = 0; +inp[8376] = 0; +inp[8377] = 0; +inp[8378] = 0; +inp[8379] = 0; +inp[8380] = 0; +inp[8381] = 0; +inp[8382] = 0; +inp[8383] = 0; +inp[8384] = 0; +inp[8385] = 0; +inp[8386] = 0; +inp[8387] = 0; +inp[8388] = 0; +inp[8389] = 0; +inp[8390] = 0; +inp[8391] = 0; +inp[8392] = 0; +inp[8393] = 0; +inp[8394] = 0; +inp[8395] = 0; +inp[8396] = 0; +inp[8397] = 0; +inp[8398] = 0; +inp[8399] = 0; +inp[8400] = 0; +inp[8401] = 0; +inp[8402] = 0; +inp[8403] = 0; +inp[8404] = 0; +inp[8405] = 0; +inp[8406] = 0; +inp[8407] = 0; +inp[8408] = 0; +inp[8409] = 0; +inp[8410] = 0; +inp[8411] = 0; +inp[8412] = 0; +inp[8413] = 0; +inp[8414] = 0; +inp[8415] = 0; +inp[8416] = 0; +inp[8417] = 0; +inp[8418] = 0; +inp[8419] = 0; +inp[8420] = 0; +inp[8421] = 0; +inp[8422] = 0; +inp[8423] = 0; +inp[8424] = 0; +inp[8425] = 0; +inp[8426] = 0; +inp[8427] = 0; +inp[8428] = 0; +inp[8429] = 0; +inp[8430] = 0; +inp[8431] = 0; +inp[8432] = 0; +inp[8433] = 0; +inp[8434] = 0; +inp[8435] = 0; +inp[8436] = 0; +inp[8437] = 0; +inp[8438] = 0; +inp[8439] = 0; +inp[8440] = 0; +inp[8441] = 0; +inp[8442] = 0; +inp[8443] = 0; +inp[8444] = 0; +inp[8445] = 0; +inp[8446] = 0; +inp[8447] = 0; +inp[8448] = 0; +inp[8449] = 0; +inp[8450] = 0; +inp[8451] = 0; +inp[8452] = 0; +inp[8453] = 0; +inp[8454] = 0; +inp[8455] = 0; +inp[8456] = 0; +inp[8457] = 0; +inp[8458] = 0; +inp[8459] = 0; +inp[8460] = 0; +inp[8461] = 0; +inp[8462] = 0; +inp[8463] = 0; +inp[8464] = 0; +inp[8465] = 0; +inp[8466] = 0; +inp[8467] = 0; +inp[8468] = 0; +inp[8469] = 0; +inp[8470] = 0; +inp[8471] = 0; +inp[8472] = 0; +inp[8473] = 0; +inp[8474] = 0; +inp[8475] = 0; +inp[8476] = 0; +inp[8477] = 0; +inp[8478] = 0; +inp[8479] = 0; +inp[8480] = 0; +inp[8481] = 0; +inp[8482] = 0; +inp[8483] = 0; +inp[8484] = 0; +inp[8485] = 0; +inp[8486] = 0; +inp[8487] = 0; +inp[8488] = 0; +inp[8489] = 0; +inp[8490] = 0; +inp[8491] = 0; +inp[8492] = 0; +inp[8493] = 0; +inp[8494] = 0; +inp[8495] = 0; +inp[8496] = 0; +inp[8497] = 0; +inp[8498] = 0; +inp[8499] = 0; +inp[8500] = 0; +inp[8501] = 0; +inp[8502] = 0; +inp[8503] = 0; +inp[8504] = 0; +inp[8505] = 0; +inp[8506] = 0; +inp[8507] = 0; +inp[8508] = 0; +inp[8509] = 0; +inp[8510] = 0; +inp[8511] = 0; +inp[8512] = 0; +inp[8513] = 0; +inp[8514] = 0; +inp[8515] = 0; +inp[8516] = 0; +inp[8517] = 0; +inp[8518] = 0; +inp[8519] = 0; +inp[8520] = 0; +inp[8521] = 0; +inp[8522] = 0; +inp[8523] = 0; +inp[8524] = 0; +inp[8525] = 0; +inp[8526] = 0; +inp[8527] = 0; +inp[8528] = 0; +inp[8529] = 0; +inp[8530] = 0; +inp[8531] = 0; +inp[8532] = 0; +inp[8533] = 0; +inp[8534] = 0; +inp[8535] = 0; +inp[8536] = 0; +inp[8537] = 0; +inp[8538] = 0; +inp[8539] = 0; +inp[8540] = 0; +inp[8541] = 0; +inp[8542] = 0; +inp[8543] = 0; +inp[8544] = 0; +inp[8545] = 0; +inp[8546] = 0; +inp[8547] = 0; +inp[8548] = 0; +inp[8549] = 0; +inp[8550] = 0; +inp[8551] = 0; +inp[8552] = 0; +inp[8553] = 0; +inp[8554] = 0; +inp[8555] = 0; +inp[8556] = 0; +inp[8557] = 0; +inp[8558] = 0; +inp[8559] = 0; +inp[8560] = 0; +inp[8561] = 0; +inp[8562] = 0; +inp[8563] = 0; +inp[8564] = 0; +inp[8565] = 0; +inp[8566] = 0; +inp[8567] = 0; +inp[8568] = 0; +inp[8569] = 0; +inp[8570] = 0; +inp[8571] = 0; +inp[8572] = 1073741824; +inp[8573] = 1073741824; +inp[8574] = 651257336; +inp[8575] = 145315153; +inp[8576] = 395007542; +inp[8577] = 19666267; +inp[8578] = 239584185; +inp[8579] = 2661539; +inp[8580] = 145315153; +inp[8581] = 360200; +inp[8582] = 88138096; +inp[8583] = 48747; +inp[8584] = 53458457; +inp[8585] = 6597; +inp[8586] = 32424193; +inp[8587] = 892; +inp[8588] = 19666267; +inp[8589] = 120; +inp[8590] = 11928194; +inp[8591] = 16; +inp[8592] = 7234815; +inp[8593] = 2; +inp[8594] = 4388137; +inp[8595] = 0; +inp[8596] = 2661539; +inp[8597] = 0; +inp[8598] = 1614305; +inp[8599] = 0; +inp[8600] = 979125; +inp[8601] = 0; +inp[8602] = 593869; +inp[8603] = 0; +inp[8604] = 360200; +inp[8605] = 0; +inp[8606] = 218472; +inp[8607] = 0; +inp[8608] = 132510; +inp[8609] = 0; +inp[8610] = 80371; +inp[8611] = 0; +inp[8612] = 48747; +inp[8613] = 0; +inp[8614] = 29567; +inp[8615] = 0; +inp[8616] = 17933; +inp[8617] = 0; +inp[8618] = 10877; +inp[8619] = 0; +inp[8620] = 6597; +inp[8621] = 0; +inp[8622] = 4001; +inp[8623] = 0; +inp[8624] = 2427; +inp[8625] = 0; +inp[8626] = 1472; +inp[8627] = 0; +inp[8628] = 892; +inp[8629] = 0; +inp[8630] = 541; +inp[8631] = 0; +inp[8632] = 328; +inp[8633] = 0; +inp[8634] = 199; +inp[8635] = 0; +inp[8636] = 120; +inp[8637] = 0; +inp[8638] = 73; +inp[8639] = 0; +inp[8640] = 44; +inp[8641] = 0; +inp[8642] = 26; +inp[8643] = 0; +inp[8644] = 16; +inp[8645] = 0; +inp[8646] = 9; +inp[8647] = 0; +inp[8648] = 6; +inp[8649] = 0; +inp[8650] = 3; +inp[8651] = 0; +inp[8652] = 2; +inp[8653] = 0; +inp[8654] = 1; +inp[8655] = 0; +inp[8656] = 0; +inp[8657] = 0; +inp[8658] = 0; +inp[8659] = 0; +inp[8660] = 0; +inp[8661] = 0; +inp[8662] = 0; +inp[8663] = 0; +inp[8664] = 0; +inp[8665] = 0; +inp[8666] = 0; +inp[8667] = 0; +inp[8668] = 0; +inp[8669] = 0; +inp[8670] = 0; +inp[8671] = 0; +inp[8672] = 0; +inp[8673] = 0; +inp[8674] = 0; +inp[8675] = 0; +inp[8676] = 0; +inp[8677] = 0; +inp[8678] = 0; +inp[8679] = 0; +inp[8680] = 0; +inp[8681] = 0; +inp[8682] = 0; +inp[8683] = 0; +inp[8684] = 0; +inp[8685] = 0; +inp[8686] = 0; +inp[8687] = 0; +inp[8688] = 0; +inp[8689] = 0; +inp[8690] = 0; +inp[8691] = 0; +inp[8692] = 0; +inp[8693] = 0; +inp[8694] = 0; +inp[8695] = 0; +inp[8696] = 0; +inp[8697] = 0; +inp[8698] = 0; +inp[8699] = 0; +inp[8700] = 0; +inp[8701] = 0; +inp[8702] = 0; +inp[8703] = 0; +inp[8704] = 0; +inp[8705] = 0; +inp[8706] = 0; +inp[8707] = 0; +inp[8708] = 0; +inp[8709] = 0; +inp[8710] = 0; +inp[8711] = 0; +inp[8712] = 0; +inp[8713] = 0; +inp[8714] = 0; +inp[8715] = 0; +inp[8716] = 0; +inp[8717] = 0; +inp[8718] = 0; +inp[8719] = 0; +inp[8720] = 0; +inp[8721] = 0; +inp[8722] = 0; +inp[8723] = 0; +inp[8724] = 0; +inp[8725] = 0; +inp[8726] = 0; +inp[8727] = 0; +inp[8728] = 0; +inp[8729] = 0; +inp[8730] = 0; +inp[8731] = 0; +inp[8732] = 0; +inp[8733] = 0; +inp[8734] = 0; +inp[8735] = 0; +inp[8736] = 0; +inp[8737] = 0; +inp[8738] = 0; +inp[8739] = 0; +inp[8740] = 0; +inp[8741] = 0; +inp[8742] = 0; +inp[8743] = 0; +inp[8744] = 0; +inp[8745] = 0; +inp[8746] = 0; +inp[8747] = 0; +inp[8748] = 0; +inp[8749] = 0; +inp[8750] = 0; +inp[8751] = 0; +inp[8752] = 0; +inp[8753] = 0; +inp[8754] = 0; +inp[8755] = 0; +inp[8756] = 0; +inp[8757] = 0; +inp[8758] = 0; +inp[8759] = 0; +inp[8760] = 0; +inp[8761] = 0; +inp[8762] = 0; +inp[8763] = 0; +inp[8764] = 0; +inp[8765] = 0; +inp[8766] = 0; +inp[8767] = 0; +inp[8768] = 0; +inp[8769] = 0; +inp[8770] = 0; +inp[8771] = 0; +inp[8772] = 0; +inp[8773] = 0; +inp[8774] = 0; +inp[8775] = 0; +inp[8776] = 0; +inp[8777] = 0; +inp[8778] = 0; +inp[8779] = 0; +inp[8780] = 0; +inp[8781] = 0; +inp[8782] = 0; +inp[8783] = 0; +inp[8784] = 0; +inp[8785] = 0; +inp[8786] = 0; +inp[8787] = 0; +inp[8788] = 0; +inp[8789] = 0; +inp[8790] = 0; +inp[8791] = 0; +inp[8792] = 0; +inp[8793] = 0; +inp[8794] = 0; +inp[8795] = 0; +inp[8796] = 0; +inp[8797] = 0; +inp[8798] = 0; +inp[8799] = 0; +inp[8800] = 0; +inp[8801] = 0; +inp[8802] = 0; +inp[8803] = 0; +inp[8804] = 0; +inp[8805] = 0; +inp[8806] = 0; +inp[8807] = 0; +inp[8808] = 0; +inp[8809] = 0; +inp[8810] = 0; +inp[8811] = 0; +inp[8812] = 0; +inp[8813] = 0; +inp[8814] = 0; +inp[8815] = 0; +inp[8816] = 0; +inp[8817] = 0; +inp[8818] = 0; +inp[8819] = 0; +inp[8820] = 0; +inp[8821] = 0; +inp[8822] = 0; +inp[8823] = 0; +inp[8824] = 0; +inp[8825] = 0; +inp[8826] = 0; +inp[8827] = 0; +inp[8828] = 1073741824; +inp[8829] = 1073741824; +inp[8830] = 836230973; +inp[8831] = 19666267; +inp[8832] = 651257336; +inp[8833] = 360200; +inp[8834] = 507199723; +inp[8835] = 6597; +inp[8836] = 395007542; +inp[8837] = 120; +inp[8838] = 307632183; +inp[8839] = 2; +inp[8840] = 239584185; +inp[8841] = 0; +inp[8842] = 186588351; +inp[8843] = 0; +inp[8844] = 145315153; +inp[8845] = 0; +inp[8846] = 113171555; +inp[8847] = 0; +inp[8848] = 88138096; +inp[8849] = 0; +inp[8850] = 68642018; +inp[8851] = 0; +inp[8852] = 53458457; +inp[8853] = 0; +inp[8854] = 41633488; +inp[8855] = 0; +inp[8856] = 32424193; +inp[8857] = 0; +inp[8858] = 25251987; +inp[8859] = 0; +inp[8860] = 19666267; +inp[8861] = 0; +inp[8862] = 15316104; +inp[8863] = 0; +inp[8864] = 11928194; +inp[8865] = 0; +inp[8866] = 9289686; +inp[8867] = 0; +inp[8868] = 7234815; +inp[8869] = 0; +inp[8870] = 5634479; +inp[8871] = 0; +inp[8872] = 4388137; +inp[8873] = 0; +inp[8874] = 3417484; +inp[8875] = 0; +inp[8876] = 2661539; +inp[8877] = 0; +inp[8878] = 2072809; +inp[8879] = 0; +inp[8880] = 1614305; +inp[8881] = 0; +inp[8882] = 1257222; +inp[8883] = 0; +inp[8884] = 979125; +inp[8885] = 0; +inp[8886] = 762543; +inp[8887] = 0; +inp[8888] = 593869; +inp[8889] = 0; +inp[8890] = 462506; +inp[8891] = 0; +inp[8892] = 360200; +inp[8893] = 0; +inp[8894] = 280524; +inp[8895] = 0; +inp[8896] = 218472; +inp[8897] = 0; +inp[8898] = 170146; +inp[8899] = 0; +inp[8900] = 132510; +inp[8901] = 0; +inp[8902] = 103199; +inp[8903] = 0; +inp[8904] = 80371; +inp[8905] = 0; +inp[8906] = 62593; +inp[8907] = 0; +inp[8908] = 48747; +inp[8909] = 0; +inp[8910] = 37964; +inp[8911] = 0; +inp[8912] = 29567; +inp[8913] = 0; +inp[8914] = 23026; +inp[8915] = 0; +inp[8916] = 17933; +inp[8917] = 0; +inp[8918] = 13966; +inp[8919] = 0; +inp[8920] = 10877; +inp[8921] = 0; +inp[8922] = 8471; +inp[8923] = 0; +inp[8924] = 6597; +inp[8925] = 0; +inp[8926] = 5137; +inp[8927] = 0; +inp[8928] = 4001; +inp[8929] = 0; +inp[8930] = 3116; +inp[8931] = 0; +inp[8932] = 2427; +inp[8933] = 0; +inp[8934] = 1890; +inp[8935] = 0; +inp[8936] = 1472; +inp[8937] = 0; +inp[8938] = 1146; +inp[8939] = 0; +inp[8940] = 892; +inp[8941] = 0; +inp[8942] = 695; +inp[8943] = 0; +inp[8944] = 541; +inp[8945] = 0; +inp[8946] = 421; +inp[8947] = 0; +inp[8948] = 328; +inp[8949] = 0; +inp[8950] = 255; +inp[8951] = 0; +inp[8952] = 199; +inp[8953] = 0; +inp[8954] = 155; +inp[8955] = 0; +inp[8956] = 120; +inp[8957] = 0; +inp[8958] = 94; +inp[8959] = 0; +inp[8960] = 73; +inp[8961] = 0; +inp[8962] = 57; +inp[8963] = 0; +inp[8964] = 44; +inp[8965] = 0; +inp[8966] = 34; +inp[8967] = 0; +inp[8968] = 26; +inp[8969] = 0; +inp[8970] = 20; +inp[8971] = 0; +inp[8972] = 16; +inp[8973] = 0; +inp[8974] = 12; +inp[8975] = 0; +inp[8976] = 9; +inp[8977] = 0; +inp[8978] = 7; +inp[8979] = 0; +inp[8980] = 6; +inp[8981] = 0; +inp[8982] = 4; +inp[8983] = 0; +inp[8984] = 3; +inp[8985] = 0; +inp[8986] = 2; +inp[8987] = 0; +inp[8988] = 2; +inp[8989] = 0; +inp[8990] = 1; +inp[8991] = 0; +inp[8992] = 1; +inp[8993] = 0; +inp[8994] = 1; +inp[8995] = 0; +inp[8996] = 0; +inp[8997] = 0; +inp[8998] = 0; +inp[8999] = 0; +inp[9000] = 0; +inp[9001] = 0; +inp[9002] = 0; +inp[9003] = 0; +inp[9004] = 0; +inp[9005] = 0; +inp[9006] = 0; +inp[9007] = 0; +inp[9008] = 0; +inp[9009] = 0; +inp[9010] = 0; +inp[9011] = 0; +inp[9012] = 0; +inp[9013] = 0; +inp[9014] = 0; +inp[9015] = 0; +inp[9016] = 0; +inp[9017] = 0; +inp[9018] = 0; +inp[9019] = 0; +inp[9020] = 0; +inp[9021] = 0; +inp[9022] = 0; +inp[9023] = 0; +inp[9024] = 0; +inp[9025] = 0; +inp[9026] = 0; +inp[9027] = 0; +inp[9028] = 0; +inp[9029] = 0; +inp[9030] = 0; +inp[9031] = 0; +inp[9032] = 0; +inp[9033] = 0; +inp[9034] = 0; +inp[9035] = 0; +inp[9036] = 0; +inp[9037] = 0; +inp[9038] = 0; +inp[9039] = 0; +inp[9040] = 0; +inp[9041] = 0; +inp[9042] = 0; +inp[9043] = 0; +inp[9044] = 0; +inp[9045] = 0; +inp[9046] = 0; +inp[9047] = 0; +inp[9048] = 0; +inp[9049] = 0; +inp[9050] = 0; +inp[9051] = 0; +inp[9052] = 0; +inp[9053] = 0; +inp[9054] = 0; +inp[9055] = 0; +inp[9056] = 0; +inp[9057] = 0; +inp[9058] = 0; +inp[9059] = 0; +inp[9060] = 0; +inp[9061] = 0; +inp[9062] = 0; +inp[9063] = 0; +inp[9064] = 0; +inp[9065] = 0; +inp[9066] = 0; +inp[9067] = 0; +inp[9068] = 0; +inp[9069] = 0; +inp[9070] = 0; +inp[9071] = 0; +inp[9072] = 0; +inp[9073] = 0; +inp[9074] = 0; +inp[9075] = 0; +inp[9076] = 0; +inp[9077] = 0; +inp[9078] = 0; +inp[9079] = 0; +inp[9080] = 0; +inp[9081] = 0; +inp[9082] = 0; +inp[9083] = 0; +inp[9084] = 1073741824; +inp[9085] = 1073741824; +inp[9086] = 947573833; +inp[9087] = 360200; +inp[9088] = 836230973; +inp[9089] = 120; +inp[9090] = 737971243; +inp[9091] = 0; +inp[9092] = 651257336; +inp[9093] = 0; +inp[9094] = 574732582; +inp[9095] = 0; +inp[9096] = 507199723; +inp[9097] = 0; +inp[9098] = 447602185; +inp[9099] = 0; +inp[9100] = 395007542; +inp[9101] = 0; +inp[9102] = 348592932; +inp[9103] = 0; +inp[9104] = 307632183; +inp[9105] = 0; +inp[9106] = 271484448; +inp[9107] = 0; +inp[9108] = 239584185; +inp[9109] = 0; +inp[9110] = 211432301; +inp[9111] = 0; +inp[9112] = 186588351; +inp[9113] = 0; +inp[9114] = 164663641; +inp[9115] = 0; +inp[9116] = 145315153; +inp[9117] = 0; +inp[9118] = 128240173; +inp[9119] = 0; +inp[9120] = 113171555; +inp[9121] = 0; +inp[9122] = 99873547; +inp[9123] = 0; +inp[9124] = 88138096; +inp[9125] = 0; +inp[9126] = 77781596; +inp[9127] = 0; +inp[9128] = 68642018; +inp[9129] = 0; +inp[9130] = 60576368; +inp[9131] = 0; +inp[9132] = 53458457; +inp[9133] = 0; +inp[9134] = 47176923; +inp[9135] = 0; +inp[9136] = 41633488; +inp[9137] = 0; +inp[9138] = 36741424; +inp[9139] = 0; +inp[9140] = 32424193; +inp[9141] = 0; +inp[9142] = 28614250; +inp[9143] = 0; +inp[9144] = 25251987; +inp[9145] = 0; +inp[9146] = 22284800; +inp[9147] = 0; +inp[9148] = 19666267; +inp[9149] = 0; +inp[9150] = 17355420; +inp[9151] = 0; +inp[9152] = 15316104; +inp[9153] = 0; +inp[9154] = 13516414; +inp[9155] = 0; +inp[9156] = 11928194; +inp[9157] = 0; +inp[9158] = 10526594; +inp[9159] = 0; +inp[9160] = 9289686; +inp[9161] = 0; +inp[9162] = 8198119; +inp[9163] = 0; +inp[9164] = 7234815; +inp[9165] = 0; +inp[9166] = 6384702; +inp[9167] = 0; +inp[9168] = 5634479; +inp[9169] = 0; +inp[9170] = 4972411; +inp[9171] = 0; +inp[9172] = 4388137; +inp[9173] = 0; +inp[9174] = 3872517; +inp[9175] = 0; +inp[9176] = 3417484; +inp[9177] = 0; +inp[9178] = 3015919; +inp[9179] = 0; +inp[9180] = 2661539; +inp[9181] = 0; +inp[9182] = 2348800; +inp[9183] = 0; +inp[9184] = 2072809; +inp[9185] = 0; +inp[9186] = 1829247; +inp[9187] = 0; +inp[9188] = 1614305; +inp[9189] = 0; +inp[9190] = 1424619; +inp[9191] = 0; +inp[9192] = 1257222; +inp[9193] = 0; +inp[9194] = 1109494; +inp[9195] = 0; +inp[9196] = 979125; +inp[9197] = 0; +inp[9198] = 864075; +inp[9199] = 0; +inp[9200] = 762543; +inp[9201] = 0; +inp[9202] = 672942; +inp[9203] = 0; +inp[9204] = 593869; +inp[9205] = 0; +inp[9206] = 524088; +inp[9207] = 0; +inp[9208] = 462506; +inp[9209] = 0; +inp[9210] = 408160; +inp[9211] = 0; +inp[9212] = 360200; +inp[9213] = 0; +inp[9214] = 317875; +inp[9215] = 0; +inp[9216] = 280524; +inp[9217] = 0; +inp[9218] = 247561; +inp[9219] = 0; +inp[9220] = 218472; +inp[9221] = 0; +inp[9222] = 192801; +inp[9223] = 0; +inp[9224] = 170146; +inp[9225] = 0; +inp[9226] = 150153; +inp[9227] = 0; +inp[9228] = 132510; +inp[9229] = 0; +inp[9230] = 116939; +inp[9231] = 0; +inp[9232] = 103199; +inp[9233] = 0; +inp[9234] = 91072; +inp[9235] = 0; +inp[9236] = 80371; +inp[9237] = 0; +inp[9238] = 70927; +inp[9239] = 0; +inp[9240] = 62593; +inp[9241] = 0; +inp[9242] = 55238; +inp[9243] = 0; +inp[9244] = 48747; +inp[9245] = 0; +inp[9246] = 43019; +inp[9247] = 0; +inp[9248] = 37964; +inp[9249] = 0; +inp[9250] = 33503; +inp[9251] = 0; +inp[9252] = 29567; +inp[9253] = 0; +inp[9254] = 26092; +inp[9255] = 0; +inp[9256] = 23026; +inp[9257] = 0; +inp[9258] = 20321; +inp[9259] = 0; +inp[9260] = 17933; +inp[9261] = 0; +inp[9262] = 15826; +inp[9263] = 0; +inp[9264] = 13966; +inp[9265] = 0; +inp[9266] = 12325; +inp[9267] = 0; +inp[9268] = 10877; +inp[9269] = 0; +inp[9270] = 9599; +inp[9271] = 0; +inp[9272] = 8471; +inp[9273] = 0; +inp[9274] = 7475; +inp[9275] = 0; +inp[9276] = 6597; +inp[9277] = 0; +inp[9278] = 5822; +inp[9279] = 0; +inp[9280] = 5137; +inp[9281] = 0; +inp[9282] = 4534; +inp[9283] = 0; +inp[9284] = 4001; +inp[9285] = 0; +inp[9286] = 3531; +inp[9287] = 0; +inp[9288] = 3116; +inp[9289] = 0; +inp[9290] = 2750; +inp[9291] = 0; +inp[9292] = 2427; +inp[9293] = 0; +inp[9294] = 2141; +inp[9295] = 0; +inp[9296] = 1890; +inp[9297] = 0; +inp[9298] = 1668; +inp[9299] = 0; +inp[9300] = 1472; +inp[9301] = 0; +inp[9302] = 1299; +inp[9303] = 0; +inp[9304] = 1146; +inp[9305] = 0; +inp[9306] = 1011; +inp[9307] = 0; +inp[9308] = 892; +inp[9309] = 0; +inp[9310] = 787; +inp[9311] = 0; +inp[9312] = 695; +inp[9313] = 0; +inp[9314] = 613; +inp[9315] = 0; +inp[9316] = 541; +inp[9317] = 0; +inp[9318] = 477; +inp[9319] = 0; +inp[9320] = 421; +inp[9321] = 0; +inp[9322] = 372; +inp[9323] = 0; +inp[9324] = 328; +inp[9325] = 0; +inp[9326] = 289; +inp[9327] = 0; +inp[9328] = 255; +inp[9329] = 0; +inp[9330] = 225; +inp[9331] = 0; +inp[9332] = 199; +inp[9333] = 0; +inp[9334] = 175; +inp[9335] = 0; +inp[9336] = 155; +inp[9337] = 0; +inp[9338] = 136; +inp[9339] = 0; +inp[9340] = 1073741824; +inp[9341] = 1073741824; +inp[9342] = 1008687095; +inp[9343] = 120; +inp[9344] = 947573833; +inp[9345] = 0; +inp[9346] = 890163237; +inp[9347] = 0; +inp[9348] = 836230973; +inp[9349] = 0; +inp[9350] = 785566299; +inp[9351] = 0; +inp[9352] = 737971243; +inp[9353] = 0; +inp[9354] = 693259826; +inp[9355] = 0; +inp[9356] = 651257336; +inp[9357] = 0; +inp[9358] = 611799649; +inp[9359] = 0; +inp[9360] = 574732582; +inp[9361] = 0; +inp[9362] = 539911295; +inp[9363] = 0; +inp[9364] = 507199723; +inp[9365] = 0; +inp[9366] = 476470046; +inp[9367] = 0; +inp[9368] = 447602185; +inp[9369] = 0; +inp[9370] = 420483339; +inp[9371] = 0; +inp[9372] = 395007542; +inp[9373] = 0; +inp[9374] = 371075245; +inp[9375] = 0; +inp[9376] = 348592932; +inp[9377] = 0; +inp[9378] = 327472754; +inp[9379] = 0; +inp[9380] = 307632183; +inp[9381] = 0; +inp[9382] = 288993691; +inp[9383] = 0; +inp[9384] = 271484448; +inp[9385] = 0; +inp[9386] = 255036037; +inp[9387] = 0; +inp[9388] = 239584185; +inp[9389] = 0; +inp[9390] = 225068513; +inp[9391] = 0; +inp[9392] = 211432301; +inp[9393] = 0; +inp[9394] = 198622265; +inp[9395] = 0; +inp[9396] = 186588351; +inp[9397] = 0; +inp[9398] = 175283534; +inp[9399] = 0; +inp[9400] = 164663641; +inp[9401] = 0; +inp[9402] = 154687176; +inp[9403] = 0; +inp[9404] = 145315153; +inp[9405] = 0; +inp[9406] = 136510953; +inp[9407] = 0; +inp[9408] = 128240173; +inp[9409] = 0; +inp[9410] = 120470493; +inp[9411] = 0; +inp[9412] = 113171555; +inp[9413] = 0; +inp[9414] = 106314837; +inp[9415] = 0; +inp[9416] = 99873547; +inp[9417] = 0; +inp[9418] = 93822514; +inp[9419] = 0; +inp[9420] = 88138096; +inp[9421] = 0; +inp[9422] = 82798078; +inp[9423] = 0; +inp[9424] = 77781596; +inp[9425] = 0; +inp[9426] = 73069048; +inp[9427] = 0; +inp[9428] = 68642018; +inp[9429] = 0; +inp[9430] = 64483208; +inp[9431] = 0; +inp[9432] = 60576368; +inp[9433] = 0; +inp[9434] = 56906231; +inp[9435] = 0; +inp[9436] = 53458457; +inp[9437] = 0; +inp[9438] = 50219573; +inp[9439] = 0; +inp[9440] = 47176923; +inp[9441] = 0; +inp[9442] = 44318617; +inp[9443] = 0; +inp[9444] = 41633488; +inp[9445] = 0; +inp[9446] = 39111043; +inp[9447] = 0; +inp[9448] = 36741424; +inp[9449] = 0; +inp[9450] = 34515374; +inp[9451] = 0; +inp[9452] = 32424193; +inp[9453] = 0; +inp[9454] = 30459710; +inp[9455] = 0; +inp[9456] = 28614250; +inp[9457] = 0; +inp[9458] = 26880600; +inp[9459] = 0; +inp[9460] = 25251987; +inp[9461] = 0; +inp[9462] = 23722046; +inp[9463] = 0; +inp[9464] = 22284800; +inp[9465] = 0; +inp[9466] = 20934632; +inp[9467] = 0; +inp[9468] = 19666267; +inp[9469] = 0; +inp[9470] = 18474748; +inp[9471] = 0; +inp[9472] = 17355420; +inp[9473] = 0; +inp[9474] = 16303908; +inp[9475] = 0; +inp[9476] = 15316104; +inp[9477] = 0; +inp[9478] = 14388148; +inp[9479] = 0; +inp[9480] = 13516414; +inp[9481] = 0; +inp[9482] = 12697496; +inp[9483] = 0; +inp[9484] = 11928194; +inp[9485] = 0; +inp[9486] = 11205501; +inp[9487] = 0; +inp[9488] = 10526594; +inp[9489] = 0; +inp[9490] = 9888820; +inp[9491] = 0; +inp[9492] = 9289686; +inp[9493] = 0; +inp[9494] = 8726853; +inp[9495] = 0; +inp[9496] = 8198119; +inp[9497] = 0; +inp[9498] = 7701421; +inp[9499] = 0; +inp[9500] = 7234815; +inp[9501] = 0; +inp[9502] = 6796480; +inp[9503] = 0; +inp[9504] = 6384702; +inp[9505] = 0; +inp[9506] = 5997872; +inp[9507] = 0; +inp[9508] = 5634479; +inp[9509] = 0; +inp[9510] = 5293104; +inp[9511] = 0; +inp[9512] = 4972411; +inp[9513] = 0; +inp[9514] = 4671147; +inp[9515] = 0; +inp[9516] = 4388137; +inp[9517] = 0; +inp[9518] = 4122273; +inp[9519] = 0; +inp[9520] = 3872517; +inp[9521] = 0; +inp[9522] = 3637893; +inp[9523] = 0; +inp[9524] = 3417484; +inp[9525] = 0; +inp[9526] = 3210429; +inp[9527] = 0; +inp[9528] = 3015919; +inp[9529] = 0; +inp[9530] = 2833194; +inp[9531] = 0; +inp[9532] = 2661539; +inp[9533] = 0; +inp[9534] = 2500285; +inp[9535] = 0; +inp[9536] = 2348800; +inp[9537] = 0; +inp[9538] = 2206494; +inp[9539] = 0; +inp[9540] = 2072809; +inp[9541] = 0; +inp[9542] = 1947224; +inp[9543] = 0; +inp[9544] = 1829247; +inp[9545] = 0; +inp[9546] = 1718419; +inp[9547] = 0; +inp[9548] = 1614305; +inp[9549] = 0; +inp[9550] = 1516499; +inp[9551] = 0; +inp[9552] = 1424619; +inp[9553] = 0; +inp[9554] = 1338306; +inp[9555] = 0; +inp[9556] = 1257222; +inp[9557] = 0; +inp[9558] = 1181051; +inp[9559] = 0; +inp[9560] = 1109494; +inp[9561] = 0; +inp[9562] = 1042273; +inp[9563] = 0; +inp[9564] = 979125; +inp[9565] = 0; +inp[9566] = 919803; +inp[9567] = 0; +inp[9568] = 864075; +inp[9569] = 0; +inp[9570] = 811723; +inp[9571] = 0; +inp[9572] = 762543; +inp[9573] = 0; +inp[9574] = 716343; +inp[9575] = 0; +inp[9576] = 672942; +inp[9577] = 0; +inp[9578] = 632171; +inp[9579] = 0; +inp[9580] = 593869; +inp[9581] = 0; +inp[9582] = 557889; +inp[9583] = 0; +inp[9584] = 524088; +inp[9585] = 0; +inp[9586] = 492335; +inp[9587] = 0; +inp[9588] = 462506; +inp[9589] = 0; +inp[9590] = 434484; +inp[9591] = 0; +inp[9592] = 408160; +inp[9593] = 0; +inp[9594] = 383431; +inp[9595] = 0; +inp[9596] = 1073741824; +inp[9597] = 1073741824; +inp[9598] = 1040706261; +inp[9599] = 0; +inp[9600] = 1008687095; +inp[9601] = 0; +inp[9602] = 977653056; +inp[9603] = 0; +inp[9604] = 947573833; +inp[9605] = 0; +inp[9606] = 918420051; +inp[9607] = 0; +inp[9608] = 890163237; +inp[9609] = 0; +inp[9610] = 862775793; +inp[9611] = 0; +inp[9612] = 836230973; +inp[9613] = 0; +inp[9614] = 810502851; +inp[9615] = 0; +inp[9616] = 785566299; +inp[9617] = 0; +inp[9618] = 761396965; +inp[9619] = 0; +inp[9620] = 737971243; +inp[9621] = 0; +inp[9622] = 715266255; +inp[9623] = 0; +inp[9624] = 693259826; +inp[9625] = 0; +inp[9626] = 671930463; +inp[9627] = 0; +inp[9628] = 651257336; +inp[9629] = 0; +inp[9630] = 631220255; +inp[9631] = 0; +inp[9632] = 611799649; +inp[9633] = 0; +inp[9634] = 592976553; +inp[9635] = 0; +inp[9636] = 574732582; +inp[9637] = 0; +inp[9638] = 557049919; +inp[9639] = 0; +inp[9640] = 539911295; +inp[9641] = 0; +inp[9642] = 523299971; +inp[9643] = 0; +inp[9644] = 507199723; +inp[9645] = 0; +inp[9646] = 491594828; +inp[9647] = 0; +inp[9648] = 476470046; +inp[9649] = 0; +inp[9650] = 461810603; +inp[9651] = 0; +inp[9652] = 447602185; +inp[9653] = 0; +inp[9654] = 433830913; +inp[9655] = 0; +inp[9656] = 420483339; +inp[9657] = 0; +inp[9658] = 407546427; +inp[9659] = 0; +inp[9660] = 395007542; +inp[9661] = 0; +inp[9662] = 382854437; +inp[9663] = 0; +inp[9664] = 371075245; +inp[9665] = 0; +inp[9666] = 359658459; +inp[9667] = 0; +inp[9668] = 348592932; +inp[9669] = 0; +inp[9670] = 337867855; +inp[9671] = 0; +inp[9672] = 327472754; +inp[9673] = 0; +inp[9674] = 317397476; +inp[9675] = 0; +inp[9676] = 307632183; +inp[9677] = 0; +inp[9678] = 298167335; +inp[9679] = 0; +inp[9680] = 288993691; +inp[9681] = 0; +inp[9682] = 280102290; +inp[9683] = 0; +inp[9684] = 271484448; +inp[9685] = 0; +inp[9686] = 263131750; +inp[9687] = 0; +inp[9688] = 255036037; +inp[9689] = 0; +inp[9690] = 247189403; +inp[9691] = 0; +inp[9692] = 239584185; +inp[9693] = 0; +inp[9694] = 232212954; +inp[9695] = 0; +inp[9696] = 225068513; +inp[9697] = 0; +inp[9698] = 218143882; +inp[9699] = 0; +inp[9700] = 211432301; +inp[9701] = 0; +inp[9702] = 204927213; +inp[9703] = 0; +inp[9704] = 198622265; +inp[9705] = 0; +inp[9706] = 192511301; +inp[9707] = 0; +inp[9708] = 186588351; +inp[9709] = 0; +inp[9710] = 180847630; +inp[9711] = 0; +inp[9712] = 175283534; +inp[9713] = 0; +inp[9714] = 169890626; +inp[9715] = 0; +inp[9716] = 164663641; +inp[9717] = 0; +inp[9718] = 159597474; +inp[9719] = 0; +inp[9720] = 154687176; +inp[9721] = 0; +inp[9722] = 149927952; +inp[9723] = 0; +inp[9724] = 145315153; +inp[9725] = 0; +inp[9726] = 140844276; +inp[9727] = 0; +inp[9728] = 136510953; +inp[9729] = 0; +inp[9730] = 132310953; +inp[9731] = 0; +inp[9732] = 128240173; +inp[9733] = 0; +inp[9734] = 124294637; +inp[9735] = 0; +inp[9736] = 120470493; +inp[9737] = 0; +inp[9738] = 116764006; +inp[9739] = 0; +inp[9740] = 113171555; +inp[9741] = 0; +inp[9742] = 109689632; +inp[9743] = 0; +inp[9744] = 106314837; +inp[9745] = 0; +inp[9746] = 103043874; +inp[9747] = 0; +inp[9748] = 99873547; +inp[9749] = 0; +inp[9750] = 96800761; +inp[9751] = 0; +inp[9752] = 93822514; +inp[9753] = 0; +inp[9754] = 90935899; +inp[9755] = 0; +inp[9756] = 88138096; +inp[9757] = 0; +inp[9758] = 85426372; +inp[9759] = 0; +inp[9760] = 82798078; +inp[9761] = 0; +inp[9762] = 80250649; +inp[9763] = 0; +inp[9764] = 77781596; +inp[9765] = 0; +inp[9766] = 75388508; +inp[9767] = 0; +inp[9768] = 73069048; +inp[9769] = 0; +inp[9770] = 70820949; +inp[9771] = 0; +inp[9772] = 68642018; +inp[9773] = 0; +inp[9774] = 66530125; +inp[9775] = 0; +inp[9776] = 64483208; +inp[9777] = 0; +inp[9778] = 62499268; +inp[9779] = 0; +inp[9780] = 60576368; +inp[9781] = 0; +inp[9782] = 58712629; +inp[9783] = 0; +inp[9784] = 56906231; +inp[9785] = 0; +inp[9786] = 55155411; +inp[9787] = 0; +inp[9788] = 53458457; +inp[9789] = 0; +inp[9790] = 51813713; +inp[9791] = 0; +inp[9792] = 50219573; +inp[9793] = 0; +inp[9794] = 48674479; +inp[9795] = 0; +inp[9796] = 47176923; +inp[9797] = 0; +inp[9798] = 45725441; +inp[9799] = 0; +inp[9800] = 44318617; +inp[9801] = 0; +inp[9802] = 42955077; +inp[9803] = 0; +inp[9804] = 41633488; +inp[9805] = 0; +inp[9806] = 40352560; +inp[9807] = 0; +inp[9808] = 39111043; +inp[9809] = 0; +inp[9810] = 37907722; +inp[9811] = 0; +inp[9812] = 36741424; +inp[9813] = 0; +inp[9814] = 35611009; +inp[9815] = 0; +inp[9816] = 34515374; +inp[9817] = 0; +inp[9818] = 33453447; +inp[9819] = 0; +inp[9820] = 32424193; +inp[9821] = 0; +inp[9822] = 31426605; +inp[9823] = 0; +inp[9824] = 30459710; +inp[9825] = 0; +inp[9826] = 29522564; +inp[9827] = 0; +inp[9828] = 28614250; +inp[9829] = 0; +inp[9830] = 27733882; +inp[9831] = 0; +inp[9832] = 26880600; +inp[9833] = 0; +inp[9834] = 26053571; +inp[9835] = 0; +inp[9836] = 25251987; +inp[9837] = 0; +inp[9838] = 24475065; +inp[9839] = 0; +inp[9840] = 23722046; +inp[9841] = 0; +inp[9842] = 22992196; +inp[9843] = 0; +inp[9844] = 22284800; +inp[9845] = 0; +inp[9846] = 21599169; +inp[9847] = 0; +inp[9848] = 20934632; +inp[9849] = 0; +inp[9850] = 20290541; +inp[9851] = 0; +inp[9852] = 1073741824; +inp[9853] = 1073741824; +inp[9854] = 1057094999; +inp[9855] = 0; +inp[9856] = 1040706261; +inp[9857] = 0; +inp[9858] = 1024571605; +inp[9859] = 0; +inp[9860] = 1008687095; +inp[9861] = 0; +inp[9862] = 993048851; +inp[9863] = 0; +inp[9864] = 977653056; +inp[9865] = 0; +inp[9866] = 962495950; +inp[9867] = 0; +inp[9868] = 947573833; +inp[9869] = 0; +inp[9870] = 932883063; +inp[9871] = 0; +inp[9872] = 918420051; +inp[9873] = 0; +inp[9874] = 904181268; +inp[9875] = 0; +inp[9876] = 890163237; +inp[9877] = 0; +inp[9878] = 876362535; +inp[9879] = 0; +inp[9880] = 862775793; +inp[9881] = 0; +inp[9882] = 849399695; +inp[9883] = 0; +inp[9884] = 836230973; +inp[9885] = 0; +inp[9886] = 823266413; +inp[9887] = 0; +inp[9888] = 810502851; +inp[9889] = 0; +inp[9890] = 797937169; +inp[9891] = 0; +inp[9892] = 785566299; +inp[9893] = 0; +inp[9894] = 773387223; +inp[9895] = 0; +inp[9896] = 761396965; +inp[9897] = 0; +inp[9898] = 749592599; +inp[9899] = 0; +inp[9900] = 737971243; +inp[9901] = 0; +inp[9902] = 726530060; +inp[9903] = 0; +inp[9904] = 715266255; +inp[9905] = 0; +inp[9906] = 704177080; +inp[9907] = 0; +inp[9908] = 693259826; +inp[9909] = 0; +inp[9910] = 682511829; +inp[9911] = 0; +inp[9912] = 671930463; +inp[9913] = 0; +inp[9914] = 661513147; +inp[9915] = 0; +inp[9916] = 651257336; +inp[9917] = 0; +inp[9918] = 641160527; +inp[9919] = 0; +inp[9920] = 631220255; +inp[9921] = 0; +inp[9922] = 621434092; +inp[9923] = 0; +inp[9924] = 611799649; +inp[9925] = 0; +inp[9926] = 602314575; +inp[9927] = 0; +inp[9928] = 592976553; +inp[9929] = 0; +inp[9930] = 583783303; +inp[9931] = 0; +inp[9932] = 574732582; +inp[9933] = 0; +inp[9934] = 565822179; +inp[9935] = 0; +inp[9936] = 557049919; +inp[9937] = 0; +inp[9938] = 548413661; +inp[9939] = 0; +inp[9940] = 539911295; +inp[9941] = 0; +inp[9942] = 531540746; +inp[9943] = 0; +inp[9944] = 523299971; +inp[9945] = 0; +inp[9946] = 515186957; +inp[9947] = 0; +inp[9948] = 507199723; +inp[9949] = 0; +inp[9950] = 499336321; +inp[9951] = 0; +inp[9952] = 491594828; +inp[9953] = 0; +inp[9954] = 483973357; +inp[9955] = 0; +inp[9956] = 476470046; +inp[9957] = 0; +inp[9958] = 469083062; +inp[9959] = 0; +inp[9960] = 461810603; +inp[9961] = 0; +inp[9962] = 454650894; +inp[9963] = 0; +inp[9964] = 447602185; +inp[9965] = 0; +inp[9966] = 440662756; +inp[9967] = 0; +inp[9968] = 433830913; +inp[9969] = 0; +inp[9970] = 427104988; +inp[9971] = 0; +inp[9972] = 420483339; +inp[9973] = 0; +inp[9974] = 413964349; +inp[9975] = 0; +inp[9976] = 407546427; +inp[9977] = 0; +inp[9978] = 401228005; +inp[9979] = 0; +inp[9980] = 395007542; +inp[9981] = 0; +inp[9982] = 388883517; +inp[9983] = 0; +inp[9984] = 382854437; +inp[9985] = 0; +inp[9986] = 376918829; +inp[9987] = 0; +inp[9988] = 371075245; +inp[9989] = 0; +inp[9990] = 365322256; +inp[9991] = 0; +inp[9992] = 359658459; +inp[9993] = 0; +inp[9994] = 354082472; +inp[9995] = 0; +inp[9996] = 348592932; +inp[9997] = 0; +inp[9998] = 343188499; +inp[9999] = 0; +inp[10000] = 337867855; +inp[10001] = 0; +inp[10002] = 332629699; +inp[10003] = 0; +inp[10004] = 327472754; +inp[10005] = 0; +inp[10006] = 322395759; +inp[10007] = 0; +inp[10008] = 317397476; +inp[10009] = 0; +inp[10010] = 312476685; +inp[10011] = 0; +inp[10012] = 307632183; +inp[10013] = 0; +inp[10014] = 302862788; +inp[10015] = 0; +inp[10016] = 298167335; +inp[10017] = 0; +inp[10018] = 293544679; +inp[10019] = 0; +inp[10020] = 288993691; +inp[10021] = 0; +inp[10022] = 284513259; +inp[10023] = 0; +inp[10024] = 280102290; +inp[10025] = 0; +inp[10026] = 275759706; +inp[10027] = 0; +inp[10028] = 271484448; +inp[10029] = 0; +inp[10030] = 267275472; +inp[10031] = 0; +inp[10032] = 263131750; +inp[10033] = 0; +inp[10034] = 259052270; +inp[10035] = 0; +inp[10036] = 255036037; +inp[10037] = 0; +inp[10038] = 251082070; +inp[10039] = 0; +inp[10040] = 247189403; +inp[10041] = 0; +inp[10042] = 243357087; +inp[10043] = 0; +inp[10044] = 239584185; +inp[10045] = 0; +inp[10046] = 235869776; +inp[10047] = 0; +inp[10048] = 232212954; +inp[10049] = 0; +inp[10050] = 228612826; +inp[10051] = 0; +inp[10052] = 225068513; +inp[10053] = 0; +inp[10054] = 221579149; +inp[10055] = 0; +inp[10056] = 218143882; +inp[10057] = 0; +inp[10058] = 214761875; +inp[10059] = 0; +inp[10060] = 211432301; +inp[10061] = 0; +inp[10062] = 208154347; +inp[10063] = 0; +inp[10064] = 204927213; +inp[10065] = 0; +inp[10066] = 201750111; +inp[10067] = 0; +inp[10068] = 198622265; +inp[10069] = 0; +inp[10070] = 195542912; +inp[10071] = 0; +inp[10072] = 192511301; +inp[10073] = 0; +inp[10074] = 189526689; +inp[10075] = 0; +inp[10076] = 186588351; +inp[10077] = 0; +inp[10078] = 183695566; +inp[10079] = 0; +inp[10080] = 180847630; +inp[10081] = 0; +inp[10082] = 178043848; +inp[10083] = 0; +inp[10084] = 175283534; +inp[10085] = 0; +inp[10086] = 172566014; +inp[10087] = 0; +inp[10088] = 169890626; +inp[10089] = 0; +inp[10090] = 167256716; +inp[10091] = 0; +inp[10092] = 164663641; +inp[10093] = 0; +inp[10094] = 162110768; +inp[10095] = 0; +inp[10096] = 159597474; +inp[10097] = 0; +inp[10098] = 157123144; +inp[10099] = 0; +inp[10100] = 154687176; +inp[10101] = 0; +inp[10102] = 152288973; +inp[10103] = 0; +inp[10104] = 149927952; +inp[10105] = 0; +inp[10106] = 147603534; +inp[10107] = 0; +inp[10108] = 1073741824; +inp[10109] = 1073741824; +inp[10110] = 1065385898; +inp[10111] = 0; +inp[10112] = 1057094999; +inp[10113] = 0; +inp[10114] = 1048868621; +inp[10115] = 0; +inp[10116] = 1040706261; +inp[10117] = 0; +inp[10118] = 1032607420; +inp[10119] = 0; +inp[10120] = 1024571605; +inp[10121] = 0; +inp[10122] = 1016598326; +inp[10123] = 0; +inp[10124] = 1008687095; +inp[10125] = 0; +inp[10126] = 1000837430; +inp[10127] = 0; +inp[10128] = 993048851; +inp[10129] = 0; +inp[10130] = 985320884; +inp[10131] = 0; +inp[10132] = 977653056; +inp[10133] = 0; +inp[10134] = 970044899; +inp[10135] = 0; +inp[10136] = 962495950; +inp[10137] = 0; +inp[10138] = 955005747; +inp[10139] = 0; +inp[10140] = 947573833; +inp[10141] = 0; +inp[10142] = 940199755; +inp[10143] = 0; +inp[10144] = 932883063; +inp[10145] = 0; +inp[10146] = 925623309; +inp[10147] = 0; +inp[10148] = 918420051; +inp[10149] = 0; +inp[10150] = 911272850; +inp[10151] = 0; +inp[10152] = 904181268; +inp[10153] = 0; +inp[10154] = 897144874; +inp[10155] = 0; +inp[10156] = 890163237; +inp[10157] = 0; +inp[10158] = 883235932; +inp[10159] = 0; +inp[10160] = 876362535; +inp[10161] = 0; +inp[10162] = 869542628; +inp[10163] = 0; +inp[10164] = 862775793; +inp[10165] = 0; +inp[10166] = 856061619; +inp[10167] = 0; +inp[10168] = 849399695; +inp[10169] = 0; +inp[10170] = 842789614; +inp[10171] = 0; +inp[10172] = 836230973; +inp[10173] = 0; +inp[10174] = 829723372; +inp[10175] = 0; +inp[10176] = 823266413; +inp[10177] = 0; +inp[10178] = 816859703; +inp[10179] = 0; +inp[10180] = 810502851; +inp[10181] = 0; +inp[10182] = 804195467; +inp[10183] = 0; +inp[10184] = 797937169; +inp[10185] = 0; +inp[10186] = 791727572; +inp[10187] = 0; +inp[10188] = 785566299; +inp[10189] = 0; +inp[10190] = 779452974; +inp[10191] = 0; +inp[10192] = 773387223; +inp[10193] = 0; +inp[10194] = 767368676; +inp[10195] = 0; +inp[10196] = 761396965; +inp[10197] = 0; +inp[10198] = 755471727; +inp[10199] = 0; +inp[10200] = 749592599; +inp[10201] = 0; +inp[10202] = 743759224; +inp[10203] = 0; +inp[10204] = 737971243; +inp[10205] = 0; +inp[10206] = 732228306; +inp[10207] = 0; +inp[10208] = 726530060; +inp[10209] = 0; +inp[10210] = 720876158; +inp[10211] = 0; +inp[10212] = 715266255; +inp[10213] = 0; +inp[10214] = 709700009; +inp[10215] = 0; +inp[10216] = 704177080; +inp[10217] = 0; +inp[10218] = 698697130; +inp[10219] = 0; +inp[10220] = 693259826; +inp[10221] = 0; +inp[10222] = 687864835; +inp[10223] = 0; +inp[10224] = 682511829; +inp[10225] = 0; +inp[10226] = 677200479; +inp[10227] = 0; +inp[10228] = 671930463; +inp[10229] = 0; +inp[10230] = 666701459; +inp[10231] = 0; +inp[10232] = 661513147; +inp[10233] = 0; +inp[10234] = 656365211; +inp[10235] = 0; +inp[10236] = 651257336; +inp[10237] = 0; +inp[10238] = 646189212; +inp[10239] = 0; +inp[10240] = 641160527; +inp[10241] = 0; +inp[10242] = 636170976; +inp[10243] = 0; +inp[10244] = 631220255; +inp[10245] = 0; +inp[10246] = 626308060; +inp[10247] = 0; +inp[10248] = 621434092; +inp[10249] = 0; +inp[10250] = 616598053; +inp[10251] = 0; +inp[10252] = 611799649; +inp[10253] = 0; +inp[10254] = 607038586; +inp[10255] = 0; +inp[10256] = 602314575; +inp[10257] = 0; +inp[10258] = 597627325; +inp[10259] = 0; +inp[10260] = 592976553; +inp[10261] = 0; +inp[10262] = 588361972; +inp[10263] = 0; +inp[10264] = 583783303; +inp[10265] = 0; +inp[10266] = 579240266; +inp[10267] = 0; +inp[10268] = 574732582; +inp[10269] = 0; +inp[10270] = 570259978; +inp[10271] = 0; +inp[10272] = 565822179; +inp[10273] = 0; +inp[10274] = 561418916; +inp[10275] = 0; +inp[10276] = 557049919; +inp[10277] = 0; +inp[10278] = 552714923; +inp[10279] = 0; +inp[10280] = 548413661; +inp[10281] = 0; +inp[10282] = 544145872; +inp[10283] = 0; +inp[10284] = 539911295; +inp[10285] = 0; +inp[10286] = 535709672; +inp[10287] = 0; +inp[10288] = 531540746; +inp[10289] = 0; +inp[10290] = 527404264; +inp[10291] = 0; +inp[10292] = 523299971; +inp[10293] = 0; +inp[10294] = 519227618; +inp[10295] = 0; +inp[10296] = 515186957; +inp[10297] = 0; +inp[10298] = 511177740; +inp[10299] = 0; +inp[10300] = 507199723; +inp[10301] = 0; +inp[10302] = 503252664; +inp[10303] = 0; +inp[10304] = 499336321; +inp[10305] = 0; +inp[10306] = 495450454; +inp[10307] = 0; +inp[10308] = 491594828; +inp[10309] = 0; +inp[10310] = 487769207; +inp[10311] = 0; +inp[10312] = 483973357; +inp[10313] = 0; +inp[10314] = 480207047; +inp[10315] = 0; +inp[10316] = 476470046; +inp[10317] = 0; +inp[10318] = 472762126; +inp[10319] = 0; +inp[10320] = 469083062; +inp[10321] = 0; +inp[10322] = 465432629; +inp[10323] = 0; +inp[10324] = 461810603; +inp[10325] = 0; +inp[10326] = 458216765; +inp[10327] = 0; +inp[10328] = 454650894; +inp[10329] = 0; +inp[10330] = 451112772; +inp[10331] = 0; +inp[10332] = 447602185; +inp[10333] = 0; +inp[10334] = 444118917; +inp[10335] = 0; +inp[10336] = 440662756; +inp[10337] = 0; +inp[10338] = 437233491; +inp[10339] = 0; +inp[10340] = 433830913; +inp[10341] = 0; +inp[10342] = 430454814; +inp[10343] = 0; +inp[10344] = 427104988; +inp[10345] = 0; +inp[10346] = 423781231; +inp[10347] = 0; +inp[10348] = 420483339; +inp[10349] = 0; +inp[10350] = 417211112; +inp[10351] = 0; +inp[10352] = 413964349; +inp[10353] = 0; +inp[10354] = 410742853; +inp[10355] = 0; +inp[10356] = 407546427; +inp[10357] = 0; +inp[10358] = 404374876; +inp[10359] = 0; +inp[10360] = 401228005; +inp[10361] = 0; +inp[10362] = 398105624; +inp[10363] = 0; +inp[10364] = 1073741824; +inp[10365] = 1073741824; +inp[10366] = 1069555701; +inp[10367] = 0; +inp[10368] = 1065385898; +inp[10369] = 0; +inp[10370] = 1061232352; +inp[10371] = 0; +inp[10372] = 1057094999; +inp[10373] = 0; +inp[10374] = 1052973777; +inp[10375] = 0; +inp[10376] = 1048868621; +inp[10377] = 0; +inp[10378] = 1044779470; +inp[10379] = 0; +inp[10380] = 1040706261; +inp[10381] = 0; +inp[10382] = 1036648931; +inp[10383] = 0; +inp[10384] = 1032607420; +inp[10385] = 0; +inp[10386] = 1028581665; +inp[10387] = 0; +inp[10388] = 1024571605; +inp[10389] = 0; +inp[10390] = 1020577179; +inp[10391] = 0; +inp[10392] = 1016598326; +inp[10393] = 0; +inp[10394] = 1012634985; +inp[10395] = 0; +inp[10396] = 1008687095; +inp[10397] = 0; +inp[10398] = 1004754597; +inp[10399] = 0; +inp[10400] = 1000837430; +inp[10401] = 0; +inp[10402] = 996935534; +inp[10403] = 0; +inp[10404] = 993048851; +inp[10405] = 0; +inp[10406] = 989177321; +inp[10407] = 0; +inp[10408] = 985320884; +inp[10409] = 0; +inp[10410] = 981479482; +inp[10411] = 0; +inp[10412] = 977653056; +inp[10413] = 0; +inp[10414] = 973841548; +inp[10415] = 0; +inp[10416] = 970044899; +inp[10417] = 0; +inp[10418] = 966263053; +inp[10419] = 0; +inp[10420] = 962495950; +inp[10421] = 0; +inp[10422] = 958743534; +inp[10423] = 0; +inp[10424] = 955005747; +inp[10425] = 0; +inp[10426] = 951282532; +inp[10427] = 0; +inp[10428] = 947573833; +inp[10429] = 0; +inp[10430] = 943879593; +inp[10431] = 0; +inp[10432] = 940199755; +inp[10433] = 0; +inp[10434] = 936534264; +inp[10435] = 0; +inp[10436] = 932883063; +inp[10437] = 0; +inp[10438] = 929246096; +inp[10439] = 0; +inp[10440] = 925623309; +inp[10441] = 0; +inp[10442] = 922014646; +inp[10443] = 0; +inp[10444] = 918420051; +inp[10445] = 0; +inp[10446] = 914839471; +inp[10447] = 0; +inp[10448] = 911272850; +inp[10449] = 0; +inp[10450] = 907720134; +inp[10451] = 0; +inp[10452] = 904181268; +inp[10453] = 0; +inp[10454] = 900656200; +inp[10455] = 0; +inp[10456] = 897144874; +inp[10457] = 0; +inp[10458] = 893647237; +inp[10459] = 0; +inp[10460] = 890163237; +inp[10461] = 0; +inp[10462] = 886692819; +inp[10463] = 0; +inp[10464] = 883235932; +inp[10465] = 0; +inp[10466] = 879792521; +inp[10467] = 0; +inp[10468] = 876362535; +inp[10469] = 0; +inp[10470] = 872945921; +inp[10471] = 0; +inp[10472] = 869542628; +inp[10473] = 0; +inp[10474] = 866152602; +inp[10475] = 0; +inp[10476] = 862775793; +inp[10477] = 0; +inp[10478] = 859412149; +inp[10479] = 0; +inp[10480] = 856061619; +inp[10481] = 0; +inp[10482] = 852724151; +inp[10483] = 0; +inp[10484] = 849399695; +inp[10485] = 0; +inp[10486] = 846088199; +inp[10487] = 0; +inp[10488] = 842789614; +inp[10489] = 0; +inp[10490] = 839503888; +inp[10491] = 0; +inp[10492] = 836230973; +inp[10493] = 0; +inp[10494] = 832970817; +inp[10495] = 0; +inp[10496] = 829723372; +inp[10497] = 0; +inp[10498] = 826488587; +inp[10499] = 0; +inp[10500] = 823266413; +inp[10501] = 0; +inp[10502] = 820056802; +inp[10503] = 0; +inp[10504] = 816859703; +inp[10505] = 0; +inp[10506] = 813675069; +inp[10507] = 0; +inp[10508] = 810502851; +inp[10509] = 0; +inp[10510] = 807342999; +inp[10511] = 0; +inp[10512] = 804195467; +inp[10513] = 0; +inp[10514] = 801060206; +inp[10515] = 0; +inp[10516] = 797937169; +inp[10517] = 0; +inp[10518] = 794826306; +inp[10519] = 0; +inp[10520] = 791727572; +inp[10521] = 0; +inp[10522] = 788640919; +inp[10523] = 0; +inp[10524] = 785566299; +inp[10525] = 0; +inp[10526] = 782503667; +inp[10527] = 0; +inp[10528] = 779452974; +inp[10529] = 0; +inp[10530] = 776414175; +inp[10531] = 0; +inp[10532] = 773387223; +inp[10533] = 0; +inp[10534] = 770372072; +inp[10535] = 0; +inp[10536] = 767368676; +inp[10537] = 0; +inp[10538] = 764376989; +inp[10539] = 0; +inp[10540] = 761396965; +inp[10541] = 0; +inp[10542] = 758428560; +inp[10543] = 0; +inp[10544] = 755471727; +inp[10545] = 0; +inp[10546] = 752526422; +inp[10547] = 0; +inp[10548] = 749592599; +inp[10549] = 0; +inp[10550] = 746670215; +inp[10551] = 0; +inp[10552] = 743759224; +inp[10553] = 0; +inp[10554] = 740859581; +inp[10555] = 0; +inp[10556] = 737971243; +inp[10557] = 0; +inp[10558] = 735094166; +inp[10559] = 0; +inp[10560] = 732228306; +inp[10561] = 0; +inp[10562] = 729373618; +inp[10563] = 0; +inp[10564] = 726530060; +inp[10565] = 0; +inp[10566] = 723697587; +inp[10567] = 0; +inp[10568] = 720876158; +inp[10569] = 0; +inp[10570] = 718065728; +inp[10571] = 0; +inp[10572] = 715266255; +inp[10573] = 0; +inp[10574] = 712477696; +inp[10575] = 0; +inp[10576] = 709700009; +inp[10577] = 0; +inp[10578] = 706933151; +inp[10579] = 0; +inp[10580] = 704177080; +inp[10581] = 0; +inp[10582] = 701431753; +inp[10583] = 0; +inp[10584] = 698697130; +inp[10585] = 0; +inp[10586] = 695973168; +inp[10587] = 0; +inp[10588] = 693259826; +inp[10589] = 0; +inp[10590] = 690557062; +inp[10591] = 0; +inp[10592] = 687864835; +inp[10593] = 0; +inp[10594] = 685183104; +inp[10595] = 0; +inp[10596] = 682511829; +inp[10597] = 0; +inp[10598] = 679850967; +inp[10599] = 0; +inp[10600] = 677200479; +inp[10601] = 0; +inp[10602] = 674560325; +inp[10603] = 0; +inp[10604] = 671930463; +inp[10605] = 0; +inp[10606] = 669310855; +inp[10607] = 0; +inp[10608] = 666701459; +inp[10609] = 0; +inp[10610] = 664102236; +inp[10611] = 0; +inp[10612] = 661513147; +inp[10613] = 0; +inp[10614] = 658934152; +inp[10615] = 0; +inp[10616] = 656365211; +inp[10617] = 0; +inp[10618] = 653806286; +inp[10619] = 0; +inp[10620] = 1073741824; +inp[10621] = 1073741824; +inp[10622] = 1071646718; +inp[10623] = 0; +inp[10624] = 1069555701; +inp[10625] = 0; +inp[10626] = 1067468764; +inp[10627] = 0; +inp[10628] = 1065385898; +inp[10629] = 0; +inp[10630] = 1063307097; +inp[10631] = 0; +inp[10632] = 1061232352; +inp[10633] = 0; +inp[10634] = 1059161656; +inp[10635] = 0; +inp[10636] = 1057094999; +inp[10637] = 0; +inp[10638] = 1055032376; +inp[10639] = 0; +inp[10640] = 1052973777; +inp[10641] = 0; +inp[10642] = 1050919194; +inp[10643] = 0; +inp[10644] = 1048868621; +inp[10645] = 0; +inp[10646] = 1046822049; +inp[10647] = 0; +inp[10648] = 1044779470; +inp[10649] = 0; +inp[10650] = 1042740876; +inp[10651] = 0; +inp[10652] = 1040706261; +inp[10653] = 0; +inp[10654] = 1038675615; +inp[10655] = 0; +inp[10656] = 1036648931; +inp[10657] = 0; +inp[10658] = 1034626202; +inp[10659] = 0; +inp[10660] = 1032607420; +inp[10661] = 0; +inp[10662] = 1030592577; +inp[10663] = 0; +inp[10664] = 1028581665; +inp[10665] = 0; +inp[10666] = 1026574677; +inp[10667] = 0; +inp[10668] = 1024571605; +inp[10669] = 0; +inp[10670] = 1022572442; +inp[10671] = 0; +inp[10672] = 1020577179; +inp[10673] = 0; +inp[10674] = 1018585810; +inp[10675] = 0; +inp[10676] = 1016598326; +inp[10677] = 0; +inp[10678] = 1014614720; +inp[10679] = 0; +inp[10680] = 1012634985; +inp[10681] = 0; +inp[10682] = 1010659112; +inp[10683] = 0; +inp[10684] = 1008687095; +inp[10685] = 0; +inp[10686] = 1006718926; +inp[10687] = 0; +inp[10688] = 1004754597; +inp[10689] = 0; +inp[10690] = 1002794101; +inp[10691] = 0; +inp[10692] = 1000837430; +inp[10693] = 0; +inp[10694] = 998884577; +inp[10695] = 0; +inp[10696] = 996935534; +inp[10697] = 0; +inp[10698] = 994990295; +inp[10699] = 0; +inp[10700] = 993048851; +inp[10701] = 0; +inp[10702] = 991111195; +inp[10703] = 0; +inp[10704] = 989177321; +inp[10705] = 0; +inp[10706] = 987247219; +inp[10707] = 0; +inp[10708] = 985320884; +inp[10709] = 0; +inp[10710] = 983398307; +inp[10711] = 0; +inp[10712] = 981479482; +inp[10713] = 0; +inp[10714] = 979564400; +inp[10715] = 0; +inp[10716] = 977653056; +inp[10717] = 0; +inp[10718] = 975745441; +inp[10719] = 0; +inp[10720] = 973841548; +inp[10721] = 0; +inp[10722] = 971941370; +inp[10723] = 0; +inp[10724] = 970044899; +inp[10725] = 0; +inp[10726] = 968152129; +inp[10727] = 0; +inp[10728] = 966263053; +inp[10729] = 0; +inp[10730] = 964377662; +inp[10731] = 0; +inp[10732] = 962495950; +inp[10733] = 0; +inp[10734] = 960617910; +inp[10735] = 0; +inp[10736] = 958743534; +inp[10737] = 0; +inp[10738] = 956872815; +inp[10739] = 0; +inp[10740] = 955005747; +inp[10741] = 0; +inp[10742] = 953142322; +inp[10743] = 0; +inp[10744] = 951282532; +inp[10745] = 0; +inp[10746] = 949426372; +inp[10747] = 0; +inp[10748] = 947573833; +inp[10749] = 0; +inp[10750] = 945724909; +inp[10751] = 0; +inp[10752] = 943879593; +inp[10753] = 0; +inp[10754] = 942037877; +inp[10755] = 0; +inp[10756] = 940199755; +inp[10757] = 0; +inp[10758] = 938365220; +inp[10759] = 0; +inp[10760] = 936534264; +inp[10761] = 0; +inp[10762] = 934706880; +inp[10763] = 0; +inp[10764] = 932883063; +inp[10765] = 0; +inp[10766] = 931062804; +inp[10767] = 0; +inp[10768] = 929246096; +inp[10769] = 0; +inp[10770] = 927432934; +inp[10771] = 0; +inp[10772] = 925623309; +inp[10773] = 0; +inp[10774] = 923817215; +inp[10775] = 0; +inp[10776] = 922014646; +inp[10777] = 0; +inp[10778] = 920215593; +inp[10779] = 0; +inp[10780] = 918420051; +inp[10781] = 0; +inp[10782] = 916628013; +inp[10783] = 0; +inp[10784] = 914839471; +inp[10785] = 0; +inp[10786] = 913054419; +inp[10787] = 0; +inp[10788] = 911272850; +inp[10789] = 0; +inp[10790] = 909494757; +inp[10791] = 0; +inp[10792] = 907720134; +inp[10793] = 0; +inp[10794] = 905948973; +inp[10795] = 0; +inp[10796] = 904181268; +inp[10797] = 0; +inp[10798] = 902417013; +inp[10799] = 0; +inp[10800] = 900656200; +inp[10801] = 0; +inp[10802] = 898898822; +inp[10803] = 0; +inp[10804] = 897144874; +inp[10805] = 0; +inp[10806] = 895394348; +inp[10807] = 0; +inp[10808] = 893647237; +inp[10809] = 0; +inp[10810] = 891903536; +inp[10811] = 0; +inp[10812] = 890163237; +inp[10813] = 0; +inp[10814] = 888426334; +inp[10815] = 0; +inp[10816] = 886692819; +inp[10817] = 0; +inp[10818] = 884962688; +inp[10819] = 0; +inp[10820] = 883235932; +inp[10821] = 0; +inp[10822] = 881512545; +inp[10823] = 0; +inp[10824] = 879792521; +inp[10825] = 0; +inp[10826] = 878075853; +inp[10827] = 0; +inp[10828] = 876362535; +inp[10829] = 0; +inp[10830] = 874652560; +inp[10831] = 0; +inp[10832] = 872945921; +inp[10833] = 0; +inp[10834] = 871242613; +inp[10835] = 0; +inp[10836] = 869542628; +inp[10837] = 0; +inp[10838] = 867845960; +inp[10839] = 0; +inp[10840] = 866152602; +inp[10841] = 0; +inp[10842] = 864462549; +inp[10843] = 0; +inp[10844] = 862775793; +inp[10845] = 0; +inp[10846] = 861092329; +inp[10847] = 0; +inp[10848] = 859412149; +inp[10849] = 0; +inp[10850] = 857735248; +inp[10851] = 0; +inp[10852] = 856061619; +inp[10853] = 0; +inp[10854] = 854391255; +inp[10855] = 0; +inp[10856] = 852724151; +inp[10857] = 0; +inp[10858] = 851060299; +inp[10859] = 0; +inp[10860] = 849399695; +inp[10861] = 0; +inp[10862] = 847742330; +inp[10863] = 0; +inp[10864] = 846088199; +inp[10865] = 0; +inp[10866] = 844437296; +inp[10867] = 0; +inp[10868] = 842789614; +inp[10869] = 0; +inp[10870] = 841145147; +inp[10871] = 0; +inp[10872] = 839503888; +inp[10873] = 0; +inp[10874] = 837865832; +inp[10875] = 0; +inp[10876] = 1073741824; +inp[10877] = 1073741824; +inp[10878] = 1072693759; +inp[10879] = 0; +inp[10880] = 1071646718; +inp[10881] = 0; +inp[10882] = 1070600699; +inp[10883] = 0; +inp[10884] = 1069555701; +inp[10885] = 0; +inp[10886] = 1068511723; +inp[10887] = 0; +inp[10888] = 1067468764; +inp[10889] = 0; +inp[10890] = 1066426822; +inp[10891] = 0; +inp[10892] = 1065385898; +inp[10893] = 0; +inp[10894] = 1064345990; +inp[10895] = 0; +inp[10896] = 1063307097; +inp[10897] = 0; +inp[10898] = 1062269218; +inp[10899] = 0; +inp[10900] = 1061232352; +inp[10901] = 0; +inp[10902] = 1060196498; +inp[10903] = 0; +inp[10904] = 1059161656; +inp[10905] = 0; +inp[10906] = 1058127823; +inp[10907] = 0; +inp[10908] = 1057094999; +inp[10909] = 0; +inp[10910] = 1056063184; +inp[10911] = 0; +inp[10912] = 1055032376; +inp[10913] = 0; +inp[10914] = 1054002574; +inp[10915] = 0; +inp[10916] = 1052973777; +inp[10917] = 0; +inp[10918] = 1051945984; +inp[10919] = 0; +inp[10920] = 1050919194; +inp[10921] = 0; +inp[10922] = 1049893407; +inp[10923] = 0; +inp[10924] = 1048868621; +inp[10925] = 0; +inp[10926] = 1047844835; +inp[10927] = 0; +inp[10928] = 1046822049; +inp[10929] = 0; +inp[10930] = 1045800261; +inp[10931] = 0; +inp[10932] = 1044779470; +inp[10933] = 0; +inp[10934] = 1043759675; +inp[10935] = 0; +inp[10936] = 1042740876; +inp[10937] = 0; +inp[10938] = 1041723072; +inp[10939] = 0; +inp[10940] = 1040706261; +inp[10941] = 0; +inp[10942] = 1039690442; +inp[10943] = 0; +inp[10944] = 1038675615; +inp[10945] = 0; +inp[10946] = 1037661778; +inp[10947] = 0; +inp[10948] = 1036648931; +inp[10949] = 0; +inp[10950] = 1035637073; +inp[10951] = 0; +inp[10952] = 1034626202; +inp[10953] = 0; +inp[10954] = 1033616318; +inp[10955] = 0; +inp[10956] = 1032607420; +inp[10957] = 0; +inp[10958] = 1031599507; +inp[10959] = 0; +inp[10960] = 1030592577; +inp[10961] = 0; +inp[10962] = 1029586630; +inp[10963] = 0; +inp[10964] = 1028581665; +inp[10965] = 0; +inp[10966] = 1027577681; +inp[10967] = 0; +inp[10968] = 1026574677; +inp[10969] = 0; +inp[10970] = 1025572652; +inp[10971] = 0; +inp[10972] = 1024571605; +inp[10973] = 0; +inp[10974] = 1023571536; +inp[10975] = 0; +inp[10976] = 1022572442; +inp[10977] = 0; +inp[10978] = 1021574324; +inp[10979] = 0; +inp[10980] = 1020577179; +inp[10981] = 0; +inp[10982] = 1019581008; +inp[10983] = 0; +inp[10984] = 1018585810; +inp[10985] = 0; +inp[10986] = 1017591583; +inp[10987] = 0; +inp[10988] = 1016598326; +inp[10989] = 0; +inp[10990] = 1015606039; +inp[10991] = 0; +inp[10992] = 1014614720; +inp[10993] = 0; +inp[10994] = 1013624369; +inp[10995] = 0; +inp[10996] = 1012634985; +inp[10997] = 0; +inp[10998] = 1011646566; +inp[10999] = 0; +inp[11000] = 1010659112; +inp[11001] = 0; +inp[11002] = 1009672622; +inp[11003] = 0; +inp[11004] = 1008687095; +inp[11005] = 0; +inp[11006] = 1007702530; +inp[11007] = 0; +inp[11008] = 1006718926; +inp[11009] = 0; +inp[11010] = 1005736282; +inp[11011] = 0; +inp[11012] = 1004754597; +inp[11013] = 0; +inp[11014] = 1003773870; +inp[11015] = 0; +inp[11016] = 1002794101; +inp[11017] = 0; +inp[11018] = 1001815287; +inp[11019] = 0; +inp[11020] = 1000837430; +inp[11021] = 0; +inp[11022] = 999860527; +inp[11023] = 0; +inp[11024] = 998884577; +inp[11025] = 0; +inp[11026] = 997909580; +inp[11027] = 0; +inp[11028] = 996935534; +inp[11029] = 0; +inp[11030] = 995962440; +inp[11031] = 0; +inp[11032] = 994990295; +inp[11033] = 0; +inp[11034] = 994019099; +inp[11035] = 0; +inp[11036] = 993048851; +inp[11037] = 0; +inp[11038] = 992079550; +inp[11039] = 0; +inp[11040] = 991111195; +inp[11041] = 0; +inp[11042] = 990143786; +inp[11043] = 0; +inp[11044] = 989177321; +inp[11045] = 0; +inp[11046] = 988211799; +inp[11047] = 0; +inp[11048] = 987247219; +inp[11049] = 0; +inp[11050] = 986283581; +inp[11051] = 0; +inp[11052] = 985320884; +inp[11053] = 0; +inp[11054] = 984359126; +inp[11055] = 0; +inp[11056] = 983398307; +inp[11057] = 0; +inp[11058] = 982438426; +inp[11059] = 0; +inp[11060] = 981479482; +inp[11061] = 0; +inp[11062] = 980521473; +inp[11063] = 0; +inp[11064] = 979564400; +inp[11065] = 0; +inp[11066] = 978608261; +inp[11067] = 0; +inp[11068] = 977653056; +inp[11069] = 0; +inp[11070] = 976698782; +inp[11071] = 0; +inp[11072] = 975745441; +inp[11073] = 0; +inp[11074] = 974793029; +inp[11075] = 0; +inp[11076] = 973841548; +inp[11077] = 0; +inp[11078] = 972890995; +inp[11079] = 0; +inp[11080] = 971941370; +inp[11081] = 0; +inp[11082] = 970992671; +inp[11083] = 0; +inp[11084] = 970044899; +inp[11085] = 0; +inp[11086] = 969098052; +inp[11087] = 0; +inp[11088] = 968152129; +inp[11089] = 0; +inp[11090] = 967207130; +inp[11091] = 0; +inp[11092] = 966263053; +inp[11093] = 0; +inp[11094] = 965319897; +inp[11095] = 0; +inp[11096] = 964377662; +inp[11097] = 0; +inp[11098] = 963436347; +inp[11099] = 0; +inp[11100] = 962495950; +inp[11101] = 0; +inp[11102] = 961556471; +inp[11103] = 0; +inp[11104] = 960617910; +inp[11105] = 0; +inp[11106] = 959680264; +inp[11107] = 0; +inp[11108] = 958743534; +inp[11109] = 0; +inp[11110] = 957807718; +inp[11111] = 0; +inp[11112] = 956872815; +inp[11113] = 0; +inp[11114] = 955938825; +inp[11115] = 0; +inp[11116] = 955005747; +inp[11117] = 0; +inp[11118] = 954073579; +inp[11119] = 0; +inp[11120] = 953142322; +inp[11121] = 0; +inp[11122] = 952211973; +inp[11123] = 0; +inp[11124] = 951282532; +inp[11125] = 0; +inp[11126] = 950353999; +inp[11127] = 0; +inp[11128] = 949426372; +inp[11129] = 0; +inp[11130] = 948499650; +inp[11131] = 0; +inp[11132] = 1073741824; +inp[11133] = 1073741824; +inp[11134] = 1073217663; +inp[11135] = 0; +inp[11136] = 1072693759; +inp[11137] = 0; +inp[11138] = 1072170111; +inp[11139] = 0; +inp[11140] = 1071646718; +inp[11141] = 0; +inp[11142] = 1071123581; +inp[11143] = 0; +inp[11144] = 1070600699; +inp[11145] = 0; +inp[11146] = 1070078072; +inp[11147] = 0; +inp[11148] = 1069555701; +inp[11149] = 0; +inp[11150] = 1069033584; +inp[11151] = 0; +inp[11152] = 1068511723; +inp[11153] = 0; +inp[11154] = 1067990116; +inp[11155] = 0; +inp[11156] = 1067468764; +inp[11157] = 0; +inp[11158] = 1066947666; +inp[11159] = 0; +inp[11160] = 1066426822; +inp[11161] = 0; +inp[11162] = 1065906233; +inp[11163] = 0; +inp[11164] = 1065385898; +inp[11165] = 0; +inp[11166] = 1064865817; +inp[11167] = 0; +inp[11168] = 1064345990; +inp[11169] = 0; +inp[11170] = 1063826417; +inp[11171] = 0; +inp[11172] = 1063307097; +inp[11173] = 0; +inp[11174] = 1062788031; +inp[11175] = 0; +inp[11176] = 1062269218; +inp[11177] = 0; +inp[11178] = 1061750659; +inp[11179] = 0; +inp[11180] = 1061232352; +inp[11181] = 0; +inp[11182] = 1060714299; +inp[11183] = 0; +inp[11184] = 1060196498; +inp[11185] = 0; +inp[11186] = 1059678951; +inp[11187] = 0; +inp[11188] = 1059161656; +inp[11189] = 0; +inp[11190] = 1058644613; +inp[11191] = 0; +inp[11192] = 1058127823; +inp[11193] = 0; +inp[11194] = 1057611285; +inp[11195] = 0; +inp[11196] = 1057094999; +inp[11197] = 0; +inp[11198] = 1056578966; +inp[11199] = 0; +inp[11200] = 1056063184; +inp[11201] = 0; +inp[11202] = 1055547654; +inp[11203] = 0; +inp[11204] = 1055032376; +inp[11205] = 0; +inp[11206] = 1054517349; +inp[11207] = 0; +inp[11208] = 1054002574; +inp[11209] = 0; +inp[11210] = 1053488050; +inp[11211] = 0; +inp[11212] = 1052973777; +inp[11213] = 0; +inp[11214] = 1052459755; +inp[11215] = 0; +inp[11216] = 1051945984; +inp[11217] = 0; +inp[11218] = 1051432464; +inp[11219] = 0; +inp[11220] = 1050919194; +inp[11221] = 0; +inp[11222] = 1050406175; +inp[11223] = 0; +inp[11224] = 1049893407; +inp[11225] = 0; +inp[11226] = 1049380889; +inp[11227] = 0; +inp[11228] = 1048868621; +inp[11229] = 0; +inp[11230] = 1048356603; +inp[11231] = 0; +inp[11232] = 1047844835; +inp[11233] = 0; +inp[11234] = 1047333317; +inp[11235] = 0; +inp[11236] = 1046822049; +inp[11237] = 0; +inp[11238] = 1046311030; +inp[11239] = 0; +inp[11240] = 1045800261; +inp[11241] = 0; +inp[11242] = 1045289741; +inp[11243] = 0; +inp[11244] = 1044779470; +inp[11245] = 0; +inp[11246] = 1044269448; +inp[11247] = 0; +inp[11248] = 1043759675; +inp[11249] = 0; +inp[11250] = 1043250151; +inp[11251] = 0; +inp[11252] = 1042740876; +inp[11253] = 0; +inp[11254] = 1042231850; +inp[11255] = 0; +inp[11256] = 1041723072; +inp[11257] = 0; +inp[11258] = 1041214542; +inp[11259] = 0; +inp[11260] = 1040706261; +inp[11261] = 0; +inp[11262] = 1040198227; +inp[11263] = 0; +inp[11264] = 1039690442; +inp[11265] = 0; +inp[11266] = 1039182905; +inp[11267] = 0; +inp[11268] = 1038675615; +inp[11269] = 0; +inp[11270] = 1038168573; +inp[11271] = 0; +inp[11272] = 1037661778; +inp[11273] = 0; +inp[11274] = 1037155231; +inp[11275] = 0; +inp[11276] = 1036648931; +inp[11277] = 0; +inp[11278] = 1036142879; +inp[11279] = 0; +inp[11280] = 1035637073; +inp[11281] = 0; +inp[11282] = 1035131514; +inp[11283] = 0; +inp[11284] = 1034626202; +inp[11285] = 0; +inp[11286] = 1034121137; +inp[11287] = 0; +inp[11288] = 1033616318; +inp[11289] = 0; +inp[11290] = 1033111746; +inp[11291] = 0; +inp[11292] = 1032607420; +inp[11293] = 0; +inp[11294] = 1032103340; +inp[11295] = 0; +inp[11296] = 1031599507; +inp[11297] = 0; +inp[11298] = 1031095919; +inp[11299] = 0; +inp[11300] = 1030592577; +inp[11301] = 0; +inp[11302] = 1030089481; +inp[11303] = 0; +inp[11304] = 1029586630; +inp[11305] = 0; +inp[11306] = 1029084025; +inp[11307] = 0; +inp[11308] = 1028581665; +inp[11309] = 0; +inp[11310] = 1028079551; +inp[11311] = 0; +inp[11312] = 1027577681; +inp[11313] = 0; +inp[11314] = 1027076057; +inp[11315] = 0; +inp[11316] = 1026574677; +inp[11317] = 0; +inp[11318] = 1026073543; +inp[11319] = 0; +inp[11320] = 1025572652; +inp[11321] = 0; +inp[11322] = 1025072007; +inp[11323] = 0; +inp[11324] = 1024571605; +inp[11325] = 0; +inp[11326] = 1024071449; +inp[11327] = 0; +inp[11328] = 1023571536; +inp[11329] = 0; +inp[11330] = 1023071867; +inp[11331] = 0; +inp[11332] = 1022572442; +inp[11333] = 0; +inp[11334] = 1022073261; +inp[11335] = 0; +inp[11336] = 1021574324; +inp[11337] = 0; +inp[11338] = 1021075630; +inp[11339] = 0; +inp[11340] = 1020577179; +inp[11341] = 0; +inp[11342] = 1020078972; +inp[11343] = 0; +inp[11344] = 1019581008; +inp[11345] = 0; +inp[11346] = 1019083288; +inp[11347] = 0; +inp[11348] = 1018585810; +inp[11349] = 0; +inp[11350] = 1018088575; +inp[11351] = 0; +inp[11352] = 1017591583; +inp[11353] = 0; +inp[11354] = 1017094833; +inp[11355] = 0; +inp[11356] = 1016598326; +inp[11357] = 0; +inp[11358] = 1016102061; +inp[11359] = 0; +inp[11360] = 1015606039; +inp[11361] = 0; +inp[11362] = 1015110258; +inp[11363] = 0; +inp[11364] = 1014614720; +inp[11365] = 0; +inp[11366] = 1014119424; +inp[11367] = 0; +inp[11368] = 1013624369; +inp[11369] = 0; +inp[11370] = 1013129556; +inp[11371] = 0; +inp[11372] = 1012634985; +inp[11373] = 0; +inp[11374] = 1012140655; +inp[11375] = 0; +inp[11376] = 1011646566; +inp[11377] = 0; +inp[11378] = 1011152719; +inp[11379] = 0; +inp[11380] = 1010659112; +inp[11381] = 0; +inp[11382] = 1010165747; +inp[11383] = 0; +inp[11384] = 1009672622; +inp[11385] = 0; +inp[11386] = 1009179738; +inp[11387] = 0; +inp[11388] = 1073741824; +inp[11389] = 1073741824; +inp[11390] = 1073479711; +inp[11391] = 0; +inp[11392] = 1073217663; +inp[11393] = 0; +inp[11394] = 1072955679; +inp[11395] = 0; +inp[11396] = 1072693759; +inp[11397] = 0; +inp[11398] = 1072431903; +inp[11399] = 0; +inp[11400] = 1072170111; +inp[11401] = 0; +inp[11402] = 1071908383; +inp[11403] = 0; +inp[11404] = 1071646718; +inp[11405] = 0; +inp[11406] = 1071385118; +inp[11407] = 0; +inp[11408] = 1071123581; +inp[11409] = 0; +inp[11410] = 1070862108; +inp[11411] = 0; +inp[11412] = 1070600699; +inp[11413] = 0; +inp[11414] = 1070339354; +inp[11415] = 0; +inp[11416] = 1070078072; +inp[11417] = 0; +inp[11418] = 1069816855; +inp[11419] = 0; +inp[11420] = 1069555701; +inp[11421] = 0; +inp[11422] = 1069294611; +inp[11423] = 0; +inp[11424] = 1069033584; +inp[11425] = 0; +inp[11426] = 1068772622; +inp[11427] = 0; +inp[11428] = 1068511723; +inp[11429] = 0; +inp[11430] = 1068250887; +inp[11431] = 0; +inp[11432] = 1067990116; +inp[11433] = 0; +inp[11434] = 1067729408; +inp[11435] = 0; +inp[11436] = 1067468764; +inp[11437] = 0; +inp[11438] = 1067208183; +inp[11439] = 0; +inp[11440] = 1066947666; +inp[11441] = 0; +inp[11442] = 1066687212; +inp[11443] = 0; +inp[11444] = 1066426822; +inp[11445] = 0; +inp[11446] = 1066166496; +inp[11447] = 0; +inp[11448] = 1065906233; +inp[11449] = 0; +inp[11450] = 1065646034; +inp[11451] = 0; +inp[11452] = 1065385898; +inp[11453] = 0; +inp[11454] = 1065125826; +inp[11455] = 0; +inp[11456] = 1064865817; +inp[11457] = 0; +inp[11458] = 1064605872; +inp[11459] = 0; +inp[11460] = 1064345990; +inp[11461] = 0; +inp[11462] = 1064086172; +inp[11463] = 0; +inp[11464] = 1063826417; +inp[11465] = 0; +inp[11466] = 1063566725; +inp[11467] = 0; +inp[11468] = 1063307097; +inp[11469] = 0; +inp[11470] = 1063047532; +inp[11471] = 0; +inp[11472] = 1062788031; +inp[11473] = 0; +inp[11474] = 1062528593; +inp[11475] = 0; +inp[11476] = 1062269218; +inp[11477] = 0; +inp[11478] = 1062009907; +inp[11479] = 0; +inp[11480] = 1061750659; +inp[11481] = 0; +inp[11482] = 1061491474; +inp[11483] = 0; +inp[11484] = 1061232352; +inp[11485] = 0; +inp[11486] = 1060973294; +inp[11487] = 0; +inp[11488] = 1060714299; +inp[11489] = 0; +inp[11490] = 1060455367; +inp[11491] = 0; +inp[11492] = 1060196498; +inp[11493] = 0; +inp[11494] = 1059937693; +inp[11495] = 0; +inp[11496] = 1059678951; +inp[11497] = 0; +inp[11498] = 1059420272; +inp[11499] = 0; +inp[11500] = 1059161656; +inp[11501] = 0; +inp[11502] = 1058903103; +inp[11503] = 0; +inp[11504] = 1058644613; +inp[11505] = 0; +inp[11506] = 1058386187; +inp[11507] = 0; +inp[11508] = 1058127823; +inp[11509] = 0; +inp[11510] = 1057869523; +inp[11511] = 0; +inp[11512] = 1057611285; +inp[11513] = 0; +inp[11514] = 1057353111; +inp[11515] = 0; +inp[11516] = 1057094999; +inp[11517] = 0; +inp[11518] = 1056836951; +inp[11519] = 0; +inp[11520] = 1056578966; +inp[11521] = 0; +inp[11522] = 1056321043; +inp[11523] = 0; +inp[11524] = 1056063184; +inp[11525] = 0; +inp[11526] = 1055805388; +inp[11527] = 0; +inp[11528] = 1055547654; +inp[11529] = 0; +inp[11530] = 1055289983; +inp[11531] = 0; +inp[11532] = 1055032376; +inp[11533] = 0; +inp[11534] = 1054774831; +inp[11535] = 0; +inp[11536] = 1054517349; +inp[11537] = 0; +inp[11538] = 1054259930; +inp[11539] = 0; +inp[11540] = 1054002574; +inp[11541] = 0; +inp[11542] = 1053745280; +inp[11543] = 0; +inp[11544] = 1053488050; +inp[11545] = 0; +inp[11546] = 1053230882; +inp[11547] = 0; +inp[11548] = 1052973777; +inp[11549] = 0; +inp[11550] = 1052716734; +inp[11551] = 0; +inp[11552] = 1052459755; +inp[11553] = 0; +inp[11554] = 1052202838; +inp[11555] = 0; +inp[11556] = 1051945984; +inp[11557] = 0; +inp[11558] = 1051689192; +inp[11559] = 0; +inp[11560] = 1051432464; +inp[11561] = 0; +inp[11562] = 1051175798; +inp[11563] = 0; +inp[11564] = 1050919194; +inp[11565] = 0; +inp[11566] = 1050662654; +inp[11567] = 0; +inp[11568] = 1050406175; +inp[11569] = 0; +inp[11570] = 1050149760; +inp[11571] = 0; +inp[11572] = 1049893407; +inp[11573] = 0; +inp[11574] = 1049637117; +inp[11575] = 0; +inp[11576] = 1049380889; +inp[11577] = 0; +inp[11578] = 1049124724; +inp[11579] = 0; +inp[11580] = 1048868621; +inp[11581] = 0; +inp[11582] = 1048612581; +inp[11583] = 0; +inp[11584] = 1048356603; +inp[11585] = 0; +inp[11586] = 1048100688; +inp[11587] = 0; +inp[11588] = 1047844835; +inp[11589] = 0; +inp[11590] = 1047589045; +inp[11591] = 0; +inp[11592] = 1047333317; +inp[11593] = 0; +inp[11594] = 1047077652; +inp[11595] = 0; +inp[11596] = 1046822049; +inp[11597] = 0; +inp[11598] = 1046566508; +inp[11599] = 0; +inp[11600] = 1046311030; +inp[11601] = 0; +inp[11602] = 1046055614; +inp[11603] = 0; +inp[11604] = 1045800261; +inp[11605] = 0; +inp[11606] = 1045544969; +inp[11607] = 0; +inp[11608] = 1045289741; +inp[11609] = 0; +inp[11610] = 1045034574; +inp[11611] = 0; +inp[11612] = 1044779470; +inp[11613] = 0; +inp[11614] = 1044524428; +inp[11615] = 0; +inp[11616] = 1044269448; +inp[11617] = 0; +inp[11618] = 1044014531; +inp[11619] = 0; +inp[11620] = 1043759675; +inp[11621] = 0; +inp[11622] = 1043504882; +inp[11623] = 0; +inp[11624] = 1043250151; +inp[11625] = 0; +inp[11626] = 1042995483; +inp[11627] = 0; +inp[11628] = 1042740876; +inp[11629] = 0; +inp[11630] = 1042486332; +inp[11631] = 0; +inp[11632] = 1042231850; +inp[11633] = 0; +inp[11634] = 1041977430; +inp[11635] = 0; +inp[11636] = 1041723072; +inp[11637] = 0; +inp[11638] = 1041468776; +inp[11639] = 0; +inp[11640] = 1041214542; +inp[11641] = 0; +inp[11642] = 1040960370; +inp[11643] = 0; +inp[11644] = 1073741824; +inp[11645] = 1073741824; +inp[11646] = 1073610759; +inp[11647] = 0; +inp[11648] = 1073479711; +inp[11649] = 0; +inp[11650] = 1073348679; +inp[11651] = 0; +inp[11652] = 1073217663; +inp[11653] = 0; +inp[11654] = 1073086663; +inp[11655] = 0; +inp[11656] = 1072955679; +inp[11657] = 0; +inp[11658] = 1072824711; +inp[11659] = 0; +inp[11660] = 1072693759; +inp[11661] = 0; +inp[11662] = 1072562823; +inp[11663] = 0; +inp[11664] = 1072431903; +inp[11665] = 0; +inp[11666] = 1072300999; +inp[11667] = 0; +inp[11668] = 1072170111; +inp[11669] = 0; +inp[11670] = 1072039239; +inp[11671] = 0; +inp[11672] = 1071908383; +inp[11673] = 0; +inp[11674] = 1071777542; +inp[11675] = 0; +inp[11676] = 1071646718; +inp[11677] = 0; +inp[11678] = 1071515910; +inp[11679] = 0; +inp[11680] = 1071385118; +inp[11681] = 0; +inp[11682] = 1071254341; +inp[11683] = 0; +inp[11684] = 1071123581; +inp[11685] = 0; +inp[11686] = 1070992836; +inp[11687] = 0; +inp[11688] = 1070862108; +inp[11689] = 0; +inp[11690] = 1070731396; +inp[11691] = 0; +inp[11692] = 1070600699; +inp[11693] = 0; +inp[11694] = 1070470018; +inp[11695] = 0; +inp[11696] = 1070339354; +inp[11697] = 0; +inp[11698] = 1070208705; +inp[11699] = 0; +inp[11700] = 1070078072; +inp[11701] = 0; +inp[11702] = 1069947456; +inp[11703] = 0; +inp[11704] = 1069816855; +inp[11705] = 0; +inp[11706] = 1069686270; +inp[11707] = 0; +inp[11708] = 1069555701; +inp[11709] = 0; +inp[11710] = 1069425148; +inp[11711] = 0; +inp[11712] = 1069294611; +inp[11713] = 0; +inp[11714] = 1069164090; +inp[11715] = 0; +inp[11716] = 1069033584; +inp[11717] = 0; +inp[11718] = 1068903095; +inp[11719] = 0; +inp[11720] = 1068772622; +inp[11721] = 0; +inp[11722] = 1068642164; +inp[11723] = 0; +inp[11724] = 1068511723; +inp[11725] = 0; +inp[11726] = 1068381297; +inp[11727] = 0; +inp[11728] = 1068250887; +inp[11729] = 0; +inp[11730] = 1068120494; +inp[11731] = 0; +inp[11732] = 1067990116; +inp[11733] = 0; +inp[11734] = 1067859754; +inp[11735] = 0; +inp[11736] = 1067729408; +inp[11737] = 0; +inp[11738] = 1067599078; +inp[11739] = 0; +inp[11740] = 1067468764; +inp[11741] = 0; +inp[11742] = 1067338465; +inp[11743] = 0; +inp[11744] = 1067208183; +inp[11745] = 0; +inp[11746] = 1067077916; +inp[11747] = 0; +inp[11748] = 1066947666; +inp[11749] = 0; +inp[11750] = 1066817431; +inp[11751] = 0; +inp[11752] = 1066687212; +inp[11753] = 0; +inp[11754] = 1066557009; +inp[11755] = 0; +inp[11756] = 1066426822; +inp[11757] = 0; +inp[11758] = 1066296651; +inp[11759] = 0; +inp[11760] = 1066166496; +inp[11761] = 0; +inp[11762] = 1066036357; +inp[11763] = 0; +inp[11764] = 1065906233; +inp[11765] = 0; +inp[11766] = 1065776126; +inp[11767] = 0; +inp[11768] = 1065646034; +inp[11769] = 0; +inp[11770] = 1065515958; +inp[11771] = 0; +inp[11772] = 1065385898; +inp[11773] = 0; +inp[11774] = 1065255854; +inp[11775] = 0; +inp[11776] = 1065125826; +inp[11777] = 0; +inp[11778] = 1064995814; +inp[11779] = 0; +inp[11780] = 1064865817; +inp[11781] = 0; +inp[11782] = 1064735837; +inp[11783] = 0; +inp[11784] = 1064605872; +inp[11785] = 0; +inp[11786] = 1064475923; +inp[11787] = 0; +inp[11788] = 1064345990; +inp[11789] = 0; +inp[11790] = 1064216073; +inp[11791] = 0; +inp[11792] = 1064086172; +inp[11793] = 0; +inp[11794] = 1063956286; +inp[11795] = 0; +inp[11796] = 1063826417; +inp[11797] = 0; +inp[11798] = 1063696563; +inp[11799] = 0; +inp[11800] = 1063566725; +inp[11801] = 0; +inp[11802] = 1063436903; +inp[11803] = 0; +inp[11804] = 1063307097; +inp[11805] = 0; +inp[11806] = 1063177307; +inp[11807] = 0; +inp[11808] = 1063047532; +inp[11809] = 0; +inp[11810] = 1062917774; +inp[11811] = 0; +inp[11812] = 1062788031; +inp[11813] = 0; +inp[11814] = 1062658304; +inp[11815] = 0; +inp[11816] = 1062528593; +inp[11817] = 0; +inp[11818] = 1062398898; +inp[11819] = 0; +inp[11820] = 1062269218; +inp[11821] = 0; +inp[11822] = 1062139555; +inp[11823] = 0; +inp[11824] = 1062009907; +inp[11825] = 0; +inp[11826] = 1061880275; +inp[11827] = 0; +inp[11828] = 1061750659; +inp[11829] = 0; +inp[11830] = 1061621058; +inp[11831] = 0; +inp[11832] = 1061491474; +inp[11833] = 0; +inp[11834] = 1061361905; +inp[11835] = 0; +inp[11836] = 1061232352; +inp[11837] = 0; +inp[11838] = 1061102815; +inp[11839] = 0; +inp[11840] = 1060973294; +inp[11841] = 0; +inp[11842] = 1060843789; +inp[11843] = 0; +inp[11844] = 1060714299; +inp[11845] = 0; +inp[11846] = 1060584825; +inp[11847] = 0; +inp[11848] = 1060455367; +inp[11849] = 0; +inp[11850] = 1060325925; +inp[11851] = 0; +inp[11852] = 1060196498; +inp[11853] = 0; +inp[11854] = 1060067088; +inp[11855] = 0; +inp[11856] = 1059937693; +inp[11857] = 0; +inp[11858] = 1059808314; +inp[11859] = 0; +inp[11860] = 1059678951; +inp[11861] = 0; +inp[11862] = 1059549603; +inp[11863] = 0; +inp[11864] = 1059420272; +inp[11865] = 0; +inp[11866] = 1059290956; +inp[11867] = 0; +inp[11868] = 1059161656; +inp[11869] = 0; +inp[11870] = 1059032371; +inp[11871] = 0; +inp[11872] = 1058903103; +inp[11873] = 0; +inp[11874] = 1058773850; +inp[11875] = 0; +inp[11876] = 1058644613; +inp[11877] = 0; +inp[11878] = 1058515392; +inp[11879] = 0; +inp[11880] = 1058386187; +inp[11881] = 0; +inp[11882] = 1058256997; +inp[11883] = 0; +inp[11884] = 1058127823; +inp[11885] = 0; +inp[11886] = 1057998665; +inp[11887] = 0; +inp[11888] = 1057869523; +inp[11889] = 0; +inp[11890] = 1057740396; +inp[11891] = 0; +inp[11892] = 1057611285; +inp[11893] = 0; +inp[11894] = 1057482190; +inp[11895] = 0; +inp[11896] = 1057353111; +inp[11897] = 0; +inp[11898] = 1057224047; +inp[11899] = 0; +inp[11900] = 1073741824; +inp[11901] = 1073741824; +inp[11902] = 1073676289; +inp[11903] = 0; +inp[11904] = 1073610759; +inp[11905] = 0; +inp[11906] = 1073545233; +inp[11907] = 0; +inp[11908] = 1073479711; +inp[11909] = 0; +inp[11910] = 1073414193; +inp[11911] = 0; +inp[11912] = 1073348679; +inp[11913] = 0; +inp[11914] = 1073283169; +inp[11915] = 0; +inp[11916] = 1073217663; +inp[11917] = 0; +inp[11918] = 1073152161; +inp[11919] = 0; +inp[11920] = 1073086663; +inp[11921] = 0; +inp[11922] = 1073021169; +inp[11923] = 0; +inp[11924] = 1072955679; +inp[11925] = 0; +inp[11926] = 1072890193; +inp[11927] = 0; +inp[11928] = 1072824711; +inp[11929] = 0; +inp[11930] = 1072759233; +inp[11931] = 0; +inp[11932] = 1072693759; +inp[11933] = 0; +inp[11934] = 1072628289; +inp[11935] = 0; +inp[11936] = 1072562823; +inp[11937] = 0; +inp[11938] = 1072497361; +inp[11939] = 0; +inp[11940] = 1072431903; +inp[11941] = 0; +inp[11942] = 1072366449; +inp[11943] = 0; +inp[11944] = 1072300999; +inp[11945] = 0; +inp[11946] = 1072235553; +inp[11947] = 0; +inp[11948] = 1072170111; +inp[11949] = 0; +inp[11950] = 1072104673; +inp[11951] = 0; +inp[11952] = 1072039239; +inp[11953] = 0; +inp[11954] = 1071973809; +inp[11955] = 0; +inp[11956] = 1071908383; +inp[11957] = 0; +inp[11958] = 1071842961; +inp[11959] = 0; +inp[11960] = 1071777542; +inp[11961] = 0; +inp[11962] = 1071712128; +inp[11963] = 0; +inp[11964] = 1071646718; +inp[11965] = 0; +inp[11966] = 1071581312; +inp[11967] = 0; +inp[11968] = 1071515910; +inp[11969] = 0; +inp[11970] = 1071450512; +inp[11971] = 0; +inp[11972] = 1071385118; +inp[11973] = 0; +inp[11974] = 1071319727; +inp[11975] = 0; +inp[11976] = 1071254341; +inp[11977] = 0; +inp[11978] = 1071188959; +inp[11979] = 0; +inp[11980] = 1071123581; +inp[11981] = 0; +inp[11982] = 1071058207; +inp[11983] = 0; +inp[11984] = 1070992836; +inp[11985] = 0; +inp[11986] = 1070927470; +inp[11987] = 0; +inp[11988] = 1070862108; +inp[11989] = 0; +inp[11990] = 1070796750; +inp[11991] = 0; +inp[11992] = 1070731396; +inp[11993] = 0; +inp[11994] = 1070666045; +inp[11995] = 0; +inp[11996] = 1070600699; +inp[11997] = 0; +inp[11998] = 1070535357; +inp[11999] = 0; +inp[12000] = 1070470018; +inp[12001] = 0; +inp[12002] = 1070404684; +inp[12003] = 0; +inp[12004] = 1070339354; +inp[12005] = 0; +inp[12006] = 1070274027; +inp[12007] = 0; +inp[12008] = 1070208705; +inp[12009] = 0; +inp[12010] = 1070143387; +inp[12011] = 0; +inp[12012] = 1070078072; +inp[12013] = 0; +inp[12014] = 1070012762; +inp[12015] = 0; +inp[12016] = 1069947456; +inp[12017] = 0; +inp[12018] = 1069882153; +inp[12019] = 0; +inp[12020] = 1069816855; +inp[12021] = 0; +inp[12022] = 1069751560; +inp[12023] = 0; +inp[12024] = 1069686270; +inp[12025] = 0; +inp[12026] = 1069620983; +inp[12027] = 0; +inp[12028] = 1069555701; +inp[12029] = 0; +inp[12030] = 1069490422; +inp[12031] = 0; +inp[12032] = 1069425148; +inp[12033] = 0; +inp[12034] = 1069359877; +inp[12035] = 0; +inp[12036] = 1069294611; +inp[12037] = 0; +inp[12038] = 1069229348; +inp[12039] = 0; +inp[12040] = 1069164090; +inp[12041] = 0; +inp[12042] = 1069098835; +inp[12043] = 0; +inp[12044] = 1069033584; +inp[12045] = 0; +inp[12046] = 1068968338; +inp[12047] = 0; +inp[12048] = 1068903095; +inp[12049] = 0; +inp[12050] = 1068837856; +inp[12051] = 0; +inp[12052] = 1068772622; +inp[12053] = 0; +inp[12054] = 1068707391; +inp[12055] = 0; +inp[12056] = 1068642164; +inp[12057] = 0; +inp[12058] = 1068576941; +inp[12059] = 0; +inp[12060] = 1068511723; +inp[12061] = 0; +inp[12062] = 1068446508; +inp[12063] = 0; +inp[12064] = 1068381297; +inp[12065] = 0; +inp[12066] = 1068316090; +inp[12067] = 0; +inp[12068] = 1068250887; +inp[12069] = 0; +inp[12070] = 1068185689; +inp[12071] = 0; +inp[12072] = 1068120494; +inp[12073] = 0; +inp[12074] = 1068055303; +inp[12075] = 0; +inp[12076] = 1067990116; +inp[12077] = 0; +inp[12078] = 1067924933; +inp[12079] = 0; +inp[12080] = 1067859754; +inp[12081] = 0; +inp[12082] = 1067794579; +inp[12083] = 0; +inp[12084] = 1067729408; +inp[12085] = 0; +inp[12086] = 1067664241; +inp[12087] = 0; +inp[12088] = 1067599078; +inp[12089] = 0; +inp[12090] = 1067533919; +inp[12091] = 0; +inp[12092] = 1067468764; +inp[12093] = 0; +inp[12094] = 1067403612; +inp[12095] = 0; +inp[12096] = 1067338465; +inp[12097] = 0; +inp[12098] = 1067273322; +inp[12099] = 0; +inp[12100] = 1067208183; +inp[12101] = 0; +inp[12102] = 1067143048; +inp[12103] = 0; +inp[12104] = 1067077916; +inp[12105] = 0; +inp[12106] = 1067012789; +inp[12107] = 0; +inp[12108] = 1066947666; +inp[12109] = 0; +inp[12110] = 1066882546; +inp[12111] = 0; +inp[12112] = 1066817431; +inp[12113] = 0; +inp[12114] = 1066752320; +inp[12115] = 0; +inp[12116] = 1066687212; +inp[12117] = 0; +inp[12118] = 1066622109; +inp[12119] = 0; +inp[12120] = 1066557009; +inp[12121] = 0; +inp[12122] = 1066491914; +inp[12123] = 0; +inp[12124] = 1066426822; +inp[12125] = 0; +inp[12126] = 1066361735; +inp[12127] = 0; +inp[12128] = 1066296651; +inp[12129] = 0; +inp[12130] = 1066231572; +inp[12131] = 0; +inp[12132] = 1066166496; +inp[12133] = 0; +inp[12134] = 1066101424; +inp[12135] = 0; +inp[12136] = 1066036357; +inp[12137] = 0; +inp[12138] = 1065971293; +inp[12139] = 0; +inp[12140] = 1065906233; +inp[12141] = 0; +inp[12142] = 1065841178; +inp[12143] = 0; +inp[12144] = 1065776126; +inp[12145] = 0; +inp[12146] = 1065711078; +inp[12147] = 0; +inp[12148] = 1065646034; +inp[12149] = 0; +inp[12150] = 1065580994; +inp[12151] = 0; +inp[12152] = 1065515958; +inp[12153] = 0; +inp[12154] = 1065450926; +inp[12155] = 0; +inp[12156] = 1073741824; +inp[12157] = 1073741824; +inp[12158] = 1073709056; +inp[12159] = 0; +inp[12160] = 1073676289; +inp[12161] = 0; +inp[12162] = 1073643524; +inp[12163] = 0; +inp[12164] = 1073610759; +inp[12165] = 0; +inp[12166] = 1073577996; +inp[12167] = 0; +inp[12168] = 1073545233; +inp[12169] = 0; +inp[12170] = 1073512472; +inp[12171] = 0; +inp[12172] = 1073479711; +inp[12173] = 0; +inp[12174] = 1073446952; +inp[12175] = 0; +inp[12176] = 1073414193; +inp[12177] = 0; +inp[12178] = 1073381436; +inp[12179] = 0; +inp[12180] = 1073348679; +inp[12181] = 0; +inp[12182] = 1073315924; +inp[12183] = 0; +inp[12184] = 1073283169; +inp[12185] = 0; +inp[12186] = 1073250416; +inp[12187] = 0; +inp[12188] = 1073217663; +inp[12189] = 0; +inp[12190] = 1073184912; +inp[12191] = 0; +inp[12192] = 1073152161; +inp[12193] = 0; +inp[12194] = 1073119412; +inp[12195] = 0; +inp[12196] = 1073086663; +inp[12197] = 0; +inp[12198] = 1073053916; +inp[12199] = 0; +inp[12200] = 1073021169; +inp[12201] = 0; +inp[12202] = 1072988424; +inp[12203] = 0; +inp[12204] = 1072955679; +inp[12205] = 0; +inp[12206] = 1072922936; +inp[12207] = 0; +inp[12208] = 1072890193; +inp[12209] = 0; +inp[12210] = 1072857452; +inp[12211] = 0; +inp[12212] = 1072824711; +inp[12213] = 0; +inp[12214] = 1072791972; +inp[12215] = 0; +inp[12216] = 1072759233; +inp[12217] = 0; +inp[12218] = 1072726496; +inp[12219] = 0; +inp[12220] = 1072693759; +inp[12221] = 0; +inp[12222] = 1072661024; +inp[12223] = 0; +inp[12224] = 1072628289; +inp[12225] = 0; +inp[12226] = 1072595556; +inp[12227] = 0; +inp[12228] = 1072562823; +inp[12229] = 0; +inp[12230] = 1072530092; +inp[12231] = 0; +inp[12232] = 1072497361; +inp[12233] = 0; +inp[12234] = 1072464632; +inp[12235] = 0; +inp[12236] = 1072431903; +inp[12237] = 0; +inp[12238] = 1072399176; +inp[12239] = 0; +inp[12240] = 1072366449; +inp[12241] = 0; +inp[12242] = 1072333724; +inp[12243] = 0; +inp[12244] = 1072300999; +inp[12245] = 0; +inp[12246] = 1072268276; +inp[12247] = 0; +inp[12248] = 1072235553; +inp[12249] = 0; +inp[12250] = 1072202831; +inp[12251] = 0; +inp[12252] = 1072170111; +inp[12253] = 0; +inp[12254] = 1072137391; +inp[12255] = 0; +inp[12256] = 1072104673; +inp[12257] = 0; +inp[12258] = 1072071955; +inp[12259] = 0; +inp[12260] = 1072039239; +inp[12261] = 0; +inp[12262] = 1072006523; +inp[12263] = 0; +inp[12264] = 1071973809; +inp[12265] = 0; +inp[12266] = 1071941095; +inp[12267] = 0; +inp[12268] = 1071908383; +inp[12269] = 0; +inp[12270] = 1071875671; +inp[12271] = 0; +inp[12272] = 1071842961; +inp[12273] = 0; +inp[12274] = 1071810251; +inp[12275] = 0; +inp[12276] = 1071777542; +inp[12277] = 0; +inp[12278] = 1071744835; +inp[12279] = 0; +inp[12280] = 1071712128; +inp[12281] = 0; +inp[12282] = 1071679423; +inp[12283] = 0; +inp[12284] = 1071646718; +inp[12285] = 0; +inp[12286] = 1071614015; +inp[12287] = 0; +inp[12288] = 1071581312; +inp[12289] = 0; +inp[12290] = 1071548610; +inp[12291] = 0; +inp[12292] = 1071515910; +inp[12293] = 0; +inp[12294] = 1071483210; +inp[12295] = 0; +inp[12296] = 1071450512; +inp[12297] = 0; +inp[12298] = 1071417814; +inp[12299] = 0; +inp[12300] = 1071385118; +inp[12301] = 0; +inp[12302] = 1071352422; +inp[12303] = 0; +inp[12304] = 1071319727; +inp[12305] = 0; +inp[12306] = 1071287034; +inp[12307] = 0; +inp[12308] = 1071254341; +inp[12309] = 0; +inp[12310] = 1071221650; +inp[12311] = 0; +inp[12312] = 1071188959; +inp[12313] = 0; +inp[12314] = 1071156269; +inp[12315] = 0; +inp[12316] = 1071123581; +inp[12317] = 0; +inp[12318] = 1071090893; +inp[12319] = 0; +inp[12320] = 1071058207; +inp[12321] = 0; +inp[12322] = 1071025521; +inp[12323] = 0; +inp[12324] = 1070992836; +inp[12325] = 0; +inp[12326] = 1070960153; +inp[12327] = 0; +inp[12328] = 1070927470; +inp[12329] = 0; +inp[12330] = 1070894789; +inp[12331] = 0; +inp[12332] = 1070862108; +inp[12333] = 0; +inp[12334] = 1070829428; +inp[12335] = 0; +inp[12336] = 1070796750; +inp[12337] = 0; +inp[12338] = 1070764072; +inp[12339] = 0; +inp[12340] = 1070731396; +inp[12341] = 0; +inp[12342] = 1070698720; +inp[12343] = 0; +inp[12344] = 1070666045; +inp[12345] = 0; +inp[12346] = 1070633372; +inp[12347] = 0; +inp[12348] = 1070600699; +inp[12349] = 0; +inp[12350] = 1070568027; +inp[12351] = 0; +inp[12352] = 1070535357; +inp[12353] = 0; +inp[12354] = 1070502687; +inp[12355] = 0; +inp[12356] = 1070470018; +inp[12357] = 0; +inp[12358] = 1070437351; +inp[12359] = 0; +inp[12360] = 1070404684; +inp[12361] = 0; +inp[12362] = 1070372018; +inp[12363] = 0; +inp[12364] = 1070339354; +inp[12365] = 0; +inp[12366] = 1070306690; +inp[12367] = 0; +inp[12368] = 1070274027; +inp[12369] = 0; +inp[12370] = 1070241366; +inp[12371] = 0; +inp[12372] = 1070208705; +inp[12373] = 0; +inp[12374] = 1070176045; +inp[12375] = 0; +inp[12376] = 1070143387; +inp[12377] = 0; +inp[12378] = 1070110729; +inp[12379] = 0; +inp[12380] = 1070078072; +inp[12381] = 0; +inp[12382] = 1070045417; +inp[12383] = 0; +inp[12384] = 1070012762; +inp[12385] = 0; +inp[12386] = 1069980108; +inp[12387] = 0; +inp[12388] = 1069947456; +inp[12389] = 0; +inp[12390] = 1069914804; +inp[12391] = 0; +inp[12392] = 1069882153; +inp[12393] = 0; +inp[12394] = 1069849503; +inp[12395] = 0; +inp[12396] = 1069816855; +inp[12397] = 0; +inp[12398] = 1069784207; +inp[12399] = 0; +inp[12400] = 1069751560; +inp[12401] = 0; +inp[12402] = 1069718915; +inp[12403] = 0; +inp[12404] = 1069686270; +inp[12405] = 0; +inp[12406] = 1069653626; +inp[12407] = 0; +inp[12408] = 1069620983; +inp[12409] = 0; +inp[12410] = 1069588342; +inp[12411] = 0; +inp[12412] = 1073741824; +inp[12413] = 1073741824; +inp[12414] = 1073725440; +inp[12415] = 0; +inp[12416] = 1073709056; +inp[12417] = 0; +inp[12418] = 1073692673; +inp[12419] = 0; +inp[12420] = 1073676289; +inp[12421] = 0; +inp[12422] = 1073659907; +inp[12423] = 0; +inp[12424] = 1073643524; +inp[12425] = 0; +inp[12426] = 1073627142; +inp[12427] = 0; +inp[12428] = 1073610759; +inp[12429] = 0; +inp[12430] = 1073594378; +inp[12431] = 0; +inp[12432] = 1073577996; +inp[12433] = 0; +inp[12434] = 1073561615; +inp[12435] = 0; +inp[12436] = 1073545233; +inp[12437] = 0; +inp[12438] = 1073528853; +inp[12439] = 0; +inp[12440] = 1073512472; +inp[12441] = 0; +inp[12442] = 1073496092; +inp[12443] = 0; +inp[12444] = 1073479711; +inp[12445] = 0; +inp[12446] = 1073463332; +inp[12447] = 0; +inp[12448] = 1073446952; +inp[12449] = 0; +inp[12450] = 1073430573; +inp[12451] = 0; +inp[12452] = 1073414193; +inp[12453] = 0; +inp[12454] = 1073397815; +inp[12455] = 0; +inp[12456] = 1073381436; +inp[12457] = 0; +inp[12458] = 1073365058; +inp[12459] = 0; +inp[12460] = 1073348679; +inp[12461] = 0; +inp[12462] = 1073332302; +inp[12463] = 0; +inp[12464] = 1073315924; +inp[12465] = 0; +inp[12466] = 1073299547; +inp[12467] = 0; +inp[12468] = 1073283169; +inp[12469] = 0; +inp[12470] = 1073266793; +inp[12471] = 0; +inp[12472] = 1073250416; +inp[12473] = 0; +inp[12474] = 1073234040; +inp[12475] = 0; +inp[12476] = 1073217663; +inp[12477] = 0; +inp[12478] = 1073201288; +inp[12479] = 0; +inp[12480] = 1073184912; +inp[12481] = 0; +inp[12482] = 1073168537; +inp[12483] = 0; +inp[12484] = 1073152161; +inp[12485] = 0; +inp[12486] = 1073135787; +inp[12487] = 0; +inp[12488] = 1073119412; +inp[12489] = 0; +inp[12490] = 1073103038; +inp[12491] = 0; +inp[12492] = 1073086663; +inp[12493] = 0; +inp[12494] = 1073070290; +inp[12495] = 0; +inp[12496] = 1073053916; +inp[12497] = 0; +inp[12498] = 1073037543; +inp[12499] = 0; +inp[12500] = 1073021169; +inp[12501] = 0; +inp[12502] = 1073004797; +inp[12503] = 0; +inp[12504] = 1072988424; +inp[12505] = 0; +inp[12506] = 1072972052; +inp[12507] = 0; +inp[12508] = 1072955679; +inp[12509] = 0; +inp[12510] = 1072939308; +inp[12511] = 0; +inp[12512] = 1072922936; +inp[12513] = 0; +inp[12514] = 1072906565; +inp[12515] = 0; +inp[12516] = 1072890193; +inp[12517] = 0; +inp[12518] = 1072873823; +inp[12519] = 0; +inp[12520] = 1072857452; +inp[12521] = 0; +inp[12522] = 1072841082; +inp[12523] = 0; +inp[12524] = 1072824711; +inp[12525] = 0; +inp[12526] = 1072808342; +inp[12527] = 0; +inp[12528] = 1072791972; +inp[12529] = 0; +inp[12530] = 1072775602; +inp[12531] = 0; +inp[12532] = 1072759233; +inp[12533] = 0; +inp[12534] = 1072742864; +inp[12535] = 0; +inp[12536] = 1072726496; +inp[12537] = 0; +inp[12538] = 1072710127; +inp[12539] = 0; +inp[12540] = 1072693759; +inp[12541] = 0; +inp[12542] = 1072677391; +inp[12543] = 0; +inp[12544] = 1072661024; +inp[12545] = 0; +inp[12546] = 1072644656; +inp[12547] = 0; +inp[12548] = 1072628289; +inp[12549] = 0; +inp[12550] = 1072611922; +inp[12551] = 0; +inp[12552] = 1072595556; +inp[12553] = 0; +inp[12554] = 1072579189; +inp[12555] = 0; +inp[12556] = 1072562823; +inp[12557] = 0; +inp[12558] = 1072546457; +inp[12559] = 0; +inp[12560] = 1072530092; +inp[12561] = 0; +inp[12562] = 1072513726; +inp[12563] = 0; +inp[12564] = 1072497361; +inp[12565] = 0; +inp[12566] = 1072480996; +inp[12567] = 0; +inp[12568] = 1072464632; +inp[12569] = 0; +inp[12570] = 1072448267; +inp[12571] = 0; +inp[12572] = 1072431903; +inp[12573] = 0; +inp[12574] = 1072415539; +inp[12575] = 0; +inp[12576] = 1072399176; +inp[12577] = 0; +inp[12578] = 1072382812; +inp[12579] = 0; +inp[12580] = 1072366449; +inp[12581] = 0; +inp[12582] = 1072350086; +inp[12583] = 0; +inp[12584] = 1072333724; +inp[12585] = 0; +inp[12586] = 1072317361; +inp[12587] = 0; +inp[12588] = 1072300999; +inp[12589] = 0; +inp[12590] = 1072284637; +inp[12591] = 0; +inp[12592] = 1072268276; +inp[12593] = 0; +inp[12594] = 1072251914; +inp[12595] = 0; +inp[12596] = 1072235553; +inp[12597] = 0; +inp[12598] = 1072219192; +inp[12599] = 0; +inp[12600] = 1072202831; +inp[12601] = 0; +inp[12602] = 1072186471; +inp[12603] = 0; +inp[12604] = 1072170111; +inp[12605] = 0; +inp[12606] = 1072153751; +inp[12607] = 0; +inp[12608] = 1072137391; +inp[12609] = 0; +inp[12610] = 1072121032; +inp[12611] = 0; +inp[12612] = 1072104673; +inp[12613] = 0; +inp[12614] = 1072088314; +inp[12615] = 0; +inp[12616] = 1072071955; +inp[12617] = 0; +inp[12618] = 1072055597; +inp[12619] = 0; +inp[12620] = 1072039239; +inp[12621] = 0; +inp[12622] = 1072022881; +inp[12623] = 0; +inp[12624] = 1072006523; +inp[12625] = 0; +inp[12626] = 1071990166; +inp[12627] = 0; +inp[12628] = 1071973809; +inp[12629] = 0; +inp[12630] = 1071957452; +inp[12631] = 0; +inp[12632] = 1071941095; +inp[12633] = 0; +inp[12634] = 1071924739; +inp[12635] = 0; +inp[12636] = 1071908383; +inp[12637] = 0; +inp[12638] = 1071892027; +inp[12639] = 0; +inp[12640] = 1071875671; +inp[12641] = 0; +inp[12642] = 1071859316; +inp[12643] = 0; +inp[12644] = 1071842961; +inp[12645] = 0; +inp[12646] = 1071826606; +inp[12647] = 0; +inp[12648] = 1071810251; +inp[12649] = 0; +inp[12650] = 1071793897; +inp[12651] = 0; +inp[12652] = 1071777542; +inp[12653] = 0; +inp[12654] = 1071761188; +inp[12655] = 0; +inp[12656] = 1071744835; +inp[12657] = 0; +inp[12658] = 1071728481; +inp[12659] = 0; +inp[12660] = 1071712128; +inp[12661] = 0; +inp[12662] = 1071695775; +inp[12663] = 0; +inp[12664] = 1071679423; +inp[12665] = 0; +inp[12666] = 1071663070; +inp[12667] = 0; +inp[12668] = 1073741824; +inp[12669] = 1073741824; +inp[12670] = 1073733632; +inp[12671] = 0; +inp[12672] = 1073725440; +inp[12673] = 0; +inp[12674] = 1073717248; +inp[12675] = 0; +inp[12676] = 1073709056; +inp[12677] = 0; +inp[12678] = 1073700864; +inp[12679] = 0; +inp[12680] = 1073692673; +inp[12681] = 0; +inp[12682] = 1073684481; +inp[12683] = 0; +inp[12684] = 1073676289; +inp[12685] = 0; +inp[12686] = 1073668098; +inp[12687] = 0; +inp[12688] = 1073659907; +inp[12689] = 0; +inp[12690] = 1073651715; +inp[12691] = 0; +inp[12692] = 1073643524; +inp[12693] = 0; +inp[12694] = 1073635333; +inp[12695] = 0; +inp[12696] = 1073627142; +inp[12697] = 0; +inp[12698] = 1073618951; +inp[12699] = 0; +inp[12700] = 1073610759; +inp[12701] = 0; +inp[12702] = 1073602569; +inp[12703] = 0; +inp[12704] = 1073594378; +inp[12705] = 0; +inp[12706] = 1073586187; +inp[12707] = 0; +inp[12708] = 1073577996; +inp[12709] = 0; +inp[12710] = 1073569805; +inp[12711] = 0; +inp[12712] = 1073561615; +inp[12713] = 0; +inp[12714] = 1073553424; +inp[12715] = 0; +inp[12716] = 1073545233; +inp[12717] = 0; +inp[12718] = 1073537043; +inp[12719] = 0; +inp[12720] = 1073528853; +inp[12721] = 0; +inp[12722] = 1073520662; +inp[12723] = 0; +inp[12724] = 1073512472; +inp[12725] = 0; +inp[12726] = 1073504282; +inp[12727] = 0; +inp[12728] = 1073496092; +inp[12729] = 0; +inp[12730] = 1073487902; +inp[12731] = 0; +inp[12732] = 1073479711; +inp[12733] = 0; +inp[12734] = 1073471522; +inp[12735] = 0; +inp[12736] = 1073463332; +inp[12737] = 0; +inp[12738] = 1073455142; +inp[12739] = 0; +inp[12740] = 1073446952; +inp[12741] = 0; +inp[12742] = 1073438762; +inp[12743] = 0; +inp[12744] = 1073430573; +inp[12745] = 0; +inp[12746] = 1073422383; +inp[12747] = 0; +inp[12748] = 1073414193; +inp[12749] = 0; +inp[12750] = 1073406004; +inp[12751] = 0; +inp[12752] = 1073397815; +inp[12753] = 0; +inp[12754] = 1073389625; +inp[12755] = 0; +inp[12756] = 1073381436; +inp[12757] = 0; +inp[12758] = 1073373247; +inp[12759] = 0; +inp[12760] = 1073365058; +inp[12761] = 0; +inp[12762] = 1073356869; +inp[12763] = 0; +inp[12764] = 1073348679; +inp[12765] = 0; +inp[12766] = 1073340491; +inp[12767] = 0; +inp[12768] = 1073332302; +inp[12769] = 0; +inp[12770] = 1073324113; +inp[12771] = 0; +inp[12772] = 1073315924; +inp[12773] = 0; +inp[12774] = 1073307735; +inp[12775] = 0; +inp[12776] = 1073299547; +inp[12777] = 0; +inp[12778] = 1073291358; +inp[12779] = 0; +inp[12780] = 1073283169; +inp[12781] = 0; +inp[12782] = 1073274981; +inp[12783] = 0; +inp[12784] = 1073266793; +inp[12785] = 0; +inp[12786] = 1073258604; +inp[12787] = 0; +inp[12788] = 1073250416; +inp[12789] = 0; +inp[12790] = 1073242228; +inp[12791] = 0; +inp[12792] = 1073234040; +inp[12793] = 0; +inp[12794] = 1073225852; +inp[12795] = 0; +inp[12796] = 1073217663; +inp[12797] = 0; +inp[12798] = 1073209476; +inp[12799] = 0; +inp[12800] = 1073201288; +inp[12801] = 0; +inp[12802] = 1073193100; +inp[12803] = 0; +inp[12804] = 1073184912; +inp[12805] = 0; +inp[12806] = 1073176724; +inp[12807] = 0; +inp[12808] = 1073168537; +inp[12809] = 0; +inp[12810] = 1073160349; +inp[12811] = 0; +inp[12812] = 1073152161; +inp[12813] = 0; +inp[12814] = 1073143974; +inp[12815] = 0; +inp[12816] = 1073135787; +inp[12817] = 0; +inp[12818] = 1073127599; +inp[12819] = 0; +inp[12820] = 1073119412; +inp[12821] = 0; +inp[12822] = 1073111225; +inp[12823] = 0; +inp[12824] = 1073103038; +inp[12825] = 0; +inp[12826] = 1073094850; +inp[12827] = 0; +inp[12828] = 1073086663; +inp[12829] = 0; +inp[12830] = 1073078476; +inp[12831] = 0; +inp[12832] = 1073070290; +inp[12833] = 0; +inp[12834] = 1073062103; +inp[12835] = 0; +inp[12836] = 1073053916; +inp[12837] = 0; +inp[12838] = 1073045729; +inp[12839] = 0; +inp[12840] = 1073037543; +inp[12841] = 0; +inp[12842] = 1073029356; +inp[12843] = 0; +inp[12844] = 1073021169; +inp[12845] = 0; +inp[12846] = 1073012983; +inp[12847] = 0; +inp[12848] = 1073004797; +inp[12849] = 0; +inp[12850] = 1072996610; +inp[12851] = 0; +inp[12852] = 1072988424; +inp[12853] = 0; +inp[12854] = 1072980238; +inp[12855] = 0; +inp[12856] = 1072972052; +inp[12857] = 0; +inp[12858] = 1072963865; +inp[12859] = 0; +inp[12860] = 1072955679; +inp[12861] = 0; +inp[12862] = 1072947493; +inp[12863] = 0; +inp[12864] = 1072939308; +inp[12865] = 0; +inp[12866] = 1072931122; +inp[12867] = 0; +inp[12868] = 1072922936; +inp[12869] = 0; +inp[12870] = 1072914750; +inp[12871] = 0; +inp[12872] = 1072906565; +inp[12873] = 0; +inp[12874] = 1072898379; +inp[12875] = 0; +inp[12876] = 1072890193; +inp[12877] = 0; +inp[12878] = 1072882008; +inp[12879] = 0; +inp[12880] = 1072873823; +inp[12881] = 0; +inp[12882] = 1072865637; +inp[12883] = 0; +inp[12884] = 1072857452; +inp[12885] = 0; +inp[12886] = 1072849267; +inp[12887] = 0; +inp[12888] = 1072841082; +inp[12889] = 0; +inp[12890] = 1072832896; +inp[12891] = 0; +inp[12892] = 1072824711; +inp[12893] = 0; +inp[12894] = 1072816526; +inp[12895] = 0; +inp[12896] = 1072808342; +inp[12897] = 0; +inp[12898] = 1072800157; +inp[12899] = 0; +inp[12900] = 1072791972; +inp[12901] = 0; +inp[12902] = 1072783787; +inp[12903] = 0; +inp[12904] = 1072775602; +inp[12905] = 0; +inp[12906] = 1072767418; +inp[12907] = 0; +inp[12908] = 1072759233; +inp[12909] = 0; +inp[12910] = 1072751049; +inp[12911] = 0; +inp[12912] = 1072742864; +inp[12913] = 0; +inp[12914] = 1072734680; +inp[12915] = 0; +inp[12916] = 1072726496; +inp[12917] = 0; +inp[12918] = 1072718312; +inp[12919] = 0; +inp[12920] = 1072710127; +inp[12921] = 0; +inp[12922] = 1072701943; +inp[12923] = 0; +inp[12924] = 1073741824; +inp[12925] = 1073741824; +inp[12926] = 1073737728; +inp[12927] = 0; +inp[12928] = 1073733632; +inp[12929] = 0; +inp[12930] = 1073729536; +inp[12931] = 0; +inp[12932] = 1073725440; +inp[12933] = 0; +inp[12934] = 1073721344; +inp[12935] = 0; +inp[12936] = 1073717248; +inp[12937] = 0; +inp[12938] = 1073713152; +inp[12939] = 0; +inp[12940] = 1073709056; +inp[12941] = 0; +inp[12942] = 1073704960; +inp[12943] = 0; +inp[12944] = 1073700864; +inp[12945] = 0; +inp[12946] = 1073696768; +inp[12947] = 0; +inp[12948] = 1073692673; +inp[12949] = 0; +inp[12950] = 1073688577; +inp[12951] = 0; +inp[12952] = 1073684481; +inp[12953] = 0; +inp[12954] = 1073680385; +inp[12955] = 0; +inp[12956] = 1073676289; +inp[12957] = 0; +inp[12958] = 1073672194; +inp[12959] = 0; +inp[12960] = 1073668098; +inp[12961] = 0; +inp[12962] = 1073664002; +inp[12963] = 0; +inp[12964] = 1073659907; +inp[12965] = 0; +inp[12966] = 1073655811; +inp[12967] = 0; +inp[12968] = 1073651715; +inp[12969] = 0; +inp[12970] = 1073647620; +inp[12971] = 0; +inp[12972] = 1073643524; +inp[12973] = 0; +inp[12974] = 1073639428; +inp[12975] = 0; +inp[12976] = 1073635333; +inp[12977] = 0; +inp[12978] = 1073631237; +inp[12979] = 0; +inp[12980] = 1073627142; +inp[12981] = 0; +inp[12982] = 1073623046; +inp[12983] = 0; +inp[12984] = 1073618951; +inp[12985] = 0; +inp[12986] = 1073614855; +inp[12987] = 0; +inp[12988] = 1073610759; +inp[12989] = 0; +inp[12990] = 1073606664; +inp[12991] = 0; +inp[12992] = 1073602569; +inp[12993] = 0; +inp[12994] = 1073598473; +inp[12995] = 0; +inp[12996] = 1073594378; +inp[12997] = 0; +inp[12998] = 1073590282; +inp[12999] = 0; +inp[13000] = 1073586187; +inp[13001] = 0; +inp[13002] = 1073582091; +inp[13003] = 0; +inp[13004] = 1073577996; +inp[13005] = 0; +inp[13006] = 1073573901; +inp[13007] = 0; +inp[13008] = 1073569805; +inp[13009] = 0; +inp[13010] = 1073565710; +inp[13011] = 0; +inp[13012] = 1073561615; +inp[13013] = 0; +inp[13014] = 1073557519; +inp[13015] = 0; +inp[13016] = 1073553424; +inp[13017] = 0; +inp[13018] = 1073549329; +inp[13019] = 0; +inp[13020] = 1073545233; +inp[13021] = 0; +inp[13022] = 1073541138; +inp[13023] = 0; +inp[13024] = 1073537043; +inp[13025] = 0; +inp[13026] = 1073532948; +inp[13027] = 0; +inp[13028] = 1073528853; +inp[13029] = 0; +inp[13030] = 1073524757; +inp[13031] = 0; +inp[13032] = 1073520662; +inp[13033] = 0; +inp[13034] = 1073516567; +inp[13035] = 0; +inp[13036] = 1073512472; +inp[13037] = 0; +inp[13038] = 1073508377; +inp[13039] = 0; +inp[13040] = 1073504282; +inp[13041] = 0; +inp[13042] = 1073500187; +inp[13043] = 0; +inp[13044] = 1073496092; +inp[13045] = 0; +inp[13046] = 1073491997; +inp[13047] = 0; +inp[13048] = 1073487902; +inp[13049] = 0; +inp[13050] = 1073483807; +inp[13051] = 0; +inp[13052] = 1073479711; +inp[13053] = 0; +inp[13054] = 1073475617; +inp[13055] = 0; +inp[13056] = 1073471522; +inp[13057] = 0; +inp[13058] = 1073467427; +inp[13059] = 0; +inp[13060] = 1073463332; +inp[13061] = 0; +inp[13062] = 1073459237; +inp[13063] = 0; +inp[13064] = 1073455142; +inp[13065] = 0; +inp[13066] = 1073451047; +inp[13067] = 0; +inp[13068] = 1073446952; +inp[13069] = 0; +inp[13070] = 1073442857; +inp[13071] = 0; +inp[13072] = 1073438762; +inp[13073] = 0; +inp[13074] = 1073434667; +inp[13075] = 0; +inp[13076] = 1073430573; +inp[13077] = 0; +inp[13078] = 1073426478; +inp[13079] = 0; +inp[13080] = 1073422383; +inp[13081] = 0; +inp[13082] = 1073418288; +inp[13083] = 0; +inp[13084] = 1073414193; +inp[13085] = 0; +inp[13086] = 1073410099; +inp[13087] = 0; +inp[13088] = 1073406004; +inp[13089] = 0; +inp[13090] = 1073401909; +inp[13091] = 0; +inp[13092] = 1073397815; +inp[13093] = 0; +inp[13094] = 1073393720; +inp[13095] = 0; +inp[13096] = 1073389625; +inp[13097] = 0; +inp[13098] = 1073385531; +inp[13099] = 0; +inp[13100] = 1073381436; +inp[13101] = 0; +inp[13102] = 1073377341; +inp[13103] = 0; +inp[13104] = 1073373247; +inp[13105] = 0; +inp[13106] = 1073369152; +inp[13107] = 0; +inp[13108] = 1073365058; +inp[13109] = 0; +inp[13110] = 1073360963; +inp[13111] = 0; +inp[13112] = 1073356869; +inp[13113] = 0; +inp[13114] = 1073352774; +inp[13115] = 0; +inp[13116] = 1073348679; +inp[13117] = 0; +inp[13118] = 1073344585; +inp[13119] = 0; +inp[13120] = 1073340491; +inp[13121] = 0; +inp[13122] = 1073336396; +inp[13123] = 0; +inp[13124] = 1073332302; +inp[13125] = 0; +inp[13126] = 1073328207; +inp[13127] = 0; +inp[13128] = 1073324113; +inp[13129] = 0; +inp[13130] = 1073320018; +inp[13131] = 0; +inp[13132] = 1073315924; +inp[13133] = 0; +inp[13134] = 1073311830; +inp[13135] = 0; +inp[13136] = 1073307735; +inp[13137] = 0; +inp[13138] = 1073303641; +inp[13139] = 0; +inp[13140] = 1073299547; +inp[13141] = 0; +inp[13142] = 1073295452; +inp[13143] = 0; +inp[13144] = 1073291358; +inp[13145] = 0; +inp[13146] = 1073287264; +inp[13147] = 0; +inp[13148] = 1073283169; +inp[13149] = 0; +inp[13150] = 1073279075; +inp[13151] = 0; +inp[13152] = 1073274981; +inp[13153] = 0; +inp[13154] = 1073270887; +inp[13155] = 0; +inp[13156] = 1073266793; +inp[13157] = 0; +inp[13158] = 1073262698; +inp[13159] = 0; +inp[13160] = 1073258604; +inp[13161] = 0; +inp[13162] = 1073254510; +inp[13163] = 0; +inp[13164] = 1073250416; +inp[13165] = 0; +inp[13166] = 1073246322; +inp[13167] = 0; +inp[13168] = 1073242228; +inp[13169] = 0; +inp[13170] = 1073238134; +inp[13171] = 0; +inp[13172] = 1073234040; +inp[13173] = 0; +inp[13174] = 1073229946; +inp[13175] = 0; +inp[13176] = 1073225852; +inp[13177] = 0; +inp[13178] = 1073221757; +inp[13179] = 0; +inp[13180] = 1073741824; +inp[13181] = 1073741824; +inp[13182] = 1073739776; +inp[13183] = 0; +inp[13184] = 1073737728; +inp[13185] = 0; +inp[13186] = 1073735680; +inp[13187] = 0; +inp[13188] = 1073733632; +inp[13189] = 0; +inp[13190] = 1073731584; +inp[13191] = 0; +inp[13192] = 1073729536; +inp[13193] = 0; +inp[13194] = 1073727488; +inp[13195] = 0; +inp[13196] = 1073725440; +inp[13197] = 0; +inp[13198] = 1073723392; +inp[13199] = 0; +inp[13200] = 1073721344; +inp[13201] = 0; +inp[13202] = 1073719296; +inp[13203] = 0; +inp[13204] = 1073717248; +inp[13205] = 0; +inp[13206] = 1073715200; +inp[13207] = 0; +inp[13208] = 1073713152; +inp[13209] = 0; +inp[13210] = 1073711104; +inp[13211] = 0; +inp[13212] = 1073709056; +inp[13213] = 0; +inp[13214] = 1073707008; +inp[13215] = 0; +inp[13216] = 1073704960; +inp[13217] = 0; +inp[13218] = 1073702912; +inp[13219] = 0; +inp[13220] = 1073700864; +inp[13221] = 0; +inp[13222] = 1073698816; +inp[13223] = 0; +inp[13224] = 1073696768; +inp[13225] = 0; +inp[13226] = 1073694721; +inp[13227] = 0; +inp[13228] = 1073692673; +inp[13229] = 0; +inp[13230] = 1073690625; +inp[13231] = 0; +inp[13232] = 1073688577; +inp[13233] = 0; +inp[13234] = 1073686529; +inp[13235] = 0; +inp[13236] = 1073684481; +inp[13237] = 0; +inp[13238] = 1073682433; +inp[13239] = 0; +inp[13240] = 1073680385; +inp[13241] = 0; +inp[13242] = 1073678337; +inp[13243] = 0; +inp[13244] = 1073676289; +inp[13245] = 0; +inp[13246] = 1073674242; +inp[13247] = 0; +inp[13248] = 1073672194; +inp[13249] = 0; +inp[13250] = 1073670146; +inp[13251] = 0; +inp[13252] = 1073668098; +inp[13253] = 0; +inp[13254] = 1073666050; +inp[13255] = 0; +inp[13256] = 1073664002; +inp[13257] = 0; +inp[13258] = 1073661954; +inp[13259] = 0; +inp[13260] = 1073659907; +inp[13261] = 0; +inp[13262] = 1073657859; +inp[13263] = 0; +inp[13264] = 1073655811; +inp[13265] = 0; +inp[13266] = 1073653763; +inp[13267] = 0; +inp[13268] = 1073651715; +inp[13269] = 0; +inp[13270] = 1073649667; +inp[13271] = 0; +inp[13272] = 1073647620; +inp[13273] = 0; +inp[13274] = 1073645572; +inp[13275] = 0; +inp[13276] = 1073643524; +inp[13277] = 0; +inp[13278] = 1073641476; +inp[13279] = 0; +inp[13280] = 1073639428; +inp[13281] = 0; +inp[13282] = 1073637381; +inp[13283] = 0; +inp[13284] = 1073635333; +inp[13285] = 0; +inp[13286] = 1073633285; +inp[13287] = 0; +inp[13288] = 1073631237; +inp[13289] = 0; +inp[13290] = 1073629189; +inp[13291] = 0; +inp[13292] = 1073627142; +inp[13293] = 0; +inp[13294] = 1073625094; +inp[13295] = 0; +inp[13296] = 1073623046; +inp[13297] = 0; +inp[13298] = 1073620998; +inp[13299] = 0; +inp[13300] = 1073618951; +inp[13301] = 0; +inp[13302] = 1073616903; +inp[13303] = 0; +inp[13304] = 1073614855; +inp[13305] = 0; +inp[13306] = 1073612807; +inp[13307] = 0; +inp[13308] = 1073610759; +inp[13309] = 0; +inp[13310] = 1073608712; +inp[13311] = 0; +inp[13312] = 1073606664; +inp[13313] = 0; +inp[13314] = 1073604616; +inp[13315] = 0; +inp[13316] = 1073602569; +inp[13317] = 0; +inp[13318] = 1073600521; +inp[13319] = 0; +inp[13320] = 1073598473; +inp[13321] = 0; +inp[13322] = 1073596425; +inp[13323] = 0; +inp[13324] = 1073594378; +inp[13325] = 0; +inp[13326] = 1073592330; +inp[13327] = 0; +inp[13328] = 1073590282; +inp[13329] = 0; +inp[13330] = 1073588234; +inp[13331] = 0; +inp[13332] = 1073586187; +inp[13333] = 0; +inp[13334] = 1073584139; +inp[13335] = 0; +inp[13336] = 1073582091; +inp[13337] = 0; +inp[13338] = 1073580044; +inp[13339] = 0; +inp[13340] = 1073577996; +inp[13341] = 0; +inp[13342] = 1073575948; +inp[13343] = 0; +inp[13344] = 1073573901; +inp[13345] = 0; +inp[13346] = 1073571853; +inp[13347] = 0; +inp[13348] = 1073569805; +inp[13349] = 0; +inp[13350] = 1073567758; +inp[13351] = 0; +inp[13352] = 1073565710; +inp[13353] = 0; +inp[13354] = 1073563662; +inp[13355] = 0; +inp[13356] = 1073561615; +inp[13357] = 0; +inp[13358] = 1073559567; +inp[13359] = 0; +inp[13360] = 1073557519; +inp[13361] = 0; +inp[13362] = 1073555472; +inp[13363] = 0; +inp[13364] = 1073553424; +inp[13365] = 0; +inp[13366] = 1073551376; +inp[13367] = 0; +inp[13368] = 1073549329; +inp[13369] = 0; +inp[13370] = 1073547281; +inp[13371] = 0; +inp[13372] = 1073545233; +inp[13373] = 0; +inp[13374] = 1073543186; +inp[13375] = 0; +inp[13376] = 1073541138; +inp[13377] = 0; +inp[13378] = 1073539091; +inp[13379] = 0; +inp[13380] = 1073537043; +inp[13381] = 0; +inp[13382] = 1073534995; +inp[13383] = 0; +inp[13384] = 1073532948; +inp[13385] = 0; +inp[13386] = 1073530900; +inp[13387] = 0; +inp[13388] = 1073528853; +inp[13389] = 0; +inp[13390] = 1073526805; +inp[13391] = 0; +inp[13392] = 1073524757; +inp[13393] = 0; +inp[13394] = 1073522710; +inp[13395] = 0; +inp[13396] = 1073520662; +inp[13397] = 0; +inp[13398] = 1073518615; +inp[13399] = 0; +inp[13400] = 1073516567; +inp[13401] = 0; +inp[13402] = 1073514520; +inp[13403] = 0; +inp[13404] = 1073512472; +inp[13405] = 0; +inp[13406] = 1073510424; +inp[13407] = 0; +inp[13408] = 1073508377; +inp[13409] = 0; +inp[13410] = 1073506329; +inp[13411] = 0; +inp[13412] = 1073504282; +inp[13413] = 0; +inp[13414] = 1073502234; +inp[13415] = 0; +inp[13416] = 1073500187; +inp[13417] = 0; +inp[13418] = 1073498139; +inp[13419] = 0; +inp[13420] = 1073496092; +inp[13421] = 0; +inp[13422] = 1073494044; +inp[13423] = 0; +inp[13424] = 1073491997; +inp[13425] = 0; +inp[13426] = 1073489949; +inp[13427] = 0; +inp[13428] = 1073487902; +inp[13429] = 0; +inp[13430] = 1073485854; +inp[13431] = 0; +inp[13432] = 1073483807; +inp[13433] = 0; +inp[13434] = 1073481759; +inp[13435] = 0; +inp[13436] = 1073741824; +inp[13437] = 1073741824; +inp[13438] = 1073740800; +inp[13439] = 0; +inp[13440] = 1073739776; +inp[13441] = 0; +inp[13442] = 1073738752; +inp[13443] = 0; +inp[13444] = 1073737728; +inp[13445] = 0; +inp[13446] = 1073736704; +inp[13447] = 0; +inp[13448] = 1073735680; +inp[13449] = 0; +inp[13450] = 1073734656; +inp[13451] = 0; +inp[13452] = 1073733632; +inp[13453] = 0; +inp[13454] = 1073732608; +inp[13455] = 0; +inp[13456] = 1073731584; +inp[13457] = 0; +inp[13458] = 1073730560; +inp[13459] = 0; +inp[13460] = 1073729536; +inp[13461] = 0; +inp[13462] = 1073728512; +inp[13463] = 0; +inp[13464] = 1073727488; +inp[13465] = 0; +inp[13466] = 1073726464; +inp[13467] = 0; +inp[13468] = 1073725440; +inp[13469] = 0; +inp[13470] = 1073724416; +inp[13471] = 0; +inp[13472] = 1073723392; +inp[13473] = 0; +inp[13474] = 1073722368; +inp[13475] = 0; +inp[13476] = 1073721344; +inp[13477] = 0; +inp[13478] = 1073720320; +inp[13479] = 0; +inp[13480] = 1073719296; +inp[13481] = 0; +inp[13482] = 1073718272; +inp[13483] = 0; +inp[13484] = 1073717248; +inp[13485] = 0; +inp[13486] = 1073716224; +inp[13487] = 0; +inp[13488] = 1073715200; +inp[13489] = 0; +inp[13490] = 1073714176; +inp[13491] = 0; +inp[13492] = 1073713152; +inp[13493] = 0; +inp[13494] = 1073712128; +inp[13495] = 0; +inp[13496] = 1073711104; +inp[13497] = 0; +inp[13498] = 1073710080; +inp[13499] = 0; +inp[13500] = 1073709056; +inp[13501] = 0; +inp[13502] = 1073708032; +inp[13503] = 0; +inp[13504] = 1073707008; +inp[13505] = 0; +inp[13506] = 1073705984; +inp[13507] = 0; +inp[13508] = 1073704960; +inp[13509] = 0; +inp[13510] = 1073703936; +inp[13511] = 0; +inp[13512] = 1073702912; +inp[13513] = 0; +inp[13514] = 1073701888; +inp[13515] = 0; +inp[13516] = 1073700864; +inp[13517] = 0; +inp[13518] = 1073699840; +inp[13519] = 0; +inp[13520] = 1073698816; +inp[13521] = 0; +inp[13522] = 1073697792; +inp[13523] = 0; +inp[13524] = 1073696768; +inp[13525] = 0; +inp[13526] = 1073695744; +inp[13527] = 0; +inp[13528] = 1073694721; +inp[13529] = 0; +inp[13530] = 1073693697; +inp[13531] = 0; +inp[13532] = 1073692673; +inp[13533] = 0; +inp[13534] = 1073691649; +inp[13535] = 0; +inp[13536] = 1073690625; +inp[13537] = 0; +inp[13538] = 1073689601; +inp[13539] = 0; +inp[13540] = 1073688577; +inp[13541] = 0; +inp[13542] = 1073687553; +inp[13543] = 0; +inp[13544] = 1073686529; +inp[13545] = 0; +inp[13546] = 1073685505; +inp[13547] = 0; +inp[13548] = 1073684481; +inp[13549] = 0; +inp[13550] = 1073683457; +inp[13551] = 0; +inp[13552] = 1073682433; +inp[13553] = 0; +inp[13554] = 1073681409; +inp[13555] = 0; +inp[13556] = 1073680385; +inp[13557] = 0; +inp[13558] = 1073679361; +inp[13559] = 0; +inp[13560] = 1073678337; +inp[13561] = 0; +inp[13562] = 1073677313; +inp[13563] = 0; +inp[13564] = 1073676289; +inp[13565] = 0; +inp[13566] = 1073675266; +inp[13567] = 0; +inp[13568] = 1073674242; +inp[13569] = 0; +inp[13570] = 1073673218; +inp[13571] = 0; +inp[13572] = 1073672194; +inp[13573] = 0; +inp[13574] = 1073671170; +inp[13575] = 0; +inp[13576] = 1073670146; +inp[13577] = 0; +inp[13578] = 1073669122; +inp[13579] = 0; +inp[13580] = 1073668098; +inp[13581] = 0; +inp[13582] = 1073667074; +inp[13583] = 0; +inp[13584] = 1073666050; +inp[13585] = 0; +inp[13586] = 1073665026; +inp[13587] = 0; +inp[13588] = 1073664002; +inp[13589] = 0; +inp[13590] = 1073662978; +inp[13591] = 0; +inp[13592] = 1073661954; +inp[13593] = 0; +inp[13594] = 1073660931; +inp[13595] = 0; +inp[13596] = 1073659907; +inp[13597] = 0; +inp[13598] = 1073658883; +inp[13599] = 0; +inp[13600] = 1073657859; +inp[13601] = 0; +inp[13602] = 1073656835; +inp[13603] = 0; +inp[13604] = 1073655811; +inp[13605] = 0; +inp[13606] = 1073654787; +inp[13607] = 0; +inp[13608] = 1073653763; +inp[13609] = 0; +inp[13610] = 1073652739; +inp[13611] = 0; +inp[13612] = 1073651715; +inp[13613] = 0; +inp[13614] = 1073650691; +inp[13615] = 0; +inp[13616] = 1073649667; +inp[13617] = 0; +inp[13618] = 1073648644; +inp[13619] = 0; +inp[13620] = 1073647620; +inp[13621] = 0; +inp[13622] = 1073646596; +inp[13623] = 0; +inp[13624] = 1073645572; +inp[13625] = 0; +inp[13626] = 1073644548; +inp[13627] = 0; +inp[13628] = 1073643524; +inp[13629] = 0; +inp[13630] = 1073642500; +inp[13631] = 0; +inp[13632] = 1073641476; +inp[13633] = 0; +inp[13634] = 1073640452; +inp[13635] = 0; +inp[13636] = 1073639428; +inp[13637] = 0; +inp[13638] = 1073638404; +inp[13639] = 0; +inp[13640] = 1073637381; +inp[13641] = 0; +inp[13642] = 1073636357; +inp[13643] = 0; +inp[13644] = 1073635333; +inp[13645] = 0; +inp[13646] = 1073634309; +inp[13647] = 0; +inp[13648] = 1073633285; +inp[13649] = 0; +inp[13650] = 1073632261; +inp[13651] = 0; +inp[13652] = 1073631237; +inp[13653] = 0; +inp[13654] = 1073630213; +inp[13655] = 0; +inp[13656] = 1073629189; +inp[13657] = 0; +inp[13658] = 1073628166; +inp[13659] = 0; +inp[13660] = 1073627142; +inp[13661] = 0; +inp[13662] = 1073626118; +inp[13663] = 0; +inp[13664] = 1073625094; +inp[13665] = 0; +inp[13666] = 1073624070; +inp[13667] = 0; +inp[13668] = 1073623046; +inp[13669] = 0; +inp[13670] = 1073622022; +inp[13671] = 0; +inp[13672] = 1073620998; +inp[13673] = 0; +inp[13674] = 1073619974; +inp[13675] = 0; +inp[13676] = 1073618951; +inp[13677] = 0; +inp[13678] = 1073617927; +inp[13679] = 0; +inp[13680] = 1073616903; +inp[13681] = 0; +inp[13682] = 1073615879; +inp[13683] = 0; +inp[13684] = 1073614855; +inp[13685] = 0; +inp[13686] = 1073613831; +inp[13687] = 0; +inp[13688] = 1073612807; +inp[13689] = 0; +inp[13690] = 1073611783; +inp[13691] = 0; +inp[13692] = 1073741824; +inp[13693] = 1073741824; +inp[13694] = 1073741312; +inp[13695] = 0; +inp[13696] = 1073740800; +inp[13697] = 0; +inp[13698] = 1073740288; +inp[13699] = 0; +inp[13700] = 1073739776; +inp[13701] = 0; +inp[13702] = 1073739264; +inp[13703] = 0; +inp[13704] = 1073738752; +inp[13705] = 0; +inp[13706] = 1073738240; +inp[13707] = 0; +inp[13708] = 1073737728; +inp[13709] = 0; +inp[13710] = 1073737216; +inp[13711] = 0; +inp[13712] = 1073736704; +inp[13713] = 0; +inp[13714] = 1073736192; +inp[13715] = 0; +inp[13716] = 1073735680; +inp[13717] = 0; +inp[13718] = 1073735168; +inp[13719] = 0; +inp[13720] = 1073734656; +inp[13721] = 0; +inp[13722] = 1073734144; +inp[13723] = 0; +inp[13724] = 1073733632; +inp[13725] = 0; +inp[13726] = 1073733120; +inp[13727] = 0; +inp[13728] = 1073732608; +inp[13729] = 0; +inp[13730] = 1073732096; +inp[13731] = 0; +inp[13732] = 1073731584; +inp[13733] = 0; +inp[13734] = 1073731072; +inp[13735] = 0; +inp[13736] = 1073730560; +inp[13737] = 0; +inp[13738] = 1073730048; +inp[13739] = 0; +inp[13740] = 1073729536; +inp[13741] = 0; +inp[13742] = 1073729024; +inp[13743] = 0; +inp[13744] = 1073728512; +inp[13745] = 0; +inp[13746] = 1073728000; +inp[13747] = 0; +inp[13748] = 1073727488; +inp[13749] = 0; +inp[13750] = 1073726976; +inp[13751] = 0; +inp[13752] = 1073726464; +inp[13753] = 0; +inp[13754] = 1073725952; +inp[13755] = 0; +inp[13756] = 1073725440; +inp[13757] = 0; +inp[13758] = 1073724928; +inp[13759] = 0; +inp[13760] = 1073724416; +inp[13761] = 0; +inp[13762] = 1073723904; +inp[13763] = 0; +inp[13764] = 1073723392; +inp[13765] = 0; +inp[13766] = 1073722880; +inp[13767] = 0; +inp[13768] = 1073722368; +inp[13769] = 0; +inp[13770] = 1073721856; +inp[13771] = 0; +inp[13772] = 1073721344; +inp[13773] = 0; +inp[13774] = 1073720832; +inp[13775] = 0; +inp[13776] = 1073720320; +inp[13777] = 0; +inp[13778] = 1073719808; +inp[13779] = 0; +inp[13780] = 1073719296; +inp[13781] = 0; +inp[13782] = 1073718784; +inp[13783] = 0; +inp[13784] = 1073718272; +inp[13785] = 0; +inp[13786] = 1073717760; +inp[13787] = 0; +inp[13788] = 1073717248; +inp[13789] = 0; +inp[13790] = 1073716736; +inp[13791] = 0; +inp[13792] = 1073716224; +inp[13793] = 0; +inp[13794] = 1073715712; +inp[13795] = 0; +inp[13796] = 1073715200; +inp[13797] = 0; +inp[13798] = 1073714688; +inp[13799] = 0; +inp[13800] = 1073714176; +inp[13801] = 0; +inp[13802] = 1073713664; +inp[13803] = 0; +inp[13804] = 1073713152; +inp[13805] = 0; +inp[13806] = 1073712640; +inp[13807] = 0; +inp[13808] = 1073712128; +inp[13809] = 0; +inp[13810] = 1073711616; +inp[13811] = 0; +inp[13812] = 1073711104; +inp[13813] = 0; +inp[13814] = 1073710592; +inp[13815] = 0; +inp[13816] = 1073710080; +inp[13817] = 0; +inp[13818] = 1073709568; +inp[13819] = 0; +inp[13820] = 1073709056; +inp[13821] = 0; +inp[13822] = 1073708544; +inp[13823] = 0; +inp[13824] = 1073708032; +inp[13825] = 0; +inp[13826] = 1073707520; +inp[13827] = 0; +inp[13828] = 1073707008; +inp[13829] = 0; +inp[13830] = 1073706496; +inp[13831] = 0; +inp[13832] = 1073705984; +inp[13833] = 0; +inp[13834] = 1073705472; +inp[13835] = 0; +inp[13836] = 1073704960; +inp[13837] = 0; +inp[13838] = 1073704448; +inp[13839] = 0; +inp[13840] = 1073703936; +inp[13841] = 0; +inp[13842] = 1073703424; +inp[13843] = 0; +inp[13844] = 1073702912; +inp[13845] = 0; +inp[13846] = 1073702400; +inp[13847] = 0; +inp[13848] = 1073701888; +inp[13849] = 0; +inp[13850] = 1073701376; +inp[13851] = 0; +inp[13852] = 1073700864; +inp[13853] = 0; +inp[13854] = 1073700352; +inp[13855] = 0; +inp[13856] = 1073699840; +inp[13857] = 0; +inp[13858] = 1073699328; +inp[13859] = 0; +inp[13860] = 1073698816; +inp[13861] = 0; +inp[13862] = 1073698304; +inp[13863] = 0; +inp[13864] = 1073697792; +inp[13865] = 0; +inp[13866] = 1073697280; +inp[13867] = 0; +inp[13868] = 1073696768; +inp[13869] = 0; +inp[13870] = 1073696256; +inp[13871] = 0; +inp[13872] = 1073695744; +inp[13873] = 0; +inp[13874] = 1073695233; +inp[13875] = 0; +inp[13876] = 1073694721; +inp[13877] = 0; +inp[13878] = 1073694209; +inp[13879] = 0; +inp[13880] = 1073693697; +inp[13881] = 0; +inp[13882] = 1073693185; +inp[13883] = 0; +inp[13884] = 1073692673; +inp[13885] = 0; +inp[13886] = 1073692161; +inp[13887] = 0; +inp[13888] = 1073691649; +inp[13889] = 0; +inp[13890] = 1073691137; +inp[13891] = 0; +inp[13892] = 1073690625; +inp[13893] = 0; +inp[13894] = 1073690113; +inp[13895] = 0; +inp[13896] = 1073689601; +inp[13897] = 0; +inp[13898] = 1073689089; +inp[13899] = 0; +inp[13900] = 1073688577; +inp[13901] = 0; +inp[13902] = 1073688065; +inp[13903] = 0; +inp[13904] = 1073687553; +inp[13905] = 0; +inp[13906] = 1073687041; +inp[13907] = 0; +inp[13908] = 1073686529; +inp[13909] = 0; +inp[13910] = 1073686017; +inp[13911] = 0; +inp[13912] = 1073685505; +inp[13913] = 0; +inp[13914] = 1073684993; +inp[13915] = 0; +inp[13916] = 1073684481; +inp[13917] = 0; +inp[13918] = 1073683969; +inp[13919] = 0; +inp[13920] = 1073683457; +inp[13921] = 0; +inp[13922] = 1073682945; +inp[13923] = 0; +inp[13924] = 1073682433; +inp[13925] = 0; +inp[13926] = 1073681921; +inp[13927] = 0; +inp[13928] = 1073681409; +inp[13929] = 0; +inp[13930] = 1073680897; +inp[13931] = 0; +inp[13932] = 1073680385; +inp[13933] = 0; +inp[13934] = 1073679873; +inp[13935] = 0; +inp[13936] = 1073679361; +inp[13937] = 0; +inp[13938] = 1073678849; +inp[13939] = 0; +inp[13940] = 1073678337; +inp[13941] = 0; +inp[13942] = 1073677825; +inp[13943] = 0; +inp[13944] = 1073677313; +inp[13945] = 0; +inp[13946] = 1073676801; +inp[13947] = 0; +inp[13948] = 1073741824; +inp[13949] = 1073741824; +inp[13950] = 1073741568; +inp[13951] = 0; +inp[13952] = 1073741312; +inp[13953] = 0; +inp[13954] = 1073741056; +inp[13955] = 0; +inp[13956] = 1073740800; +inp[13957] = 0; +inp[13958] = 1073740544; +inp[13959] = 0; +inp[13960] = 1073740288; +inp[13961] = 0; +inp[13962] = 1073740032; +inp[13963] = 0; +inp[13964] = 1073739776; +inp[13965] = 0; +inp[13966] = 1073739520; +inp[13967] = 0; +inp[13968] = 1073739264; +inp[13969] = 0; +inp[13970] = 1073739008; +inp[13971] = 0; +inp[13972] = 1073738752; +inp[13973] = 0; +inp[13974] = 1073738496; +inp[13975] = 0; +inp[13976] = 1073738240; +inp[13977] = 0; +inp[13978] = 1073737984; +inp[13979] = 0; +inp[13980] = 1073737728; +inp[13981] = 0; +inp[13982] = 1073737472; +inp[13983] = 0; +inp[13984] = 1073737216; +inp[13985] = 0; +inp[13986] = 1073736960; +inp[13987] = 0; +inp[13988] = 1073736704; +inp[13989] = 0; +inp[13990] = 1073736448; +inp[13991] = 0; +inp[13992] = 1073736192; +inp[13993] = 0; +inp[13994] = 1073735936; +inp[13995] = 0; +inp[13996] = 1073735680; +inp[13997] = 0; +inp[13998] = 1073735424; +inp[13999] = 0; +inp[14000] = 1073735168; +inp[14001] = 0; +inp[14002] = 1073734912; +inp[14003] = 0; +inp[14004] = 1073734656; +inp[14005] = 0; +inp[14006] = 1073734400; +inp[14007] = 0; +inp[14008] = 1073734144; +inp[14009] = 0; +inp[14010] = 1073733888; +inp[14011] = 0; +inp[14012] = 1073733632; +inp[14013] = 0; +inp[14014] = 1073733376; +inp[14015] = 0; +inp[14016] = 1073733120; +inp[14017] = 0; +inp[14018] = 1073732864; +inp[14019] = 0; +inp[14020] = 1073732608; +inp[14021] = 0; +inp[14022] = 1073732352; +inp[14023] = 0; +inp[14024] = 1073732096; +inp[14025] = 0; +inp[14026] = 1073731840; +inp[14027] = 0; +inp[14028] = 1073731584; +inp[14029] = 0; +inp[14030] = 1073731328; +inp[14031] = 0; +inp[14032] = 1073731072; +inp[14033] = 0; +inp[14034] = 1073730816; +inp[14035] = 0; +inp[14036] = 1073730560; +inp[14037] = 0; +inp[14038] = 1073730304; +inp[14039] = 0; +inp[14040] = 1073730048; +inp[14041] = 0; +inp[14042] = 1073729792; +inp[14043] = 0; +inp[14044] = 1073729536; +inp[14045] = 0; +inp[14046] = 1073729280; +inp[14047] = 0; +inp[14048] = 1073729024; +inp[14049] = 0; +inp[14050] = 1073728768; +inp[14051] = 0; +inp[14052] = 1073728512; +inp[14053] = 0; +inp[14054] = 1073728256; +inp[14055] = 0; +inp[14056] = 1073728000; +inp[14057] = 0; +inp[14058] = 1073727744; +inp[14059] = 0; +inp[14060] = 1073727488; +inp[14061] = 0; +inp[14062] = 1073727232; +inp[14063] = 0; +inp[14064] = 1073726976; +inp[14065] = 0; +inp[14066] = 1073726720; +inp[14067] = 0; +inp[14068] = 1073726464; +inp[14069] = 0; +inp[14070] = 1073726208; +inp[14071] = 0; +inp[14072] = 1073725952; +inp[14073] = 0; +inp[14074] = 1073725696; +inp[14075] = 0; +inp[14076] = 1073725440; +inp[14077] = 0; +inp[14078] = 1073725184; +inp[14079] = 0; +inp[14080] = 1073724928; +inp[14081] = 0; +inp[14082] = 1073724672; +inp[14083] = 0; +inp[14084] = 1073724416; +inp[14085] = 0; +inp[14086] = 1073724160; +inp[14087] = 0; +inp[14088] = 1073723904; +inp[14089] = 0; +inp[14090] = 1073723648; +inp[14091] = 0; +inp[14092] = 1073723392; +inp[14093] = 0; +inp[14094] = 1073723136; +inp[14095] = 0; +inp[14096] = 1073722880; +inp[14097] = 0; +inp[14098] = 1073722624; +inp[14099] = 0; +inp[14100] = 1073722368; +inp[14101] = 0; +inp[14102] = 1073722112; +inp[14103] = 0; +inp[14104] = 1073721856; +inp[14105] = 0; +inp[14106] = 1073721600; +inp[14107] = 0; +inp[14108] = 1073721344; +inp[14109] = 0; +inp[14110] = 1073721088; +inp[14111] = 0; +inp[14112] = 1073720832; +inp[14113] = 0; +inp[14114] = 1073720576; +inp[14115] = 0; +inp[14116] = 1073720320; +inp[14117] = 0; +inp[14118] = 1073720064; +inp[14119] = 0; +inp[14120] = 1073719808; +inp[14121] = 0; +inp[14122] = 1073719552; +inp[14123] = 0; +inp[14124] = 1073719296; +inp[14125] = 0; +inp[14126] = 1073719040; +inp[14127] = 0; +inp[14128] = 1073718784; +inp[14129] = 0; +inp[14130] = 1073718528; +inp[14131] = 0; +inp[14132] = 1073718272; +inp[14133] = 0; +inp[14134] = 1073718016; +inp[14135] = 0; +inp[14136] = 1073717760; +inp[14137] = 0; +inp[14138] = 1073717504; +inp[14139] = 0; +inp[14140] = 1073717248; +inp[14141] = 0; +inp[14142] = 1073716992; +inp[14143] = 0; +inp[14144] = 1073716736; +inp[14145] = 0; +inp[14146] = 1073716480; +inp[14147] = 0; +inp[14148] = 1073716224; +inp[14149] = 0; +inp[14150] = 1073715968; +inp[14151] = 0; +inp[14152] = 1073715712; +inp[14153] = 0; +inp[14154] = 1073715456; +inp[14155] = 0; +inp[14156] = 1073715200; +inp[14157] = 0; +inp[14158] = 1073714944; +inp[14159] = 0; +inp[14160] = 1073714688; +inp[14161] = 0; +inp[14162] = 1073714432; +inp[14163] = 0; +inp[14164] = 1073714176; +inp[14165] = 0; +inp[14166] = 1073713920; +inp[14167] = 0; +inp[14168] = 1073713664; +inp[14169] = 0; +inp[14170] = 1073713408; +inp[14171] = 0; +inp[14172] = 1073713152; +inp[14173] = 0; +inp[14174] = 1073712896; +inp[14175] = 0; +inp[14176] = 1073712640; +inp[14177] = 0; +inp[14178] = 1073712384; +inp[14179] = 0; +inp[14180] = 1073712128; +inp[14181] = 0; +inp[14182] = 1073711872; +inp[14183] = 0; +inp[14184] = 1073711616; +inp[14185] = 0; +inp[14186] = 1073711360; +inp[14187] = 0; +inp[14188] = 1073711104; +inp[14189] = 0; +inp[14190] = 1073710848; +inp[14191] = 0; +inp[14192] = 1073710592; +inp[14193] = 0; +inp[14194] = 1073710336; +inp[14195] = 0; +inp[14196] = 1073710080; +inp[14197] = 0; +inp[14198] = 1073709824; +inp[14199] = 0; +inp[14200] = 1073709568; +inp[14201] = 0; +inp[14202] = 1073709312; +inp[14203] = 0; +inp[14204] = 1073741824; +inp[14205] = 1073741824; +inp[14206] = 1073741696; +inp[14207] = 0; +inp[14208] = 1073741568; +inp[14209] = 0; +inp[14210] = 1073741440; +inp[14211] = 0; +inp[14212] = 1073741312; +inp[14213] = 0; +inp[14214] = 1073741184; +inp[14215] = 0; +inp[14216] = 1073741056; +inp[14217] = 0; +inp[14218] = 1073740928; +inp[14219] = 0; +inp[14220] = 1073740800; +inp[14221] = 0; +inp[14222] = 1073740672; +inp[14223] = 0; +inp[14224] = 1073740544; +inp[14225] = 0; +inp[14226] = 1073740416; +inp[14227] = 0; +inp[14228] = 1073740288; +inp[14229] = 0; +inp[14230] = 1073740160; +inp[14231] = 0; +inp[14232] = 1073740032; +inp[14233] = 0; +inp[14234] = 1073739904; +inp[14235] = 0; +inp[14236] = 1073739776; +inp[14237] = 0; +inp[14238] = 1073739648; +inp[14239] = 0; +inp[14240] = 1073739520; +inp[14241] = 0; +inp[14242] = 1073739392; +inp[14243] = 0; +inp[14244] = 1073739264; +inp[14245] = 0; +inp[14246] = 1073739136; +inp[14247] = 0; +inp[14248] = 1073739008; +inp[14249] = 0; +inp[14250] = 1073738880; +inp[14251] = 0; +inp[14252] = 1073738752; +inp[14253] = 0; +inp[14254] = 1073738624; +inp[14255] = 0; +inp[14256] = 1073738496; +inp[14257] = 0; +inp[14258] = 1073738368; +inp[14259] = 0; +inp[14260] = 1073738240; +inp[14261] = 0; +inp[14262] = 1073738112; +inp[14263] = 0; +inp[14264] = 1073737984; +inp[14265] = 0; +inp[14266] = 1073737856; +inp[14267] = 0; +inp[14268] = 1073737728; +inp[14269] = 0; +inp[14270] = 1073737600; +inp[14271] = 0; +inp[14272] = 1073737472; +inp[14273] = 0; +inp[14274] = 1073737344; +inp[14275] = 0; +inp[14276] = 1073737216; +inp[14277] = 0; +inp[14278] = 1073737088; +inp[14279] = 0; +inp[14280] = 1073736960; +inp[14281] = 0; +inp[14282] = 1073736832; +inp[14283] = 0; +inp[14284] = 1073736704; +inp[14285] = 0; +inp[14286] = 1073736576; +inp[14287] = 0; +inp[14288] = 1073736448; +inp[14289] = 0; +inp[14290] = 1073736320; +inp[14291] = 0; +inp[14292] = 1073736192; +inp[14293] = 0; +inp[14294] = 1073736064; +inp[14295] = 0; +inp[14296] = 1073735936; +inp[14297] = 0; +inp[14298] = 1073735808; +inp[14299] = 0; +inp[14300] = 1073735680; +inp[14301] = 0; +inp[14302] = 1073735552; +inp[14303] = 0; +inp[14304] = 1073735424; +inp[14305] = 0; +inp[14306] = 1073735296; +inp[14307] = 0; +inp[14308] = 1073735168; +inp[14309] = 0; +inp[14310] = 1073735040; +inp[14311] = 0; +inp[14312] = 1073734912; +inp[14313] = 0; +inp[14314] = 1073734784; +inp[14315] = 0; +inp[14316] = 1073734656; +inp[14317] = 0; +inp[14318] = 1073734528; +inp[14319] = 0; +inp[14320] = 1073734400; +inp[14321] = 0; +inp[14322] = 1073734272; +inp[14323] = 0; +inp[14324] = 1073734144; +inp[14325] = 0; +inp[14326] = 1073734016; +inp[14327] = 0; +inp[14328] = 1073733888; +inp[14329] = 0; +inp[14330] = 1073733760; +inp[14331] = 0; +inp[14332] = 1073733632; +inp[14333] = 0; +inp[14334] = 1073733504; +inp[14335] = 0; +inp[14336] = 1073733376; +inp[14337] = 0; +inp[14338] = 1073733248; +inp[14339] = 0; +inp[14340] = 1073733120; +inp[14341] = 0; +inp[14342] = 1073732992; +inp[14343] = 0; +inp[14344] = 1073732864; +inp[14345] = 0; +inp[14346] = 1073732736; +inp[14347] = 0; +inp[14348] = 1073732608; +inp[14349] = 0; +inp[14350] = 1073732480; +inp[14351] = 0; +inp[14352] = 1073732352; +inp[14353] = 0; +inp[14354] = 1073732224; +inp[14355] = 0; +inp[14356] = 1073732096; +inp[14357] = 0; +inp[14358] = 1073731968; +inp[14359] = 0; +inp[14360] = 1073731840; +inp[14361] = 0; +inp[14362] = 1073731712; +inp[14363] = 0; +inp[14364] = 1073731584; +inp[14365] = 0; +inp[14366] = 1073731456; +inp[14367] = 0; +inp[14368] = 1073731328; +inp[14369] = 0; +inp[14370] = 1073731200; +inp[14371] = 0; +inp[14372] = 1073731072; +inp[14373] = 0; +inp[14374] = 1073730944; +inp[14375] = 0; +inp[14376] = 1073730816; +inp[14377] = 0; +inp[14378] = 1073730688; +inp[14379] = 0; +inp[14380] = 1073730560; +inp[14381] = 0; +inp[14382] = 1073730432; +inp[14383] = 0; +inp[14384] = 1073730304; +inp[14385] = 0; +inp[14386] = 1073730176; +inp[14387] = 0; +inp[14388] = 1073730048; +inp[14389] = 0; +inp[14390] = 1073729920; +inp[14391] = 0; +inp[14392] = 1073729792; +inp[14393] = 0; +inp[14394] = 1073729664; +inp[14395] = 0; +inp[14396] = 1073729536; +inp[14397] = 0; +inp[14398] = 1073729408; +inp[14399] = 0; +inp[14400] = 1073729280; +inp[14401] = 0; +inp[14402] = 1073729152; +inp[14403] = 0; +inp[14404] = 1073729024; +inp[14405] = 0; +inp[14406] = 1073728896; +inp[14407] = 0; +inp[14408] = 1073728768; +inp[14409] = 0; +inp[14410] = 1073728640; +inp[14411] = 0; +inp[14412] = 1073728512; +inp[14413] = 0; +inp[14414] = 1073728384; +inp[14415] = 0; +inp[14416] = 1073728256; +inp[14417] = 0; +inp[14418] = 1073728128; +inp[14419] = 0; +inp[14420] = 1073728000; +inp[14421] = 0; +inp[14422] = 1073727872; +inp[14423] = 0; +inp[14424] = 1073727744; +inp[14425] = 0; +inp[14426] = 1073727616; +inp[14427] = 0; +inp[14428] = 1073727488; +inp[14429] = 0; +inp[14430] = 1073727360; +inp[14431] = 0; +inp[14432] = 1073727232; +inp[14433] = 0; +inp[14434] = 1073727104; +inp[14435] = 0; +inp[14436] = 1073726976; +inp[14437] = 0; +inp[14438] = 1073726848; +inp[14439] = 0; +inp[14440] = 1073726720; +inp[14441] = 0; +inp[14442] = 1073726592; +inp[14443] = 0; +inp[14444] = 1073726464; +inp[14445] = 0; +inp[14446] = 1073726336; +inp[14447] = 0; +inp[14448] = 1073726208; +inp[14449] = 0; +inp[14450] = 1073726080; +inp[14451] = 0; +inp[14452] = 1073725952; +inp[14453] = 0; +inp[14454] = 1073725824; +inp[14455] = 0; +inp[14456] = 1073725696; +inp[14457] = 0; +inp[14458] = 1073725568; +inp[14459] = 0; +inp[14460] = 1073741824; +inp[14461] = 1073741824; +inp[14462] = 1073741760; +inp[14463] = 0; +inp[14464] = 1073741696; +inp[14465] = 0; +inp[14466] = 1073741632; +inp[14467] = 0; +inp[14468] = 1073741568; +inp[14469] = 0; +inp[14470] = 1073741504; +inp[14471] = 0; +inp[14472] = 1073741440; +inp[14473] = 0; +inp[14474] = 1073741376; +inp[14475] = 0; +inp[14476] = 1073741312; +inp[14477] = 0; +inp[14478] = 1073741248; +inp[14479] = 0; +inp[14480] = 1073741184; +inp[14481] = 0; +inp[14482] = 1073741120; +inp[14483] = 0; +inp[14484] = 1073741056; +inp[14485] = 0; +inp[14486] = 1073740992; +inp[14487] = 0; +inp[14488] = 1073740928; +inp[14489] = 0; +inp[14490] = 1073740864; +inp[14491] = 0; +inp[14492] = 1073740800; +inp[14493] = 0; +inp[14494] = 1073740736; +inp[14495] = 0; +inp[14496] = 1073740672; +inp[14497] = 0; +inp[14498] = 1073740608; +inp[14499] = 0; +inp[14500] = 1073740544; +inp[14501] = 0; +inp[14502] = 1073740480; +inp[14503] = 0; +inp[14504] = 1073740416; +inp[14505] = 0; +inp[14506] = 1073740352; +inp[14507] = 0; +inp[14508] = 1073740288; +inp[14509] = 0; +inp[14510] = 1073740224; +inp[14511] = 0; +inp[14512] = 1073740160; +inp[14513] = 0; +inp[14514] = 1073740096; +inp[14515] = 0; +inp[14516] = 1073740032; +inp[14517] = 0; +inp[14518] = 1073739968; +inp[14519] = 0; +inp[14520] = 1073739904; +inp[14521] = 0; +inp[14522] = 1073739840; +inp[14523] = 0; +inp[14524] = 1073739776; +inp[14525] = 0; +inp[14526] = 1073739712; +inp[14527] = 0; +inp[14528] = 1073739648; +inp[14529] = 0; +inp[14530] = 1073739584; +inp[14531] = 0; +inp[14532] = 1073739520; +inp[14533] = 0; +inp[14534] = 1073739456; +inp[14535] = 0; +inp[14536] = 1073739392; +inp[14537] = 0; +inp[14538] = 1073739328; +inp[14539] = 0; +inp[14540] = 1073739264; +inp[14541] = 0; +inp[14542] = 1073739200; +inp[14543] = 0; +inp[14544] = 1073739136; +inp[14545] = 0; +inp[14546] = 1073739072; +inp[14547] = 0; +inp[14548] = 1073739008; +inp[14549] = 0; +inp[14550] = 1073738944; +inp[14551] = 0; +inp[14552] = 1073738880; +inp[14553] = 0; +inp[14554] = 1073738816; +inp[14555] = 0; +inp[14556] = 1073738752; +inp[14557] = 0; +inp[14558] = 1073738688; +inp[14559] = 0; +inp[14560] = 1073738624; +inp[14561] = 0; +inp[14562] = 1073738560; +inp[14563] = 0; +inp[14564] = 1073738496; +inp[14565] = 0; +inp[14566] = 1073738432; +inp[14567] = 0; +inp[14568] = 1073738368; +inp[14569] = 0; +inp[14570] = 1073738304; +inp[14571] = 0; +inp[14572] = 1073738240; +inp[14573] = 0; +inp[14574] = 1073738176; +inp[14575] = 0; +inp[14576] = 1073738112; +inp[14577] = 0; +inp[14578] = 1073738048; +inp[14579] = 0; +inp[14580] = 1073737984; +inp[14581] = 0; +inp[14582] = 1073737920; +inp[14583] = 0; +inp[14584] = 1073737856; +inp[14585] = 0; +inp[14586] = 1073737792; +inp[14587] = 0; +inp[14588] = 1073737728; +inp[14589] = 0; +inp[14590] = 1073737664; +inp[14591] = 0; +inp[14592] = 1073737600; +inp[14593] = 0; +inp[14594] = 1073737536; +inp[14595] = 0; +inp[14596] = 1073737472; +inp[14597] = 0; +inp[14598] = 1073737408; +inp[14599] = 0; +inp[14600] = 1073737344; +inp[14601] = 0; +inp[14602] = 1073737280; +inp[14603] = 0; +inp[14604] = 1073737216; +inp[14605] = 0; +inp[14606] = 1073737152; +inp[14607] = 0; +inp[14608] = 1073737088; +inp[14609] = 0; +inp[14610] = 1073737024; +inp[14611] = 0; +inp[14612] = 1073736960; +inp[14613] = 0; +inp[14614] = 1073736896; +inp[14615] = 0; +inp[14616] = 1073736832; +inp[14617] = 0; +inp[14618] = 1073736768; +inp[14619] = 0; +inp[14620] = 1073736704; +inp[14621] = 0; +inp[14622] = 1073736640; +inp[14623] = 0; +inp[14624] = 1073736576; +inp[14625] = 0; +inp[14626] = 1073736512; +inp[14627] = 0; +inp[14628] = 1073736448; +inp[14629] = 0; +inp[14630] = 1073736384; +inp[14631] = 0; +inp[14632] = 1073736320; +inp[14633] = 0; +inp[14634] = 1073736256; +inp[14635] = 0; +inp[14636] = 1073736192; +inp[14637] = 0; +inp[14638] = 1073736128; +inp[14639] = 0; +inp[14640] = 1073736064; +inp[14641] = 0; +inp[14642] = 1073736000; +inp[14643] = 0; +inp[14644] = 1073735936; +inp[14645] = 0; +inp[14646] = 1073735872; +inp[14647] = 0; +inp[14648] = 1073735808; +inp[14649] = 0; +inp[14650] = 1073735744; +inp[14651] = 0; +inp[14652] = 1073735680; +inp[14653] = 0; +inp[14654] = 1073735616; +inp[14655] = 0; +inp[14656] = 1073735552; +inp[14657] = 0; +inp[14658] = 1073735488; +inp[14659] = 0; +inp[14660] = 1073735424; +inp[14661] = 0; +inp[14662] = 1073735360; +inp[14663] = 0; +inp[14664] = 1073735296; +inp[14665] = 0; +inp[14666] = 1073735232; +inp[14667] = 0; +inp[14668] = 1073735168; +inp[14669] = 0; +inp[14670] = 1073735104; +inp[14671] = 0; +inp[14672] = 1073735040; +inp[14673] = 0; +inp[14674] = 1073734976; +inp[14675] = 0; +inp[14676] = 1073734912; +inp[14677] = 0; +inp[14678] = 1073734848; +inp[14679] = 0; +inp[14680] = 1073734784; +inp[14681] = 0; +inp[14682] = 1073734720; +inp[14683] = 0; +inp[14684] = 1073734656; +inp[14685] = 0; +inp[14686] = 1073734592; +inp[14687] = 0; +inp[14688] = 1073734528; +inp[14689] = 0; +inp[14690] = 1073734464; +inp[14691] = 0; +inp[14692] = 1073734400; +inp[14693] = 0; +inp[14694] = 1073734336; +inp[14695] = 0; +inp[14696] = 1073734272; +inp[14697] = 0; +inp[14698] = 1073734208; +inp[14699] = 0; +inp[14700] = 1073734144; +inp[14701] = 0; +inp[14702] = 1073734080; +inp[14703] = 0; +inp[14704] = 1073734016; +inp[14705] = 0; +inp[14706] = 1073733952; +inp[14707] = 0; +inp[14708] = 1073733888; +inp[14709] = 0; +inp[14710] = 1073733824; +inp[14711] = 0; +inp[14712] = 1073733760; +inp[14713] = 0; +inp[14714] = 1073733696; +inp[14715] = 0; +inp[14716] = 1073741824; +inp[14717] = 1073741824; +inp[14718] = 1073741792; +inp[14719] = 0; +inp[14720] = 1073741760; +inp[14721] = 0; +inp[14722] = 1073741728; +inp[14723] = 0; +inp[14724] = 1073741696; +inp[14725] = 0; +inp[14726] = 1073741664; +inp[14727] = 0; +inp[14728] = 1073741632; +inp[14729] = 0; +inp[14730] = 1073741600; +inp[14731] = 0; +inp[14732] = 1073741568; +inp[14733] = 0; +inp[14734] = 1073741536; +inp[14735] = 0; +inp[14736] = 1073741504; +inp[14737] = 0; +inp[14738] = 1073741472; +inp[14739] = 0; +inp[14740] = 1073741440; +inp[14741] = 0; +inp[14742] = 1073741408; +inp[14743] = 0; +inp[14744] = 1073741376; +inp[14745] = 0; +inp[14746] = 1073741344; +inp[14747] = 0; +inp[14748] = 1073741312; +inp[14749] = 0; +inp[14750] = 1073741280; +inp[14751] = 0; +inp[14752] = 1073741248; +inp[14753] = 0; +inp[14754] = 1073741216; +inp[14755] = 0; +inp[14756] = 1073741184; +inp[14757] = 0; +inp[14758] = 1073741152; +inp[14759] = 0; +inp[14760] = 1073741120; +inp[14761] = 0; +inp[14762] = 1073741088; +inp[14763] = 0; +inp[14764] = 1073741056; +inp[14765] = 0; +inp[14766] = 1073741024; +inp[14767] = 0; +inp[14768] = 1073740992; +inp[14769] = 0; +inp[14770] = 1073740960; +inp[14771] = 0; +inp[14772] = 1073740928; +inp[14773] = 0; +inp[14774] = 1073740896; +inp[14775] = 0; +inp[14776] = 1073740864; +inp[14777] = 0; +inp[14778] = 1073740832; +inp[14779] = 0; +inp[14780] = 1073740800; +inp[14781] = 0; +inp[14782] = 1073740768; +inp[14783] = 0; +inp[14784] = 1073740736; +inp[14785] = 0; +inp[14786] = 1073740704; +inp[14787] = 0; +inp[14788] = 1073740672; +inp[14789] = 0; +inp[14790] = 1073740640; +inp[14791] = 0; +inp[14792] = 1073740608; +inp[14793] = 0; +inp[14794] = 1073740576; +inp[14795] = 0; +inp[14796] = 1073740544; +inp[14797] = 0; +inp[14798] = 1073740512; +inp[14799] = 0; +inp[14800] = 1073740480; +inp[14801] = 0; +inp[14802] = 1073740448; +inp[14803] = 0; +inp[14804] = 1073740416; +inp[14805] = 0; +inp[14806] = 1073740384; +inp[14807] = 0; +inp[14808] = 1073740352; +inp[14809] = 0; +inp[14810] = 1073740320; +inp[14811] = 0; +inp[14812] = 1073740288; +inp[14813] = 0; +inp[14814] = 1073740256; +inp[14815] = 0; +inp[14816] = 1073740224; +inp[14817] = 0; +inp[14818] = 1073740192; +inp[14819] = 0; +inp[14820] = 1073740160; +inp[14821] = 0; +inp[14822] = 1073740128; +inp[14823] = 0; +inp[14824] = 1073740096; +inp[14825] = 0; +inp[14826] = 1073740064; +inp[14827] = 0; +inp[14828] = 1073740032; +inp[14829] = 0; +inp[14830] = 1073740000; +inp[14831] = 0; +inp[14832] = 1073739968; +inp[14833] = 0; +inp[14834] = 1073739936; +inp[14835] = 0; +inp[14836] = 1073739904; +inp[14837] = 0; +inp[14838] = 1073739872; +inp[14839] = 0; +inp[14840] = 1073739840; +inp[14841] = 0; +inp[14842] = 1073739808; +inp[14843] = 0; +inp[14844] = 1073739776; +inp[14845] = 0; +inp[14846] = 1073739744; +inp[14847] = 0; +inp[14848] = 1073739712; +inp[14849] = 0; +inp[14850] = 1073739680; +inp[14851] = 0; +inp[14852] = 1073739648; +inp[14853] = 0; +inp[14854] = 1073739616; +inp[14855] = 0; +inp[14856] = 1073739584; +inp[14857] = 0; +inp[14858] = 1073739552; +inp[14859] = 0; +inp[14860] = 1073739520; +inp[14861] = 0; +inp[14862] = 1073739488; +inp[14863] = 0; +inp[14864] = 1073739456; +inp[14865] = 0; +inp[14866] = 1073739424; +inp[14867] = 0; +inp[14868] = 1073739392; +inp[14869] = 0; +inp[14870] = 1073739360; +inp[14871] = 0; +inp[14872] = 1073739328; +inp[14873] = 0; +inp[14874] = 1073739296; +inp[14875] = 0; +inp[14876] = 1073739264; +inp[14877] = 0; +inp[14878] = 1073739232; +inp[14879] = 0; +inp[14880] = 1073739200; +inp[14881] = 0; +inp[14882] = 1073739168; +inp[14883] = 0; +inp[14884] = 1073739136; +inp[14885] = 0; +inp[14886] = 1073739104; +inp[14887] = 0; +inp[14888] = 1073739072; +inp[14889] = 0; +inp[14890] = 1073739040; +inp[14891] = 0; +inp[14892] = 1073739008; +inp[14893] = 0; +inp[14894] = 1073738976; +inp[14895] = 0; +inp[14896] = 1073738944; +inp[14897] = 0; +inp[14898] = 1073738912; +inp[14899] = 0; +inp[14900] = 1073738880; +inp[14901] = 0; +inp[14902] = 1073738848; +inp[14903] = 0; +inp[14904] = 1073738816; +inp[14905] = 0; +inp[14906] = 1073738784; +inp[14907] = 0; +inp[14908] = 1073738752; +inp[14909] = 0; +inp[14910] = 1073738720; +inp[14911] = 0; +inp[14912] = 1073738688; +inp[14913] = 0; +inp[14914] = 1073738656; +inp[14915] = 0; +inp[14916] = 1073738624; +inp[14917] = 0; +inp[14918] = 1073738592; +inp[14919] = 0; +inp[14920] = 1073738560; +inp[14921] = 0; +inp[14922] = 1073738528; +inp[14923] = 0; +inp[14924] = 1073738496; +inp[14925] = 0; +inp[14926] = 1073738464; +inp[14927] = 0; +inp[14928] = 1073738432; +inp[14929] = 0; +inp[14930] = 1073738400; +inp[14931] = 0; +inp[14932] = 1073738368; +inp[14933] = 0; +inp[14934] = 1073738336; +inp[14935] = 0; +inp[14936] = 1073738304; +inp[14937] = 0; +inp[14938] = 1073738272; +inp[14939] = 0; +inp[14940] = 1073738240; +inp[14941] = 0; +inp[14942] = 1073738208; +inp[14943] = 0; +inp[14944] = 1073738176; +inp[14945] = 0; +inp[14946] = 1073738144; +inp[14947] = 0; +inp[14948] = 1073738112; +inp[14949] = 0; +inp[14950] = 1073738080; +inp[14951] = 0; +inp[14952] = 1073738048; +inp[14953] = 0; +inp[14954] = 1073738016; +inp[14955] = 0; +inp[14956] = 1073737984; +inp[14957] = 0; +inp[14958] = 1073737952; +inp[14959] = 0; +inp[14960] = 1073737920; +inp[14961] = 0; +inp[14962] = 1073737888; +inp[14963] = 0; +inp[14964] = 1073737856; +inp[14965] = 0; +inp[14966] = 1073737824; +inp[14967] = 0; +inp[14968] = 1073737792; +inp[14969] = 0; +inp[14970] = 1073737760; +inp[14971] = 0; +inp[14972] = 1073741824; +inp[14973] = 1073741824; +inp[14974] = 1073741808; +inp[14975] = 0; +inp[14976] = 1073741792; +inp[14977] = 0; +inp[14978] = 1073741776; +inp[14979] = 0; +inp[14980] = 1073741760; +inp[14981] = 0; +inp[14982] = 1073741744; +inp[14983] = 0; +inp[14984] = 1073741728; +inp[14985] = 0; +inp[14986] = 1073741712; +inp[14987] = 0; +inp[14988] = 1073741696; +inp[14989] = 0; +inp[14990] = 1073741680; +inp[14991] = 0; +inp[14992] = 1073741664; +inp[14993] = 0; +inp[14994] = 1073741648; +inp[14995] = 0; +inp[14996] = 1073741632; +inp[14997] = 0; +inp[14998] = 1073741616; +inp[14999] = 0; +inp[15000] = 1073741600; +inp[15001] = 0; +inp[15002] = 1073741584; +inp[15003] = 0; +inp[15004] = 1073741568; +inp[15005] = 0; +inp[15006] = 1073741552; +inp[15007] = 0; +inp[15008] = 1073741536; +inp[15009] = 0; +inp[15010] = 1073741520; +inp[15011] = 0; +inp[15012] = 1073741504; +inp[15013] = 0; +inp[15014] = 1073741488; +inp[15015] = 0; +inp[15016] = 1073741472; +inp[15017] = 0; +inp[15018] = 1073741456; +inp[15019] = 0; +inp[15020] = 1073741440; +inp[15021] = 0; +inp[15022] = 1073741424; +inp[15023] = 0; +inp[15024] = 1073741408; +inp[15025] = 0; +inp[15026] = 1073741392; +inp[15027] = 0; +inp[15028] = 1073741376; +inp[15029] = 0; +inp[15030] = 1073741360; +inp[15031] = 0; +inp[15032] = 1073741344; +inp[15033] = 0; +inp[15034] = 1073741328; +inp[15035] = 0; +inp[15036] = 1073741312; +inp[15037] = 0; +inp[15038] = 1073741296; +inp[15039] = 0; +inp[15040] = 1073741280; +inp[15041] = 0; +inp[15042] = 1073741264; +inp[15043] = 0; +inp[15044] = 1073741248; +inp[15045] = 0; +inp[15046] = 1073741232; +inp[15047] = 0; +inp[15048] = 1073741216; +inp[15049] = 0; +inp[15050] = 1073741200; +inp[15051] = 0; +inp[15052] = 1073741184; +inp[15053] = 0; +inp[15054] = 1073741168; +inp[15055] = 0; +inp[15056] = 1073741152; +inp[15057] = 0; +inp[15058] = 1073741136; +inp[15059] = 0; +inp[15060] = 1073741120; +inp[15061] = 0; +inp[15062] = 1073741104; +inp[15063] = 0; +inp[15064] = 1073741088; +inp[15065] = 0; +inp[15066] = 1073741072; +inp[15067] = 0; +inp[15068] = 1073741056; +inp[15069] = 0; +inp[15070] = 1073741040; +inp[15071] = 0; +inp[15072] = 1073741024; +inp[15073] = 0; +inp[15074] = 1073741008; +inp[15075] = 0; +inp[15076] = 1073740992; +inp[15077] = 0; +inp[15078] = 1073740976; +inp[15079] = 0; +inp[15080] = 1073740960; +inp[15081] = 0; +inp[15082] = 1073740944; +inp[15083] = 0; +inp[15084] = 1073740928; +inp[15085] = 0; +inp[15086] = 1073740912; +inp[15087] = 0; +inp[15088] = 1073740896; +inp[15089] = 0; +inp[15090] = 1073740880; +inp[15091] = 0; +inp[15092] = 1073740864; +inp[15093] = 0; +inp[15094] = 1073740848; +inp[15095] = 0; +inp[15096] = 1073740832; +inp[15097] = 0; +inp[15098] = 1073740816; +inp[15099] = 0; +inp[15100] = 1073740800; +inp[15101] = 0; +inp[15102] = 1073740784; +inp[15103] = 0; +inp[15104] = 1073740768; +inp[15105] = 0; +inp[15106] = 1073740752; +inp[15107] = 0; +inp[15108] = 1073740736; +inp[15109] = 0; +inp[15110] = 1073740720; +inp[15111] = 0; +inp[15112] = 1073740704; +inp[15113] = 0; +inp[15114] = 1073740688; +inp[15115] = 0; +inp[15116] = 1073740672; +inp[15117] = 0; +inp[15118] = 1073740656; +inp[15119] = 0; +inp[15120] = 1073740640; +inp[15121] = 0; +inp[15122] = 1073740624; +inp[15123] = 0; +inp[15124] = 1073740608; +inp[15125] = 0; +inp[15126] = 1073740592; +inp[15127] = 0; +inp[15128] = 1073740576; +inp[15129] = 0; +inp[15130] = 1073740560; +inp[15131] = 0; +inp[15132] = 1073740544; +inp[15133] = 0; +inp[15134] = 1073740528; +inp[15135] = 0; +inp[15136] = 1073740512; +inp[15137] = 0; +inp[15138] = 1073740496; +inp[15139] = 0; +inp[15140] = 1073740480; +inp[15141] = 0; +inp[15142] = 1073740464; +inp[15143] = 0; +inp[15144] = 1073740448; +inp[15145] = 0; +inp[15146] = 1073740432; +inp[15147] = 0; +inp[15148] = 1073740416; +inp[15149] = 0; +inp[15150] = 1073740400; +inp[15151] = 0; +inp[15152] = 1073740384; +inp[15153] = 0; +inp[15154] = 1073740368; +inp[15155] = 0; +inp[15156] = 1073740352; +inp[15157] = 0; +inp[15158] = 1073740336; +inp[15159] = 0; +inp[15160] = 1073740320; +inp[15161] = 0; +inp[15162] = 1073740304; +inp[15163] = 0; +inp[15164] = 1073740288; +inp[15165] = 0; +inp[15166] = 1073740272; +inp[15167] = 0; +inp[15168] = 1073740256; +inp[15169] = 0; +inp[15170] = 1073740240; +inp[15171] = 0; +inp[15172] = 1073740224; +inp[15173] = 0; +inp[15174] = 1073740208; +inp[15175] = 0; +inp[15176] = 1073740192; +inp[15177] = 0; +inp[15178] = 1073740176; +inp[15179] = 0; +inp[15180] = 1073740160; +inp[15181] = 0; +inp[15182] = 1073740144; +inp[15183] = 0; +inp[15184] = 1073740128; +inp[15185] = 0; +inp[15186] = 1073740112; +inp[15187] = 0; +inp[15188] = 1073740096; +inp[15189] = 0; +inp[15190] = 1073740080; +inp[15191] = 0; +inp[15192] = 1073740064; +inp[15193] = 0; +inp[15194] = 1073740048; +inp[15195] = 0; +inp[15196] = 1073740032; +inp[15197] = 0; +inp[15198] = 1073740016; +inp[15199] = 0; +inp[15200] = 1073740000; +inp[15201] = 0; +inp[15202] = 1073739984; +inp[15203] = 0; +inp[15204] = 1073739968; +inp[15205] = 0; +inp[15206] = 1073739952; +inp[15207] = 0; +inp[15208] = 1073739936; +inp[15209] = 0; +inp[15210] = 1073739920; +inp[15211] = 0; +inp[15212] = 1073739904; +inp[15213] = 0; +inp[15214] = 1073739888; +inp[15215] = 0; +inp[15216] = 1073739872; +inp[15217] = 0; +inp[15218] = 1073739856; +inp[15219] = 0; +inp[15220] = 1073739840; +inp[15221] = 0; +inp[15222] = 1073739824; +inp[15223] = 0; +inp[15224] = 1073739808; +inp[15225] = 0; +inp[15226] = 1073739792; +inp[15227] = 0; +inp[15228] = 1073741824; +inp[15229] = 1073741824; +inp[15230] = 1073741816; +inp[15231] = 0; +inp[15232] = 1073741808; +inp[15233] = 0; +inp[15234] = 1073741800; +inp[15235] = 0; +inp[15236] = 1073741792; +inp[15237] = 0; +inp[15238] = 1073741784; +inp[15239] = 0; +inp[15240] = 1073741776; +inp[15241] = 0; +inp[15242] = 1073741768; +inp[15243] = 0; +inp[15244] = 1073741760; +inp[15245] = 0; +inp[15246] = 1073741752; +inp[15247] = 0; +inp[15248] = 1073741744; +inp[15249] = 0; +inp[15250] = 1073741736; +inp[15251] = 0; +inp[15252] = 1073741728; +inp[15253] = 0; +inp[15254] = 1073741720; +inp[15255] = 0; +inp[15256] = 1073741712; +inp[15257] = 0; +inp[15258] = 1073741704; +inp[15259] = 0; +inp[15260] = 1073741696; +inp[15261] = 0; +inp[15262] = 1073741688; +inp[15263] = 0; +inp[15264] = 1073741680; +inp[15265] = 0; +inp[15266] = 1073741672; +inp[15267] = 0; +inp[15268] = 1073741664; +inp[15269] = 0; +inp[15270] = 1073741656; +inp[15271] = 0; +inp[15272] = 1073741648; +inp[15273] = 0; +inp[15274] = 1073741640; +inp[15275] = 0; +inp[15276] = 1073741632; +inp[15277] = 0; +inp[15278] = 1073741624; +inp[15279] = 0; +inp[15280] = 1073741616; +inp[15281] = 0; +inp[15282] = 1073741608; +inp[15283] = 0; +inp[15284] = 1073741600; +inp[15285] = 0; +inp[15286] = 1073741592; +inp[15287] = 0; +inp[15288] = 1073741584; +inp[15289] = 0; +inp[15290] = 1073741576; +inp[15291] = 0; +inp[15292] = 1073741568; +inp[15293] = 0; +inp[15294] = 1073741560; +inp[15295] = 0; +inp[15296] = 1073741552; +inp[15297] = 0; +inp[15298] = 1073741544; +inp[15299] = 0; +inp[15300] = 1073741536; +inp[15301] = 0; +inp[15302] = 1073741528; +inp[15303] = 0; +inp[15304] = 1073741520; +inp[15305] = 0; +inp[15306] = 1073741512; +inp[15307] = 0; +inp[15308] = 1073741504; +inp[15309] = 0; +inp[15310] = 1073741496; +inp[15311] = 0; +inp[15312] = 1073741488; +inp[15313] = 0; +inp[15314] = 1073741480; +inp[15315] = 0; +inp[15316] = 1073741472; +inp[15317] = 0; +inp[15318] = 1073741464; +inp[15319] = 0; +inp[15320] = 1073741456; +inp[15321] = 0; +inp[15322] = 1073741448; +inp[15323] = 0; +inp[15324] = 1073741440; +inp[15325] = 0; +inp[15326] = 1073741432; +inp[15327] = 0; +inp[15328] = 1073741424; +inp[15329] = 0; +inp[15330] = 1073741416; +inp[15331] = 0; +inp[15332] = 1073741408; +inp[15333] = 0; +inp[15334] = 1073741400; +inp[15335] = 0; +inp[15336] = 1073741392; +inp[15337] = 0; +inp[15338] = 1073741384; +inp[15339] = 0; +inp[15340] = 1073741376; +inp[15341] = 0; +inp[15342] = 1073741368; +inp[15343] = 0; +inp[15344] = 1073741360; +inp[15345] = 0; +inp[15346] = 1073741352; +inp[15347] = 0; +inp[15348] = 1073741344; +inp[15349] = 0; +inp[15350] = 1073741336; +inp[15351] = 0; +inp[15352] = 1073741328; +inp[15353] = 0; +inp[15354] = 1073741320; +inp[15355] = 0; +inp[15356] = 1073741312; +inp[15357] = 0; +inp[15358] = 1073741304; +inp[15359] = 0; +inp[15360] = 1073741296; +inp[15361] = 0; +inp[15362] = 1073741288; +inp[15363] = 0; +inp[15364] = 1073741280; +inp[15365] = 0; +inp[15366] = 1073741272; +inp[15367] = 0; +inp[15368] = 1073741264; +inp[15369] = 0; +inp[15370] = 1073741256; +inp[15371] = 0; +inp[15372] = 1073741248; +inp[15373] = 0; +inp[15374] = 1073741240; +inp[15375] = 0; +inp[15376] = 1073741232; +inp[15377] = 0; +inp[15378] = 1073741224; +inp[15379] = 0; +inp[15380] = 1073741216; +inp[15381] = 0; +inp[15382] = 1073741208; +inp[15383] = 0; +inp[15384] = 1073741200; +inp[15385] = 0; +inp[15386] = 1073741192; +inp[15387] = 0; +inp[15388] = 1073741184; +inp[15389] = 0; +inp[15390] = 1073741176; +inp[15391] = 0; +inp[15392] = 1073741168; +inp[15393] = 0; +inp[15394] = 1073741160; +inp[15395] = 0; +inp[15396] = 1073741152; +inp[15397] = 0; +inp[15398] = 1073741144; +inp[15399] = 0; +inp[15400] = 1073741136; +inp[15401] = 0; +inp[15402] = 1073741128; +inp[15403] = 0; +inp[15404] = 1073741120; +inp[15405] = 0; +inp[15406] = 1073741112; +inp[15407] = 0; +inp[15408] = 1073741104; +inp[15409] = 0; +inp[15410] = 1073741096; +inp[15411] = 0; +inp[15412] = 1073741088; +inp[15413] = 0; +inp[15414] = 1073741080; +inp[15415] = 0; +inp[15416] = 1073741072; +inp[15417] = 0; +inp[15418] = 1073741064; +inp[15419] = 0; +inp[15420] = 1073741056; +inp[15421] = 0; +inp[15422] = 1073741048; +inp[15423] = 0; +inp[15424] = 1073741040; +inp[15425] = 0; +inp[15426] = 1073741032; +inp[15427] = 0; +inp[15428] = 1073741024; +inp[15429] = 0; +inp[15430] = 1073741016; +inp[15431] = 0; +inp[15432] = 1073741008; +inp[15433] = 0; +inp[15434] = 1073741000; +inp[15435] = 0; +inp[15436] = 1073740992; +inp[15437] = 0; +inp[15438] = 1073740984; +inp[15439] = 0; +inp[15440] = 1073740976; +inp[15441] = 0; +inp[15442] = 1073740968; +inp[15443] = 0; +inp[15444] = 1073740960; +inp[15445] = 0; +inp[15446] = 1073740952; +inp[15447] = 0; +inp[15448] = 1073740944; +inp[15449] = 0; +inp[15450] = 1073740936; +inp[15451] = 0; +inp[15452] = 1073740928; +inp[15453] = 0; +inp[15454] = 1073740920; +inp[15455] = 0; +inp[15456] = 1073740912; +inp[15457] = 0; +inp[15458] = 1073740904; +inp[15459] = 0; +inp[15460] = 1073740896; +inp[15461] = 0; +inp[15462] = 1073740888; +inp[15463] = 0; +inp[15464] = 1073740880; +inp[15465] = 0; +inp[15466] = 1073740872; +inp[15467] = 0; +inp[15468] = 1073740864; +inp[15469] = 0; +inp[15470] = 1073740856; +inp[15471] = 0; +inp[15472] = 1073740848; +inp[15473] = 0; +inp[15474] = 1073740840; +inp[15475] = 0; +inp[15476] = 1073740832; +inp[15477] = 0; +inp[15478] = 1073740824; +inp[15479] = 0; +inp[15480] = 1073740816; +inp[15481] = 0; +inp[15482] = 1073740808; +inp[15483] = 0; +inp[15484] = 1073741824; +inp[15485] = 1073741824; +inp[15486] = 1073741820; +inp[15487] = 0; +inp[15488] = 1073741816; +inp[15489] = 0; +inp[15490] = 1073741812; +inp[15491] = 0; +inp[15492] = 1073741808; +inp[15493] = 0; +inp[15494] = 1073741804; +inp[15495] = 0; +inp[15496] = 1073741800; +inp[15497] = 0; +inp[15498] = 1073741796; +inp[15499] = 0; +inp[15500] = 1073741792; +inp[15501] = 0; +inp[15502] = 1073741788; +inp[15503] = 0; +inp[15504] = 1073741784; +inp[15505] = 0; +inp[15506] = 1073741780; +inp[15507] = 0; +inp[15508] = 1073741776; +inp[15509] = 0; +inp[15510] = 1073741772; +inp[15511] = 0; +inp[15512] = 1073741768; +inp[15513] = 0; +inp[15514] = 1073741764; +inp[15515] = 0; +inp[15516] = 1073741760; +inp[15517] = 0; +inp[15518] = 1073741756; +inp[15519] = 0; +inp[15520] = 1073741752; +inp[15521] = 0; +inp[15522] = 1073741748; +inp[15523] = 0; +inp[15524] = 1073741744; +inp[15525] = 0; +inp[15526] = 1073741740; +inp[15527] = 0; +inp[15528] = 1073741736; +inp[15529] = 0; +inp[15530] = 1073741732; +inp[15531] = 0; +inp[15532] = 1073741728; +inp[15533] = 0; +inp[15534] = 1073741724; +inp[15535] = 0; +inp[15536] = 1073741720; +inp[15537] = 0; +inp[15538] = 1073741716; +inp[15539] = 0; +inp[15540] = 1073741712; +inp[15541] = 0; +inp[15542] = 1073741708; +inp[15543] = 0; +inp[15544] = 1073741704; +inp[15545] = 0; +inp[15546] = 1073741700; +inp[15547] = 0; +inp[15548] = 1073741696; +inp[15549] = 0; +inp[15550] = 1073741692; +inp[15551] = 0; +inp[15552] = 1073741688; +inp[15553] = 0; +inp[15554] = 1073741684; +inp[15555] = 0; +inp[15556] = 1073741680; +inp[15557] = 0; +inp[15558] = 1073741676; +inp[15559] = 0; +inp[15560] = 1073741672; +inp[15561] = 0; +inp[15562] = 1073741668; +inp[15563] = 0; +inp[15564] = 1073741664; +inp[15565] = 0; +inp[15566] = 1073741660; +inp[15567] = 0; +inp[15568] = 1073741656; +inp[15569] = 0; +inp[15570] = 1073741652; +inp[15571] = 0; +inp[15572] = 1073741648; +inp[15573] = 0; +inp[15574] = 1073741644; +inp[15575] = 0; +inp[15576] = 1073741640; +inp[15577] = 0; +inp[15578] = 1073741636; +inp[15579] = 0; +inp[15580] = 1073741632; +inp[15581] = 0; +inp[15582] = 1073741628; +inp[15583] = 0; +inp[15584] = 1073741624; +inp[15585] = 0; +inp[15586] = 1073741620; +inp[15587] = 0; +inp[15588] = 1073741616; +inp[15589] = 0; +inp[15590] = 1073741612; +inp[15591] = 0; +inp[15592] = 1073741608; +inp[15593] = 0; +inp[15594] = 1073741604; +inp[15595] = 0; +inp[15596] = 1073741600; +inp[15597] = 0; +inp[15598] = 1073741596; +inp[15599] = 0; +inp[15600] = 1073741592; +inp[15601] = 0; +inp[15602] = 1073741588; +inp[15603] = 0; +inp[15604] = 1073741584; +inp[15605] = 0; +inp[15606] = 1073741580; +inp[15607] = 0; +inp[15608] = 1073741576; +inp[15609] = 0; +inp[15610] = 1073741572; +inp[15611] = 0; +inp[15612] = 1073741568; +inp[15613] = 0; +inp[15614] = 1073741564; +inp[15615] = 0; +inp[15616] = 1073741560; +inp[15617] = 0; +inp[15618] = 1073741556; +inp[15619] = 0; +inp[15620] = 1073741552; +inp[15621] = 0; +inp[15622] = 1073741548; +inp[15623] = 0; +inp[15624] = 1073741544; +inp[15625] = 0; +inp[15626] = 1073741540; +inp[15627] = 0; +inp[15628] = 1073741536; +inp[15629] = 0; +inp[15630] = 1073741532; +inp[15631] = 0; +inp[15632] = 1073741528; +inp[15633] = 0; +inp[15634] = 1073741524; +inp[15635] = 0; +inp[15636] = 1073741520; +inp[15637] = 0; +inp[15638] = 1073741516; +inp[15639] = 0; +inp[15640] = 1073741512; +inp[15641] = 0; +inp[15642] = 1073741508; +inp[15643] = 0; +inp[15644] = 1073741504; +inp[15645] = 0; +inp[15646] = 1073741500; +inp[15647] = 0; +inp[15648] = 1073741496; +inp[15649] = 0; +inp[15650] = 1073741492; +inp[15651] = 0; +inp[15652] = 1073741488; +inp[15653] = 0; +inp[15654] = 1073741484; +inp[15655] = 0; +inp[15656] = 1073741480; +inp[15657] = 0; +inp[15658] = 1073741476; +inp[15659] = 0; +inp[15660] = 1073741472; +inp[15661] = 0; +inp[15662] = 1073741468; +inp[15663] = 0; +inp[15664] = 1073741464; +inp[15665] = 0; +inp[15666] = 1073741460; +inp[15667] = 0; +inp[15668] = 1073741456; +inp[15669] = 0; +inp[15670] = 1073741452; +inp[15671] = 0; +inp[15672] = 1073741448; +inp[15673] = 0; +inp[15674] = 1073741444; +inp[15675] = 0; +inp[15676] = 1073741440; +inp[15677] = 0; +inp[15678] = 1073741436; +inp[15679] = 0; +inp[15680] = 1073741432; +inp[15681] = 0; +inp[15682] = 1073741428; +inp[15683] = 0; +inp[15684] = 1073741424; +inp[15685] = 0; +inp[15686] = 1073741420; +inp[15687] = 0; +inp[15688] = 1073741416; +inp[15689] = 0; +inp[15690] = 1073741412; +inp[15691] = 0; +inp[15692] = 1073741408; +inp[15693] = 0; +inp[15694] = 1073741404; +inp[15695] = 0; +inp[15696] = 1073741400; +inp[15697] = 0; +inp[15698] = 1073741396; +inp[15699] = 0; +inp[15700] = 1073741392; +inp[15701] = 0; +inp[15702] = 1073741388; +inp[15703] = 0; +inp[15704] = 1073741384; +inp[15705] = 0; +inp[15706] = 1073741380; +inp[15707] = 0; +inp[15708] = 1073741376; +inp[15709] = 0; +inp[15710] = 1073741372; +inp[15711] = 0; +inp[15712] = 1073741368; +inp[15713] = 0; +inp[15714] = 1073741364; +inp[15715] = 0; +inp[15716] = 1073741360; +inp[15717] = 0; +inp[15718] = 1073741356; +inp[15719] = 0; +inp[15720] = 1073741352; +inp[15721] = 0; +inp[15722] = 1073741348; +inp[15723] = 0; +inp[15724] = 1073741344; +inp[15725] = 0; +inp[15726] = 1073741340; +inp[15727] = 0; +inp[15728] = 1073741336; +inp[15729] = 0; +inp[15730] = 1073741332; +inp[15731] = 0; +inp[15732] = 1073741328; +inp[15733] = 0; +inp[15734] = 1073741324; +inp[15735] = 0; +inp[15736] = 1073741320; +inp[15737] = 0; +inp[15738] = 1073741316; +inp[15739] = 0; +inp[15740] = 1073741824; +inp[15741] = 1073741824; +inp[15742] = 1073741822; +inp[15743] = 0; +inp[15744] = 1073741820; +inp[15745] = 0; +inp[15746] = 1073741818; +inp[15747] = 0; +inp[15748] = 1073741816; +inp[15749] = 0; +inp[15750] = 1073741814; +inp[15751] = 0; +inp[15752] = 1073741812; +inp[15753] = 0; +inp[15754] = 1073741810; +inp[15755] = 0; +inp[15756] = 1073741808; +inp[15757] = 0; +inp[15758] = 1073741806; +inp[15759] = 0; +inp[15760] = 1073741804; +inp[15761] = 0; +inp[15762] = 1073741802; +inp[15763] = 0; +inp[15764] = 1073741800; +inp[15765] = 0; +inp[15766] = 1073741798; +inp[15767] = 0; +inp[15768] = 1073741796; +inp[15769] = 0; +inp[15770] = 1073741794; +inp[15771] = 0; +inp[15772] = 1073741792; +inp[15773] = 0; +inp[15774] = 1073741790; +inp[15775] = 0; +inp[15776] = 1073741788; +inp[15777] = 0; +inp[15778] = 1073741786; +inp[15779] = 0; +inp[15780] = 1073741784; +inp[15781] = 0; +inp[15782] = 1073741782; +inp[15783] = 0; +inp[15784] = 1073741780; +inp[15785] = 0; +inp[15786] = 1073741778; +inp[15787] = 0; +inp[15788] = 1073741776; +inp[15789] = 0; +inp[15790] = 1073741774; +inp[15791] = 0; +inp[15792] = 1073741772; +inp[15793] = 0; +inp[15794] = 1073741770; +inp[15795] = 0; +inp[15796] = 1073741768; +inp[15797] = 0; +inp[15798] = 1073741766; +inp[15799] = 0; +inp[15800] = 1073741764; +inp[15801] = 0; +inp[15802] = 1073741762; +inp[15803] = 0; +inp[15804] = 1073741760; +inp[15805] = 0; +inp[15806] = 1073741758; +inp[15807] = 0; +inp[15808] = 1073741756; +inp[15809] = 0; +inp[15810] = 1073741754; +inp[15811] = 0; +inp[15812] = 1073741752; +inp[15813] = 0; +inp[15814] = 1073741750; +inp[15815] = 0; +inp[15816] = 1073741748; +inp[15817] = 0; +inp[15818] = 1073741746; +inp[15819] = 0; +inp[15820] = 1073741744; +inp[15821] = 0; +inp[15822] = 1073741742; +inp[15823] = 0; +inp[15824] = 1073741740; +inp[15825] = 0; +inp[15826] = 1073741738; +inp[15827] = 0; +inp[15828] = 1073741736; +inp[15829] = 0; +inp[15830] = 1073741734; +inp[15831] = 0; +inp[15832] = 1073741732; +inp[15833] = 0; +inp[15834] = 1073741730; +inp[15835] = 0; +inp[15836] = 1073741728; +inp[15837] = 0; +inp[15838] = 1073741726; +inp[15839] = 0; +inp[15840] = 1073741724; +inp[15841] = 0; +inp[15842] = 1073741722; +inp[15843] = 0; +inp[15844] = 1073741720; +inp[15845] = 0; +inp[15846] = 1073741718; +inp[15847] = 0; +inp[15848] = 1073741716; +inp[15849] = 0; +inp[15850] = 1073741714; +inp[15851] = 0; +inp[15852] = 1073741712; +inp[15853] = 0; +inp[15854] = 1073741710; +inp[15855] = 0; +inp[15856] = 1073741708; +inp[15857] = 0; +inp[15858] = 1073741706; +inp[15859] = 0; +inp[15860] = 1073741704; +inp[15861] = 0; +inp[15862] = 1073741702; +inp[15863] = 0; +inp[15864] = 1073741700; +inp[15865] = 0; +inp[15866] = 1073741698; +inp[15867] = 0; +inp[15868] = 1073741696; +inp[15869] = 0; +inp[15870] = 1073741694; +inp[15871] = 0; +inp[15872] = 1073741692; +inp[15873] = 0; +inp[15874] = 1073741690; +inp[15875] = 0; +inp[15876] = 1073741688; +inp[15877] = 0; +inp[15878] = 1073741686; +inp[15879] = 0; +inp[15880] = 1073741684; +inp[15881] = 0; +inp[15882] = 1073741682; +inp[15883] = 0; +inp[15884] = 1073741680; +inp[15885] = 0; +inp[15886] = 1073741678; +inp[15887] = 0; +inp[15888] = 1073741676; +inp[15889] = 0; +inp[15890] = 1073741674; +inp[15891] = 0; +inp[15892] = 1073741672; +inp[15893] = 0; +inp[15894] = 1073741670; +inp[15895] = 0; +inp[15896] = 1073741668; +inp[15897] = 0; +inp[15898] = 1073741666; +inp[15899] = 0; +inp[15900] = 1073741664; +inp[15901] = 0; +inp[15902] = 1073741662; +inp[15903] = 0; +inp[15904] = 1073741660; +inp[15905] = 0; +inp[15906] = 1073741658; +inp[15907] = 0; +inp[15908] = 1073741656; +inp[15909] = 0; +inp[15910] = 1073741654; +inp[15911] = 0; +inp[15912] = 1073741652; +inp[15913] = 0; +inp[15914] = 1073741650; +inp[15915] = 0; +inp[15916] = 1073741648; +inp[15917] = 0; +inp[15918] = 1073741646; +inp[15919] = 0; +inp[15920] = 1073741644; +inp[15921] = 0; +inp[15922] = 1073741642; +inp[15923] = 0; +inp[15924] = 1073741640; +inp[15925] = 0; +inp[15926] = 1073741638; +inp[15927] = 0; +inp[15928] = 1073741636; +inp[15929] = 0; +inp[15930] = 1073741634; +inp[15931] = 0; +inp[15932] = 1073741632; +inp[15933] = 0; +inp[15934] = 1073741630; +inp[15935] = 0; +inp[15936] = 1073741628; +inp[15937] = 0; +inp[15938] = 1073741626; +inp[15939] = 0; +inp[15940] = 1073741624; +inp[15941] = 0; +inp[15942] = 1073741622; +inp[15943] = 0; +inp[15944] = 1073741620; +inp[15945] = 0; +inp[15946] = 1073741618; +inp[15947] = 0; +inp[15948] = 1073741616; +inp[15949] = 0; +inp[15950] = 1073741614; +inp[15951] = 0; +inp[15952] = 1073741612; +inp[15953] = 0; +inp[15954] = 1073741610; +inp[15955] = 0; +inp[15956] = 1073741608; +inp[15957] = 0; +inp[15958] = 1073741606; +inp[15959] = 0; +inp[15960] = 1073741604; +inp[15961] = 0; +inp[15962] = 1073741602; +inp[15963] = 0; +inp[15964] = 1073741600; +inp[15965] = 0; +inp[15966] = 1073741598; +inp[15967] = 0; +inp[15968] = 1073741596; +inp[15969] = 0; +inp[15970] = 1073741594; +inp[15971] = 0; +inp[15972] = 1073741592; +inp[15973] = 0; +inp[15974] = 1073741590; +inp[15975] = 0; +inp[15976] = 1073741588; +inp[15977] = 0; +inp[15978] = 1073741586; +inp[15979] = 0; +inp[15980] = 1073741584; +inp[15981] = 0; +inp[15982] = 1073741582; +inp[15983] = 0; +inp[15984] = 1073741580; +inp[15985] = 0; +inp[15986] = 1073741578; +inp[15987] = 0; +inp[15988] = 1073741576; +inp[15989] = 0; +inp[15990] = 1073741574; +inp[15991] = 0; +inp[15992] = 1073741572; +inp[15993] = 0; +inp[15994] = 1073741570; +inp[15995] = 0; +inp[15996] = 1073741824; +inp[15997] = 1073741824; +inp[15998] = 1073741823; +inp[15999] = 0; +inp[16000] = 1073741822; +inp[16001] = 0; +inp[16002] = 1073741821; +inp[16003] = 0; +inp[16004] = 1073741820; +inp[16005] = 0; +inp[16006] = 1073741819; +inp[16007] = 0; +inp[16008] = 1073741818; +inp[16009] = 0; +inp[16010] = 1073741817; +inp[16011] = 0; +inp[16012] = 1073741816; +inp[16013] = 0; +inp[16014] = 1073741815; +inp[16015] = 0; +inp[16016] = 1073741814; +inp[16017] = 0; +inp[16018] = 1073741813; +inp[16019] = 0; +inp[16020] = 1073741812; +inp[16021] = 0; +inp[16022] = 1073741811; +inp[16023] = 0; +inp[16024] = 1073741810; +inp[16025] = 0; +inp[16026] = 1073741809; +inp[16027] = 0; +inp[16028] = 1073741808; +inp[16029] = 0; +inp[16030] = 1073741807; +inp[16031] = 0; +inp[16032] = 1073741806; +inp[16033] = 0; +inp[16034] = 1073741805; +inp[16035] = 0; +inp[16036] = 1073741804; +inp[16037] = 0; +inp[16038] = 1073741803; +inp[16039] = 0; +inp[16040] = 1073741802; +inp[16041] = 0; +inp[16042] = 1073741801; +inp[16043] = 0; +inp[16044] = 1073741800; +inp[16045] = 0; +inp[16046] = 1073741799; +inp[16047] = 0; +inp[16048] = 1073741798; +inp[16049] = 0; +inp[16050] = 1073741797; +inp[16051] = 0; +inp[16052] = 1073741796; +inp[16053] = 0; +inp[16054] = 1073741795; +inp[16055] = 0; +inp[16056] = 1073741794; +inp[16057] = 0; +inp[16058] = 1073741793; +inp[16059] = 0; +inp[16060] = 1073741792; +inp[16061] = 0; +inp[16062] = 1073741791; +inp[16063] = 0; +inp[16064] = 1073741790; +inp[16065] = 0; +inp[16066] = 1073741789; +inp[16067] = 0; +inp[16068] = 1073741788; +inp[16069] = 0; +inp[16070] = 1073741787; +inp[16071] = 0; +inp[16072] = 1073741786; +inp[16073] = 0; +inp[16074] = 1073741785; +inp[16075] = 0; +inp[16076] = 1073741784; +inp[16077] = 0; +inp[16078] = 1073741783; +inp[16079] = 0; +inp[16080] = 1073741782; +inp[16081] = 0; +inp[16082] = 1073741781; +inp[16083] = 0; +inp[16084] = 1073741780; +inp[16085] = 0; +inp[16086] = 1073741779; +inp[16087] = 0; +inp[16088] = 1073741778; +inp[16089] = 0; +inp[16090] = 1073741777; +inp[16091] = 0; +inp[16092] = 1073741776; +inp[16093] = 0; +inp[16094] = 1073741775; +inp[16095] = 0; +inp[16096] = 1073741774; +inp[16097] = 0; +inp[16098] = 1073741773; +inp[16099] = 0; +inp[16100] = 1073741772; +inp[16101] = 0; +inp[16102] = 1073741771; +inp[16103] = 0; +inp[16104] = 1073741770; +inp[16105] = 0; +inp[16106] = 1073741769; +inp[16107] = 0; +inp[16108] = 1073741768; +inp[16109] = 0; +inp[16110] = 1073741767; +inp[16111] = 0; +inp[16112] = 1073741766; +inp[16113] = 0; +inp[16114] = 1073741765; +inp[16115] = 0; +inp[16116] = 1073741764; +inp[16117] = 0; +inp[16118] = 1073741763; +inp[16119] = 0; +inp[16120] = 1073741762; +inp[16121] = 0; +inp[16122] = 1073741761; +inp[16123] = 0; +inp[16124] = 1073741760; +inp[16125] = 0; +inp[16126] = 1073741759; +inp[16127] = 0; +inp[16128] = 1073741758; +inp[16129] = 0; +inp[16130] = 1073741757; +inp[16131] = 0; +inp[16132] = 1073741756; +inp[16133] = 0; +inp[16134] = 1073741755; +inp[16135] = 0; +inp[16136] = 1073741754; +inp[16137] = 0; +inp[16138] = 1073741753; +inp[16139] = 0; +inp[16140] = 1073741752; +inp[16141] = 0; +inp[16142] = 1073741751; +inp[16143] = 0; +inp[16144] = 1073741750; +inp[16145] = 0; +inp[16146] = 1073741749; +inp[16147] = 0; +inp[16148] = 1073741748; +inp[16149] = 0; +inp[16150] = 1073741747; +inp[16151] = 0; +inp[16152] = 1073741746; +inp[16153] = 0; +inp[16154] = 1073741745; +inp[16155] = 0; +inp[16156] = 1073741744; +inp[16157] = 0; +inp[16158] = 1073741743; +inp[16159] = 0; +inp[16160] = 1073741742; +inp[16161] = 0; +inp[16162] = 1073741741; +inp[16163] = 0; +inp[16164] = 1073741740; +inp[16165] = 0; +inp[16166] = 1073741739; +inp[16167] = 0; +inp[16168] = 1073741738; +inp[16169] = 0; +inp[16170] = 1073741737; +inp[16171] = 0; +inp[16172] = 1073741736; +inp[16173] = 0; +inp[16174] = 1073741735; +inp[16175] = 0; +inp[16176] = 1073741734; +inp[16177] = 0; +inp[16178] = 1073741733; +inp[16179] = 0; +inp[16180] = 1073741732; +inp[16181] = 0; +inp[16182] = 1073741731; +inp[16183] = 0; +inp[16184] = 1073741730; +inp[16185] = 0; +inp[16186] = 1073741729; +inp[16187] = 0; +inp[16188] = 1073741728; +inp[16189] = 0; +inp[16190] = 1073741727; +inp[16191] = 0; +inp[16192] = 1073741726; +inp[16193] = 0; +inp[16194] = 1073741725; +inp[16195] = 0; +inp[16196] = 1073741724; +inp[16197] = 0; +inp[16198] = 1073741723; +inp[16199] = 0; +inp[16200] = 1073741722; +inp[16201] = 0; +inp[16202] = 1073741721; +inp[16203] = 0; +inp[16204] = 1073741720; +inp[16205] = 0; +inp[16206] = 1073741719; +inp[16207] = 0; +inp[16208] = 1073741718; +inp[16209] = 0; +inp[16210] = 1073741717; +inp[16211] = 0; +inp[16212] = 1073741716; +inp[16213] = 0; +inp[16214] = 1073741715; +inp[16215] = 0; +inp[16216] = 1073741714; +inp[16217] = 0; +inp[16218] = 1073741713; +inp[16219] = 0; +inp[16220] = 1073741712; +inp[16221] = 0; +inp[16222] = 1073741711; +inp[16223] = 0; +inp[16224] = 1073741710; +inp[16225] = 0; +inp[16226] = 1073741709; +inp[16227] = 0; +inp[16228] = 1073741708; +inp[16229] = 0; +inp[16230] = 1073741707; +inp[16231] = 0; +inp[16232] = 1073741706; +inp[16233] = 0; +inp[16234] = 1073741705; +inp[16235] = 0; +inp[16236] = 1073741704; +inp[16237] = 0; +inp[16238] = 1073741703; +inp[16239] = 0; +inp[16240] = 1073741702; +inp[16241] = 0; +inp[16242] = 1073741701; +inp[16243] = 0; +inp[16244] = 1073741700; +inp[16245] = 0; +inp[16246] = 1073741699; +inp[16247] = 0; +inp[16248] = 1073741698; +inp[16249] = 0; +inp[16250] = 1073741697; +inp[16251] = 0; +inp[16252] = 1073741824; +inp[16253] = 1073741824; +inp[16254] = 1073741823; +inp[16255] = 0; +inp[16256] = 1073741823; +inp[16257] = 0; +inp[16258] = 1073741822; +inp[16259] = 0; +inp[16260] = 1073741822; +inp[16261] = 0; +inp[16262] = 1073741821; +inp[16263] = 0; +inp[16264] = 1073741821; +inp[16265] = 0; +inp[16266] = 1073741820; +inp[16267] = 0; +inp[16268] = 1073741820; +inp[16269] = 0; +inp[16270] = 1073741819; +inp[16271] = 0; +inp[16272] = 1073741819; +inp[16273] = 0; +inp[16274] = 1073741818; +inp[16275] = 0; +inp[16276] = 1073741818; +inp[16277] = 0; +inp[16278] = 1073741817; +inp[16279] = 0; +inp[16280] = 1073741817; +inp[16281] = 0; +inp[16282] = 1073741816; +inp[16283] = 0; +inp[16284] = 1073741816; +inp[16285] = 0; +inp[16286] = 1073741815; +inp[16287] = 0; +inp[16288] = 1073741815; +inp[16289] = 0; +inp[16290] = 1073741814; +inp[16291] = 0; +inp[16292] = 1073741814; +inp[16293] = 0; +inp[16294] = 1073741813; +inp[16295] = 0; +inp[16296] = 1073741813; +inp[16297] = 0; +inp[16298] = 1073741812; +inp[16299] = 0; +inp[16300] = 1073741812; +inp[16301] = 0; +inp[16302] = 1073741811; +inp[16303] = 0; +inp[16304] = 1073741811; +inp[16305] = 0; +inp[16306] = 1073741810; +inp[16307] = 0; +inp[16308] = 1073741810; +inp[16309] = 0; +inp[16310] = 1073741809; +inp[16311] = 0; +inp[16312] = 1073741809; +inp[16313] = 0; +inp[16314] = 1073741808; +inp[16315] = 0; +inp[16316] = 1073741808; +inp[16317] = 0; +inp[16318] = 1073741807; +inp[16319] = 0; +inp[16320] = 1073741807; +inp[16321] = 0; +inp[16322] = 1073741806; +inp[16323] = 0; +inp[16324] = 1073741806; +inp[16325] = 0; +inp[16326] = 1073741805; +inp[16327] = 0; +inp[16328] = 1073741805; +inp[16329] = 0; +inp[16330] = 1073741804; +inp[16331] = 0; +inp[16332] = 1073741804; +inp[16333] = 0; +inp[16334] = 1073741803; +inp[16335] = 0; +inp[16336] = 1073741803; +inp[16337] = 0; +inp[16338] = 1073741802; +inp[16339] = 0; +inp[16340] = 1073741802; +inp[16341] = 0; +inp[16342] = 1073741801; +inp[16343] = 0; +inp[16344] = 1073741801; +inp[16345] = 0; +inp[16346] = 1073741800; +inp[16347] = 0; +inp[16348] = 1073741800; +inp[16349] = 0; +inp[16350] = 1073741799; +inp[16351] = 0; +inp[16352] = 1073741799; +inp[16353] = 0; +inp[16354] = 1073741798; +inp[16355] = 0; +inp[16356] = 1073741798; +inp[16357] = 0; +inp[16358] = 1073741797; +inp[16359] = 0; +inp[16360] = 1073741797; +inp[16361] = 0; +inp[16362] = 1073741796; +inp[16363] = 0; +inp[16364] = 1073741796; +inp[16365] = 0; +inp[16366] = 1073741795; +inp[16367] = 0; +inp[16368] = 1073741795; +inp[16369] = 0; +inp[16370] = 1073741794; +inp[16371] = 0; +inp[16372] = 1073741794; +inp[16373] = 0; +inp[16374] = 1073741793; +inp[16375] = 0; +inp[16376] = 1073741793; +inp[16377] = 0; +inp[16378] = 1073741792; +inp[16379] = 0; +inp[16380] = 1073741792; +inp[16381] = 0; +inp[16382] = 1073741791; +inp[16383] = 0; +inp[16384] = 1073741791; +inp[16385] = 0; +inp[16386] = 1073741790; +inp[16387] = 0; +inp[16388] = 1073741790; +inp[16389] = 0; +inp[16390] = 1073741789; +inp[16391] = 0; +inp[16392] = 1073741789; +inp[16393] = 0; +inp[16394] = 1073741788; +inp[16395] = 0; +inp[16396] = 1073741788; +inp[16397] = 0; +inp[16398] = 1073741787; +inp[16399] = 0; +inp[16400] = 1073741787; +inp[16401] = 0; +inp[16402] = 1073741786; +inp[16403] = 0; +inp[16404] = 1073741786; +inp[16405] = 0; +inp[16406] = 1073741785; +inp[16407] = 0; +inp[16408] = 1073741785; +inp[16409] = 0; +inp[16410] = 1073741784; +inp[16411] = 0; +inp[16412] = 1073741784; +inp[16413] = 0; +inp[16414] = 1073741783; +inp[16415] = 0; +inp[16416] = 1073741783; +inp[16417] = 0; +inp[16418] = 1073741782; +inp[16419] = 0; +inp[16420] = 1073741782; +inp[16421] = 0; +inp[16422] = 1073741781; +inp[16423] = 0; +inp[16424] = 1073741781; +inp[16425] = 0; +inp[16426] = 1073741780; +inp[16427] = 0; +inp[16428] = 1073741780; +inp[16429] = 0; +inp[16430] = 1073741779; +inp[16431] = 0; +inp[16432] = 1073741779; +inp[16433] = 0; +inp[16434] = 1073741778; +inp[16435] = 0; +inp[16436] = 1073741778; +inp[16437] = 0; +inp[16438] = 1073741777; +inp[16439] = 0; +inp[16440] = 1073741777; +inp[16441] = 0; +inp[16442] = 1073741776; +inp[16443] = 0; +inp[16444] = 1073741776; +inp[16445] = 0; +inp[16446] = 1073741775; +inp[16447] = 0; +inp[16448] = 1073741775; +inp[16449] = 0; +inp[16450] = 1073741774; +inp[16451] = 0; +inp[16452] = 1073741774; +inp[16453] = 0; +inp[16454] = 1073741773; +inp[16455] = 0; +inp[16456] = 1073741773; +inp[16457] = 0; +inp[16458] = 1073741772; +inp[16459] = 0; +inp[16460] = 1073741772; +inp[16461] = 0; +inp[16462] = 1073741771; +inp[16463] = 0; +inp[16464] = 1073741771; +inp[16465] = 0; +inp[16466] = 1073741770; +inp[16467] = 0; +inp[16468] = 1073741770; +inp[16469] = 0; +inp[16470] = 1073741769; +inp[16471] = 0; +inp[16472] = 1073741769; +inp[16473] = 0; +inp[16474] = 1073741768; +inp[16475] = 0; +inp[16476] = 1073741768; +inp[16477] = 0; +inp[16478] = 1073741767; +inp[16479] = 0; +inp[16480] = 1073741767; +inp[16481] = 0; +inp[16482] = 1073741766; +inp[16483] = 0; +inp[16484] = 1073741766; +inp[16485] = 0; +inp[16486] = 1073741765; +inp[16487] = 0; +inp[16488] = 1073741765; +inp[16489] = 0; +inp[16490] = 1073741764; +inp[16491] = 0; +inp[16492] = 1073741764; +inp[16493] = 0; +inp[16494] = 1073741763; +inp[16495] = 0; +inp[16496] = 1073741763; +inp[16497] = 0; +inp[16498] = 1073741762; +inp[16499] = 0; +inp[16500] = 1073741762; +inp[16501] = 0; +inp[16502] = 1073741761; +inp[16503] = 0; +inp[16504] = 1073741761; +inp[16505] = 0; +inp[16506] = 1073741760; +inp[16507] = 0; +inp[16508] = 1073741824; +inp[16509] = 1073741824; +inp[16510] = 1073741823; +inp[16511] = 0; +inp[16512] = 1073741823; +inp[16513] = 0; +inp[16514] = 1073741823; +inp[16515] = 0; +inp[16516] = 1073741823; +inp[16517] = 0; +inp[16518] = 1073741822; +inp[16519] = 0; +inp[16520] = 1073741822; +inp[16521] = 0; +inp[16522] = 1073741822; +inp[16523] = 0; +inp[16524] = 1073741822; +inp[16525] = 0; +inp[16526] = 1073741821; +inp[16527] = 0; +inp[16528] = 1073741821; +inp[16529] = 0; +inp[16530] = 1073741821; +inp[16531] = 0; +inp[16532] = 1073741821; +inp[16533] = 0; +inp[16534] = 1073741820; +inp[16535] = 0; +inp[16536] = 1073741820; +inp[16537] = 0; +inp[16538] = 1073741820; +inp[16539] = 0; +inp[16540] = 1073741820; +inp[16541] = 0; +inp[16542] = 1073741819; +inp[16543] = 0; +inp[16544] = 1073741819; +inp[16545] = 0; +inp[16546] = 1073741819; +inp[16547] = 0; +inp[16548] = 1073741819; +inp[16549] = 0; +inp[16550] = 1073741818; +inp[16551] = 0; +inp[16552] = 1073741818; +inp[16553] = 0; +inp[16554] = 1073741818; +inp[16555] = 0; +inp[16556] = 1073741818; +inp[16557] = 0; +inp[16558] = 1073741817; +inp[16559] = 0; +inp[16560] = 1073741817; +inp[16561] = 0; +inp[16562] = 1073741817; +inp[16563] = 0; +inp[16564] = 1073741817; +inp[16565] = 0; +inp[16566] = 1073741816; +inp[16567] = 0; +inp[16568] = 1073741816; +inp[16569] = 0; +inp[16570] = 1073741816; +inp[16571] = 0; +inp[16572] = 1073741816; +inp[16573] = 0; +inp[16574] = 1073741815; +inp[16575] = 0; +inp[16576] = 1073741815; +inp[16577] = 0; +inp[16578] = 1073741815; +inp[16579] = 0; +inp[16580] = 1073741815; +inp[16581] = 0; +inp[16582] = 1073741814; +inp[16583] = 0; +inp[16584] = 1073741814; +inp[16585] = 0; +inp[16586] = 1073741814; +inp[16587] = 0; +inp[16588] = 1073741814; +inp[16589] = 0; +inp[16590] = 1073741813; +inp[16591] = 0; +inp[16592] = 1073741813; +inp[16593] = 0; +inp[16594] = 1073741813; +inp[16595] = 0; +inp[16596] = 1073741813; +inp[16597] = 0; +inp[16598] = 1073741812; +inp[16599] = 0; +inp[16600] = 1073741812; +inp[16601] = 0; +inp[16602] = 1073741812; +inp[16603] = 0; +inp[16604] = 1073741812; +inp[16605] = 0; +inp[16606] = 1073741811; +inp[16607] = 0; +inp[16608] = 1073741811; +inp[16609] = 0; +inp[16610] = 1073741811; +inp[16611] = 0; +inp[16612] = 1073741811; +inp[16613] = 0; +inp[16614] = 1073741810; +inp[16615] = 0; +inp[16616] = 1073741810; +inp[16617] = 0; +inp[16618] = 1073741810; +inp[16619] = 0; +inp[16620] = 1073741810; +inp[16621] = 0; +inp[16622] = 1073741809; +inp[16623] = 0; +inp[16624] = 1073741809; +inp[16625] = 0; +inp[16626] = 1073741809; +inp[16627] = 0; +inp[16628] = 1073741809; +inp[16629] = 0; +inp[16630] = 1073741808; +inp[16631] = 0; +inp[16632] = 1073741808; +inp[16633] = 0; +inp[16634] = 1073741808; +inp[16635] = 0; +inp[16636] = 1073741808; +inp[16637] = 0; +inp[16638] = 1073741807; +inp[16639] = 0; +inp[16640] = 1073741807; +inp[16641] = 0; +inp[16642] = 1073741807; +inp[16643] = 0; +inp[16644] = 1073741807; +inp[16645] = 0; +inp[16646] = 1073741806; +inp[16647] = 0; +inp[16648] = 1073741806; +inp[16649] = 0; +inp[16650] = 1073741806; +inp[16651] = 0; +inp[16652] = 1073741806; +inp[16653] = 0; +inp[16654] = 1073741805; +inp[16655] = 0; +inp[16656] = 1073741805; +inp[16657] = 0; +inp[16658] = 1073741805; +inp[16659] = 0; +inp[16660] = 1073741805; +inp[16661] = 0; +inp[16662] = 1073741804; +inp[16663] = 0; +inp[16664] = 1073741804; +inp[16665] = 0; +inp[16666] = 1073741804; +inp[16667] = 0; +inp[16668] = 1073741804; +inp[16669] = 0; +inp[16670] = 1073741803; +inp[16671] = 0; +inp[16672] = 1073741803; +inp[16673] = 0; +inp[16674] = 1073741803; +inp[16675] = 0; +inp[16676] = 1073741803; +inp[16677] = 0; +inp[16678] = 1073741802; +inp[16679] = 0; +inp[16680] = 1073741802; +inp[16681] = 0; +inp[16682] = 1073741802; +inp[16683] = 0; +inp[16684] = 1073741802; +inp[16685] = 0; +inp[16686] = 1073741801; +inp[16687] = 0; +inp[16688] = 1073741801; +inp[16689] = 0; +inp[16690] = 1073741801; +inp[16691] = 0; +inp[16692] = 1073741801; +inp[16693] = 0; +inp[16694] = 1073741800; +inp[16695] = 0; +inp[16696] = 1073741800; +inp[16697] = 0; +inp[16698] = 1073741800; +inp[16699] = 0; +inp[16700] = 1073741800; +inp[16701] = 0; +inp[16702] = 1073741799; +inp[16703] = 0; +inp[16704] = 1073741799; +inp[16705] = 0; +inp[16706] = 1073741799; +inp[16707] = 0; +inp[16708] = 1073741799; +inp[16709] = 0; +inp[16710] = 1073741798; +inp[16711] = 0; +inp[16712] = 1073741798; +inp[16713] = 0; +inp[16714] = 1073741798; +inp[16715] = 0; +inp[16716] = 1073741798; +inp[16717] = 0; +inp[16718] = 1073741797; +inp[16719] = 0; +inp[16720] = 1073741797; +inp[16721] = 0; +inp[16722] = 1073741797; +inp[16723] = 0; +inp[16724] = 1073741797; +inp[16725] = 0; +inp[16726] = 1073741796; +inp[16727] = 0; +inp[16728] = 1073741796; +inp[16729] = 0; +inp[16730] = 1073741796; +inp[16731] = 0; +inp[16732] = 1073741796; +inp[16733] = 0; +inp[16734] = 1073741795; +inp[16735] = 0; +inp[16736] = 1073741795; +inp[16737] = 0; +inp[16738] = 1073741795; +inp[16739] = 0; +inp[16740] = 1073741795; +inp[16741] = 0; +inp[16742] = 1073741794; +inp[16743] = 0; +inp[16744] = 1073741794; +inp[16745] = 0; +inp[16746] = 1073741794; +inp[16747] = 0; +inp[16748] = 1073741794; +inp[16749] = 0; +inp[16750] = 1073741793; +inp[16751] = 0; +inp[16752] = 1073741793; +inp[16753] = 0; +inp[16754] = 1073741793; +inp[16755] = 0; +inp[16756] = 1073741793; +inp[16757] = 0; +inp[16758] = 1073741792; +inp[16759] = 0; +inp[16760] = 1073741792; +inp[16761] = 0; +inp[16762] = 1073741792; +inp[16763] = 0; +inp[16764] = 1073741824; +inp[16765] = 1073741824; +inp[16766] = 395007542; +inp[16767] = 395007542; +inp[16768] = 145315153; +inp[16769] = 145315153; +inp[16770] = 53458457; +inp[16771] = 53458457; +inp[16772] = 19666267; +inp[16773] = 19666267; +inp[16774] = 7234815; +inp[16775] = 7234815; +inp[16776] = 2661539; +inp[16777] = 2661539; +inp[16778] = 979125; +inp[16779] = 979125; +inp[16780] = 360200; +inp[16781] = 360200; +inp[16782] = 132510; +inp[16783] = 132510; +inp[16784] = 48747; +inp[16785] = 48747; +inp[16786] = 17933; +inp[16787] = 17933; +inp[16788] = 6597; +inp[16789] = 6597; +inp[16790] = 2427; +inp[16791] = 2427; +inp[16792] = 892; +inp[16793] = 892; +inp[16794] = 328; +inp[16795] = 328; +inp[16796] = 120; +inp[16797] = 120; +inp[16798] = 44; +inp[16799] = 44; +inp[16800] = 16; +inp[16801] = 16; +inp[16802] = 6; +inp[16803] = 6; +inp[16804] = 2; +inp[16805] = 2; +inp[16806] = 0; +inp[16807] = 0; +inp[16808] = 0; +inp[16809] = 0; +inp[16810] = 0; +inp[16811] = 0; +inp[16812] = 0; +inp[16813] = 0; +inp[16814] = 0; +inp[16815] = 0; +inp[16816] = 0; +inp[16817] = 0; +inp[16818] = 0; +inp[16819] = 0; +inp[16820] = 0; +inp[16821] = 0; +inp[16822] = 0; +inp[16823] = 0; +inp[16824] = 0; +inp[16825] = 0; +inp[16826] = 0; +inp[16827] = 0; +inp[16828] = 0; +inp[16829] = 0; +inp[16830] = 0; +inp[16831] = 0; +inp[16832] = 0; +inp[16833] = 0; +inp[16834] = 0; +inp[16835] = 0; +inp[16836] = 0; +inp[16837] = 0; +inp[16838] = 0; +inp[16839] = 0; +inp[16840] = 0; +inp[16841] = 0; +inp[16842] = 0; +inp[16843] = 0; +inp[16844] = 0; +inp[16845] = 0; +inp[16846] = 0; +inp[16847] = 0; +inp[16848] = 0; +inp[16849] = 0; +inp[16850] = 0; +inp[16851] = 0; +inp[16852] = 0; +inp[16853] = 0; +inp[16854] = 0; +inp[16855] = 0; +inp[16856] = 0; +inp[16857] = 0; +inp[16858] = 0; +inp[16859] = 0; +inp[16860] = 0; +inp[16861] = 0; +inp[16862] = 0; +inp[16863] = 0; +inp[16864] = 0; +inp[16865] = 0; +inp[16866] = 0; +inp[16867] = 0; +inp[16868] = 0; +inp[16869] = 0; +inp[16870] = 0; +inp[16871] = 0; +inp[16872] = 0; +inp[16873] = 0; +inp[16874] = 0; +inp[16875] = 0; +inp[16876] = 0; +inp[16877] = 0; +inp[16878] = 0; +inp[16879] = 0; +inp[16880] = 0; +inp[16881] = 0; +inp[16882] = 0; +inp[16883] = 0; +inp[16884] = 0; +inp[16885] = 0; +inp[16886] = 0; +inp[16887] = 0; +inp[16888] = 0; +inp[16889] = 0; +inp[16890] = 0; +inp[16891] = 0; +inp[16892] = 0; +inp[16893] = 0; +inp[16894] = 0; +inp[16895] = 0; +inp[16896] = 0; +inp[16897] = 0; +inp[16898] = 0; +inp[16899] = 0; +inp[16900] = 0; +inp[16901] = 0; +inp[16902] = 0; +inp[16903] = 0; +inp[16904] = 0; +inp[16905] = 0; +inp[16906] = 0; +inp[16907] = 0; +inp[16908] = 0; +inp[16909] = 0; +inp[16910] = 0; +inp[16911] = 0; +inp[16912] = 0; +inp[16913] = 0; +inp[16914] = 0; +inp[16915] = 0; +inp[16916] = 0; +inp[16917] = 0; +inp[16918] = 0; +inp[16919] = 0; +inp[16920] = 0; +inp[16921] = 0; +inp[16922] = 0; +inp[16923] = 0; +inp[16924] = 0; +inp[16925] = 0; +inp[16926] = 0; +inp[16927] = 0; +inp[16928] = 0; +inp[16929] = 0; +inp[16930] = 0; +inp[16931] = 0; +inp[16932] = 0; +inp[16933] = 0; +inp[16934] = 0; +inp[16935] = 0; +inp[16936] = 0; +inp[16937] = 0; +inp[16938] = 0; +inp[16939] = 0; +inp[16940] = 0; +inp[16941] = 0; +inp[16942] = 0; +inp[16943] = 0; +inp[16944] = 0; +inp[16945] = 0; +inp[16946] = 0; +inp[16947] = 0; +inp[16948] = 0; +inp[16949] = 0; +inp[16950] = 0; +inp[16951] = 0; +inp[16952] = 0; +inp[16953] = 0; +inp[16954] = 0; +inp[16955] = 0; +inp[16956] = 0; +inp[16957] = 0; +inp[16958] = 0; +inp[16959] = 0; +inp[16960] = 0; +inp[16961] = 0; +inp[16962] = 0; +inp[16963] = 0; +inp[16964] = 0; +inp[16965] = 0; +inp[16966] = 0; +inp[16967] = 0; +inp[16968] = 0; +inp[16969] = 0; +inp[16970] = 0; +inp[16971] = 0; +inp[16972] = 0; +inp[16973] = 0; +inp[16974] = 0; +inp[16975] = 0; +inp[16976] = 0; +inp[16977] = 0; +inp[16978] = 0; +inp[16979] = 0; +inp[16980] = 0; +inp[16981] = 0; +inp[16982] = 0; +inp[16983] = 0; +inp[16984] = 0; +inp[16985] = 0; +inp[16986] = 0; +inp[16987] = 0; +inp[16988] = 0; +inp[16989] = 0; +inp[16990] = 0; +inp[16991] = 0; +inp[16992] = 0; +inp[16993] = 0; +inp[16994] = 0; +inp[16995] = 0; +inp[16996] = 0; +inp[16997] = 0; +inp[16998] = 0; +inp[16999] = 0; +inp[17000] = 0; +inp[17001] = 0; +inp[17002] = 0; +inp[17003] = 0; +inp[17004] = 0; +inp[17005] = 0; +inp[17006] = 0; +inp[17007] = 0; +inp[17008] = 0; +inp[17009] = 0; +inp[17010] = 0; +inp[17011] = 0; +inp[17012] = 0; +inp[17013] = 0; +inp[17014] = 0; +inp[17015] = 0; +inp[17016] = 0; +inp[17017] = 0; +inp[17018] = 0; +inp[17019] = 0; +inp[17020] = 0; +inp[17021] = 0; +inp[17022] = 0; +inp[17023] = 0; +inp[17024] = 0; +inp[17025] = 0; +inp[17026] = 0; +inp[17027] = 0; +inp[17028] = 0; +inp[17029] = 0; +inp[17030] = 0; +inp[17031] = 0; +inp[17032] = 0; +inp[17033] = 0; +inp[17034] = 0; +inp[17035] = 0; +inp[17036] = 0; +inp[17037] = 0; +inp[17038] = 0; +inp[17039] = 0; +inp[17040] = 0; +inp[17041] = 0; +inp[17042] = 0; +inp[17043] = 0; +inp[17044] = 0; +inp[17045] = 0; +inp[17046] = 0; +inp[17047] = 0; +inp[17048] = 0; +inp[17049] = 0; +inp[17050] = 0; +inp[17051] = 0; +inp[17052] = 0; +inp[17053] = 0; +inp[17054] = 0; +inp[17055] = 0; +inp[17056] = 0; +inp[17057] = 0; +inp[17058] = 0; +inp[17059] = 0; +inp[17060] = 0; +inp[17061] = 0; +inp[17062] = 0; +inp[17063] = 0; +inp[17064] = 0; +inp[17065] = 0; +inp[17066] = 0; +inp[17067] = 0; +inp[17068] = 0; +inp[17069] = 0; +inp[17070] = 0; +inp[17071] = 0; +inp[17072] = 0; +inp[17073] = 0; +inp[17074] = 0; +inp[17075] = 0; +inp[17076] = 0; +inp[17077] = 0; +inp[17078] = 0; +inp[17079] = 0; +inp[17080] = 0; +inp[17081] = 0; +inp[17082] = 0; +inp[17083] = 0; +inp[17084] = 0; +inp[17085] = 0; +inp[17086] = 0; +inp[17087] = 0; +inp[17088] = 0; +inp[17089] = 0; +inp[17090] = 0; +inp[17091] = 0; +inp[17092] = 0; +inp[17093] = 0; +inp[17094] = 0; +inp[17095] = 0; +inp[17096] = 0; +inp[17097] = 0; +inp[17098] = 0; +inp[17099] = 0; +inp[17100] = 0; +inp[17101] = 0; +inp[17102] = 0; +inp[17103] = 0; +inp[17104] = 0; +inp[17105] = 0; +inp[17106] = 0; +inp[17107] = 0; +inp[17108] = 0; +inp[17109] = 0; +inp[17110] = 0; +inp[17111] = 0; +inp[17112] = 0; +inp[17113] = 0; +inp[17114] = 0; +inp[17115] = 0; +inp[17116] = 0; +inp[17117] = 0; +inp[17118] = 0; +inp[17119] = 0; +inp[17120] = 0; +inp[17121] = 0; +inp[17122] = 0; +inp[17123] = 0; +inp[17124] = 0; +inp[17125] = 0; +inp[17126] = 0; +inp[17127] = 0; +inp[17128] = 0; +inp[17129] = 0; +inp[17130] = 0; +inp[17131] = 0; +inp[17132] = 0; +inp[17133] = 0; +inp[17134] = 0; +inp[17135] = 0; +inp[17136] = 0; +inp[17137] = 0; +inp[17138] = 0; +inp[17139] = 0; +inp[17140] = 0; +inp[17141] = 0; +inp[17142] = 0; +inp[17143] = 0; +inp[17144] = 0; +inp[17145] = 0; +inp[17146] = 0; +inp[17147] = 0; +inp[17148] = 0; +inp[17149] = 0; +inp[17150] = 0; +inp[17151] = 0; +inp[17152] = 0; +inp[17153] = 0; +inp[17154] = 0; +inp[17155] = 0; +inp[17156] = 0; +inp[17157] = 0; +inp[17158] = 0; +inp[17159] = 0; +inp[17160] = 0; +inp[17161] = 0; +inp[17162] = 0; +inp[17163] = 0; +inp[17164] = 0; +inp[17165] = 0; +inp[17166] = 0; +inp[17167] = 0; +inp[17168] = 0; +inp[17169] = 0; +inp[17170] = 0; +inp[17171] = 0; +inp[17172] = 0; +inp[17173] = 0; +inp[17174] = 0; +inp[17175] = 0; +inp[17176] = 0; +inp[17177] = 0; +inp[17178] = 0; +inp[17179] = 0; +inp[17180] = 0; +inp[17181] = 0; +inp[17182] = 0; +inp[17183] = 0; +inp[17184] = 0; +inp[17185] = 0; +inp[17186] = 0; +inp[17187] = 0; +inp[17188] = 0; +inp[17189] = 0; +inp[17190] = 0; +inp[17191] = 0; +inp[17192] = 0; +inp[17193] = 0; +inp[17194] = 0; +inp[17195] = 0; +inp[17196] = 0; +inp[17197] = 0; +inp[17198] = 0; +inp[17199] = 0; +inp[17200] = 0; +inp[17201] = 0; +inp[17202] = 0; +inp[17203] = 0; +inp[17204] = 0; +inp[17205] = 0; +inp[17206] = 0; +inp[17207] = 0; +inp[17208] = 0; +inp[17209] = 0; +inp[17210] = 0; +inp[17211] = 0; +inp[17212] = 0; +inp[17213] = 0; +inp[17214] = 0; +inp[17215] = 0; +inp[17216] = 0; +inp[17217] = 0; +inp[17218] = 0; +inp[17219] = 0; +inp[17220] = 0; +inp[17221] = 0; +inp[17222] = 0; +inp[17223] = 0; +inp[17224] = 0; +inp[17225] = 0; +inp[17226] = 0; +inp[17227] = 0; +inp[17228] = 0; +inp[17229] = 0; +inp[17230] = 0; +inp[17231] = 0; +inp[17232] = 0; +inp[17233] = 0; +inp[17234] = 0; +inp[17235] = 0; +inp[17236] = 0; +inp[17237] = 0; +inp[17238] = 0; +inp[17239] = 0; +inp[17240] = 0; +inp[17241] = 0; +inp[17242] = 0; +inp[17243] = 0; +inp[17244] = 0; +inp[17245] = 0; +inp[17246] = 0; +inp[17247] = 0; +inp[17248] = 0; +inp[17249] = 0; +inp[17250] = 0; +inp[17251] = 0; +inp[17252] = 0; +inp[17253] = 0; +inp[17254] = 0; +inp[17255] = 0; +inp[17256] = 0; +inp[17257] = 0; +inp[17258] = 0; +inp[17259] = 0; +inp[17260] = 0; +inp[17261] = 0; +inp[17262] = 0; +inp[17263] = 0; +inp[17264] = 0; +inp[17265] = 0; +inp[17266] = 0; +inp[17267] = 0; +inp[17268] = 0; +inp[17269] = 0; +inp[17270] = 0; +inp[17271] = 0; +inp[17272] = 0; +inp[17273] = 0; +inp[17274] = 0; +inp[17275] = 0; +inp[17276] = 1073741824; +inp[17277] = 1073741824; +inp[17278] = 651257336; +inp[17279] = 145315153; +inp[17280] = 395007542; +inp[17281] = 19666267; +inp[17282] = 239584185; +inp[17283] = 2661539; +inp[17284] = 145315153; +inp[17285] = 360200; +inp[17286] = 88138096; +inp[17287] = 48747; +inp[17288] = 53458457; +inp[17289] = 6597; +inp[17290] = 32424193; +inp[17291] = 892; +inp[17292] = 19666267; +inp[17293] = 120; +inp[17294] = 11928194; +inp[17295] = 16; +inp[17296] = 7234815; +inp[17297] = 2; +inp[17298] = 4388137; +inp[17299] = 0; +inp[17300] = 2661539; +inp[17301] = 0; +inp[17302] = 1614305; +inp[17303] = 0; +inp[17304] = 979125; +inp[17305] = 0; +inp[17306] = 593869; +inp[17307] = 0; +inp[17308] = 360200; +inp[17309] = 0; +inp[17310] = 218472; +inp[17311] = 0; +inp[17312] = 132510; +inp[17313] = 0; +inp[17314] = 80371; +inp[17315] = 0; +inp[17316] = 48747; +inp[17317] = 0; +inp[17318] = 29567; +inp[17319] = 0; +inp[17320] = 17933; +inp[17321] = 0; +inp[17322] = 10877; +inp[17323] = 0; +inp[17324] = 6597; +inp[17325] = 0; +inp[17326] = 4001; +inp[17327] = 0; +inp[17328] = 2427; +inp[17329] = 0; +inp[17330] = 1472; +inp[17331] = 0; +inp[17332] = 892; +inp[17333] = 0; +inp[17334] = 541; +inp[17335] = 0; +inp[17336] = 328; +inp[17337] = 0; +inp[17338] = 199; +inp[17339] = 0; +inp[17340] = 120; +inp[17341] = 0; +inp[17342] = 73; +inp[17343] = 0; +inp[17344] = 44; +inp[17345] = 0; +inp[17346] = 26; +inp[17347] = 0; +inp[17348] = 16; +inp[17349] = 0; +inp[17350] = 9; +inp[17351] = 0; +inp[17352] = 6; +inp[17353] = 0; +inp[17354] = 3; +inp[17355] = 0; +inp[17356] = 2; +inp[17357] = 0; +inp[17358] = 1; +inp[17359] = 0; +inp[17360] = 0; +inp[17361] = 0; +inp[17362] = 0; +inp[17363] = 0; +inp[17364] = 0; +inp[17365] = 0; +inp[17366] = 0; +inp[17367] = 0; +inp[17368] = 0; +inp[17369] = 0; +inp[17370] = 0; +inp[17371] = 0; +inp[17372] = 0; +inp[17373] = 0; +inp[17374] = 0; +inp[17375] = 0; +inp[17376] = 0; +inp[17377] = 0; +inp[17378] = 0; +inp[17379] = 0; +inp[17380] = 0; +inp[17381] = 0; +inp[17382] = 0; +inp[17383] = 0; +inp[17384] = 0; +inp[17385] = 0; +inp[17386] = 0; +inp[17387] = 0; +inp[17388] = 0; +inp[17389] = 0; +inp[17390] = 0; +inp[17391] = 0; +inp[17392] = 0; +inp[17393] = 0; +inp[17394] = 0; +inp[17395] = 0; +inp[17396] = 0; +inp[17397] = 0; +inp[17398] = 0; +inp[17399] = 0; +inp[17400] = 0; +inp[17401] = 0; +inp[17402] = 0; +inp[17403] = 0; +inp[17404] = 0; +inp[17405] = 0; +inp[17406] = 0; +inp[17407] = 0; +inp[17408] = 0; +inp[17409] = 0; +inp[17410] = 0; +inp[17411] = 0; +inp[17412] = 0; +inp[17413] = 0; +inp[17414] = 0; +inp[17415] = 0; +inp[17416] = 0; +inp[17417] = 0; +inp[17418] = 0; +inp[17419] = 0; +inp[17420] = 0; +inp[17421] = 0; +inp[17422] = 0; +inp[17423] = 0; +inp[17424] = 0; +inp[17425] = 0; +inp[17426] = 0; +inp[17427] = 0; +inp[17428] = 0; +inp[17429] = 0; +inp[17430] = 0; +inp[17431] = 0; +inp[17432] = 0; +inp[17433] = 0; +inp[17434] = 0; +inp[17435] = 0; +inp[17436] = 0; +inp[17437] = 0; +inp[17438] = 0; +inp[17439] = 0; +inp[17440] = 0; +inp[17441] = 0; +inp[17442] = 0; +inp[17443] = 0; +inp[17444] = 0; +inp[17445] = 0; +inp[17446] = 0; +inp[17447] = 0; +inp[17448] = 0; +inp[17449] = 0; +inp[17450] = 0; +inp[17451] = 0; +inp[17452] = 0; +inp[17453] = 0; +inp[17454] = 0; +inp[17455] = 0; +inp[17456] = 0; +inp[17457] = 0; +inp[17458] = 0; +inp[17459] = 0; +inp[17460] = 0; +inp[17461] = 0; +inp[17462] = 0; +inp[17463] = 0; +inp[17464] = 0; +inp[17465] = 0; +inp[17466] = 0; +inp[17467] = 0; +inp[17468] = 0; +inp[17469] = 0; +inp[17470] = 0; +inp[17471] = 0; +inp[17472] = 0; +inp[17473] = 0; +inp[17474] = 0; +inp[17475] = 0; +inp[17476] = 0; +inp[17477] = 0; +inp[17478] = 0; +inp[17479] = 0; +inp[17480] = 0; +inp[17481] = 0; +inp[17482] = 0; +inp[17483] = 0; +inp[17484] = 0; +inp[17485] = 0; +inp[17486] = 0; +inp[17487] = 0; +inp[17488] = 0; +inp[17489] = 0; +inp[17490] = 0; +inp[17491] = 0; +inp[17492] = 0; +inp[17493] = 0; +inp[17494] = 0; +inp[17495] = 0; +inp[17496] = 0; +inp[17497] = 0; +inp[17498] = 0; +inp[17499] = 0; +inp[17500] = 0; +inp[17501] = 0; +inp[17502] = 0; +inp[17503] = 0; +inp[17504] = 0; +inp[17505] = 0; +inp[17506] = 0; +inp[17507] = 0; +inp[17508] = 0; +inp[17509] = 0; +inp[17510] = 0; +inp[17511] = 0; +inp[17512] = 0; +inp[17513] = 0; +inp[17514] = 0; +inp[17515] = 0; +inp[17516] = 0; +inp[17517] = 0; +inp[17518] = 0; +inp[17519] = 0; +inp[17520] = 0; +inp[17521] = 0; +inp[17522] = 0; +inp[17523] = 0; +inp[17524] = 0; +inp[17525] = 0; +inp[17526] = 0; +inp[17527] = 0; +inp[17528] = 0; +inp[17529] = 0; +inp[17530] = 0; +inp[17531] = 0; +inp[17532] = 0; +inp[17533] = 0; +inp[17534] = 0; +inp[17535] = 0; +inp[17536] = 0; +inp[17537] = 0; +inp[17538] = 0; +inp[17539] = 0; +inp[17540] = 0; +inp[17541] = 0; +inp[17542] = 0; +inp[17543] = 0; +inp[17544] = 0; +inp[17545] = 0; +inp[17546] = 0; +inp[17547] = 0; +inp[17548] = 0; +inp[17549] = 0; +inp[17550] = 0; +inp[17551] = 0; +inp[17552] = 0; +inp[17553] = 0; +inp[17554] = 0; +inp[17555] = 0; +inp[17556] = 0; +inp[17557] = 0; +inp[17558] = 0; +inp[17559] = 0; +inp[17560] = 0; +inp[17561] = 0; +inp[17562] = 0; +inp[17563] = 0; +inp[17564] = 0; +inp[17565] = 0; +inp[17566] = 0; +inp[17567] = 0; +inp[17568] = 0; +inp[17569] = 0; +inp[17570] = 0; +inp[17571] = 0; +inp[17572] = 0; +inp[17573] = 0; +inp[17574] = 0; +inp[17575] = 0; +inp[17576] = 0; +inp[17577] = 0; +inp[17578] = 0; +inp[17579] = 0; +inp[17580] = 0; +inp[17581] = 0; +inp[17582] = 0; +inp[17583] = 0; +inp[17584] = 0; +inp[17585] = 0; +inp[17586] = 0; +inp[17587] = 0; +inp[17588] = 0; +inp[17589] = 0; +inp[17590] = 0; +inp[17591] = 0; +inp[17592] = 0; +inp[17593] = 0; +inp[17594] = 0; +inp[17595] = 0; +inp[17596] = 0; +inp[17597] = 0; +inp[17598] = 0; +inp[17599] = 0; +inp[17600] = 0; +inp[17601] = 0; +inp[17602] = 0; +inp[17603] = 0; +inp[17604] = 0; +inp[17605] = 0; +inp[17606] = 0; +inp[17607] = 0; +inp[17608] = 0; +inp[17609] = 0; +inp[17610] = 0; +inp[17611] = 0; +inp[17612] = 0; +inp[17613] = 0; +inp[17614] = 0; +inp[17615] = 0; +inp[17616] = 0; +inp[17617] = 0; +inp[17618] = 0; +inp[17619] = 0; +inp[17620] = 0; +inp[17621] = 0; +inp[17622] = 0; +inp[17623] = 0; +inp[17624] = 0; +inp[17625] = 0; +inp[17626] = 0; +inp[17627] = 0; +inp[17628] = 0; +inp[17629] = 0; +inp[17630] = 0; +inp[17631] = 0; +inp[17632] = 0; +inp[17633] = 0; +inp[17634] = 0; +inp[17635] = 0; +inp[17636] = 0; +inp[17637] = 0; +inp[17638] = 0; +inp[17639] = 0; +inp[17640] = 0; +inp[17641] = 0; +inp[17642] = 0; +inp[17643] = 0; +inp[17644] = 0; +inp[17645] = 0; +inp[17646] = 0; +inp[17647] = 0; +inp[17648] = 0; +inp[17649] = 0; +inp[17650] = 0; +inp[17651] = 0; +inp[17652] = 0; +inp[17653] = 0; +inp[17654] = 0; +inp[17655] = 0; +inp[17656] = 0; +inp[17657] = 0; +inp[17658] = 0; +inp[17659] = 0; +inp[17660] = 0; +inp[17661] = 0; +inp[17662] = 0; +inp[17663] = 0; +inp[17664] = 0; +inp[17665] = 0; +inp[17666] = 0; +inp[17667] = 0; +inp[17668] = 0; +inp[17669] = 0; +inp[17670] = 0; +inp[17671] = 0; +inp[17672] = 0; +inp[17673] = 0; +inp[17674] = 0; +inp[17675] = 0; +inp[17676] = 0; +inp[17677] = 0; +inp[17678] = 0; +inp[17679] = 0; +inp[17680] = 0; +inp[17681] = 0; +inp[17682] = 0; +inp[17683] = 0; +inp[17684] = 0; +inp[17685] = 0; +inp[17686] = 0; +inp[17687] = 0; +inp[17688] = 0; +inp[17689] = 0; +inp[17690] = 0; +inp[17691] = 0; +inp[17692] = 0; +inp[17693] = 0; +inp[17694] = 0; +inp[17695] = 0; +inp[17696] = 0; +inp[17697] = 0; +inp[17698] = 0; +inp[17699] = 0; +inp[17700] = 0; +inp[17701] = 0; +inp[17702] = 0; +inp[17703] = 0; +inp[17704] = 0; +inp[17705] = 0; +inp[17706] = 0; +inp[17707] = 0; +inp[17708] = 0; +inp[17709] = 0; +inp[17710] = 0; +inp[17711] = 0; +inp[17712] = 0; +inp[17713] = 0; +inp[17714] = 0; +inp[17715] = 0; +inp[17716] = 0; +inp[17717] = 0; +inp[17718] = 0; +inp[17719] = 0; +inp[17720] = 0; +inp[17721] = 0; +inp[17722] = 0; +inp[17723] = 0; +inp[17724] = 0; +inp[17725] = 0; +inp[17726] = 0; +inp[17727] = 0; +inp[17728] = 0; +inp[17729] = 0; +inp[17730] = 0; +inp[17731] = 0; +inp[17732] = 0; +inp[17733] = 0; +inp[17734] = 0; +inp[17735] = 0; +inp[17736] = 0; +inp[17737] = 0; +inp[17738] = 0; +inp[17739] = 0; +inp[17740] = 0; +inp[17741] = 0; +inp[17742] = 0; +inp[17743] = 0; +inp[17744] = 0; +inp[17745] = 0; +inp[17746] = 0; +inp[17747] = 0; +inp[17748] = 0; +inp[17749] = 0; +inp[17750] = 0; +inp[17751] = 0; +inp[17752] = 0; +inp[17753] = 0; +inp[17754] = 0; +inp[17755] = 0; +inp[17756] = 0; +inp[17757] = 0; +inp[17758] = 0; +inp[17759] = 0; +inp[17760] = 0; +inp[17761] = 0; +inp[17762] = 0; +inp[17763] = 0; +inp[17764] = 0; +inp[17765] = 0; +inp[17766] = 0; +inp[17767] = 0; +inp[17768] = 0; +inp[17769] = 0; +inp[17770] = 0; +inp[17771] = 0; +inp[17772] = 0; +inp[17773] = 0; +inp[17774] = 0; +inp[17775] = 0; +inp[17776] = 0; +inp[17777] = 0; +inp[17778] = 0; +inp[17779] = 0; +inp[17780] = 0; +inp[17781] = 0; +inp[17782] = 0; +inp[17783] = 0; +inp[17784] = 0; +inp[17785] = 0; +inp[17786] = 0; +inp[17787] = 0; +inp[17788] = 1073741824; +inp[17789] = 1073741824; +inp[17790] = 836230973; +inp[17791] = 19666267; +inp[17792] = 651257336; +inp[17793] = 360200; +inp[17794] = 507199723; +inp[17795] = 6597; +inp[17796] = 395007542; +inp[17797] = 120; +inp[17798] = 307632183; +inp[17799] = 2; +inp[17800] = 239584185; +inp[17801] = 0; +inp[17802] = 186588351; +inp[17803] = 0; +inp[17804] = 145315153; +inp[17805] = 0; +inp[17806] = 113171555; +inp[17807] = 0; +inp[17808] = 88138096; +inp[17809] = 0; +inp[17810] = 68642018; +inp[17811] = 0; +inp[17812] = 53458457; +inp[17813] = 0; +inp[17814] = 41633488; +inp[17815] = 0; +inp[17816] = 32424193; +inp[17817] = 0; +inp[17818] = 25251987; +inp[17819] = 0; +inp[17820] = 19666267; +inp[17821] = 0; +inp[17822] = 15316104; +inp[17823] = 0; +inp[17824] = 11928194; +inp[17825] = 0; +inp[17826] = 9289686; +inp[17827] = 0; +inp[17828] = 7234815; +inp[17829] = 0; +inp[17830] = 5634479; +inp[17831] = 0; +inp[17832] = 4388137; +inp[17833] = 0; +inp[17834] = 3417484; +inp[17835] = 0; +inp[17836] = 2661539; +inp[17837] = 0; +inp[17838] = 2072809; +inp[17839] = 0; +inp[17840] = 1614305; +inp[17841] = 0; +inp[17842] = 1257222; +inp[17843] = 0; +inp[17844] = 979125; +inp[17845] = 0; +inp[17846] = 762543; +inp[17847] = 0; +inp[17848] = 593869; +inp[17849] = 0; +inp[17850] = 462506; +inp[17851] = 0; +inp[17852] = 360200; +inp[17853] = 0; +inp[17854] = 280524; +inp[17855] = 0; +inp[17856] = 218472; +inp[17857] = 0; +inp[17858] = 170146; +inp[17859] = 0; +inp[17860] = 132510; +inp[17861] = 0; +inp[17862] = 103199; +inp[17863] = 0; +inp[17864] = 80371; +inp[17865] = 0; +inp[17866] = 62593; +inp[17867] = 0; +inp[17868] = 48747; +inp[17869] = 0; +inp[17870] = 37964; +inp[17871] = 0; +inp[17872] = 29567; +inp[17873] = 0; +inp[17874] = 23026; +inp[17875] = 0; +inp[17876] = 17933; +inp[17877] = 0; +inp[17878] = 13966; +inp[17879] = 0; +inp[17880] = 10877; +inp[17881] = 0; +inp[17882] = 8471; +inp[17883] = 0; +inp[17884] = 6597; +inp[17885] = 0; +inp[17886] = 5137; +inp[17887] = 0; +inp[17888] = 4001; +inp[17889] = 0; +inp[17890] = 3116; +inp[17891] = 0; +inp[17892] = 2427; +inp[17893] = 0; +inp[17894] = 1890; +inp[17895] = 0; +inp[17896] = 1472; +inp[17897] = 0; +inp[17898] = 1146; +inp[17899] = 0; +inp[17900] = 892; +inp[17901] = 0; +inp[17902] = 695; +inp[17903] = 0; +inp[17904] = 541; +inp[17905] = 0; +inp[17906] = 421; +inp[17907] = 0; +inp[17908] = 328; +inp[17909] = 0; +inp[17910] = 255; +inp[17911] = 0; +inp[17912] = 199; +inp[17913] = 0; +inp[17914] = 155; +inp[17915] = 0; +inp[17916] = 120; +inp[17917] = 0; +inp[17918] = 94; +inp[17919] = 0; +inp[17920] = 73; +inp[17921] = 0; +inp[17922] = 57; +inp[17923] = 0; +inp[17924] = 44; +inp[17925] = 0; +inp[17926] = 34; +inp[17927] = 0; +inp[17928] = 26; +inp[17929] = 0; +inp[17930] = 20; +inp[17931] = 0; +inp[17932] = 16; +inp[17933] = 0; +inp[17934] = 12; +inp[17935] = 0; +inp[17936] = 9; +inp[17937] = 0; +inp[17938] = 7; +inp[17939] = 0; +inp[17940] = 6; +inp[17941] = 0; +inp[17942] = 4; +inp[17943] = 0; +inp[17944] = 3; +inp[17945] = 0; +inp[17946] = 2; +inp[17947] = 0; +inp[17948] = 2; +inp[17949] = 0; +inp[17950] = 1; +inp[17951] = 0; +inp[17952] = 1; +inp[17953] = 0; +inp[17954] = 1; +inp[17955] = 0; +inp[17956] = 0; +inp[17957] = 0; +inp[17958] = 0; +inp[17959] = 0; +inp[17960] = 0; +inp[17961] = 0; +inp[17962] = 0; +inp[17963] = 0; +inp[17964] = 0; +inp[17965] = 0; +inp[17966] = 0; +inp[17967] = 0; +inp[17968] = 0; +inp[17969] = 0; +inp[17970] = 0; +inp[17971] = 0; +inp[17972] = 0; +inp[17973] = 0; +inp[17974] = 0; +inp[17975] = 0; +inp[17976] = 0; +inp[17977] = 0; +inp[17978] = 0; +inp[17979] = 0; +inp[17980] = 0; +inp[17981] = 0; +inp[17982] = 0; +inp[17983] = 0; +inp[17984] = 0; +inp[17985] = 0; +inp[17986] = 0; +inp[17987] = 0; +inp[17988] = 0; +inp[17989] = 0; +inp[17990] = 0; +inp[17991] = 0; +inp[17992] = 0; +inp[17993] = 0; +inp[17994] = 0; +inp[17995] = 0; +inp[17996] = 0; +inp[17997] = 0; +inp[17998] = 0; +inp[17999] = 0; +inp[18000] = 0; +inp[18001] = 0; +inp[18002] = 0; +inp[18003] = 0; +inp[18004] = 0; +inp[18005] = 0; +inp[18006] = 0; +inp[18007] = 0; +inp[18008] = 0; +inp[18009] = 0; +inp[18010] = 0; +inp[18011] = 0; +inp[18012] = 0; +inp[18013] = 0; +inp[18014] = 0; +inp[18015] = 0; +inp[18016] = 0; +inp[18017] = 0; +inp[18018] = 0; +inp[18019] = 0; +inp[18020] = 0; +inp[18021] = 0; +inp[18022] = 0; +inp[18023] = 0; +inp[18024] = 0; +inp[18025] = 0; +inp[18026] = 0; +inp[18027] = 0; +inp[18028] = 0; +inp[18029] = 0; +inp[18030] = 0; +inp[18031] = 0; +inp[18032] = 0; +inp[18033] = 0; +inp[18034] = 0; +inp[18035] = 0; +inp[18036] = 0; +inp[18037] = 0; +inp[18038] = 0; +inp[18039] = 0; +inp[18040] = 0; +inp[18041] = 0; +inp[18042] = 0; +inp[18043] = 0; +inp[18044] = 0; +inp[18045] = 0; +inp[18046] = 0; +inp[18047] = 0; +inp[18048] = 0; +inp[18049] = 0; +inp[18050] = 0; +inp[18051] = 0; +inp[18052] = 0; +inp[18053] = 0; +inp[18054] = 0; +inp[18055] = 0; +inp[18056] = 0; +inp[18057] = 0; +inp[18058] = 0; +inp[18059] = 0; +inp[18060] = 0; +inp[18061] = 0; +inp[18062] = 0; +inp[18063] = 0; +inp[18064] = 0; +inp[18065] = 0; +inp[18066] = 0; +inp[18067] = 0; +inp[18068] = 0; +inp[18069] = 0; +inp[18070] = 0; +inp[18071] = 0; +inp[18072] = 0; +inp[18073] = 0; +inp[18074] = 0; +inp[18075] = 0; +inp[18076] = 0; +inp[18077] = 0; +inp[18078] = 0; +inp[18079] = 0; +inp[18080] = 0; +inp[18081] = 0; +inp[18082] = 0; +inp[18083] = 0; +inp[18084] = 0; +inp[18085] = 0; +inp[18086] = 0; +inp[18087] = 0; +inp[18088] = 0; +inp[18089] = 0; +inp[18090] = 0; +inp[18091] = 0; +inp[18092] = 0; +inp[18093] = 0; +inp[18094] = 0; +inp[18095] = 0; +inp[18096] = 0; +inp[18097] = 0; +inp[18098] = 0; +inp[18099] = 0; +inp[18100] = 0; +inp[18101] = 0; +inp[18102] = 0; +inp[18103] = 0; +inp[18104] = 0; +inp[18105] = 0; +inp[18106] = 0; +inp[18107] = 0; +inp[18108] = 0; +inp[18109] = 0; +inp[18110] = 0; +inp[18111] = 0; +inp[18112] = 0; +inp[18113] = 0; +inp[18114] = 0; +inp[18115] = 0; +inp[18116] = 0; +inp[18117] = 0; +inp[18118] = 0; +inp[18119] = 0; +inp[18120] = 0; +inp[18121] = 0; +inp[18122] = 0; +inp[18123] = 0; +inp[18124] = 0; +inp[18125] = 0; +inp[18126] = 0; +inp[18127] = 0; +inp[18128] = 0; +inp[18129] = 0; +inp[18130] = 0; +inp[18131] = 0; +inp[18132] = 0; +inp[18133] = 0; +inp[18134] = 0; +inp[18135] = 0; +inp[18136] = 0; +inp[18137] = 0; +inp[18138] = 0; +inp[18139] = 0; +inp[18140] = 0; +inp[18141] = 0; +inp[18142] = 0; +inp[18143] = 0; +inp[18144] = 0; +inp[18145] = 0; +inp[18146] = 0; +inp[18147] = 0; +inp[18148] = 0; +inp[18149] = 0; +inp[18150] = 0; +inp[18151] = 0; +inp[18152] = 0; +inp[18153] = 0; +inp[18154] = 0; +inp[18155] = 0; +inp[18156] = 0; +inp[18157] = 0; +inp[18158] = 0; +inp[18159] = 0; +inp[18160] = 0; +inp[18161] = 0; +inp[18162] = 0; +inp[18163] = 0; +inp[18164] = 0; +inp[18165] = 0; +inp[18166] = 0; +inp[18167] = 0; +inp[18168] = 0; +inp[18169] = 0; +inp[18170] = 0; +inp[18171] = 0; +inp[18172] = 0; +inp[18173] = 0; +inp[18174] = 0; +inp[18175] = 0; +inp[18176] = 0; +inp[18177] = 0; +inp[18178] = 0; +inp[18179] = 0; +inp[18180] = 0; +inp[18181] = 0; +inp[18182] = 0; +inp[18183] = 0; +inp[18184] = 0; +inp[18185] = 0; +inp[18186] = 0; +inp[18187] = 0; +inp[18188] = 0; +inp[18189] = 0; +inp[18190] = 0; +inp[18191] = 0; +inp[18192] = 0; +inp[18193] = 0; +inp[18194] = 0; +inp[18195] = 0; +inp[18196] = 0; +inp[18197] = 0; +inp[18198] = 0; +inp[18199] = 0; +inp[18200] = 0; +inp[18201] = 0; +inp[18202] = 0; +inp[18203] = 0; +inp[18204] = 0; +inp[18205] = 0; +inp[18206] = 0; +inp[18207] = 0; +inp[18208] = 0; +inp[18209] = 0; +inp[18210] = 0; +inp[18211] = 0; +inp[18212] = 0; +inp[18213] = 0; +inp[18214] = 0; +inp[18215] = 0; +inp[18216] = 0; +inp[18217] = 0; +inp[18218] = 0; +inp[18219] = 0; +inp[18220] = 0; +inp[18221] = 0; +inp[18222] = 0; +inp[18223] = 0; +inp[18224] = 0; +inp[18225] = 0; +inp[18226] = 0; +inp[18227] = 0; +inp[18228] = 0; +inp[18229] = 0; +inp[18230] = 0; +inp[18231] = 0; +inp[18232] = 0; +inp[18233] = 0; +inp[18234] = 0; +inp[18235] = 0; +inp[18236] = 0; +inp[18237] = 0; +inp[18238] = 0; +inp[18239] = 0; +inp[18240] = 0; +inp[18241] = 0; +inp[18242] = 0; +inp[18243] = 0; +inp[18244] = 0; +inp[18245] = 0; +inp[18246] = 0; +inp[18247] = 0; +inp[18248] = 0; +inp[18249] = 0; +inp[18250] = 0; +inp[18251] = 0; +inp[18252] = 0; +inp[18253] = 0; +inp[18254] = 0; +inp[18255] = 0; +inp[18256] = 0; +inp[18257] = 0; +inp[18258] = 0; +inp[18259] = 0; +inp[18260] = 0; +inp[18261] = 0; +inp[18262] = 0; +inp[18263] = 0; +inp[18264] = 0; +inp[18265] = 0; +inp[18266] = 0; +inp[18267] = 0; +inp[18268] = 0; +inp[18269] = 0; +inp[18270] = 0; +inp[18271] = 0; +inp[18272] = 0; +inp[18273] = 0; +inp[18274] = 0; +inp[18275] = 0; +inp[18276] = 0; +inp[18277] = 0; +inp[18278] = 0; +inp[18279] = 0; +inp[18280] = 0; +inp[18281] = 0; +inp[18282] = 0; +inp[18283] = 0; +inp[18284] = 0; +inp[18285] = 0; +inp[18286] = 0; +inp[18287] = 0; +inp[18288] = 0; +inp[18289] = 0; +inp[18290] = 0; +inp[18291] = 0; +inp[18292] = 0; +inp[18293] = 0; +inp[18294] = 0; +inp[18295] = 0; +inp[18296] = 0; +inp[18297] = 0; +inp[18298] = 0; +inp[18299] = 0; +inp[18300] = 1073741824; +inp[18301] = 1073741824; +inp[18302] = 947573833; +inp[18303] = 360200; +inp[18304] = 836230973; +inp[18305] = 120; +inp[18306] = 737971243; +inp[18307] = 0; +inp[18308] = 651257336; +inp[18309] = 0; +inp[18310] = 574732582; +inp[18311] = 0; +inp[18312] = 507199723; +inp[18313] = 0; +inp[18314] = 447602185; +inp[18315] = 0; +inp[18316] = 395007542; +inp[18317] = 0; +inp[18318] = 348592932; +inp[18319] = 0; +inp[18320] = 307632183; +inp[18321] = 0; +inp[18322] = 271484448; +inp[18323] = 0; +inp[18324] = 239584185; +inp[18325] = 0; +inp[18326] = 211432301; +inp[18327] = 0; +inp[18328] = 186588351; +inp[18329] = 0; +inp[18330] = 164663641; +inp[18331] = 0; +inp[18332] = 145315153; +inp[18333] = 0; +inp[18334] = 128240173; +inp[18335] = 0; +inp[18336] = 113171555; +inp[18337] = 0; +inp[18338] = 99873547; +inp[18339] = 0; +inp[18340] = 88138096; +inp[18341] = 0; +inp[18342] = 77781596; +inp[18343] = 0; +inp[18344] = 68642018; +inp[18345] = 0; +inp[18346] = 60576368; +inp[18347] = 0; +inp[18348] = 53458457; +inp[18349] = 0; +inp[18350] = 47176923; +inp[18351] = 0; +inp[18352] = 41633488; +inp[18353] = 0; +inp[18354] = 36741424; +inp[18355] = 0; +inp[18356] = 32424193; +inp[18357] = 0; +inp[18358] = 28614250; +inp[18359] = 0; +inp[18360] = 25251987; +inp[18361] = 0; +inp[18362] = 22284800; +inp[18363] = 0; +inp[18364] = 19666267; +inp[18365] = 0; +inp[18366] = 17355420; +inp[18367] = 0; +inp[18368] = 15316104; +inp[18369] = 0; +inp[18370] = 13516414; +inp[18371] = 0; +inp[18372] = 11928194; +inp[18373] = 0; +inp[18374] = 10526594; +inp[18375] = 0; +inp[18376] = 9289686; +inp[18377] = 0; +inp[18378] = 8198119; +inp[18379] = 0; +inp[18380] = 7234815; +inp[18381] = 0; +inp[18382] = 6384702; +inp[18383] = 0; +inp[18384] = 5634479; +inp[18385] = 0; +inp[18386] = 4972411; +inp[18387] = 0; +inp[18388] = 4388137; +inp[18389] = 0; +inp[18390] = 3872517; +inp[18391] = 0; +inp[18392] = 3417484; +inp[18393] = 0; +inp[18394] = 3015919; +inp[18395] = 0; +inp[18396] = 2661539; +inp[18397] = 0; +inp[18398] = 2348800; +inp[18399] = 0; +inp[18400] = 2072809; +inp[18401] = 0; +inp[18402] = 1829247; +inp[18403] = 0; +inp[18404] = 1614305; +inp[18405] = 0; +inp[18406] = 1424619; +inp[18407] = 0; +inp[18408] = 1257222; +inp[18409] = 0; +inp[18410] = 1109494; +inp[18411] = 0; +inp[18412] = 979125; +inp[18413] = 0; +inp[18414] = 864075; +inp[18415] = 0; +inp[18416] = 762543; +inp[18417] = 0; +inp[18418] = 672942; +inp[18419] = 0; +inp[18420] = 593869; +inp[18421] = 0; +inp[18422] = 524088; +inp[18423] = 0; +inp[18424] = 462506; +inp[18425] = 0; +inp[18426] = 408160; +inp[18427] = 0; +inp[18428] = 360200; +inp[18429] = 0; +inp[18430] = 317875; +inp[18431] = 0; +inp[18432] = 280524; +inp[18433] = 0; +inp[18434] = 247561; +inp[18435] = 0; +inp[18436] = 218472; +inp[18437] = 0; +inp[18438] = 192801; +inp[18439] = 0; +inp[18440] = 170146; +inp[18441] = 0; +inp[18442] = 150153; +inp[18443] = 0; +inp[18444] = 132510; +inp[18445] = 0; +inp[18446] = 116939; +inp[18447] = 0; +inp[18448] = 103199; +inp[18449] = 0; +inp[18450] = 91072; +inp[18451] = 0; +inp[18452] = 80371; +inp[18453] = 0; +inp[18454] = 70927; +inp[18455] = 0; +inp[18456] = 62593; +inp[18457] = 0; +inp[18458] = 55238; +inp[18459] = 0; +inp[18460] = 48747; +inp[18461] = 0; +inp[18462] = 43019; +inp[18463] = 0; +inp[18464] = 37964; +inp[18465] = 0; +inp[18466] = 33503; +inp[18467] = 0; +inp[18468] = 29567; +inp[18469] = 0; +inp[18470] = 26092; +inp[18471] = 0; +inp[18472] = 23026; +inp[18473] = 0; +inp[18474] = 20321; +inp[18475] = 0; +inp[18476] = 17933; +inp[18477] = 0; +inp[18478] = 15826; +inp[18479] = 0; +inp[18480] = 13966; +inp[18481] = 0; +inp[18482] = 12325; +inp[18483] = 0; +inp[18484] = 10877; +inp[18485] = 0; +inp[18486] = 9599; +inp[18487] = 0; +inp[18488] = 8471; +inp[18489] = 0; +inp[18490] = 7475; +inp[18491] = 0; +inp[18492] = 6597; +inp[18493] = 0; +inp[18494] = 5822; +inp[18495] = 0; +inp[18496] = 5137; +inp[18497] = 0; +inp[18498] = 4534; +inp[18499] = 0; +inp[18500] = 4001; +inp[18501] = 0; +inp[18502] = 3531; +inp[18503] = 0; +inp[18504] = 3116; +inp[18505] = 0; +inp[18506] = 2750; +inp[18507] = 0; +inp[18508] = 2427; +inp[18509] = 0; +inp[18510] = 2141; +inp[18511] = 0; +inp[18512] = 1890; +inp[18513] = 0; +inp[18514] = 1668; +inp[18515] = 0; +inp[18516] = 1472; +inp[18517] = 0; +inp[18518] = 1299; +inp[18519] = 0; +inp[18520] = 1146; +inp[18521] = 0; +inp[18522] = 1011; +inp[18523] = 0; +inp[18524] = 892; +inp[18525] = 0; +inp[18526] = 787; +inp[18527] = 0; +inp[18528] = 695; +inp[18529] = 0; +inp[18530] = 613; +inp[18531] = 0; +inp[18532] = 541; +inp[18533] = 0; +inp[18534] = 477; +inp[18535] = 0; +inp[18536] = 421; +inp[18537] = 0; +inp[18538] = 372; +inp[18539] = 0; +inp[18540] = 328; +inp[18541] = 0; +inp[18542] = 289; +inp[18543] = 0; +inp[18544] = 255; +inp[18545] = 0; +inp[18546] = 225; +inp[18547] = 0; +inp[18548] = 199; +inp[18549] = 0; +inp[18550] = 175; +inp[18551] = 0; +inp[18552] = 155; +inp[18553] = 0; +inp[18554] = 136; +inp[18555] = 0; +inp[18556] = 120; +inp[18557] = 0; +inp[18558] = 106; +inp[18559] = 0; +inp[18560] = 94; +inp[18561] = 0; +inp[18562] = 83; +inp[18563] = 0; +inp[18564] = 73; +inp[18565] = 0; +inp[18566] = 64; +inp[18567] = 0; +inp[18568] = 57; +inp[18569] = 0; +inp[18570] = 50; +inp[18571] = 0; +inp[18572] = 44; +inp[18573] = 0; +inp[18574] = 39; +inp[18575] = 0; +inp[18576] = 34; +inp[18577] = 0; +inp[18578] = 30; +inp[18579] = 0; +inp[18580] = 26; +inp[18581] = 0; +inp[18582] = 23; +inp[18583] = 0; +inp[18584] = 20; +inp[18585] = 0; +inp[18586] = 18; +inp[18587] = 0; +inp[18588] = 16; +inp[18589] = 0; +inp[18590] = 14; +inp[18591] = 0; +inp[18592] = 12; +inp[18593] = 0; +inp[18594] = 11; +inp[18595] = 0; +inp[18596] = 9; +inp[18597] = 0; +inp[18598] = 8; +inp[18599] = 0; +inp[18600] = 7; +inp[18601] = 0; +inp[18602] = 6; +inp[18603] = 0; +inp[18604] = 6; +inp[18605] = 0; +inp[18606] = 5; +inp[18607] = 0; +inp[18608] = 4; +inp[18609] = 0; +inp[18610] = 4; +inp[18611] = 0; +inp[18612] = 3; +inp[18613] = 0; +inp[18614] = 3; +inp[18615] = 0; +inp[18616] = 2; +inp[18617] = 0; +inp[18618] = 2; +inp[18619] = 0; +inp[18620] = 2; +inp[18621] = 0; +inp[18622] = 1; +inp[18623] = 0; +inp[18624] = 1; +inp[18625] = 0; +inp[18626] = 1; +inp[18627] = 0; +inp[18628] = 1; +inp[18629] = 0; +inp[18630] = 1; +inp[18631] = 0; +inp[18632] = 1; +inp[18633] = 0; +inp[18634] = 0; +inp[18635] = 0; +inp[18636] = 0; +inp[18637] = 0; +inp[18638] = 0; +inp[18639] = 0; +inp[18640] = 0; +inp[18641] = 0; +inp[18642] = 0; +inp[18643] = 0; +inp[18644] = 0; +inp[18645] = 0; +inp[18646] = 0; +inp[18647] = 0; +inp[18648] = 0; +inp[18649] = 0; +inp[18650] = 0; +inp[18651] = 0; +inp[18652] = 0; +inp[18653] = 0; +inp[18654] = 0; +inp[18655] = 0; +inp[18656] = 0; +inp[18657] = 0; +inp[18658] = 0; +inp[18659] = 0; +inp[18660] = 0; +inp[18661] = 0; +inp[18662] = 0; +inp[18663] = 0; +inp[18664] = 0; +inp[18665] = 0; +inp[18666] = 0; +inp[18667] = 0; +inp[18668] = 0; +inp[18669] = 0; +inp[18670] = 0; +inp[18671] = 0; +inp[18672] = 0; +inp[18673] = 0; +inp[18674] = 0; +inp[18675] = 0; +inp[18676] = 0; +inp[18677] = 0; +inp[18678] = 0; +inp[18679] = 0; +inp[18680] = 0; +inp[18681] = 0; +inp[18682] = 0; +inp[18683] = 0; +inp[18684] = 0; +inp[18685] = 0; +inp[18686] = 0; +inp[18687] = 0; +inp[18688] = 0; +inp[18689] = 0; +inp[18690] = 0; +inp[18691] = 0; +inp[18692] = 0; +inp[18693] = 0; +inp[18694] = 0; +inp[18695] = 0; +inp[18696] = 0; +inp[18697] = 0; +inp[18698] = 0; +inp[18699] = 0; +inp[18700] = 0; +inp[18701] = 0; +inp[18702] = 0; +inp[18703] = 0; +inp[18704] = 0; +inp[18705] = 0; +inp[18706] = 0; +inp[18707] = 0; +inp[18708] = 0; +inp[18709] = 0; +inp[18710] = 0; +inp[18711] = 0; +inp[18712] = 0; +inp[18713] = 0; +inp[18714] = 0; +inp[18715] = 0; +inp[18716] = 0; +inp[18717] = 0; +inp[18718] = 0; +inp[18719] = 0; +inp[18720] = 0; +inp[18721] = 0; +inp[18722] = 0; +inp[18723] = 0; +inp[18724] = 0; +inp[18725] = 0; +inp[18726] = 0; +inp[18727] = 0; +inp[18728] = 0; +inp[18729] = 0; +inp[18730] = 0; +inp[18731] = 0; +inp[18732] = 0; +inp[18733] = 0; +inp[18734] = 0; +inp[18735] = 0; +inp[18736] = 0; +inp[18737] = 0; +inp[18738] = 0; +inp[18739] = 0; +inp[18740] = 0; +inp[18741] = 0; +inp[18742] = 0; +inp[18743] = 0; +inp[18744] = 0; +inp[18745] = 0; +inp[18746] = 0; +inp[18747] = 0; +inp[18748] = 0; +inp[18749] = 0; +inp[18750] = 0; +inp[18751] = 0; +inp[18752] = 0; +inp[18753] = 0; +inp[18754] = 0; +inp[18755] = 0; +inp[18756] = 0; +inp[18757] = 0; +inp[18758] = 0; +inp[18759] = 0; +inp[18760] = 0; +inp[18761] = 0; +inp[18762] = 0; +inp[18763] = 0; +inp[18764] = 0; +inp[18765] = 0; +inp[18766] = 0; +inp[18767] = 0; +inp[18768] = 0; +inp[18769] = 0; +inp[18770] = 0; +inp[18771] = 0; +inp[18772] = 0; +inp[18773] = 0; +inp[18774] = 0; +inp[18775] = 0; +inp[18776] = 0; +inp[18777] = 0; +inp[18778] = 0; +inp[18779] = 0; +inp[18780] = 0; +inp[18781] = 0; +inp[18782] = 0; +inp[18783] = 0; +inp[18784] = 0; +inp[18785] = 0; +inp[18786] = 0; +inp[18787] = 0; +inp[18788] = 0; +inp[18789] = 0; +inp[18790] = 0; +inp[18791] = 0; +inp[18792] = 0; +inp[18793] = 0; +inp[18794] = 0; +inp[18795] = 0; +inp[18796] = 0; +inp[18797] = 0; +inp[18798] = 0; +inp[18799] = 0; +inp[18800] = 0; +inp[18801] = 0; +inp[18802] = 0; +inp[18803] = 0; +inp[18804] = 0; +inp[18805] = 0; +inp[18806] = 0; +inp[18807] = 0; +inp[18808] = 0; +inp[18809] = 0; +inp[18810] = 0; +inp[18811] = 0; +inp[18812] = 1073741824; +inp[18813] = 1073741824; +inp[18814] = 1008687095; +inp[18815] = 120; +inp[18816] = 947573833; +inp[18817] = 0; +inp[18818] = 890163237; +inp[18819] = 0; +inp[18820] = 836230973; +inp[18821] = 0; +inp[18822] = 785566299; +inp[18823] = 0; +inp[18824] = 737971243; +inp[18825] = 0; +inp[18826] = 693259826; +inp[18827] = 0; +inp[18828] = 651257336; +inp[18829] = 0; +inp[18830] = 611799649; +inp[18831] = 0; +inp[18832] = 574732582; +inp[18833] = 0; +inp[18834] = 539911295; +inp[18835] = 0; +inp[18836] = 507199723; +inp[18837] = 0; +inp[18838] = 476470046; +inp[18839] = 0; +inp[18840] = 447602185; +inp[18841] = 0; +inp[18842] = 420483339; +inp[18843] = 0; +inp[18844] = 395007542; +inp[18845] = 0; +inp[18846] = 371075245; +inp[18847] = 0; +inp[18848] = 348592932; +inp[18849] = 0; +inp[18850] = 327472754; +inp[18851] = 0; +inp[18852] = 307632183; +inp[18853] = 0; +inp[18854] = 288993691; +inp[18855] = 0; +inp[18856] = 271484448; +inp[18857] = 0; +inp[18858] = 255036037; +inp[18859] = 0; +inp[18860] = 239584185; +inp[18861] = 0; +inp[18862] = 225068513; +inp[18863] = 0; +inp[18864] = 211432301; +inp[18865] = 0; +inp[18866] = 198622265; +inp[18867] = 0; +inp[18868] = 186588351; +inp[18869] = 0; +inp[18870] = 175283534; +inp[18871] = 0; +inp[18872] = 164663641; +inp[18873] = 0; +inp[18874] = 154687176; +inp[18875] = 0; +inp[18876] = 145315153; +inp[18877] = 0; +inp[18878] = 136510953; +inp[18879] = 0; +inp[18880] = 128240173; +inp[18881] = 0; +inp[18882] = 120470493; +inp[18883] = 0; +inp[18884] = 113171555; +inp[18885] = 0; +inp[18886] = 106314837; +inp[18887] = 0; +inp[18888] = 99873547; +inp[18889] = 0; +inp[18890] = 93822514; +inp[18891] = 0; +inp[18892] = 88138096; +inp[18893] = 0; +inp[18894] = 82798078; +inp[18895] = 0; +inp[18896] = 77781596; +inp[18897] = 0; +inp[18898] = 73069048; +inp[18899] = 0; +inp[18900] = 68642018; +inp[18901] = 0; +inp[18902] = 64483208; +inp[18903] = 0; +inp[18904] = 60576368; +inp[18905] = 0; +inp[18906] = 56906231; +inp[18907] = 0; +inp[18908] = 53458457; +inp[18909] = 0; +inp[18910] = 50219573; +inp[18911] = 0; +inp[18912] = 47176923; +inp[18913] = 0; +inp[18914] = 44318617; +inp[18915] = 0; +inp[18916] = 41633488; +inp[18917] = 0; +inp[18918] = 39111043; +inp[18919] = 0; +inp[18920] = 36741424; +inp[18921] = 0; +inp[18922] = 34515374; +inp[18923] = 0; +inp[18924] = 32424193; +inp[18925] = 0; +inp[18926] = 30459710; +inp[18927] = 0; +inp[18928] = 28614250; +inp[18929] = 0; +inp[18930] = 26880600; +inp[18931] = 0; +inp[18932] = 25251987; +inp[18933] = 0; +inp[18934] = 23722046; +inp[18935] = 0; +inp[18936] = 22284800; +inp[18937] = 0; +inp[18938] = 20934632; +inp[18939] = 0; +inp[18940] = 19666267; +inp[18941] = 0; +inp[18942] = 18474748; +inp[18943] = 0; +inp[18944] = 17355420; +inp[18945] = 0; +inp[18946] = 16303908; +inp[18947] = 0; +inp[18948] = 15316104; +inp[18949] = 0; +inp[18950] = 14388148; +inp[18951] = 0; +inp[18952] = 13516414; +inp[18953] = 0; +inp[18954] = 12697496; +inp[18955] = 0; +inp[18956] = 11928194; +inp[18957] = 0; +inp[18958] = 11205501; +inp[18959] = 0; +inp[18960] = 10526594; +inp[18961] = 0; +inp[18962] = 9888820; +inp[18963] = 0; +inp[18964] = 9289686; +inp[18965] = 0; +inp[18966] = 8726853; +inp[18967] = 0; +inp[18968] = 8198119; +inp[18969] = 0; +inp[18970] = 7701421; +inp[18971] = 0; +inp[18972] = 7234815; +inp[18973] = 0; +inp[18974] = 6796480; +inp[18975] = 0; +inp[18976] = 6384702; +inp[18977] = 0; +inp[18978] = 5997872; +inp[18979] = 0; +inp[18980] = 5634479; +inp[18981] = 0; +inp[18982] = 5293104; +inp[18983] = 0; +inp[18984] = 4972411; +inp[18985] = 0; +inp[18986] = 4671147; +inp[18987] = 0; +inp[18988] = 4388137; +inp[18989] = 0; +inp[18990] = 4122273; +inp[18991] = 0; +inp[18992] = 3872517; +inp[18993] = 0; +inp[18994] = 3637893; +inp[18995] = 0; +inp[18996] = 3417484; +inp[18997] = 0; +inp[18998] = 3210429; +inp[18999] = 0; +inp[19000] = 3015919; +inp[19001] = 0; +inp[19002] = 2833194; +inp[19003] = 0; +inp[19004] = 2661539; +inp[19005] = 0; +inp[19006] = 2500285; +inp[19007] = 0; +inp[19008] = 2348800; +inp[19009] = 0; +inp[19010] = 2206494; +inp[19011] = 0; +inp[19012] = 2072809; +inp[19013] = 0; +inp[19014] = 1947224; +inp[19015] = 0; +inp[19016] = 1829247; +inp[19017] = 0; +inp[19018] = 1718419; +inp[19019] = 0; +inp[19020] = 1614305; +inp[19021] = 0; +inp[19022] = 1516499; +inp[19023] = 0; +inp[19024] = 1424619; +inp[19025] = 0; +inp[19026] = 1338306; +inp[19027] = 0; +inp[19028] = 1257222; +inp[19029] = 0; +inp[19030] = 1181051; +inp[19031] = 0; +inp[19032] = 1109494; +inp[19033] = 0; +inp[19034] = 1042273; +inp[19035] = 0; +inp[19036] = 979125; +inp[19037] = 0; +inp[19038] = 919803; +inp[19039] = 0; +inp[19040] = 864075; +inp[19041] = 0; +inp[19042] = 811723; +inp[19043] = 0; +inp[19044] = 762543; +inp[19045] = 0; +inp[19046] = 716343; +inp[19047] = 0; +inp[19048] = 672942; +inp[19049] = 0; +inp[19050] = 632171; +inp[19051] = 0; +inp[19052] = 593869; +inp[19053] = 0; +inp[19054] = 557889; +inp[19055] = 0; +inp[19056] = 524088; +inp[19057] = 0; +inp[19058] = 492335; +inp[19059] = 0; +inp[19060] = 462506; +inp[19061] = 0; +inp[19062] = 434484; +inp[19063] = 0; +inp[19064] = 408160; +inp[19065] = 0; +inp[19066] = 383431; +inp[19067] = 0; +inp[19068] = 360200; +inp[19069] = 0; +inp[19070] = 338376; +inp[19071] = 0; +inp[19072] = 317875; +inp[19073] = 0; +inp[19074] = 298616; +inp[19075] = 0; +inp[19076] = 280524; +inp[19077] = 0; +inp[19078] = 263528; +inp[19079] = 0; +inp[19080] = 247561; +inp[19081] = 0; +inp[19082] = 232562; +inp[19083] = 0; +inp[19084] = 218472; +inp[19085] = 0; +inp[19086] = 205235; +inp[19087] = 0; +inp[19088] = 192801; +inp[19089] = 0; +inp[19090] = 181120; +inp[19091] = 0; +inp[19092] = 170146; +inp[19093] = 0; +inp[19094] = 159837; +inp[19095] = 0; +inp[19096] = 150153; +inp[19097] = 0; +inp[19098] = 141056; +inp[19099] = 0; +inp[19100] = 132510; +inp[19101] = 0; +inp[19102] = 124481; +inp[19103] = 0; +inp[19104] = 116939; +inp[19105] = 0; +inp[19106] = 109854; +inp[19107] = 0; +inp[19108] = 103199; +inp[19109] = 0; +inp[19110] = 96946; +inp[19111] = 0; +inp[19112] = 91072; +inp[19113] = 0; +inp[19114] = 85555; +inp[19115] = 0; +inp[19116] = 80371; +inp[19117] = 0; +inp[19118] = 75502; +inp[19119] = 0; +inp[19120] = 70927; +inp[19121] = 0; +inp[19122] = 66630; +inp[19123] = 0; +inp[19124] = 62593; +inp[19125] = 0; +inp[19126] = 58801; +inp[19127] = 0; +inp[19128] = 55238; +inp[19129] = 0; +inp[19130] = 51891; +inp[19131] = 0; +inp[19132] = 48747; +inp[19133] = 0; +inp[19134] = 45794; +inp[19135] = 0; +inp[19136] = 43019; +inp[19137] = 0; +inp[19138] = 40413; +inp[19139] = 0; +inp[19140] = 37964; +inp[19141] = 0; +inp[19142] = 35664; +inp[19143] = 0; +inp[19144] = 33503; +inp[19145] = 0; +inp[19146] = 31473; +inp[19147] = 0; +inp[19148] = 29567; +inp[19149] = 0; +inp[19150] = 27775; +inp[19151] = 0; +inp[19152] = 26092; +inp[19153] = 0; +inp[19154] = 24511; +inp[19155] = 0; +inp[19156] = 23026; +inp[19157] = 0; +inp[19158] = 21631; +inp[19159] = 0; +inp[19160] = 20321; +inp[19161] = 0; +inp[19162] = 19089; +inp[19163] = 0; +inp[19164] = 17933; +inp[19165] = 0; +inp[19166] = 16846; +inp[19167] = 0; +inp[19168] = 15826; +inp[19169] = 0; +inp[19170] = 14867; +inp[19171] = 0; +inp[19172] = 13966; +inp[19173] = 0; +inp[19174] = 13120; +inp[19175] = 0; +inp[19176] = 12325; +inp[19177] = 0; +inp[19178] = 11578; +inp[19179] = 0; +inp[19180] = 10877; +inp[19181] = 0; +inp[19182] = 10218; +inp[19183] = 0; +inp[19184] = 9599; +inp[19185] = 0; +inp[19186] = 9017; +inp[19187] = 0; +inp[19188] = 8471; +inp[19189] = 0; +inp[19190] = 7957; +inp[19191] = 0; +inp[19192] = 7475; +inp[19193] = 0; +inp[19194] = 7022; +inp[19195] = 0; +inp[19196] = 6597; +inp[19197] = 0; +inp[19198] = 6197; +inp[19199] = 0; +inp[19200] = 5822; +inp[19201] = 0; +inp[19202] = 5469; +inp[19203] = 0; +inp[19204] = 5137; +inp[19205] = 0; +inp[19206] = 4826; +inp[19207] = 0; +inp[19208] = 4534; +inp[19209] = 0; +inp[19210] = 4259; +inp[19211] = 0; +inp[19212] = 4001; +inp[19213] = 0; +inp[19214] = 3759; +inp[19215] = 0; +inp[19216] = 3531; +inp[19217] = 0; +inp[19218] = 3317; +inp[19219] = 0; +inp[19220] = 3116; +inp[19221] = 0; +inp[19222] = 2927; +inp[19223] = 0; +inp[19224] = 2750; +inp[19225] = 0; +inp[19226] = 2583; +inp[19227] = 0; +inp[19228] = 2427; +inp[19229] = 0; +inp[19230] = 2279; +inp[19231] = 0; +inp[19232] = 2141; +inp[19233] = 0; +inp[19234] = 2012; +inp[19235] = 0; +inp[19236] = 1890; +inp[19237] = 0; +inp[19238] = 1775; +inp[19239] = 0; +inp[19240] = 1668; +inp[19241] = 0; +inp[19242] = 1566; +inp[19243] = 0; +inp[19244] = 1472; +inp[19245] = 0; +inp[19246] = 1382; +inp[19247] = 0; +inp[19248] = 1299; +inp[19249] = 0; +inp[19250] = 1220; +inp[19251] = 0; +inp[19252] = 1146; +inp[19253] = 0; +inp[19254] = 1076; +inp[19255] = 0; +inp[19256] = 1011; +inp[19257] = 0; +inp[19258] = 950; +inp[19259] = 0; +inp[19260] = 892; +inp[19261] = 0; +inp[19262] = 838; +inp[19263] = 0; +inp[19264] = 787; +inp[19265] = 0; +inp[19266] = 740; +inp[19267] = 0; +inp[19268] = 695; +inp[19269] = 0; +inp[19270] = 653; +inp[19271] = 0; +inp[19272] = 613; +inp[19273] = 0; +inp[19274] = 576; +inp[19275] = 0; +inp[19276] = 541; +inp[19277] = 0; +inp[19278] = 508; +inp[19279] = 0; +inp[19280] = 477; +inp[19281] = 0; +inp[19282] = 448; +inp[19283] = 0; +inp[19284] = 421; +inp[19285] = 0; +inp[19286] = 396; +inp[19287] = 0; +inp[19288] = 372; +inp[19289] = 0; +inp[19290] = 349; +inp[19291] = 0; +inp[19292] = 328; +inp[19293] = 0; +inp[19294] = 308; +inp[19295] = 0; +inp[19296] = 289; +inp[19297] = 0; +inp[19298] = 272; +inp[19299] = 0; +inp[19300] = 255; +inp[19301] = 0; +inp[19302] = 240; +inp[19303] = 0; +inp[19304] = 225; +inp[19305] = 0; +inp[19306] = 212; +inp[19307] = 0; +inp[19308] = 199; +inp[19309] = 0; +inp[19310] = 187; +inp[19311] = 0; +inp[19312] = 175; +inp[19313] = 0; +inp[19314] = 165; +inp[19315] = 0; +inp[19316] = 155; +inp[19317] = 0; +inp[19318] = 145; +inp[19319] = 0; +inp[19320] = 136; +inp[19321] = 0; +inp[19322] = 128; +inp[19323] = 0; +inp[19324] = 1073741824; +inp[19325] = 1073741824; +inp[19326] = 1040706261; +inp[19327] = 0; +inp[19328] = 1008687095; +inp[19329] = 0; +inp[19330] = 977653056; +inp[19331] = 0; +inp[19332] = 947573833; +inp[19333] = 0; +inp[19334] = 918420051; +inp[19335] = 0; +inp[19336] = 890163237; +inp[19337] = 0; +inp[19338] = 862775793; +inp[19339] = 0; +inp[19340] = 836230973; +inp[19341] = 0; +inp[19342] = 810502851; +inp[19343] = 0; +inp[19344] = 785566299; +inp[19345] = 0; +inp[19346] = 761396965; +inp[19347] = 0; +inp[19348] = 737971243; +inp[19349] = 0; +inp[19350] = 715266255; +inp[19351] = 0; +inp[19352] = 693259826; +inp[19353] = 0; +inp[19354] = 671930463; +inp[19355] = 0; +inp[19356] = 651257336; +inp[19357] = 0; +inp[19358] = 631220255; +inp[19359] = 0; +inp[19360] = 611799649; +inp[19361] = 0; +inp[19362] = 592976553; +inp[19363] = 0; +inp[19364] = 574732582; +inp[19365] = 0; +inp[19366] = 557049919; +inp[19367] = 0; +inp[19368] = 539911295; +inp[19369] = 0; +inp[19370] = 523299971; +inp[19371] = 0; +inp[19372] = 507199723; +inp[19373] = 0; +inp[19374] = 491594828; +inp[19375] = 0; +inp[19376] = 476470046; +inp[19377] = 0; +inp[19378] = 461810603; +inp[19379] = 0; +inp[19380] = 447602185; +inp[19381] = 0; +inp[19382] = 433830913; +inp[19383] = 0; +inp[19384] = 420483339; +inp[19385] = 0; +inp[19386] = 407546427; +inp[19387] = 0; +inp[19388] = 395007542; +inp[19389] = 0; +inp[19390] = 382854437; +inp[19391] = 0; +inp[19392] = 371075245; +inp[19393] = 0; +inp[19394] = 359658459; +inp[19395] = 0; +inp[19396] = 348592932; +inp[19397] = 0; +inp[19398] = 337867855; +inp[19399] = 0; +inp[19400] = 327472754; +inp[19401] = 0; +inp[19402] = 317397476; +inp[19403] = 0; +inp[19404] = 307632183; +inp[19405] = 0; +inp[19406] = 298167335; +inp[19407] = 0; +inp[19408] = 288993691; +inp[19409] = 0; +inp[19410] = 280102290; +inp[19411] = 0; +inp[19412] = 271484448; +inp[19413] = 0; +inp[19414] = 263131750; +inp[19415] = 0; +inp[19416] = 255036037; +inp[19417] = 0; +inp[19418] = 247189403; +inp[19419] = 0; +inp[19420] = 239584185; +inp[19421] = 0; +inp[19422] = 232212954; +inp[19423] = 0; +inp[19424] = 225068513; +inp[19425] = 0; +inp[19426] = 218143882; +inp[19427] = 0; +inp[19428] = 211432301; +inp[19429] = 0; +inp[19430] = 204927213; +inp[19431] = 0; +inp[19432] = 198622265; +inp[19433] = 0; +inp[19434] = 192511301; +inp[19435] = 0; +inp[19436] = 186588351; +inp[19437] = 0; +inp[19438] = 180847630; +inp[19439] = 0; +inp[19440] = 175283534; +inp[19441] = 0; +inp[19442] = 169890626; +inp[19443] = 0; +inp[19444] = 164663641; +inp[19445] = 0; +inp[19446] = 159597474; +inp[19447] = 0; +inp[19448] = 154687176; +inp[19449] = 0; +inp[19450] = 149927952; +inp[19451] = 0; +inp[19452] = 145315153; +inp[19453] = 0; +inp[19454] = 140844276; +inp[19455] = 0; +inp[19456] = 136510953; +inp[19457] = 0; +inp[19458] = 132310953; +inp[19459] = 0; +inp[19460] = 128240173; +inp[19461] = 0; +inp[19462] = 124294637; +inp[19463] = 0; +inp[19464] = 120470493; +inp[19465] = 0; +inp[19466] = 116764006; +inp[19467] = 0; +inp[19468] = 113171555; +inp[19469] = 0; +inp[19470] = 109689632; +inp[19471] = 0; +inp[19472] = 106314837; +inp[19473] = 0; +inp[19474] = 103043874; +inp[19475] = 0; +inp[19476] = 99873547; +inp[19477] = 0; +inp[19478] = 96800761; +inp[19479] = 0; +inp[19480] = 93822514; +inp[19481] = 0; +inp[19482] = 90935899; +inp[19483] = 0; +inp[19484] = 88138096; +inp[19485] = 0; +inp[19486] = 85426372; +inp[19487] = 0; +inp[19488] = 82798078; +inp[19489] = 0; +inp[19490] = 80250649; +inp[19491] = 0; +inp[19492] = 77781596; +inp[19493] = 0; +inp[19494] = 75388508; +inp[19495] = 0; +inp[19496] = 73069048; +inp[19497] = 0; +inp[19498] = 70820949; +inp[19499] = 0; +inp[19500] = 68642018; +inp[19501] = 0; +inp[19502] = 66530125; +inp[19503] = 0; +inp[19504] = 64483208; +inp[19505] = 0; +inp[19506] = 62499268; +inp[19507] = 0; +inp[19508] = 60576368; +inp[19509] = 0; +inp[19510] = 58712629; +inp[19511] = 0; +inp[19512] = 56906231; +inp[19513] = 0; +inp[19514] = 55155411; +inp[19515] = 0; +inp[19516] = 53458457; +inp[19517] = 0; +inp[19518] = 51813713; +inp[19519] = 0; +inp[19520] = 50219573; +inp[19521] = 0; +inp[19522] = 48674479; +inp[19523] = 0; +inp[19524] = 47176923; +inp[19525] = 0; +inp[19526] = 45725441; +inp[19527] = 0; +inp[19528] = 44318617; +inp[19529] = 0; +inp[19530] = 42955077; +inp[19531] = 0; +inp[19532] = 41633488; +inp[19533] = 0; +inp[19534] = 40352560; +inp[19535] = 0; +inp[19536] = 39111043; +inp[19537] = 0; +inp[19538] = 37907722; +inp[19539] = 0; +inp[19540] = 36741424; +inp[19541] = 0; +inp[19542] = 35611009; +inp[19543] = 0; +inp[19544] = 34515374; +inp[19545] = 0; +inp[19546] = 33453447; +inp[19547] = 0; +inp[19548] = 32424193; +inp[19549] = 0; +inp[19550] = 31426605; +inp[19551] = 0; +inp[19552] = 30459710; +inp[19553] = 0; +inp[19554] = 29522564; +inp[19555] = 0; +inp[19556] = 28614250; +inp[19557] = 0; +inp[19558] = 27733882; +inp[19559] = 0; +inp[19560] = 26880600; +inp[19561] = 0; +inp[19562] = 26053571; +inp[19563] = 0; +inp[19564] = 25251987; +inp[19565] = 0; +inp[19566] = 24475065; +inp[19567] = 0; +inp[19568] = 23722046; +inp[19569] = 0; +inp[19570] = 22992196; +inp[19571] = 0; +inp[19572] = 22284800; +inp[19573] = 0; +inp[19574] = 21599169; +inp[19575] = 0; +inp[19576] = 20934632; +inp[19577] = 0; +inp[19578] = 20290541; +inp[19579] = 0; +inp[19580] = 19666267; +inp[19581] = 0; +inp[19582] = 19061200; +inp[19583] = 0; +inp[19584] = 18474748; +inp[19585] = 0; +inp[19586] = 17906340; +inp[19587] = 0; +inp[19588] = 17355420; +inp[19589] = 0; +inp[19590] = 16821450; +inp[19591] = 0; +inp[19592] = 16303908; +inp[19593] = 0; +inp[19594] = 15802289; +inp[19595] = 0; +inp[19596] = 15316104; +inp[19597] = 0; +inp[19598] = 14844877; +inp[19599] = 0; +inp[19600] = 14388148; +inp[19601] = 0; +inp[19602] = 13945471; +inp[19603] = 0; +inp[19604] = 13516414; +inp[19605] = 0; +inp[19606] = 13100558; +inp[19607] = 0; +inp[19608] = 12697496; +inp[19609] = 0; +inp[19610] = 12306835; +inp[19611] = 0; +inp[19612] = 11928194; +inp[19613] = 0; +inp[19614] = 11561202; +inp[19615] = 0; +inp[19616] = 11205501; +inp[19617] = 0; +inp[19618] = 10860744; +inp[19619] = 0; +inp[19620] = 10526594; +inp[19621] = 0; +inp[19622] = 10202725; +inp[19623] = 0; +inp[19624] = 9888820; +inp[19625] = 0; +inp[19626] = 9584573; +inp[19627] = 0; +inp[19628] = 9289686; +inp[19629] = 0; +inp[19630] = 9003873; +inp[19631] = 0; +inp[19632] = 8726853; +inp[19633] = 0; +inp[19634] = 8458356; +inp[19635] = 0; +inp[19636] = 8198119; +inp[19637] = 0; +inp[19638] = 7945890; +inp[19639] = 0; +inp[19640] = 7701421; +inp[19641] = 0; +inp[19642] = 7464473; +inp[19643] = 0; +inp[19644] = 7234815; +inp[19645] = 0; +inp[19646] = 7012223; +inp[19647] = 0; +inp[19648] = 6796480; +inp[19649] = 0; +inp[19650] = 6587374; +inp[19651] = 0; +inp[19652] = 6384702; +inp[19653] = 0; +inp[19654] = 6188265; +inp[19655] = 0; +inp[19656] = 5997872; +inp[19657] = 0; +inp[19658] = 5813337; +inp[19659] = 0; +inp[19660] = 5634479; +inp[19661] = 0; +inp[19662] = 5461125; +inp[19663] = 0; +inp[19664] = 5293104; +inp[19665] = 0; +inp[19666] = 5130252; +inp[19667] = 0; +inp[19668] = 4972411; +inp[19669] = 0; +inp[19670] = 4819426; +inp[19671] = 0; +inp[19672] = 4671147; +inp[19673] = 0; +inp[19674] = 4527431; +inp[19675] = 0; +inp[19676] = 4388137; +inp[19677] = 0; +inp[19678] = 4253128; +inp[19679] = 0; +inp[19680] = 4122273; +inp[19681] = 0; +inp[19682] = 3995444; +inp[19683] = 0; +inp[19684] = 3872517; +inp[19685] = 0; +inp[19686] = 3753372; +inp[19687] = 0; +inp[19688] = 3637893; +inp[19689] = 0; +inp[19690] = 3525967; +inp[19691] = 0; +inp[19692] = 3417484; +inp[19693] = 0; +inp[19694] = 3312339; +inp[19695] = 0; +inp[19696] = 3210429; +inp[19697] = 0; +inp[19698] = 3111655; +inp[19699] = 0; +inp[19700] = 3015919; +inp[19701] = 0; +inp[19702] = 2923129; +inp[19703] = 0; +inp[19704] = 2833194; +inp[19705] = 0; +inp[19706] = 2746026; +inp[19707] = 0; +inp[19708] = 2661539; +inp[19709] = 0; +inp[19710] = 2579652; +inp[19711] = 0; +inp[19712] = 2500285; +inp[19713] = 0; +inp[19714] = 2423359; +inp[19715] = 0; +inp[19716] = 2348800; +inp[19717] = 0; +inp[19718] = 2276535; +inp[19719] = 0; +inp[19720] = 2206494; +inp[19721] = 0; +inp[19722] = 2138607; +inp[19723] = 0; +inp[19724] = 2072809; +inp[19725] = 0; +inp[19726] = 2009035; +inp[19727] = 0; +inp[19728] = 1947224; +inp[19729] = 0; +inp[19730] = 1887314; +inp[19731] = 0; +inp[19732] = 1829247; +inp[19733] = 0; +inp[19734] = 1772967; +inp[19735] = 0; +inp[19736] = 1718419; +inp[19737] = 0; +inp[19738] = 1665549; +inp[19739] = 0; +inp[19740] = 1614305; +inp[19741] = 0; +inp[19742] = 1564638; +inp[19743] = 0; +inp[19744] = 1516499; +inp[19745] = 0; +inp[19746] = 1469841; +inp[19747] = 0; +inp[19748] = 1424619; +inp[19749] = 0; +inp[19750] = 1380788; +inp[19751] = 0; +inp[19752] = 1338306; +inp[19753] = 0; +inp[19754] = 1297130; +inp[19755] = 0; +inp[19756] = 1257222; +inp[19757] = 0; +inp[19758] = 1218541; +inp[19759] = 0; +inp[19760] = 1181051; +inp[19761] = 0; +inp[19762] = 1144714; +inp[19763] = 0; +inp[19764] = 1109494; +inp[19765] = 0; +inp[19766] = 1075359; +inp[19767] = 0; +inp[19768] = 1042273; +inp[19769] = 0; +inp[19770] = 1010206; +inp[19771] = 0; +inp[19772] = 979125; +inp[19773] = 0; +inp[19774] = 949001; +inp[19775] = 0; +inp[19776] = 919803; +inp[19777] = 0; +inp[19778] = 891504; +inp[19779] = 0; +inp[19780] = 864075; +inp[19781] = 0; +inp[19782] = 837490; +inp[19783] = 0; +inp[19784] = 811723; +inp[19785] = 0; +inp[19786] = 786749; +inp[19787] = 0; +inp[19788] = 762543; +inp[19789] = 0; +inp[19790] = 739082; +inp[19791] = 0; +inp[19792] = 716343; +inp[19793] = 0; +inp[19794] = 694304; +inp[19795] = 0; +inp[19796] = 672942; +inp[19797] = 0; +inp[19798] = 652238; +inp[19799] = 0; +inp[19800] = 632171; +inp[19801] = 0; +inp[19802] = 612721; +inp[19803] = 0; +inp[19804] = 593869; +inp[19805] = 0; +inp[19806] = 575598; +inp[19807] = 0; +inp[19808] = 557889; +inp[19809] = 0; +inp[19810] = 540724; +inp[19811] = 0; +inp[19812] = 524088; +inp[19813] = 0; +inp[19814] = 507963; +inp[19815] = 0; +inp[19816] = 492335; +inp[19817] = 0; +inp[19818] = 477187; +inp[19819] = 0; +inp[19820] = 462506; +inp[19821] = 0; +inp[19822] = 448276; +inp[19823] = 0; +inp[19824] = 434484; +inp[19825] = 0; +inp[19826] = 421116; +inp[19827] = 0; +inp[19828] = 408160; +inp[19829] = 0; +inp[19830] = 395602; +inp[19831] = 0; +inp[19832] = 383431; +inp[19833] = 0; +inp[19834] = 371634; +inp[19835] = 0; +inp[19836] = 1073741824; +inp[19837] = 1073741824; +inp[19838] = 1057094999; +inp[19839] = 0; +inp[19840] = 1040706261; +inp[19841] = 0; +inp[19842] = 1024571605; +inp[19843] = 0; +inp[19844] = 1008687095; +inp[19845] = 0; +inp[19846] = 993048851; +inp[19847] = 0; +inp[19848] = 977653056; +inp[19849] = 0; +inp[19850] = 962495950; +inp[19851] = 0; +inp[19852] = 947573833; +inp[19853] = 0; +inp[19854] = 932883063; +inp[19855] = 0; +inp[19856] = 918420051; +inp[19857] = 0; +inp[19858] = 904181268; +inp[19859] = 0; +inp[19860] = 890163237; +inp[19861] = 0; +inp[19862] = 876362535; +inp[19863] = 0; +inp[19864] = 862775793; +inp[19865] = 0; +inp[19866] = 849399695; +inp[19867] = 0; +inp[19868] = 836230973; +inp[19869] = 0; +inp[19870] = 823266413; +inp[19871] = 0; +inp[19872] = 810502851; +inp[19873] = 0; +inp[19874] = 797937169; +inp[19875] = 0; +inp[19876] = 785566299; +inp[19877] = 0; +inp[19878] = 773387223; +inp[19879] = 0; +inp[19880] = 761396965; +inp[19881] = 0; +inp[19882] = 749592599; +inp[19883] = 0; +inp[19884] = 737971243; +inp[19885] = 0; +inp[19886] = 726530060; +inp[19887] = 0; +inp[19888] = 715266255; +inp[19889] = 0; +inp[19890] = 704177080; +inp[19891] = 0; +inp[19892] = 693259826; +inp[19893] = 0; +inp[19894] = 682511829; +inp[19895] = 0; +inp[19896] = 671930463; +inp[19897] = 0; +inp[19898] = 661513147; +inp[19899] = 0; +inp[19900] = 651257336; +inp[19901] = 0; +inp[19902] = 641160527; +inp[19903] = 0; +inp[19904] = 631220255; +inp[19905] = 0; +inp[19906] = 621434092; +inp[19907] = 0; +inp[19908] = 611799649; +inp[19909] = 0; +inp[19910] = 602314575; +inp[19911] = 0; +inp[19912] = 592976553; +inp[19913] = 0; +inp[19914] = 583783303; +inp[19915] = 0; +inp[19916] = 574732582; +inp[19917] = 0; +inp[19918] = 565822179; +inp[19919] = 0; +inp[19920] = 557049919; +inp[19921] = 0; +inp[19922] = 548413661; +inp[19923] = 0; +inp[19924] = 539911295; +inp[19925] = 0; +inp[19926] = 531540746; +inp[19927] = 0; +inp[19928] = 523299971; +inp[19929] = 0; +inp[19930] = 515186957; +inp[19931] = 0; +inp[19932] = 507199723; +inp[19933] = 0; +inp[19934] = 499336321; +inp[19935] = 0; +inp[19936] = 491594828; +inp[19937] = 0; +inp[19938] = 483973357; +inp[19939] = 0; +inp[19940] = 476470046; +inp[19941] = 0; +inp[19942] = 469083062; +inp[19943] = 0; +inp[19944] = 461810603; +inp[19945] = 0; +inp[19946] = 454650894; +inp[19947] = 0; +inp[19948] = 447602185; +inp[19949] = 0; +inp[19950] = 440662756; +inp[19951] = 0; +inp[19952] = 433830913; +inp[19953] = 0; +inp[19954] = 427104988; +inp[19955] = 0; +inp[19956] = 420483339; +inp[19957] = 0; +inp[19958] = 413964349; +inp[19959] = 0; +inp[19960] = 407546427; +inp[19961] = 0; +inp[19962] = 401228005; +inp[19963] = 0; +inp[19964] = 395007542; +inp[19965] = 0; +inp[19966] = 388883517; +inp[19967] = 0; +inp[19968] = 382854437; +inp[19969] = 0; +inp[19970] = 376918829; +inp[19971] = 0; +inp[19972] = 371075245; +inp[19973] = 0; +inp[19974] = 365322256; +inp[19975] = 0; +inp[19976] = 359658459; +inp[19977] = 0; +inp[19978] = 354082472; +inp[19979] = 0; +inp[19980] = 348592932; +inp[19981] = 0; +inp[19982] = 343188499; +inp[19983] = 0; +inp[19984] = 337867855; +inp[19985] = 0; +inp[19986] = 332629699; +inp[19987] = 0; +inp[19988] = 327472754; +inp[19989] = 0; +inp[19990] = 322395759; +inp[19991] = 0; +inp[19992] = 317397476; +inp[19993] = 0; +inp[19994] = 312476685; +inp[19995] = 0; +inp[19996] = 307632183; +inp[19997] = 0; +inp[19998] = 302862788; +inp[19999] = 0; +inp[20000] = 298167335; +inp[20001] = 0; +inp[20002] = 293544679; +inp[20003] = 0; +inp[20004] = 288993691; +inp[20005] = 0; +inp[20006] = 284513259; +inp[20007] = 0; +inp[20008] = 280102290; +inp[20009] = 0; +inp[20010] = 275759706; +inp[20011] = 0; +inp[20012] = 271484448; +inp[20013] = 0; +inp[20014] = 267275472; +inp[20015] = 0; +inp[20016] = 263131750; +inp[20017] = 0; +inp[20018] = 259052270; +inp[20019] = 0; +inp[20020] = 255036037; +inp[20021] = 0; +inp[20022] = 251082070; +inp[20023] = 0; +inp[20024] = 247189403; +inp[20025] = 0; +inp[20026] = 243357087; +inp[20027] = 0; +inp[20028] = 239584185; +inp[20029] = 0; +inp[20030] = 235869776; +inp[20031] = 0; +inp[20032] = 232212954; +inp[20033] = 0; +inp[20034] = 228612826; +inp[20035] = 0; +inp[20036] = 225068513; +inp[20037] = 0; +inp[20038] = 221579149; +inp[20039] = 0; +inp[20040] = 218143882; +inp[20041] = 0; +inp[20042] = 214761875; +inp[20043] = 0; +inp[20044] = 211432301; +inp[20045] = 0; +inp[20046] = 208154347; +inp[20047] = 0; +inp[20048] = 204927213; +inp[20049] = 0; +inp[20050] = 201750111; +inp[20051] = 0; +inp[20052] = 198622265; +inp[20053] = 0; +inp[20054] = 195542912; +inp[20055] = 0; +inp[20056] = 192511301; +inp[20057] = 0; +inp[20058] = 189526689; +inp[20059] = 0; +inp[20060] = 186588351; +inp[20061] = 0; +inp[20062] = 183695566; +inp[20063] = 0; +inp[20064] = 180847630; +inp[20065] = 0; +inp[20066] = 178043848; +inp[20067] = 0; +inp[20068] = 175283534; +inp[20069] = 0; +inp[20070] = 172566014; +inp[20071] = 0; +inp[20072] = 169890626; +inp[20073] = 0; +inp[20074] = 167256716; +inp[20075] = 0; +inp[20076] = 164663641; +inp[20077] = 0; +inp[20078] = 162110768; +inp[20079] = 0; +inp[20080] = 159597474; +inp[20081] = 0; +inp[20082] = 157123144; +inp[20083] = 0; +inp[20084] = 154687176; +inp[20085] = 0; +inp[20086] = 152288973; +inp[20087] = 0; +inp[20088] = 149927952; +inp[20089] = 0; +inp[20090] = 147603534; +inp[20091] = 0; +inp[20092] = 145315153; +inp[20093] = 0; +inp[20094] = 143062251; +inp[20095] = 0; +inp[20096] = 140844276; +inp[20097] = 0; +inp[20098] = 138660688; +inp[20099] = 0; +inp[20100] = 136510953; +inp[20101] = 0; +inp[20102] = 134394547; +inp[20103] = 0; +inp[20104] = 132310953; +inp[20105] = 0; +inp[20106] = 130259662; +inp[20107] = 0; +inp[20108] = 128240173; +inp[20109] = 0; +inp[20110] = 126251993; +inp[20111] = 0; +inp[20112] = 124294637; +inp[20113] = 0; +inp[20114] = 122367628; +inp[20115] = 0; +inp[20116] = 120470493; +inp[20117] = 0; +inp[20118] = 118602771; +inp[20119] = 0; +inp[20120] = 116764006; +inp[20121] = 0; +inp[20122] = 114953748; +inp[20123] = 0; +inp[20124] = 113171555; +inp[20125] = 0; +inp[20126] = 111416993; +inp[20127] = 0; +inp[20128] = 109689632; +inp[20129] = 0; +inp[20130] = 107989052; +inp[20131] = 0; +inp[20132] = 106314837; +inp[20133] = 0; +inp[20134] = 104666578; +inp[20135] = 0; +inp[20136] = 103043874; +inp[20137] = 0; +inp[20138] = 101446326; +inp[20139] = 0; +inp[20140] = 99873547; +inp[20141] = 0; +inp[20142] = 98325151; +inp[20143] = 0; +inp[20144] = 96800761; +inp[20145] = 0; +inp[20146] = 95300004; +inp[20147] = 0; +inp[20148] = 93822514; +inp[20149] = 0; +inp[20150] = 92367931; +inp[20151] = 0; +inp[20152] = 90935899; +inp[20153] = 0; +inp[20154] = 89526069; +inp[20155] = 0; +inp[20156] = 88138096; +inp[20157] = 0; +inp[20158] = 86771641; +inp[20159] = 0; +inp[20160] = 85426372; +inp[20161] = 0; +inp[20162] = 84101958; +inp[20163] = 0; +inp[20164] = 82798078; +inp[20165] = 0; +inp[20166] = 81514413; +inp[20167] = 0; +inp[20168] = 80250649; +inp[20169] = 0; +inp[20170] = 79006478; +inp[20171] = 0; +inp[20172] = 77781596; +inp[20173] = 0; +inp[20174] = 76575704; +inp[20175] = 0; +inp[20176] = 75388508; +inp[20177] = 0; +inp[20178] = 74219718; +inp[20179] = 0; +inp[20180] = 73069048; +inp[20181] = 0; +inp[20182] = 71936217; +inp[20183] = 0; +inp[20184] = 70820949; +inp[20185] = 0; +inp[20186] = 69722972; +inp[20187] = 0; +inp[20188] = 68642018; +inp[20189] = 0; +inp[20190] = 67577822; +inp[20191] = 0; +inp[20192] = 66530125; +inp[20193] = 0; +inp[20194] = 65498671; +inp[20195] = 0; +inp[20196] = 64483208; +inp[20197] = 0; +inp[20198] = 63483489; +inp[20199] = 0; +inp[20200] = 62499268; +inp[20201] = 0; +inp[20202] = 61530307; +inp[20203] = 0; +inp[20204] = 60576368; +inp[20205] = 0; +inp[20206] = 59637218; +inp[20207] = 0; +inp[20208] = 58712629; +inp[20209] = 0; +inp[20210] = 57802374; +inp[20211] = 0; +inp[20212] = 56906231; +inp[20213] = 0; +inp[20214] = 56023982; +inp[20215] = 0; +inp[20216] = 55155411; +inp[20217] = 0; +inp[20218] = 54300305; +inp[20219] = 0; +inp[20220] = 53458457; +inp[20221] = 0; +inp[20222] = 52629661; +inp[20223] = 0; +inp[20224] = 51813713; +inp[20225] = 0; +inp[20226] = 51010416; +inp[20227] = 0; +inp[20228] = 50219573; +inp[20229] = 0; +inp[20230] = 49440991; +inp[20231] = 0; +inp[20232] = 48674479; +inp[20233] = 0; +inp[20234] = 47919851; +inp[20235] = 0; +inp[20236] = 47176923; +inp[20237] = 0; +inp[20238] = 46445512; +inp[20239] = 0; +inp[20240] = 45725441; +inp[20241] = 0; +inp[20242] = 45016534; +inp[20243] = 0; +inp[20244] = 44318617; +inp[20245] = 0; +inp[20246] = 43631521; +inp[20247] = 0; +inp[20248] = 42955077; +inp[20249] = 0; +inp[20250] = 42289120; +inp[20251] = 0; +inp[20252] = 41633488; +inp[20253] = 0; +inp[20254] = 40988021; +inp[20255] = 0; +inp[20256] = 40352560; +inp[20257] = 0; +inp[20258] = 39726952; +inp[20259] = 0; +inp[20260] = 39111043; +inp[20261] = 0; +inp[20262] = 38504682; +inp[20263] = 0; +inp[20264] = 37907722; +inp[20265] = 0; +inp[20266] = 37320018; +inp[20267] = 0; +inp[20268] = 36741424; +inp[20269] = 0; +inp[20270] = 36171801; +inp[20271] = 0; +inp[20272] = 35611009; +inp[20273] = 0; +inp[20274] = 35058912; +inp[20275] = 0; +inp[20276] = 34515374; +inp[20277] = 0; +inp[20278] = 33980263; +inp[20279] = 0; +inp[20280] = 33453447; +inp[20281] = 0; +inp[20282] = 32934800; +inp[20283] = 0; +inp[20284] = 32424193; +inp[20285] = 0; +inp[20286] = 31921503; +inp[20287] = 0; +inp[20288] = 31426605; +inp[20289] = 0; +inp[20290] = 30939381; +inp[20291] = 0; +inp[20292] = 30459710; +inp[20293] = 0; +inp[20294] = 29987476; +inp[20295] = 0; +inp[20296] = 29522564; +inp[20297] = 0; +inp[20298] = 29064859; +inp[20299] = 0; +inp[20300] = 28614250; +inp[20301] = 0; +inp[20302] = 28170627; +inp[20303] = 0; +inp[20304] = 27733882; +inp[20305] = 0; +inp[20306] = 27303908; +inp[20307] = 0; +inp[20308] = 26880600; +inp[20309] = 0; +inp[20310] = 26463855; +inp[20311] = 0; +inp[20312] = 26053571; +inp[20313] = 0; +inp[20314] = 25649648; +inp[20315] = 0; +inp[20316] = 25251987; +inp[20317] = 0; +inp[20318] = 24860491; +inp[20319] = 0; +inp[20320] = 24475065; +inp[20321] = 0; +inp[20322] = 24095614; +inp[20323] = 0; +inp[20324] = 23722046; +inp[20325] = 0; +inp[20326] = 23354270; +inp[20327] = 0; +inp[20328] = 22992196; +inp[20329] = 0; +inp[20330] = 22635735; +inp[20331] = 0; +inp[20332] = 22284800; +inp[20333] = 0; +inp[20334] = 21939306; +inp[20335] = 0; +inp[20336] = 21599169; +inp[20337] = 0; +inp[20338] = 21264305; +inp[20339] = 0; +inp[20340] = 20934632; +inp[20341] = 0; +inp[20342] = 20610071; +inp[20343] = 0; +inp[20344] = 20290541; +inp[20345] = 0; +inp[20346] = 19975966; +inp[20347] = 0; +inp[20348] = 1073741824; +inp[20349] = 1073741824; +inp[20350] = 1065385898; +inp[20351] = 0; +inp[20352] = 1057094999; +inp[20353] = 0; +inp[20354] = 1048868621; +inp[20355] = 0; +inp[20356] = 1040706261; +inp[20357] = 0; +inp[20358] = 1032607420; +inp[20359] = 0; +inp[20360] = 1024571605; +inp[20361] = 0; +inp[20362] = 1016598326; +inp[20363] = 0; +inp[20364] = 1008687095; +inp[20365] = 0; +inp[20366] = 1000837430; +inp[20367] = 0; +inp[20368] = 993048851; +inp[20369] = 0; +inp[20370] = 985320884; +inp[20371] = 0; +inp[20372] = 977653056; +inp[20373] = 0; +inp[20374] = 970044899; +inp[20375] = 0; +inp[20376] = 962495950; +inp[20377] = 0; +inp[20378] = 955005747; +inp[20379] = 0; +inp[20380] = 947573833; +inp[20381] = 0; +inp[20382] = 940199755; +inp[20383] = 0; +inp[20384] = 932883063; +inp[20385] = 0; +inp[20386] = 925623309; +inp[20387] = 0; +inp[20388] = 918420051; +inp[20389] = 0; +inp[20390] = 911272850; +inp[20391] = 0; +inp[20392] = 904181268; +inp[20393] = 0; +inp[20394] = 897144874; +inp[20395] = 0; +inp[20396] = 890163237; +inp[20397] = 0; +inp[20398] = 883235932; +inp[20399] = 0; +inp[20400] = 876362535; +inp[20401] = 0; +inp[20402] = 869542628; +inp[20403] = 0; +inp[20404] = 862775793; +inp[20405] = 0; +inp[20406] = 856061619; +inp[20407] = 0; +inp[20408] = 849399695; +inp[20409] = 0; +inp[20410] = 842789614; +inp[20411] = 0; +inp[20412] = 836230973; +inp[20413] = 0; +inp[20414] = 829723372; +inp[20415] = 0; +inp[20416] = 823266413; +inp[20417] = 0; +inp[20418] = 816859703; +inp[20419] = 0; +inp[20420] = 810502851; +inp[20421] = 0; +inp[20422] = 804195467; +inp[20423] = 0; +inp[20424] = 797937169; +inp[20425] = 0; +inp[20426] = 791727572; +inp[20427] = 0; +inp[20428] = 785566299; +inp[20429] = 0; +inp[20430] = 779452974; +inp[20431] = 0; +inp[20432] = 773387223; +inp[20433] = 0; +inp[20434] = 767368676; +inp[20435] = 0; +inp[20436] = 761396965; +inp[20437] = 0; +inp[20438] = 755471727; +inp[20439] = 0; +inp[20440] = 749592599; +inp[20441] = 0; +inp[20442] = 743759224; +inp[20443] = 0; +inp[20444] = 737971243; +inp[20445] = 0; +inp[20446] = 732228306; +inp[20447] = 0; +inp[20448] = 726530060; +inp[20449] = 0; +inp[20450] = 720876158; +inp[20451] = 0; +inp[20452] = 715266255; +inp[20453] = 0; +inp[20454] = 709700009; +inp[20455] = 0; +inp[20456] = 704177080; +inp[20457] = 0; +inp[20458] = 698697130; +inp[20459] = 0; +inp[20460] = 693259826; +inp[20461] = 0; +inp[20462] = 687864835; +inp[20463] = 0; +inp[20464] = 682511829; +inp[20465] = 0; +inp[20466] = 677200479; +inp[20467] = 0; +inp[20468] = 671930463; +inp[20469] = 0; +inp[20470] = 666701459; +inp[20471] = 0; +inp[20472] = 661513147; +inp[20473] = 0; +inp[20474] = 656365211; +inp[20475] = 0; +inp[20476] = 651257336; +inp[20477] = 0; +inp[20478] = 646189212; +inp[20479] = 0; +inp[20480] = 641160527; +inp[20481] = 0; +inp[20482] = 636170976; +inp[20483] = 0; +inp[20484] = 631220255; +inp[20485] = 0; +inp[20486] = 626308060; +inp[20487] = 0; +inp[20488] = 621434092; +inp[20489] = 0; +inp[20490] = 616598053; +inp[20491] = 0; +inp[20492] = 611799649; +inp[20493] = 0; +inp[20494] = 607038586; +inp[20495] = 0; +inp[20496] = 602314575; +inp[20497] = 0; +inp[20498] = 597627325; +inp[20499] = 0; +inp[20500] = 592976553; +inp[20501] = 0; +inp[20502] = 588361972; +inp[20503] = 0; +inp[20504] = 583783303; +inp[20505] = 0; +inp[20506] = 579240266; +inp[20507] = 0; +inp[20508] = 574732582; +inp[20509] = 0; +inp[20510] = 570259978; +inp[20511] = 0; +inp[20512] = 565822179; +inp[20513] = 0; +inp[20514] = 561418916; +inp[20515] = 0; +inp[20516] = 557049919; +inp[20517] = 0; +inp[20518] = 552714923; +inp[20519] = 0; +inp[20520] = 548413661; +inp[20521] = 0; +inp[20522] = 544145872; +inp[20523] = 0; +inp[20524] = 539911295; +inp[20525] = 0; +inp[20526] = 535709672; +inp[20527] = 0; +inp[20528] = 531540746; +inp[20529] = 0; +inp[20530] = 527404264; +inp[20531] = 0; +inp[20532] = 523299971; +inp[20533] = 0; +inp[20534] = 519227618; +inp[20535] = 0; +inp[20536] = 515186957; +inp[20537] = 0; +inp[20538] = 511177740; +inp[20539] = 0; +inp[20540] = 507199723; +inp[20541] = 0; +inp[20542] = 503252664; +inp[20543] = 0; +inp[20544] = 499336321; +inp[20545] = 0; +inp[20546] = 495450454; +inp[20547] = 0; +inp[20548] = 491594828; +inp[20549] = 0; +inp[20550] = 487769207; +inp[20551] = 0; +inp[20552] = 483973357; +inp[20553] = 0; +inp[20554] = 480207047; +inp[20555] = 0; +inp[20556] = 476470046; +inp[20557] = 0; +inp[20558] = 472762126; +inp[20559] = 0; +inp[20560] = 469083062; +inp[20561] = 0; +inp[20562] = 465432629; +inp[20563] = 0; +inp[20564] = 461810603; +inp[20565] = 0; +inp[20566] = 458216765; +inp[20567] = 0; +inp[20568] = 454650894; +inp[20569] = 0; +inp[20570] = 451112772; +inp[20571] = 0; +inp[20572] = 447602185; +inp[20573] = 0; +inp[20574] = 444118917; +inp[20575] = 0; +inp[20576] = 440662756; +inp[20577] = 0; +inp[20578] = 437233491; +inp[20579] = 0; +inp[20580] = 433830913; +inp[20581] = 0; +inp[20582] = 430454814; +inp[20583] = 0; +inp[20584] = 427104988; +inp[20585] = 0; +inp[20586] = 423781231; +inp[20587] = 0; +inp[20588] = 420483339; +inp[20589] = 0; +inp[20590] = 417211112; +inp[20591] = 0; +inp[20592] = 413964349; +inp[20593] = 0; +inp[20594] = 410742853; +inp[20595] = 0; +inp[20596] = 407546427; +inp[20597] = 0; +inp[20598] = 404374876; +inp[20599] = 0; +inp[20600] = 401228005; +inp[20601] = 0; +inp[20602] = 398105624; +inp[20603] = 0; +inp[20604] = 395007542; +inp[20605] = 0; +inp[20606] = 391933569; +inp[20607] = 0; +inp[20608] = 388883517; +inp[20609] = 0; +inp[20610] = 385857202; +inp[20611] = 0; +inp[20612] = 382854437; +inp[20613] = 0; +inp[20614] = 379875040; +inp[20615] = 0; +inp[20616] = 376918829; +inp[20617] = 0; +inp[20618] = 373985624; +inp[20619] = 0; +inp[20620] = 371075245; +inp[20621] = 0; +inp[20622] = 368187514; +inp[20623] = 0; +inp[20624] = 365322256; +inp[20625] = 0; +inp[20626] = 362479296; +inp[20627] = 0; +inp[20628] = 359658459; +inp[20629] = 0; +inp[20630] = 356859575; +inp[20631] = 0; +inp[20632] = 354082472; +inp[20633] = 0; +inp[20634] = 351326980; +inp[20635] = 0; +inp[20636] = 348592932; +inp[20637] = 0; +inp[20638] = 345880160; +inp[20639] = 0; +inp[20640] = 343188499; +inp[20641] = 0; +inp[20642] = 340517785; +inp[20643] = 0; +inp[20644] = 337867855; +inp[20645] = 0; +inp[20646] = 335238546; +inp[20647] = 0; +inp[20648] = 332629699; +inp[20649] = 0; +inp[20650] = 330041155; +inp[20651] = 0; +inp[20652] = 327472754; +inp[20653] = 0; +inp[20654] = 324924341; +inp[20655] = 0; +inp[20656] = 322395759; +inp[20657] = 0; +inp[20658] = 319886856; +inp[20659] = 0; +inp[20660] = 317397476; +inp[20661] = 0; +inp[20662] = 314927470; +inp[20663] = 0; +inp[20664] = 312476685; +inp[20665] = 0; +inp[20666] = 310044972; +inp[20667] = 0; +inp[20668] = 307632183; +inp[20669] = 0; +inp[20670] = 305238170; +inp[20671] = 0; +inp[20672] = 302862788; +inp[20673] = 0; +inp[20674] = 300505891; +inp[20675] = 0; +inp[20676] = 298167335; +inp[20677] = 0; +inp[20678] = 295846979; +inp[20679] = 0; +inp[20680] = 293544679; +inp[20681] = 0; +inp[20682] = 291260297; +inp[20683] = 0; +inp[20684] = 288993691; +inp[20685] = 0; +inp[20686] = 286744724; +inp[20687] = 0; +inp[20688] = 284513259; +inp[20689] = 0; +inp[20690] = 282299159; +inp[20691] = 0; +inp[20692] = 280102290; +inp[20693] = 0; +inp[20694] = 277922516; +inp[20695] = 0; +inp[20696] = 275759706; +inp[20697] = 0; +inp[20698] = 273613727; +inp[20699] = 0; +inp[20700] = 271484448; +inp[20701] = 0; +inp[20702] = 269371740; +inp[20703] = 0; +inp[20704] = 267275472; +inp[20705] = 0; +inp[20706] = 265195518; +inp[20707] = 0; +inp[20708] = 263131750; +inp[20709] = 0; +inp[20710] = 261084042; +inp[20711] = 0; +inp[20712] = 259052270; +inp[20713] = 0; +inp[20714] = 257036309; +inp[20715] = 0; +inp[20716] = 255036037; +inp[20717] = 0; +inp[20718] = 253051331; +inp[20719] = 0; +inp[20720] = 251082070; +inp[20721] = 0; +inp[20722] = 249128134; +inp[20723] = 0; +inp[20724] = 247189403; +inp[20725] = 0; +inp[20726] = 245265760; +inp[20727] = 0; +inp[20728] = 243357087; +inp[20729] = 0; +inp[20730] = 241463267; +inp[20731] = 0; +inp[20732] = 239584185; +inp[20733] = 0; +inp[20734] = 237719726; +inp[20735] = 0; +inp[20736] = 235869776; +inp[20737] = 0; +inp[20738] = 234034223; +inp[20739] = 0; +inp[20740] = 232212954; +inp[20741] = 0; +inp[20742] = 230405859; +inp[20743] = 0; +inp[20744] = 228612826; +inp[20745] = 0; +inp[20746] = 226833747; +inp[20747] = 0; +inp[20748] = 225068513; +inp[20749] = 0; +inp[20750] = 223317016; +inp[20751] = 0; +inp[20752] = 221579149; +inp[20753] = 0; +inp[20754] = 219854806; +inp[20755] = 0; +inp[20756] = 218143882; +inp[20757] = 0; +inp[20758] = 216446273; +inp[20759] = 0; +inp[20760] = 214761875; +inp[20761] = 0; +inp[20762] = 213090585; +inp[20763] = 0; +inp[20764] = 211432301; +inp[20765] = 0; +inp[20766] = 209786922; +inp[20767] = 0; +inp[20768] = 208154347; +inp[20769] = 0; +inp[20770] = 206534477; +inp[20771] = 0; +inp[20772] = 204927213; +inp[20773] = 0; +inp[20774] = 203332457; +inp[20775] = 0; +inp[20776] = 201750111; +inp[20777] = 0; +inp[20778] = 200180079; +inp[20779] = 0; +inp[20780] = 198622265; +inp[20781] = 0; +inp[20782] = 197076575; +inp[20783] = 0; +inp[20784] = 195542912; +inp[20785] = 0; +inp[20786] = 194021185; +inp[20787] = 0; +inp[20788] = 192511301; +inp[20789] = 0; +inp[20790] = 191013166; +inp[20791] = 0; +inp[20792] = 189526689; +inp[20793] = 0; +inp[20794] = 188051781; +inp[20795] = 0; +inp[20796] = 186588351; +inp[20797] = 0; +inp[20798] = 185136308; +inp[20799] = 0; +inp[20800] = 183695566; +inp[20801] = 0; +inp[20802] = 182266036; +inp[20803] = 0; +inp[20804] = 180847630; +inp[20805] = 0; +inp[20806] = 179440263; +inp[20807] = 0; +inp[20808] = 178043848; +inp[20809] = 0; +inp[20810] = 176658300; +inp[20811] = 0; +inp[20812] = 175283534; +inp[20813] = 0; +inp[20814] = 173919467; +inp[20815] = 0; +inp[20816] = 172566014; +inp[20817] = 0; +inp[20818] = 171223095; +inp[20819] = 0; +inp[20820] = 169890626; +inp[20821] = 0; +inp[20822] = 168568527; +inp[20823] = 0; +inp[20824] = 167256716; +inp[20825] = 0; +inp[20826] = 165955114; +inp[20827] = 0; +inp[20828] = 164663641; +inp[20829] = 0; +inp[20830] = 163382219; +inp[20831] = 0; +inp[20832] = 162110768; +inp[20833] = 0; +inp[20834] = 160849212; +inp[20835] = 0; +inp[20836] = 159597474; +inp[20837] = 0; +inp[20838] = 158355476; +inp[20839] = 0; +inp[20840] = 157123144; +inp[20841] = 0; +inp[20842] = 155900402; +inp[20843] = 0; +inp[20844] = 154687176; +inp[20845] = 0; +inp[20846] = 153483390; +inp[20847] = 0; +inp[20848] = 152288973; +inp[20849] = 0; +inp[20850] = 151103851; +inp[20851] = 0; +inp[20852] = 149927952; +inp[20853] = 0; +inp[20854] = 148761203; +inp[20855] = 0; +inp[20856] = 147603534; +inp[20857] = 0; +inp[20858] = 146454874; +inp[20859] = 0; +inp[20860] = 1073741824; +inp[20861] = 1073741824; +inp[20862] = 1069555701; +inp[20863] = 0; +inp[20864] = 1065385898; +inp[20865] = 0; +inp[20866] = 1061232352; +inp[20867] = 0; +inp[20868] = 1057094999; +inp[20869] = 0; +inp[20870] = 1052973777; +inp[20871] = 0; +inp[20872] = 1048868621; +inp[20873] = 0; +inp[20874] = 1044779470; +inp[20875] = 0; +inp[20876] = 1040706261; +inp[20877] = 0; +inp[20878] = 1036648931; +inp[20879] = 0; +inp[20880] = 1032607420; +inp[20881] = 0; +inp[20882] = 1028581665; +inp[20883] = 0; +inp[20884] = 1024571605; +inp[20885] = 0; +inp[20886] = 1020577179; +inp[20887] = 0; +inp[20888] = 1016598326; +inp[20889] = 0; +inp[20890] = 1012634985; +inp[20891] = 0; +inp[20892] = 1008687095; +inp[20893] = 0; +inp[20894] = 1004754597; +inp[20895] = 0; +inp[20896] = 1000837430; +inp[20897] = 0; +inp[20898] = 996935534; +inp[20899] = 0; +inp[20900] = 993048851; +inp[20901] = 0; +inp[20902] = 989177321; +inp[20903] = 0; +inp[20904] = 985320884; +inp[20905] = 0; +inp[20906] = 981479482; +inp[20907] = 0; +inp[20908] = 977653056; +inp[20909] = 0; +inp[20910] = 973841548; +inp[20911] = 0; +inp[20912] = 970044899; +inp[20913] = 0; +inp[20914] = 966263053; +inp[20915] = 0; +inp[20916] = 962495950; +inp[20917] = 0; +inp[20918] = 958743534; +inp[20919] = 0; +inp[20920] = 955005747; +inp[20921] = 0; +inp[20922] = 951282532; +inp[20923] = 0; +inp[20924] = 947573833; +inp[20925] = 0; +inp[20926] = 943879593; +inp[20927] = 0; +inp[20928] = 940199755; +inp[20929] = 0; +inp[20930] = 936534264; +inp[20931] = 0; +inp[20932] = 932883063; +inp[20933] = 0; +inp[20934] = 929246096; +inp[20935] = 0; +inp[20936] = 925623309; +inp[20937] = 0; +inp[20938] = 922014646; +inp[20939] = 0; +inp[20940] = 918420051; +inp[20941] = 0; +inp[20942] = 914839471; +inp[20943] = 0; +inp[20944] = 911272850; +inp[20945] = 0; +inp[20946] = 907720134; +inp[20947] = 0; +inp[20948] = 904181268; +inp[20949] = 0; +inp[20950] = 900656200; +inp[20951] = 0; +inp[20952] = 897144874; +inp[20953] = 0; +inp[20954] = 893647237; +inp[20955] = 0; +inp[20956] = 890163237; +inp[20957] = 0; +inp[20958] = 886692819; +inp[20959] = 0; +inp[20960] = 883235932; +inp[20961] = 0; +inp[20962] = 879792521; +inp[20963] = 0; +inp[20964] = 876362535; +inp[20965] = 0; +inp[20966] = 872945921; +inp[20967] = 0; +inp[20968] = 869542628; +inp[20969] = 0; +inp[20970] = 866152602; +inp[20971] = 0; +inp[20972] = 862775793; +inp[20973] = 0; +inp[20974] = 859412149; +inp[20975] = 0; +inp[20976] = 856061619; +inp[20977] = 0; +inp[20978] = 852724151; +inp[20979] = 0; +inp[20980] = 849399695; +inp[20981] = 0; +inp[20982] = 846088199; +inp[20983] = 0; +inp[20984] = 842789614; +inp[20985] = 0; +inp[20986] = 839503888; +inp[20987] = 0; +inp[20988] = 836230973; +inp[20989] = 0; +inp[20990] = 832970817; +inp[20991] = 0; +inp[20992] = 829723372; +inp[20993] = 0; +inp[20994] = 826488587; +inp[20995] = 0; +inp[20996] = 823266413; +inp[20997] = 0; +inp[20998] = 820056802; +inp[20999] = 0; +inp[21000] = 816859703; +inp[21001] = 0; +inp[21002] = 813675069; +inp[21003] = 0; +inp[21004] = 810502851; +inp[21005] = 0; +inp[21006] = 807342999; +inp[21007] = 0; +inp[21008] = 804195467; +inp[21009] = 0; +inp[21010] = 801060206; +inp[21011] = 0; +inp[21012] = 797937169; +inp[21013] = 0; +inp[21014] = 794826306; +inp[21015] = 0; +inp[21016] = 791727572; +inp[21017] = 0; +inp[21018] = 788640919; +inp[21019] = 0; +inp[21020] = 785566299; +inp[21021] = 0; +inp[21022] = 782503667; +inp[21023] = 0; +inp[21024] = 779452974; +inp[21025] = 0; +inp[21026] = 776414175; +inp[21027] = 0; +inp[21028] = 773387223; +inp[21029] = 0; +inp[21030] = 770372072; +inp[21031] = 0; +inp[21032] = 767368676; +inp[21033] = 0; +inp[21034] = 764376989; +inp[21035] = 0; +inp[21036] = 761396965; +inp[21037] = 0; +inp[21038] = 758428560; +inp[21039] = 0; +inp[21040] = 755471727; +inp[21041] = 0; +inp[21042] = 752526422; +inp[21043] = 0; +inp[21044] = 749592599; +inp[21045] = 0; +inp[21046] = 746670215; +inp[21047] = 0; +inp[21048] = 743759224; +inp[21049] = 0; +inp[21050] = 740859581; +inp[21051] = 0; +inp[21052] = 737971243; +inp[21053] = 0; +inp[21054] = 735094166; +inp[21055] = 0; +inp[21056] = 732228306; +inp[21057] = 0; +inp[21058] = 729373618; +inp[21059] = 0; +inp[21060] = 726530060; +inp[21061] = 0; +inp[21062] = 723697587; +inp[21063] = 0; +inp[21064] = 720876158; +inp[21065] = 0; +inp[21066] = 718065728; +inp[21067] = 0; +inp[21068] = 715266255; +inp[21069] = 0; +inp[21070] = 712477696; +inp[21071] = 0; +inp[21072] = 709700009; +inp[21073] = 0; +inp[21074] = 706933151; +inp[21075] = 0; +inp[21076] = 704177080; +inp[21077] = 0; +inp[21078] = 701431753; +inp[21079] = 0; +inp[21080] = 698697130; +inp[21081] = 0; +inp[21082] = 695973168; +inp[21083] = 0; +inp[21084] = 693259826; +inp[21085] = 0; +inp[21086] = 690557062; +inp[21087] = 0; +inp[21088] = 687864835; +inp[21089] = 0; +inp[21090] = 685183104; +inp[21091] = 0; +inp[21092] = 682511829; +inp[21093] = 0; +inp[21094] = 679850967; +inp[21095] = 0; +inp[21096] = 677200479; +inp[21097] = 0; +inp[21098] = 674560325; +inp[21099] = 0; +inp[21100] = 671930463; +inp[21101] = 0; +inp[21102] = 669310855; +inp[21103] = 0; +inp[21104] = 666701459; +inp[21105] = 0; +inp[21106] = 664102236; +inp[21107] = 0; +inp[21108] = 661513147; +inp[21109] = 0; +inp[21110] = 658934152; +inp[21111] = 0; +inp[21112] = 656365211; +inp[21113] = 0; +inp[21114] = 653806286; +inp[21115] = 0; +inp[21116] = 651257336; +inp[21117] = 0; +inp[21118] = 648718325; +inp[21119] = 0; +inp[21120] = 646189212; +inp[21121] = 0; +inp[21122] = 643669959; +inp[21123] = 0; +inp[21124] = 641160527; +inp[21125] = 0; +inp[21126] = 638660879; +inp[21127] = 0; +inp[21128] = 636170976; +inp[21129] = 0; +inp[21130] = 633690781; +inp[21131] = 0; +inp[21132] = 631220255; +inp[21133] = 0; +inp[21134] = 628759360; +inp[21135] = 0; +inp[21136] = 626308060; +inp[21137] = 0; +inp[21138] = 623866316; +inp[21139] = 0; +inp[21140] = 621434092; +inp[21141] = 0; +inp[21142] = 619011350; +inp[21143] = 0; +inp[21144] = 616598053; +inp[21145] = 0; +inp[21146] = 614194165; +inp[21147] = 0; +inp[21148] = 611799649; +inp[21149] = 0; +inp[21150] = 609414468; +inp[21151] = 0; +inp[21152] = 607038586; +inp[21153] = 0; +inp[21154] = 604671967; +inp[21155] = 0; +inp[21156] = 602314575; +inp[21157] = 0; +inp[21158] = 599966373; +inp[21159] = 0; +inp[21160] = 597627325; +inp[21161] = 0; +inp[21162] = 595297397; +inp[21163] = 0; +inp[21164] = 592976553; +inp[21165] = 0; +inp[21166] = 590664756; +inp[21167] = 0; +inp[21168] = 588361972; +inp[21169] = 0; +inp[21170] = 586068167; +inp[21171] = 0; +inp[21172] = 583783303; +inp[21173] = 0; +inp[21174] = 581507348; +inp[21175] = 0; +inp[21176] = 579240266; +inp[21177] = 0; +inp[21178] = 576982022; +inp[21179] = 0; +inp[21180] = 574732582; +inp[21181] = 0; +inp[21182] = 572491912; +inp[21183] = 0; +inp[21184] = 570259978; +inp[21185] = 0; +inp[21186] = 568036745; +inp[21187] = 0; +inp[21188] = 565822179; +inp[21189] = 0; +inp[21190] = 563616248; +inp[21191] = 0; +inp[21192] = 561418916; +inp[21193] = 0; +inp[21194] = 559230151; +inp[21195] = 0; +inp[21196] = 557049919; +inp[21197] = 0; +inp[21198] = 554878188; +inp[21199] = 0; +inp[21200] = 552714923; +inp[21201] = 0; +inp[21202] = 550560091; +inp[21203] = 0; +inp[21204] = 548413661; +inp[21205] = 0; +inp[21206] = 546275599; +inp[21207] = 0; +inp[21208] = 544145872; +inp[21209] = 0; +inp[21210] = 542024448; +inp[21211] = 0; +inp[21212] = 539911295; +inp[21213] = 0; +inp[21214] = 537806381; +inp[21215] = 0; +inp[21216] = 535709672; +inp[21217] = 0; +inp[21218] = 533621138; +inp[21219] = 0; +inp[21220] = 531540746; +inp[21221] = 0; +inp[21222] = 529468465; +inp[21223] = 0; +inp[21224] = 527404264; +inp[21225] = 0; +inp[21226] = 525348109; +inp[21227] = 0; +inp[21228] = 523299971; +inp[21229] = 0; +inp[21230] = 521259818; +inp[21231] = 0; +inp[21232] = 519227618; +inp[21233] = 0; +inp[21234] = 517203342; +inp[21235] = 0; +inp[21236] = 515186957; +inp[21237] = 0; +inp[21238] = 513178433; +inp[21239] = 0; +inp[21240] = 511177740; +inp[21241] = 0; +inp[21242] = 509184847; +inp[21243] = 0; +inp[21244] = 507199723; +inp[21245] = 0; +inp[21246] = 505222339; +inp[21247] = 0; +inp[21248] = 503252664; +inp[21249] = 0; +inp[21250] = 501290668; +inp[21251] = 0; +inp[21252] = 499336321; +inp[21253] = 0; +inp[21254] = 497389593; +inp[21255] = 0; +inp[21256] = 495450454; +inp[21257] = 0; +inp[21258] = 493518876; +inp[21259] = 0; +inp[21260] = 491594828; +inp[21261] = 0; +inp[21262] = 489678282; +inp[21263] = 0; +inp[21264] = 487769207; +inp[21265] = 0; +inp[21266] = 485867575; +inp[21267] = 0; +inp[21268] = 483973357; +inp[21269] = 0; +inp[21270] = 482086524; +inp[21271] = 0; +inp[21272] = 480207047; +inp[21273] = 0; +inp[21274] = 478334897; +inp[21275] = 0; +inp[21276] = 476470046; +inp[21277] = 0; +inp[21278] = 474612465; +inp[21279] = 0; +inp[21280] = 472762126; +inp[21281] = 0; +inp[21282] = 470919001; +inp[21283] = 0; +inp[21284] = 469083062; +inp[21285] = 0; +inp[21286] = 467254281; +inp[21287] = 0; +inp[21288] = 465432629; +inp[21289] = 0; +inp[21290] = 463618079; +inp[21291] = 0; +inp[21292] = 461810603; +inp[21293] = 0; +inp[21294] = 460010175; +inp[21295] = 0; +inp[21296] = 458216765; +inp[21297] = 0; +inp[21298] = 456430347; +inp[21299] = 0; +inp[21300] = 454650894; +inp[21301] = 0; +inp[21302] = 452878378; +inp[21303] = 0; +inp[21304] = 451112772; +inp[21305] = 0; +inp[21306] = 449354050; +inp[21307] = 0; +inp[21308] = 447602185; +inp[21309] = 0; +inp[21310] = 445857149; +inp[21311] = 0; +inp[21312] = 444118917; +inp[21313] = 0; +inp[21314] = 442387461; +inp[21315] = 0; +inp[21316] = 440662756; +inp[21317] = 0; +inp[21318] = 438944775; +inp[21319] = 0; +inp[21320] = 437233491; +inp[21321] = 0; +inp[21322] = 435528880; +inp[21323] = 0; +inp[21324] = 433830913; +inp[21325] = 0; +inp[21326] = 432139567; +inp[21327] = 0; +inp[21328] = 430454814; +inp[21329] = 0; +inp[21330] = 428776630; +inp[21331] = 0; +inp[21332] = 427104988; +inp[21333] = 0; +inp[21334] = 425439864; +inp[21335] = 0; +inp[21336] = 423781231; +inp[21337] = 0; +inp[21338] = 422129065; +inp[21339] = 0; +inp[21340] = 420483339; +inp[21341] = 0; +inp[21342] = 418844030; +inp[21343] = 0; +inp[21344] = 417211112; +inp[21345] = 0; +inp[21346] = 415584560; +inp[21347] = 0; +inp[21348] = 413964349; +inp[21349] = 0; +inp[21350] = 412350455; +inp[21351] = 0; +inp[21352] = 410742853; +inp[21353] = 0; +inp[21354] = 409141519; +inp[21355] = 0; +inp[21356] = 407546427; +inp[21357] = 0; +inp[21358] = 405957554; +inp[21359] = 0; +inp[21360] = 404374876; +inp[21361] = 0; +inp[21362] = 402798367; +inp[21363] = 0; +inp[21364] = 401228005; +inp[21365] = 0; +inp[21366] = 399663766; +inp[21367] = 0; +inp[21368] = 398105624; +inp[21369] = 0; +inp[21370] = 396553557; +inp[21371] = 0; +inp[21372] = 1073741824; +inp[21373] = 1073741824; +inp[21374] = 1071646718; +inp[21375] = 0; +inp[21376] = 1069555701; +inp[21377] = 0; +inp[21378] = 1067468764; +inp[21379] = 0; +inp[21380] = 1065385898; +inp[21381] = 0; +inp[21382] = 1063307097; +inp[21383] = 0; +inp[21384] = 1061232352; +inp[21385] = 0; +inp[21386] = 1059161656; +inp[21387] = 0; +inp[21388] = 1057094999; +inp[21389] = 0; +inp[21390] = 1055032376; +inp[21391] = 0; +inp[21392] = 1052973777; +inp[21393] = 0; +inp[21394] = 1050919194; +inp[21395] = 0; +inp[21396] = 1048868621; +inp[21397] = 0; +inp[21398] = 1046822049; +inp[21399] = 0; +inp[21400] = 1044779470; +inp[21401] = 0; +inp[21402] = 1042740876; +inp[21403] = 0; +inp[21404] = 1040706261; +inp[21405] = 0; +inp[21406] = 1038675615; +inp[21407] = 0; +inp[21408] = 1036648931; +inp[21409] = 0; +inp[21410] = 1034626202; +inp[21411] = 0; +inp[21412] = 1032607420; +inp[21413] = 0; +inp[21414] = 1030592577; +inp[21415] = 0; +inp[21416] = 1028581665; +inp[21417] = 0; +inp[21418] = 1026574677; +inp[21419] = 0; +inp[21420] = 1024571605; +inp[21421] = 0; +inp[21422] = 1022572442; +inp[21423] = 0; +inp[21424] = 1020577179; +inp[21425] = 0; +inp[21426] = 1018585810; +inp[21427] = 0; +inp[21428] = 1016598326; +inp[21429] = 0; +inp[21430] = 1014614720; +inp[21431] = 0; +inp[21432] = 1012634985; +inp[21433] = 0; +inp[21434] = 1010659112; +inp[21435] = 0; +inp[21436] = 1008687095; +inp[21437] = 0; +inp[21438] = 1006718926; +inp[21439] = 0; +inp[21440] = 1004754597; +inp[21441] = 0; +inp[21442] = 1002794101; +inp[21443] = 0; +inp[21444] = 1000837430; +inp[21445] = 0; +inp[21446] = 998884577; +inp[21447] = 0; +inp[21448] = 996935534; +inp[21449] = 0; +inp[21450] = 994990295; +inp[21451] = 0; +inp[21452] = 993048851; +inp[21453] = 0; +inp[21454] = 991111195; +inp[21455] = 0; +inp[21456] = 989177321; +inp[21457] = 0; +inp[21458] = 987247219; +inp[21459] = 0; +inp[21460] = 985320884; +inp[21461] = 0; +inp[21462] = 983398307; +inp[21463] = 0; +inp[21464] = 981479482; +inp[21465] = 0; +inp[21466] = 979564400; +inp[21467] = 0; +inp[21468] = 977653056; +inp[21469] = 0; +inp[21470] = 975745441; +inp[21471] = 0; +inp[21472] = 973841548; +inp[21473] = 0; +inp[21474] = 971941370; +inp[21475] = 0; +inp[21476] = 970044899; +inp[21477] = 0; +inp[21478] = 968152129; +inp[21479] = 0; +inp[21480] = 966263053; +inp[21481] = 0; +inp[21482] = 964377662; +inp[21483] = 0; +inp[21484] = 962495950; +inp[21485] = 0; +inp[21486] = 960617910; +inp[21487] = 0; +inp[21488] = 958743534; +inp[21489] = 0; +inp[21490] = 956872815; +inp[21491] = 0; +inp[21492] = 955005747; +inp[21493] = 0; +inp[21494] = 953142322; +inp[21495] = 0; +inp[21496] = 951282532; +inp[21497] = 0; +inp[21498] = 949426372; +inp[21499] = 0; +inp[21500] = 947573833; +inp[21501] = 0; +inp[21502] = 945724909; +inp[21503] = 0; +inp[21504] = 943879593; +inp[21505] = 0; +inp[21506] = 942037877; +inp[21507] = 0; +inp[21508] = 940199755; +inp[21509] = 0; +inp[21510] = 938365220; +inp[21511] = 0; +inp[21512] = 936534264; +inp[21513] = 0; +inp[21514] = 934706880; +inp[21515] = 0; +inp[21516] = 932883063; +inp[21517] = 0; +inp[21518] = 931062804; +inp[21519] = 0; +inp[21520] = 929246096; +inp[21521] = 0; +inp[21522] = 927432934; +inp[21523] = 0; +inp[21524] = 925623309; +inp[21525] = 0; +inp[21526] = 923817215; +inp[21527] = 0; +inp[21528] = 922014646; +inp[21529] = 0; +inp[21530] = 920215593; +inp[21531] = 0; +inp[21532] = 918420051; +inp[21533] = 0; +inp[21534] = 916628013; +inp[21535] = 0; +inp[21536] = 914839471; +inp[21537] = 0; +inp[21538] = 913054419; +inp[21539] = 0; +inp[21540] = 911272850; +inp[21541] = 0; +inp[21542] = 909494757; +inp[21543] = 0; +inp[21544] = 907720134; +inp[21545] = 0; +inp[21546] = 905948973; +inp[21547] = 0; +inp[21548] = 904181268; +inp[21549] = 0; +inp[21550] = 902417013; +inp[21551] = 0; +inp[21552] = 900656200; +inp[21553] = 0; +inp[21554] = 898898822; +inp[21555] = 0; +inp[21556] = 897144874; +inp[21557] = 0; +inp[21558] = 895394348; +inp[21559] = 0; +inp[21560] = 893647237; +inp[21561] = 0; +inp[21562] = 891903536; +inp[21563] = 0; +inp[21564] = 890163237; +inp[21565] = 0; +inp[21566] = 888426334; +inp[21567] = 0; +inp[21568] = 886692819; +inp[21569] = 0; +inp[21570] = 884962688; +inp[21571] = 0; +inp[21572] = 883235932; +inp[21573] = 0; +inp[21574] = 881512545; +inp[21575] = 0; +inp[21576] = 879792521; +inp[21577] = 0; +inp[21578] = 878075853; +inp[21579] = 0; +inp[21580] = 876362535; +inp[21581] = 0; +inp[21582] = 874652560; +inp[21583] = 0; +inp[21584] = 872945921; +inp[21585] = 0; +inp[21586] = 871242613; +inp[21587] = 0; +inp[21588] = 869542628; +inp[21589] = 0; +inp[21590] = 867845960; +inp[21591] = 0; +inp[21592] = 866152602; +inp[21593] = 0; +inp[21594] = 864462549; +inp[21595] = 0; +inp[21596] = 862775793; +inp[21597] = 0; +inp[21598] = 861092329; +inp[21599] = 0; +inp[21600] = 859412149; +inp[21601] = 0; +inp[21602] = 857735248; +inp[21603] = 0; +inp[21604] = 856061619; +inp[21605] = 0; +inp[21606] = 854391255; +inp[21607] = 0; +inp[21608] = 852724151; +inp[21609] = 0; +inp[21610] = 851060299; +inp[21611] = 0; +inp[21612] = 849399695; +inp[21613] = 0; +inp[21614] = 847742330; +inp[21615] = 0; +inp[21616] = 846088199; +inp[21617] = 0; +inp[21618] = 844437296; +inp[21619] = 0; +inp[21620] = 842789614; +inp[21621] = 0; +inp[21622] = 841145147; +inp[21623] = 0; +inp[21624] = 839503888; +inp[21625] = 0; +inp[21626] = 837865832; +inp[21627] = 0; +inp[21628] = 836230973; +inp[21629] = 0; +inp[21630] = 834599303; +inp[21631] = 0; +inp[21632] = 832970817; +inp[21633] = 0; +inp[21634] = 831345509; +inp[21635] = 0; +inp[21636] = 829723372; +inp[21637] = 0; +inp[21638] = 828104400; +inp[21639] = 0; +inp[21640] = 826488587; +inp[21641] = 0; +inp[21642] = 824875927; +inp[21643] = 0; +inp[21644] = 823266413; +inp[21645] = 0; +inp[21646] = 821660040; +inp[21647] = 0; +inp[21648] = 820056802; +inp[21649] = 0; +inp[21650] = 818456691; +inp[21651] = 0; +inp[21652] = 816859703; +inp[21653] = 0; +inp[21654] = 815265831; +inp[21655] = 0; +inp[21656] = 813675069; +inp[21657] = 0; +inp[21658] = 812087411; +inp[21659] = 0; +inp[21660] = 810502851; +inp[21661] = 0; +inp[21662] = 808921382; +inp[21663] = 0; +inp[21664] = 807342999; +inp[21665] = 0; +inp[21666] = 805767696; +inp[21667] = 0; +inp[21668] = 804195467; +inp[21669] = 0; +inp[21670] = 802626306; +inp[21671] = 0; +inp[21672] = 801060206; +inp[21673] = 0; +inp[21674] = 799497163; +inp[21675] = 0; +inp[21676] = 797937169; +inp[21677] = 0; +inp[21678] = 796380218; +inp[21679] = 0; +inp[21680] = 794826306; +inp[21681] = 0; +inp[21682] = 793275426; +inp[21683] = 0; +inp[21684] = 791727572; +inp[21685] = 0; +inp[21686] = 790182738; +inp[21687] = 0; +inp[21688] = 788640919; +inp[21689] = 0; +inp[21690] = 787102108; +inp[21691] = 0; +inp[21692] = 785566299; +inp[21693] = 0; +inp[21694] = 784033488; +inp[21695] = 0; +inp[21696] = 782503667; +inp[21697] = 0; +inp[21698] = 780976831; +inp[21699] = 0; +inp[21700] = 779452974; +inp[21701] = 0; +inp[21702] = 777932091; +inp[21703] = 0; +inp[21704] = 776414175; +inp[21705] = 0; +inp[21706] = 774899221; +inp[21707] = 0; +inp[21708] = 773387223; +inp[21709] = 0; +inp[21710] = 771878175; +inp[21711] = 0; +inp[21712] = 770372072; +inp[21713] = 0; +inp[21714] = 768868907; +inp[21715] = 0; +inp[21716] = 767368676; +inp[21717] = 0; +inp[21718] = 765871371; +inp[21719] = 0; +inp[21720] = 764376989; +inp[21721] = 0; +inp[21722] = 762885522; +inp[21723] = 0; +inp[21724] = 761396965; +inp[21725] = 0; +inp[21726] = 759911313; +inp[21727] = 0; +inp[21728] = 758428560; +inp[21729] = 0; +inp[21730] = 756948700; +inp[21731] = 0; +inp[21732] = 755471727; +inp[21733] = 0; +inp[21734] = 753997636; +inp[21735] = 0; +inp[21736] = 752526422; +inp[21737] = 0; +inp[21738] = 751058078; +inp[21739] = 0; +inp[21740] = 749592599; +inp[21741] = 0; +inp[21742] = 748129980; +inp[21743] = 0; +inp[21744] = 746670215; +inp[21745] = 0; +inp[21746] = 745213298; +inp[21747] = 0; +inp[21748] = 743759224; +inp[21749] = 0; +inp[21750] = 742307986; +inp[21751] = 0; +inp[21752] = 740859581; +inp[21753] = 0; +inp[21754] = 739414002; +inp[21755] = 0; +inp[21756] = 737971243; +inp[21757] = 0; +inp[21758] = 736531300; +inp[21759] = 0; +inp[21760] = 735094166; +inp[21761] = 0; +inp[21762] = 733659836; +inp[21763] = 0; +inp[21764] = 732228306; +inp[21765] = 0; +inp[21766] = 730799568; +inp[21767] = 0; +inp[21768] = 729373618; +inp[21769] = 0; +inp[21770] = 727950450; +inp[21771] = 0; +inp[21772] = 726530060; +inp[21773] = 0; +inp[21774] = 725112440; +inp[21775] = 0; +inp[21776] = 723697587; +inp[21777] = 0; +inp[21778] = 722285495; +inp[21779] = 0; +inp[21780] = 720876158; +inp[21781] = 0; +inp[21782] = 719469571; +inp[21783] = 0; +inp[21784] = 718065728; +inp[21785] = 0; +inp[21786] = 716664625; +inp[21787] = 0; +inp[21788] = 715266255; +inp[21789] = 0; +inp[21790] = 713870614; +inp[21791] = 0; +inp[21792] = 712477696; +inp[21793] = 0; +inp[21794] = 711087496; +inp[21795] = 0; +inp[21796] = 709700009; +inp[21797] = 0; +inp[21798] = 708315229; +inp[21799] = 0; +inp[21800] = 706933151; +inp[21801] = 0; +inp[21802] = 705553769; +inp[21803] = 0; +inp[21804] = 704177080; +inp[21805] = 0; +inp[21806] = 702803076; +inp[21807] = 0; +inp[21808] = 701431753; +inp[21809] = 0; +inp[21810] = 700063106; +inp[21811] = 0; +inp[21812] = 698697130; +inp[21813] = 0; +inp[21814] = 697333819; +inp[21815] = 0; +inp[21816] = 695973168; +inp[21817] = 0; +inp[21818] = 694615172; +inp[21819] = 0; +inp[21820] = 693259826; +inp[21821] = 0; +inp[21822] = 691907124; +inp[21823] = 0; +inp[21824] = 690557062; +inp[21825] = 0; +inp[21826] = 689209634; +inp[21827] = 0; +inp[21828] = 687864835; +inp[21829] = 0; +inp[21830] = 686522660; +inp[21831] = 0; +inp[21832] = 685183104; +inp[21833] = 0; +inp[21834] = 683846162; +inp[21835] = 0; +inp[21836] = 682511829; +inp[21837] = 0; +inp[21838] = 681180099; +inp[21839] = 0; +inp[21840] = 679850967; +inp[21841] = 0; +inp[21842] = 678524429; +inp[21843] = 0; +inp[21844] = 677200479; +inp[21845] = 0; +inp[21846] = 675879113; +inp[21847] = 0; +inp[21848] = 674560325; +inp[21849] = 0; +inp[21850] = 673244110; +inp[21851] = 0; +inp[21852] = 671930463; +inp[21853] = 0; +inp[21854] = 670619380; +inp[21855] = 0; +inp[21856] = 669310855; +inp[21857] = 0; +inp[21858] = 668004883; +inp[21859] = 0; +inp[21860] = 666701459; +inp[21861] = 0; +inp[21862] = 665400579; +inp[21863] = 0; +inp[21864] = 664102236; +inp[21865] = 0; +inp[21866] = 662806428; +inp[21867] = 0; +inp[21868] = 661513147; +inp[21869] = 0; +inp[21870] = 660222390; +inp[21871] = 0; +inp[21872] = 658934152; +inp[21873] = 0; +inp[21874] = 657648427; +inp[21875] = 0; +inp[21876] = 656365211; +inp[21877] = 0; +inp[21878] = 655084499; +inp[21879] = 0; +inp[21880] = 653806286; +inp[21881] = 0; +inp[21882] = 652530566; +inp[21883] = 0; +inp[21884] = 1073741824; +inp[21885] = 1073741824; +inp[21886] = 1072693759; +inp[21887] = 0; +inp[21888] = 1071646718; +inp[21889] = 0; +inp[21890] = 1070600699; +inp[21891] = 0; +inp[21892] = 1069555701; +inp[21893] = 0; +inp[21894] = 1068511723; +inp[21895] = 0; +inp[21896] = 1067468764; +inp[21897] = 0; +inp[21898] = 1066426822; +inp[21899] = 0; +inp[21900] = 1065385898; +inp[21901] = 0; +inp[21902] = 1064345990; +inp[21903] = 0; +inp[21904] = 1063307097; +inp[21905] = 0; +inp[21906] = 1062269218; +inp[21907] = 0; +inp[21908] = 1061232352; +inp[21909] = 0; +inp[21910] = 1060196498; +inp[21911] = 0; +inp[21912] = 1059161656; +inp[21913] = 0; +inp[21914] = 1058127823; +inp[21915] = 0; +inp[21916] = 1057094999; +inp[21917] = 0; +inp[21918] = 1056063184; +inp[21919] = 0; +inp[21920] = 1055032376; +inp[21921] = 0; +inp[21922] = 1054002574; +inp[21923] = 0; +inp[21924] = 1052973777; +inp[21925] = 0; +inp[21926] = 1051945984; +inp[21927] = 0; +inp[21928] = 1050919194; +inp[21929] = 0; +inp[21930] = 1049893407; +inp[21931] = 0; +inp[21932] = 1048868621; +inp[21933] = 0; +inp[21934] = 1047844835; +inp[21935] = 0; +inp[21936] = 1046822049; +inp[21937] = 0; +inp[21938] = 1045800261; +inp[21939] = 0; +inp[21940] = 1044779470; +inp[21941] = 0; +inp[21942] = 1043759675; +inp[21943] = 0; +inp[21944] = 1042740876; +inp[21945] = 0; +inp[21946] = 1041723072; +inp[21947] = 0; +inp[21948] = 1040706261; +inp[21949] = 0; +inp[21950] = 1039690442; +inp[21951] = 0; +inp[21952] = 1038675615; +inp[21953] = 0; +inp[21954] = 1037661778; +inp[21955] = 0; +inp[21956] = 1036648931; +inp[21957] = 0; +inp[21958] = 1035637073; +inp[21959] = 0; +inp[21960] = 1034626202; +inp[21961] = 0; +inp[21962] = 1033616318; +inp[21963] = 0; +inp[21964] = 1032607420; +inp[21965] = 0; +inp[21966] = 1031599507; +inp[21967] = 0; +inp[21968] = 1030592577; +inp[21969] = 0; +inp[21970] = 1029586630; +inp[21971] = 0; +inp[21972] = 1028581665; +inp[21973] = 0; +inp[21974] = 1027577681; +inp[21975] = 0; +inp[21976] = 1026574677; +inp[21977] = 0; +inp[21978] = 1025572652; +inp[21979] = 0; +inp[21980] = 1024571605; +inp[21981] = 0; +inp[21982] = 1023571536; +inp[21983] = 0; +inp[21984] = 1022572442; +inp[21985] = 0; +inp[21986] = 1021574324; +inp[21987] = 0; +inp[21988] = 1020577179; +inp[21989] = 0; +inp[21990] = 1019581008; +inp[21991] = 0; +inp[21992] = 1018585810; +inp[21993] = 0; +inp[21994] = 1017591583; +inp[21995] = 0; +inp[21996] = 1016598326; +inp[21997] = 0; +inp[21998] = 1015606039; +inp[21999] = 0; +inp[22000] = 1014614720; +inp[22001] = 0; +inp[22002] = 1013624369; +inp[22003] = 0; +inp[22004] = 1012634985; +inp[22005] = 0; +inp[22006] = 1011646566; +inp[22007] = 0; +inp[22008] = 1010659112; +inp[22009] = 0; +inp[22010] = 1009672622; +inp[22011] = 0; +inp[22012] = 1008687095; +inp[22013] = 0; +inp[22014] = 1007702530; +inp[22015] = 0; +inp[22016] = 1006718926; +inp[22017] = 0; +inp[22018] = 1005736282; +inp[22019] = 0; +inp[22020] = 1004754597; +inp[22021] = 0; +inp[22022] = 1003773870; +inp[22023] = 0; +inp[22024] = 1002794101; +inp[22025] = 0; +inp[22026] = 1001815287; +inp[22027] = 0; +inp[22028] = 1000837430; +inp[22029] = 0; +inp[22030] = 999860527; +inp[22031] = 0; +inp[22032] = 998884577; +inp[22033] = 0; +inp[22034] = 997909580; +inp[22035] = 0; +inp[22036] = 996935534; +inp[22037] = 0; +inp[22038] = 995962440; +inp[22039] = 0; +inp[22040] = 994990295; +inp[22041] = 0; +inp[22042] = 994019099; +inp[22043] = 0; +inp[22044] = 993048851; +inp[22045] = 0; +inp[22046] = 992079550; +inp[22047] = 0; +inp[22048] = 991111195; +inp[22049] = 0; +inp[22050] = 990143786; +inp[22051] = 0; +inp[22052] = 989177321; +inp[22053] = 0; +inp[22054] = 988211799; +inp[22055] = 0; +inp[22056] = 987247219; +inp[22057] = 0; +inp[22058] = 986283581; +inp[22059] = 0; +inp[22060] = 985320884; +inp[22061] = 0; +inp[22062] = 984359126; +inp[22063] = 0; +inp[22064] = 983398307; +inp[22065] = 0; +inp[22066] = 982438426; +inp[22067] = 0; +inp[22068] = 981479482; +inp[22069] = 0; +inp[22070] = 980521473; +inp[22071] = 0; +inp[22072] = 979564400; +inp[22073] = 0; +inp[22074] = 978608261; +inp[22075] = 0; +inp[22076] = 977653056; +inp[22077] = 0; +inp[22078] = 976698782; +inp[22079] = 0; +inp[22080] = 975745441; +inp[22081] = 0; +inp[22082] = 974793029; +inp[22083] = 0; +inp[22084] = 973841548; +inp[22085] = 0; +inp[22086] = 972890995; +inp[22087] = 0; +inp[22088] = 971941370; +inp[22089] = 0; +inp[22090] = 970992671; +inp[22091] = 0; +inp[22092] = 970044899; +inp[22093] = 0; +inp[22094] = 969098052; +inp[22095] = 0; +inp[22096] = 968152129; +inp[22097] = 0; +inp[22098] = 967207130; +inp[22099] = 0; +inp[22100] = 966263053; +inp[22101] = 0; +inp[22102] = 965319897; +inp[22103] = 0; +inp[22104] = 964377662; +inp[22105] = 0; +inp[22106] = 963436347; +inp[22107] = 0; +inp[22108] = 962495950; +inp[22109] = 0; +inp[22110] = 961556471; +inp[22111] = 0; +inp[22112] = 960617910; +inp[22113] = 0; +inp[22114] = 959680264; +inp[22115] = 0; +inp[22116] = 958743534; +inp[22117] = 0; +inp[22118] = 957807718; +inp[22119] = 0; +inp[22120] = 956872815; +inp[22121] = 0; +inp[22122] = 955938825; +inp[22123] = 0; +inp[22124] = 955005747; +inp[22125] = 0; +inp[22126] = 954073579; +inp[22127] = 0; +inp[22128] = 953142322; +inp[22129] = 0; +inp[22130] = 952211973; +inp[22131] = 0; +inp[22132] = 951282532; +inp[22133] = 0; +inp[22134] = 950353999; +inp[22135] = 0; +inp[22136] = 949426372; +inp[22137] = 0; +inp[22138] = 948499650; +inp[22139] = 0; +inp[22140] = 947573833; +inp[22141] = 0; +inp[22142] = 946648920; +inp[22143] = 0; +inp[22144] = 945724909; +inp[22145] = 0; +inp[22146] = 944801801; +inp[22147] = 0; +inp[22148] = 943879593; +inp[22149] = 0; +inp[22150] = 942958286; +inp[22151] = 0; +inp[22152] = 942037877; +inp[22153] = 0; +inp[22154] = 941118368; +inp[22155] = 0; +inp[22156] = 940199755; +inp[22157] = 0; +inp[22158] = 939282040; +inp[22159] = 0; +inp[22160] = 938365220; +inp[22161] = 0; +inp[22162] = 937449295; +inp[22163] = 0; +inp[22164] = 936534264; +inp[22165] = 0; +inp[22166] = 935620126; +inp[22167] = 0; +inp[22168] = 934706880; +inp[22169] = 0; +inp[22170] = 933794526; +inp[22171] = 0; +inp[22172] = 932883063; +inp[22173] = 0; +inp[22174] = 931972489; +inp[22175] = 0; +inp[22176] = 931062804; +inp[22177] = 0; +inp[22178] = 930154006; +inp[22179] = 0; +inp[22180] = 929246096; +inp[22181] = 0; +inp[22182] = 928339072; +inp[22183] = 0; +inp[22184] = 927432934; +inp[22185] = 0; +inp[22186] = 926527680; +inp[22187] = 0; +inp[22188] = 925623309; +inp[22189] = 0; +inp[22190] = 924719821; +inp[22191] = 0; +inp[22192] = 923817215; +inp[22193] = 0; +inp[22194] = 922915491; +inp[22195] = 0; +inp[22196] = 922014646; +inp[22197] = 0; +inp[22198] = 921114680; +inp[22199] = 0; +inp[22200] = 920215593; +inp[22201] = 0; +inp[22202] = 919317384; +inp[22203] = 0; +inp[22204] = 918420051; +inp[22205] = 0; +inp[22206] = 917523595; +inp[22207] = 0; +inp[22208] = 916628013; +inp[22209] = 0; +inp[22210] = 915733305; +inp[22211] = 0; +inp[22212] = 914839471; +inp[22213] = 0; +inp[22214] = 913946509; +inp[22215] = 0; +inp[22216] = 913054419; +inp[22217] = 0; +inp[22218] = 912163199; +inp[22219] = 0; +inp[22220] = 911272850; +inp[22221] = 0; +inp[22222] = 910383369; +inp[22223] = 0; +inp[22224] = 909494757; +inp[22225] = 0; +inp[22226] = 908607012; +inp[22227] = 0; +inp[22228] = 907720134; +inp[22229] = 0; +inp[22230] = 906834121; +inp[22231] = 0; +inp[22232] = 905948973; +inp[22233] = 0; +inp[22234] = 905064689; +inp[22235] = 0; +inp[22236] = 904181268; +inp[22237] = 0; +inp[22238] = 903298710; +inp[22239] = 0; +inp[22240] = 902417013; +inp[22241] = 0; +inp[22242] = 901536176; +inp[22243] = 0; +inp[22244] = 900656200; +inp[22245] = 0; +inp[22246] = 899777082; +inp[22247] = 0; +inp[22248] = 898898822; +inp[22249] = 0; +inp[22250] = 898021420; +inp[22251] = 0; +inp[22252] = 897144874; +inp[22253] = 0; +inp[22254] = 896269183; +inp[22255] = 0; +inp[22256] = 895394348; +inp[22257] = 0; +inp[22258] = 894520366; +inp[22259] = 0; +inp[22260] = 893647237; +inp[22261] = 0; +inp[22262] = 892774961; +inp[22263] = 0; +inp[22264] = 891903536; +inp[22265] = 0; +inp[22266] = 891032962; +inp[22267] = 0; +inp[22268] = 890163237; +inp[22269] = 0; +inp[22270] = 889294361; +inp[22271] = 0; +inp[22272] = 888426334; +inp[22273] = 0; +inp[22274] = 887559153; +inp[22275] = 0; +inp[22276] = 886692819; +inp[22277] = 0; +inp[22278] = 885827331; +inp[22279] = 0; +inp[22280] = 884962688; +inp[22281] = 0; +inp[22282] = 884098888; +inp[22283] = 0; +inp[22284] = 883235932; +inp[22285] = 0; +inp[22286] = 882373818; +inp[22287] = 0; +inp[22288] = 881512545; +inp[22289] = 0; +inp[22290] = 880652113; +inp[22291] = 0; +inp[22292] = 879792521; +inp[22293] = 0; +inp[22294] = 878933768; +inp[22295] = 0; +inp[22296] = 878075853; +inp[22297] = 0; +inp[22298] = 877218776; +inp[22299] = 0; +inp[22300] = 876362535; +inp[22301] = 0; +inp[22302] = 875507130; +inp[22303] = 0; +inp[22304] = 874652560; +inp[22305] = 0; +inp[22306] = 873798824; +inp[22307] = 0; +inp[22308] = 872945921; +inp[22309] = 0; +inp[22310] = 872093851; +inp[22311] = 0; +inp[22312] = 871242613; +inp[22313] = 0; +inp[22314] = 870392205; +inp[22315] = 0; +inp[22316] = 869542628; +inp[22317] = 0; +inp[22318] = 868693880; +inp[22319] = 0; +inp[22320] = 867845960; +inp[22321] = 0; +inp[22322] = 866998868; +inp[22323] = 0; +inp[22324] = 866152602; +inp[22325] = 0; +inp[22326] = 865307163; +inp[22327] = 0; +inp[22328] = 864462549; +inp[22329] = 0; +inp[22330] = 863618759; +inp[22331] = 0; +inp[22332] = 862775793; +inp[22333] = 0; +inp[22334] = 861933650; +inp[22335] = 0; +inp[22336] = 861092329; +inp[22337] = 0; +inp[22338] = 860251829; +inp[22339] = 0; +inp[22340] = 859412149; +inp[22341] = 0; +inp[22342] = 858573289; +inp[22343] = 0; +inp[22344] = 857735248; +inp[22345] = 0; +inp[22346] = 856898025; +inp[22347] = 0; +inp[22348] = 856061619; +inp[22349] = 0; +inp[22350] = 855226029; +inp[22351] = 0; +inp[22352] = 854391255; +inp[22353] = 0; +inp[22354] = 853557296; +inp[22355] = 0; +inp[22356] = 852724151; +inp[22357] = 0; +inp[22358] = 851891819; +inp[22359] = 0; +inp[22360] = 851060299; +inp[22361] = 0; +inp[22362] = 850229592; +inp[22363] = 0; +inp[22364] = 849399695; +inp[22365] = 0; +inp[22366] = 848570608; +inp[22367] = 0; +inp[22368] = 847742330; +inp[22369] = 0; +inp[22370] = 846914861; +inp[22371] = 0; +inp[22372] = 846088199; +inp[22373] = 0; +inp[22374] = 845262344; +inp[22375] = 0; +inp[22376] = 844437296; +inp[22377] = 0; +inp[22378] = 843613052; +inp[22379] = 0; +inp[22380] = 842789614; +inp[22381] = 0; +inp[22382] = 841966979; +inp[22383] = 0; +inp[22384] = 841145147; +inp[22385] = 0; +inp[22386] = 840324117; +inp[22387] = 0; +inp[22388] = 839503888; +inp[22389] = 0; +inp[22390] = 838684460; +inp[22391] = 0; +inp[22392] = 837865832; +inp[22393] = 0; +inp[22394] = 837048004; +inp[22395] = 0; +inp[22396] = 1073741824; +inp[22397] = 1073741824; +inp[22398] = 1073217663; +inp[22399] = 0; +inp[22400] = 1072693759; +inp[22401] = 0; +inp[22402] = 1072170111; +inp[22403] = 0; +inp[22404] = 1071646718; +inp[22405] = 0; +inp[22406] = 1071123581; +inp[22407] = 0; +inp[22408] = 1070600699; +inp[22409] = 0; +inp[22410] = 1070078072; +inp[22411] = 0; +inp[22412] = 1069555701; +inp[22413] = 0; +inp[22414] = 1069033584; +inp[22415] = 0; +inp[22416] = 1068511723; +inp[22417] = 0; +inp[22418] = 1067990116; +inp[22419] = 0; +inp[22420] = 1067468764; +inp[22421] = 0; +inp[22422] = 1066947666; +inp[22423] = 0; +inp[22424] = 1066426822; +inp[22425] = 0; +inp[22426] = 1065906233; +inp[22427] = 0; +inp[22428] = 1065385898; +inp[22429] = 0; +inp[22430] = 1064865817; +inp[22431] = 0; +inp[22432] = 1064345990; +inp[22433] = 0; +inp[22434] = 1063826417; +inp[22435] = 0; +inp[22436] = 1063307097; +inp[22437] = 0; +inp[22438] = 1062788031; +inp[22439] = 0; +inp[22440] = 1062269218; +inp[22441] = 0; +inp[22442] = 1061750659; +inp[22443] = 0; +inp[22444] = 1061232352; +inp[22445] = 0; +inp[22446] = 1060714299; +inp[22447] = 0; +inp[22448] = 1060196498; +inp[22449] = 0; +inp[22450] = 1059678951; +inp[22451] = 0; +inp[22452] = 1059161656; +inp[22453] = 0; +inp[22454] = 1058644613; +inp[22455] = 0; +inp[22456] = 1058127823; +inp[22457] = 0; +inp[22458] = 1057611285; +inp[22459] = 0; +inp[22460] = 1057094999; +inp[22461] = 0; +inp[22462] = 1056578966; +inp[22463] = 0; +inp[22464] = 1056063184; +inp[22465] = 0; +inp[22466] = 1055547654; +inp[22467] = 0; +inp[22468] = 1055032376; +inp[22469] = 0; +inp[22470] = 1054517349; +inp[22471] = 0; +inp[22472] = 1054002574; +inp[22473] = 0; +inp[22474] = 1053488050; +inp[22475] = 0; +inp[22476] = 1052973777; +inp[22477] = 0; +inp[22478] = 1052459755; +inp[22479] = 0; +inp[22480] = 1051945984; +inp[22481] = 0; +inp[22482] = 1051432464; +inp[22483] = 0; +inp[22484] = 1050919194; +inp[22485] = 0; +inp[22486] = 1050406175; +inp[22487] = 0; +inp[22488] = 1049893407; +inp[22489] = 0; +inp[22490] = 1049380889; +inp[22491] = 0; +inp[22492] = 1048868621; +inp[22493] = 0; +inp[22494] = 1048356603; +inp[22495] = 0; +inp[22496] = 1047844835; +inp[22497] = 0; +inp[22498] = 1047333317; +inp[22499] = 0; +inp[22500] = 1046822049; +inp[22501] = 0; +inp[22502] = 1046311030; +inp[22503] = 0; +inp[22504] = 1045800261; +inp[22505] = 0; +inp[22506] = 1045289741; +inp[22507] = 0; +inp[22508] = 1044779470; +inp[22509] = 0; +inp[22510] = 1044269448; +inp[22511] = 0; +inp[22512] = 1043759675; +inp[22513] = 0; +inp[22514] = 1043250151; +inp[22515] = 0; +inp[22516] = 1042740876; +inp[22517] = 0; +inp[22518] = 1042231850; +inp[22519] = 0; +inp[22520] = 1041723072; +inp[22521] = 0; +inp[22522] = 1041214542; +inp[22523] = 0; +inp[22524] = 1040706261; +inp[22525] = 0; +inp[22526] = 1040198227; +inp[22527] = 0; +inp[22528] = 1039690442; +inp[22529] = 0; +inp[22530] = 1039182905; +inp[22531] = 0; +inp[22532] = 1038675615; +inp[22533] = 0; +inp[22534] = 1038168573; +inp[22535] = 0; +inp[22536] = 1037661778; +inp[22537] = 0; +inp[22538] = 1037155231; +inp[22539] = 0; +inp[22540] = 1036648931; +inp[22541] = 0; +inp[22542] = 1036142879; +inp[22543] = 0; +inp[22544] = 1035637073; +inp[22545] = 0; +inp[22546] = 1035131514; +inp[22547] = 0; +inp[22548] = 1034626202; +inp[22549] = 0; +inp[22550] = 1034121137; +inp[22551] = 0; +inp[22552] = 1033616318; +inp[22553] = 0; +inp[22554] = 1033111746; +inp[22555] = 0; +inp[22556] = 1032607420; +inp[22557] = 0; +inp[22558] = 1032103340; +inp[22559] = 0; +inp[22560] = 1031599507; +inp[22561] = 0; +inp[22562] = 1031095919; +inp[22563] = 0; +inp[22564] = 1030592577; +inp[22565] = 0; +inp[22566] = 1030089481; +inp[22567] = 0; +inp[22568] = 1029586630; +inp[22569] = 0; +inp[22570] = 1029084025; +inp[22571] = 0; +inp[22572] = 1028581665; +inp[22573] = 0; +inp[22574] = 1028079551; +inp[22575] = 0; +inp[22576] = 1027577681; +inp[22577] = 0; +inp[22578] = 1027076057; +inp[22579] = 0; +inp[22580] = 1026574677; +inp[22581] = 0; +inp[22582] = 1026073543; +inp[22583] = 0; +inp[22584] = 1025572652; +inp[22585] = 0; +inp[22586] = 1025072007; +inp[22587] = 0; +inp[22588] = 1024571605; +inp[22589] = 0; +inp[22590] = 1024071449; +inp[22591] = 0; +inp[22592] = 1023571536; +inp[22593] = 0; +inp[22594] = 1023071867; +inp[22595] = 0; +inp[22596] = 1022572442; +inp[22597] = 0; +inp[22598] = 1022073261; +inp[22599] = 0; +inp[22600] = 1021574324; +inp[22601] = 0; +inp[22602] = 1021075630; +inp[22603] = 0; +inp[22604] = 1020577179; +inp[22605] = 0; +inp[22606] = 1020078972; +inp[22607] = 0; +inp[22608] = 1019581008; +inp[22609] = 0; +inp[22610] = 1019083288; +inp[22611] = 0; +inp[22612] = 1018585810; +inp[22613] = 0; +inp[22614] = 1018088575; +inp[22615] = 0; +inp[22616] = 1017591583; +inp[22617] = 0; +inp[22618] = 1017094833; +inp[22619] = 0; +inp[22620] = 1016598326; +inp[22621] = 0; +inp[22622] = 1016102061; +inp[22623] = 0; +inp[22624] = 1015606039; +inp[22625] = 0; +inp[22626] = 1015110258; +inp[22627] = 0; +inp[22628] = 1014614720; +inp[22629] = 0; +inp[22630] = 1014119424; +inp[22631] = 0; +inp[22632] = 1013624369; +inp[22633] = 0; +inp[22634] = 1013129556; +inp[22635] = 0; +inp[22636] = 1012634985; +inp[22637] = 0; +inp[22638] = 1012140655; +inp[22639] = 0; +inp[22640] = 1011646566; +inp[22641] = 0; +inp[22642] = 1011152719; +inp[22643] = 0; +inp[22644] = 1010659112; +inp[22645] = 0; +inp[22646] = 1010165747; +inp[22647] = 0; +inp[22648] = 1009672622; +inp[22649] = 0; +inp[22650] = 1009179738; +inp[22651] = 0; +inp[22652] = 1008687095; +inp[22653] = 0; +inp[22654] = 1008194692; +inp[22655] = 0; +inp[22656] = 1007702530; +inp[22657] = 0; +inp[22658] = 1007210608; +inp[22659] = 0; +inp[22660] = 1006718926; +inp[22661] = 0; +inp[22662] = 1006227484; +inp[22663] = 0; +inp[22664] = 1005736282; +inp[22665] = 0; +inp[22666] = 1005245319; +inp[22667] = 0; +inp[22668] = 1004754597; +inp[22669] = 0; +inp[22670] = 1004264114; +inp[22671] = 0; +inp[22672] = 1003773870; +inp[22673] = 0; +inp[22674] = 1003283866; +inp[22675] = 0; +inp[22676] = 1002794101; +inp[22677] = 0; +inp[22678] = 1002304575; +inp[22679] = 0; +inp[22680] = 1001815287; +inp[22681] = 0; +inp[22682] = 1001326239; +inp[22683] = 0; +inp[22684] = 1000837430; +inp[22685] = 0; +inp[22686] = 1000348859; +inp[22687] = 0; +inp[22688] = 999860527; +inp[22689] = 0; +inp[22690] = 999372433; +inp[22691] = 0; +inp[22692] = 998884577; +inp[22693] = 0; +inp[22694] = 998396959; +inp[22695] = 0; +inp[22696] = 997909580; +inp[22697] = 0; +inp[22698] = 997422438; +inp[22699] = 0; +inp[22700] = 996935534; +inp[22701] = 0; +inp[22702] = 996448868; +inp[22703] = 0; +inp[22704] = 995962440; +inp[22705] = 0; +inp[22706] = 995476249; +inp[22707] = 0; +inp[22708] = 994990295; +inp[22709] = 0; +inp[22710] = 994504578; +inp[22711] = 0; +inp[22712] = 994019099; +inp[22713] = 0; +inp[22714] = 993533857; +inp[22715] = 0; +inp[22716] = 993048851; +inp[22717] = 0; +inp[22718] = 992564082; +inp[22719] = 0; +inp[22720] = 992079550; +inp[22721] = 0; +inp[22722] = 991595255; +inp[22723] = 0; +inp[22724] = 991111195; +inp[22725] = 0; +inp[22726] = 990627373; +inp[22727] = 0; +inp[22728] = 990143786; +inp[22729] = 0; +inp[22730] = 989660435; +inp[22731] = 0; +inp[22732] = 989177321; +inp[22733] = 0; +inp[22734] = 988694442; +inp[22735] = 0; +inp[22736] = 988211799; +inp[22737] = 0; +inp[22738] = 987729391; +inp[22739] = 0; +inp[22740] = 987247219; +inp[22741] = 0; +inp[22742] = 986765282; +inp[22743] = 0; +inp[22744] = 986283581; +inp[22745] = 0; +inp[22746] = 985802115; +inp[22747] = 0; +inp[22748] = 985320884; +inp[22749] = 0; +inp[22750] = 984839887; +inp[22751] = 0; +inp[22752] = 984359126; +inp[22753] = 0; +inp[22754] = 983878599; +inp[22755] = 0; +inp[22756] = 983398307; +inp[22757] = 0; +inp[22758] = 982918249; +inp[22759] = 0; +inp[22760] = 982438426; +inp[22761] = 0; +inp[22762] = 981958837; +inp[22763] = 0; +inp[22764] = 981479482; +inp[22765] = 0; +inp[22766] = 981000361; +inp[22767] = 0; +inp[22768] = 980521473; +inp[22769] = 0; +inp[22770] = 980042820; +inp[22771] = 0; +inp[22772] = 979564400; +inp[22773] = 0; +inp[22774] = 979086214; +inp[22775] = 0; +inp[22776] = 978608261; +inp[22777] = 0; +inp[22778] = 978130542; +inp[22779] = 0; +inp[22780] = 977653056; +inp[22781] = 0; +inp[22782] = 977175803; +inp[22783] = 0; +inp[22784] = 976698782; +inp[22785] = 0; +inp[22786] = 976221995; +inp[22787] = 0; +inp[22788] = 975745441; +inp[22789] = 0; +inp[22790] = 975269119; +inp[22791] = 0; +inp[22792] = 974793029; +inp[22793] = 0; +inp[22794] = 974317172; +inp[22795] = 0; +inp[22796] = 973841548; +inp[22797] = 0; +inp[22798] = 973366155; +inp[22799] = 0; +inp[22800] = 972890995; +inp[22801] = 0; +inp[22802] = 972416066; +inp[22803] = 0; +inp[22804] = 971941370; +inp[22805] = 0; +inp[22806] = 971466905; +inp[22807] = 0; +inp[22808] = 970992671; +inp[22809] = 0; +inp[22810] = 970518670; +inp[22811] = 0; +inp[22812] = 970044899; +inp[22813] = 0; +inp[22814] = 969571360; +inp[22815] = 0; +inp[22816] = 969098052; +inp[22817] = 0; +inp[22818] = 968624975; +inp[22819] = 0; +inp[22820] = 968152129; +inp[22821] = 0; +inp[22822] = 967679514; +inp[22823] = 0; +inp[22824] = 967207130; +inp[22825] = 0; +inp[22826] = 966734976; +inp[22827] = 0; +inp[22828] = 966263053; +inp[22829] = 0; +inp[22830] = 965791360; +inp[22831] = 0; +inp[22832] = 965319897; +inp[22833] = 0; +inp[22834] = 964848664; +inp[22835] = 0; +inp[22836] = 964377662; +inp[22837] = 0; +inp[22838] = 963906889; +inp[22839] = 0; +inp[22840] = 963436347; +inp[22841] = 0; +inp[22842] = 962966033; +inp[22843] = 0; +inp[22844] = 962495950; +inp[22845] = 0; +inp[22846] = 962026096; +inp[22847] = 0; +inp[22848] = 961556471; +inp[22849] = 0; +inp[22850] = 961087076; +inp[22851] = 0; +inp[22852] = 960617910; +inp[22853] = 0; +inp[22854] = 960148972; +inp[22855] = 0; +inp[22856] = 959680264; +inp[22857] = 0; +inp[22858] = 959211785; +inp[22859] = 0; +inp[22860] = 958743534; +inp[22861] = 0; +inp[22862] = 958275512; +inp[22863] = 0; +inp[22864] = 957807718; +inp[22865] = 0; +inp[22866] = 957340153; +inp[22867] = 0; +inp[22868] = 956872815; +inp[22869] = 0; +inp[22870] = 956405706; +inp[22871] = 0; +inp[22872] = 955938825; +inp[22873] = 0; +inp[22874] = 955472172; +inp[22875] = 0; +inp[22876] = 955005747; +inp[22877] = 0; +inp[22878] = 954539549; +inp[22879] = 0; +inp[22880] = 954073579; +inp[22881] = 0; +inp[22882] = 953607837; +inp[22883] = 0; +inp[22884] = 953142322; +inp[22885] = 0; +inp[22886] = 952677034; +inp[22887] = 0; +inp[22888] = 952211973; +inp[22889] = 0; +inp[22890] = 951747139; +inp[22891] = 0; +inp[22892] = 951282532; +inp[22893] = 0; +inp[22894] = 950818152; +inp[22895] = 0; +inp[22896] = 950353999; +inp[22897] = 0; +inp[22898] = 949890072; +inp[22899] = 0; +inp[22900] = 949426372; +inp[22901] = 0; +inp[22902] = 948962898; +inp[22903] = 0; +inp[22904] = 948499650; +inp[22905] = 0; +inp[22906] = 948036629; +inp[22907] = 0; +inp[22908] = 1073741824; +inp[22909] = 1073741824; +inp[22910] = 1073479711; +inp[22911] = 0; +inp[22912] = 1073217663; +inp[22913] = 0; +inp[22914] = 1072955679; +inp[22915] = 0; +inp[22916] = 1072693759; +inp[22917] = 0; +inp[22918] = 1072431903; +inp[22919] = 0; +inp[22920] = 1072170111; +inp[22921] = 0; +inp[22922] = 1071908383; +inp[22923] = 0; +inp[22924] = 1071646718; +inp[22925] = 0; +inp[22926] = 1071385118; +inp[22927] = 0; +inp[22928] = 1071123581; +inp[22929] = 0; +inp[22930] = 1070862108; +inp[22931] = 0; +inp[22932] = 1070600699; +inp[22933] = 0; +inp[22934] = 1070339354; +inp[22935] = 0; +inp[22936] = 1070078072; +inp[22937] = 0; +inp[22938] = 1069816855; +inp[22939] = 0; +inp[22940] = 1069555701; +inp[22941] = 0; +inp[22942] = 1069294611; +inp[22943] = 0; +inp[22944] = 1069033584; +inp[22945] = 0; +inp[22946] = 1068772622; +inp[22947] = 0; +inp[22948] = 1068511723; +inp[22949] = 0; +inp[22950] = 1068250887; +inp[22951] = 0; +inp[22952] = 1067990116; +inp[22953] = 0; +inp[22954] = 1067729408; +inp[22955] = 0; +inp[22956] = 1067468764; +inp[22957] = 0; +inp[22958] = 1067208183; +inp[22959] = 0; +inp[22960] = 1066947666; +inp[22961] = 0; +inp[22962] = 1066687212; +inp[22963] = 0; +inp[22964] = 1066426822; +inp[22965] = 0; +inp[22966] = 1066166496; +inp[22967] = 0; +inp[22968] = 1065906233; +inp[22969] = 0; +inp[22970] = 1065646034; +inp[22971] = 0; +inp[22972] = 1065385898; +inp[22973] = 0; +inp[22974] = 1065125826; +inp[22975] = 0; +inp[22976] = 1064865817; +inp[22977] = 0; +inp[22978] = 1064605872; +inp[22979] = 0; +inp[22980] = 1064345990; +inp[22981] = 0; +inp[22982] = 1064086172; +inp[22983] = 0; +inp[22984] = 1063826417; +inp[22985] = 0; +inp[22986] = 1063566725; +inp[22987] = 0; +inp[22988] = 1063307097; +inp[22989] = 0; +inp[22990] = 1063047532; +inp[22991] = 0; +inp[22992] = 1062788031; +inp[22993] = 0; +inp[22994] = 1062528593; +inp[22995] = 0; +inp[22996] = 1062269218; +inp[22997] = 0; +inp[22998] = 1062009907; +inp[22999] = 0; +inp[23000] = 1061750659; +inp[23001] = 0; +inp[23002] = 1061491474; +inp[23003] = 0; +inp[23004] = 1061232352; +inp[23005] = 0; +inp[23006] = 1060973294; +inp[23007] = 0; +inp[23008] = 1060714299; +inp[23009] = 0; +inp[23010] = 1060455367; +inp[23011] = 0; +inp[23012] = 1060196498; +inp[23013] = 0; +inp[23014] = 1059937693; +inp[23015] = 0; +inp[23016] = 1059678951; +inp[23017] = 0; +inp[23018] = 1059420272; +inp[23019] = 0; +inp[23020] = 1059161656; +inp[23021] = 0; +inp[23022] = 1058903103; +inp[23023] = 0; +inp[23024] = 1058644613; +inp[23025] = 0; +inp[23026] = 1058386187; +inp[23027] = 0; +inp[23028] = 1058127823; +inp[23029] = 0; +inp[23030] = 1057869523; +inp[23031] = 0; +inp[23032] = 1057611285; +inp[23033] = 0; +inp[23034] = 1057353111; +inp[23035] = 0; +inp[23036] = 1057094999; +inp[23037] = 0; +inp[23038] = 1056836951; +inp[23039] = 0; +inp[23040] = 1056578966; +inp[23041] = 0; +inp[23042] = 1056321043; +inp[23043] = 0; +inp[23044] = 1056063184; +inp[23045] = 0; +inp[23046] = 1055805388; +inp[23047] = 0; +inp[23048] = 1055547654; +inp[23049] = 0; +inp[23050] = 1055289983; +inp[23051] = 0; +inp[23052] = 1055032376; +inp[23053] = 0; +inp[23054] = 1054774831; +inp[23055] = 0; +inp[23056] = 1054517349; +inp[23057] = 0; +inp[23058] = 1054259930; +inp[23059] = 0; +inp[23060] = 1054002574; +inp[23061] = 0; +inp[23062] = 1053745280; +inp[23063] = 0; +inp[23064] = 1053488050; +inp[23065] = 0; +inp[23066] = 1053230882; +inp[23067] = 0; +inp[23068] = 1052973777; +inp[23069] = 0; +inp[23070] = 1052716734; +inp[23071] = 0; +inp[23072] = 1052459755; +inp[23073] = 0; +inp[23074] = 1052202838; +inp[23075] = 0; +inp[23076] = 1051945984; +inp[23077] = 0; +inp[23078] = 1051689192; +inp[23079] = 0; +inp[23080] = 1051432464; +inp[23081] = 0; +inp[23082] = 1051175798; +inp[23083] = 0; +inp[23084] = 1050919194; +inp[23085] = 0; +inp[23086] = 1050662654; +inp[23087] = 0; +inp[23088] = 1050406175; +inp[23089] = 0; +inp[23090] = 1050149760; +inp[23091] = 0; +inp[23092] = 1049893407; +inp[23093] = 0; +inp[23094] = 1049637117; +inp[23095] = 0; +inp[23096] = 1049380889; +inp[23097] = 0; +inp[23098] = 1049124724; +inp[23099] = 0; +inp[23100] = 1048868621; +inp[23101] = 0; +inp[23102] = 1048612581; +inp[23103] = 0; +inp[23104] = 1048356603; +inp[23105] = 0; +inp[23106] = 1048100688; +inp[23107] = 0; +inp[23108] = 1047844835; +inp[23109] = 0; +inp[23110] = 1047589045; +inp[23111] = 0; +inp[23112] = 1047333317; +inp[23113] = 0; +inp[23114] = 1047077652; +inp[23115] = 0; +inp[23116] = 1046822049; +inp[23117] = 0; +inp[23118] = 1046566508; +inp[23119] = 0; +inp[23120] = 1046311030; +inp[23121] = 0; +inp[23122] = 1046055614; +inp[23123] = 0; +inp[23124] = 1045800261; +inp[23125] = 0; +inp[23126] = 1045544969; +inp[23127] = 0; +inp[23128] = 1045289741; +inp[23129] = 0; +inp[23130] = 1045034574; +inp[23131] = 0; +inp[23132] = 1044779470; +inp[23133] = 0; +inp[23134] = 1044524428; +inp[23135] = 0; +inp[23136] = 1044269448; +inp[23137] = 0; +inp[23138] = 1044014531; +inp[23139] = 0; +inp[23140] = 1043759675; +inp[23141] = 0; +inp[23142] = 1043504882; +inp[23143] = 0; +inp[23144] = 1043250151; +inp[23145] = 0; +inp[23146] = 1042995483; +inp[23147] = 0; +inp[23148] = 1042740876; +inp[23149] = 0; +inp[23150] = 1042486332; +inp[23151] = 0; +inp[23152] = 1042231850; +inp[23153] = 0; +inp[23154] = 1041977430; +inp[23155] = 0; +inp[23156] = 1041723072; +inp[23157] = 0; +inp[23158] = 1041468776; +inp[23159] = 0; +inp[23160] = 1041214542; +inp[23161] = 0; +inp[23162] = 1040960370; +inp[23163] = 0; +inp[23164] = 1040706261; +inp[23165] = 0; +inp[23166] = 1040452213; +inp[23167] = 0; +inp[23168] = 1040198227; +inp[23169] = 0; +inp[23170] = 1039944304; +inp[23171] = 0; +inp[23172] = 1039690442; +inp[23173] = 0; +inp[23174] = 1039436642; +inp[23175] = 0; +inp[23176] = 1039182905; +inp[23177] = 0; +inp[23178] = 1038929229; +inp[23179] = 0; +inp[23180] = 1038675615; +inp[23181] = 0; +inp[23182] = 1038422063; +inp[23183] = 0; +inp[23184] = 1038168573; +inp[23185] = 0; +inp[23186] = 1037915145; +inp[23187] = 0; +inp[23188] = 1037661778; +inp[23189] = 0; +inp[23190] = 1037408474; +inp[23191] = 0; +inp[23192] = 1037155231; +inp[23193] = 0; +inp[23194] = 1036902050; +inp[23195] = 0; +inp[23196] = 1036648931; +inp[23197] = 0; +inp[23198] = 1036395874; +inp[23199] = 0; +inp[23200] = 1036142879; +inp[23201] = 0; +inp[23202] = 1035889945; +inp[23203] = 0; +inp[23204] = 1035637073; +inp[23205] = 0; +inp[23206] = 1035384263; +inp[23207] = 0; +inp[23208] = 1035131514; +inp[23209] = 0; +inp[23210] = 1034878828; +inp[23211] = 0; +inp[23212] = 1034626202; +inp[23213] = 0; +inp[23214] = 1034373639; +inp[23215] = 0; +inp[23216] = 1034121137; +inp[23217] = 0; +inp[23218] = 1033868697; +inp[23219] = 0; +inp[23220] = 1033616318; +inp[23221] = 0; +inp[23222] = 1033364001; +inp[23223] = 0; +inp[23224] = 1033111746; +inp[23225] = 0; +inp[23226] = 1032859552; +inp[23227] = 0; +inp[23228] = 1032607420; +inp[23229] = 0; +inp[23230] = 1032355350; +inp[23231] = 0; +inp[23232] = 1032103340; +inp[23233] = 0; +inp[23234] = 1031851393; +inp[23235] = 0; +inp[23236] = 1031599507; +inp[23237] = 0; +inp[23238] = 1031347682; +inp[23239] = 0; +inp[23240] = 1031095919; +inp[23241] = 0; +inp[23242] = 1030844217; +inp[23243] = 0; +inp[23244] = 1030592577; +inp[23245] = 0; +inp[23246] = 1030340998; +inp[23247] = 0; +inp[23248] = 1030089481; +inp[23249] = 0; +inp[23250] = 1029838025; +inp[23251] = 0; +inp[23252] = 1029586630; +inp[23253] = 0; +inp[23254] = 1029335297; +inp[23255] = 0; +inp[23256] = 1029084025; +inp[23257] = 0; +inp[23258] = 1028832815; +inp[23259] = 0; +inp[23260] = 1028581665; +inp[23261] = 0; +inp[23262] = 1028330577; +inp[23263] = 0; +inp[23264] = 1028079551; +inp[23265] = 0; +inp[23266] = 1027828585; +inp[23267] = 0; +inp[23268] = 1027577681; +inp[23269] = 0; +inp[23270] = 1027326839; +inp[23271] = 0; +inp[23272] = 1027076057; +inp[23273] = 0; +inp[23274] = 1026825337; +inp[23275] = 0; +inp[23276] = 1026574677; +inp[23277] = 0; +inp[23278] = 1026324079; +inp[23279] = 0; +inp[23280] = 1026073543; +inp[23281] = 0; +inp[23282] = 1025823067; +inp[23283] = 0; +inp[23284] = 1025572652; +inp[23285] = 0; +inp[23286] = 1025322299; +inp[23287] = 0; +inp[23288] = 1025072007; +inp[23289] = 0; +inp[23290] = 1024821776; +inp[23291] = 0; +inp[23292] = 1024571605; +inp[23293] = 0; +inp[23294] = 1024321496; +inp[23295] = 0; +inp[23296] = 1024071449; +inp[23297] = 0; +inp[23298] = 1023821462; +inp[23299] = 0; +inp[23300] = 1023571536; +inp[23301] = 0; +inp[23302] = 1023321671; +inp[23303] = 0; +inp[23304] = 1023071867; +inp[23305] = 0; +inp[23306] = 1022822124; +inp[23307] = 0; +inp[23308] = 1022572442; +inp[23309] = 0; +inp[23310] = 1022322821; +inp[23311] = 0; +inp[23312] = 1022073261; +inp[23313] = 0; +inp[23314] = 1021823762; +inp[23315] = 0; +inp[23316] = 1021574324; +inp[23317] = 0; +inp[23318] = 1021324946; +inp[23319] = 0; +inp[23320] = 1021075630; +inp[23321] = 0; +inp[23322] = 1020826374; +inp[23323] = 0; +inp[23324] = 1020577179; +inp[23325] = 0; +inp[23326] = 1020328045; +inp[23327] = 0; +inp[23328] = 1020078972; +inp[23329] = 0; +inp[23330] = 1019829960; +inp[23331] = 0; +inp[23332] = 1019581008; +inp[23333] = 0; +inp[23334] = 1019332118; +inp[23335] = 0; +inp[23336] = 1019083288; +inp[23337] = 0; +inp[23338] = 1018834518; +inp[23339] = 0; +inp[23340] = 1018585810; +inp[23341] = 0; +inp[23342] = 1018337162; +inp[23343] = 0; +inp[23344] = 1018088575; +inp[23345] = 0; +inp[23346] = 1017840048; +inp[23347] = 0; +inp[23348] = 1017591583; +inp[23349] = 0; +inp[23350] = 1017343178; +inp[23351] = 0; +inp[23352] = 1017094833; +inp[23353] = 0; +inp[23354] = 1016846549; +inp[23355] = 0; +inp[23356] = 1016598326; +inp[23357] = 0; +inp[23358] = 1016350163; +inp[23359] = 0; +inp[23360] = 1016102061; +inp[23361] = 0; +inp[23362] = 1015854020; +inp[23363] = 0; +inp[23364] = 1015606039; +inp[23365] = 0; +inp[23366] = 1015358118; +inp[23367] = 0; +inp[23368] = 1015110258; +inp[23369] = 0; +inp[23370] = 1014862459; +inp[23371] = 0; +inp[23372] = 1014614720; +inp[23373] = 0; +inp[23374] = 1014367042; +inp[23375] = 0; +inp[23376] = 1014119424; +inp[23377] = 0; +inp[23378] = 1013871866; +inp[23379] = 0; +inp[23380] = 1013624369; +inp[23381] = 0; +inp[23382] = 1013376932; +inp[23383] = 0; +inp[23384] = 1013129556; +inp[23385] = 0; +inp[23386] = 1012882240; +inp[23387] = 0; +inp[23388] = 1012634985; +inp[23389] = 0; +inp[23390] = 1012387790; +inp[23391] = 0; +inp[23392] = 1012140655; +inp[23393] = 0; +inp[23394] = 1011893580; +inp[23395] = 0; +inp[23396] = 1011646566; +inp[23397] = 0; +inp[23398] = 1011399612; +inp[23399] = 0; +inp[23400] = 1011152719; +inp[23401] = 0; +inp[23402] = 1010905885; +inp[23403] = 0; +inp[23404] = 1010659112; +inp[23405] = 0; +inp[23406] = 1010412399; +inp[23407] = 0; +inp[23408] = 1010165747; +inp[23409] = 0; +inp[23410] = 1009919154; +inp[23411] = 0; +inp[23412] = 1009672622; +inp[23413] = 0; +inp[23414] = 1009426150; +inp[23415] = 0; +inp[23416] = 1009179738; +inp[23417] = 0; +inp[23418] = 1008933387; +inp[23419] = 0; +inp[23420] = 1073741824; +inp[23421] = 1073741824; +inp[23422] = 1073610759; +inp[23423] = 0; +inp[23424] = 1073479711; +inp[23425] = 0; +inp[23426] = 1073348679; +inp[23427] = 0; +inp[23428] = 1073217663; +inp[23429] = 0; +inp[23430] = 1073086663; +inp[23431] = 0; +inp[23432] = 1072955679; +inp[23433] = 0; +inp[23434] = 1072824711; +inp[23435] = 0; +inp[23436] = 1072693759; +inp[23437] = 0; +inp[23438] = 1072562823; +inp[23439] = 0; +inp[23440] = 1072431903; +inp[23441] = 0; +inp[23442] = 1072300999; +inp[23443] = 0; +inp[23444] = 1072170111; +inp[23445] = 0; +inp[23446] = 1072039239; +inp[23447] = 0; +inp[23448] = 1071908383; +inp[23449] = 0; +inp[23450] = 1071777542; +inp[23451] = 0; +inp[23452] = 1071646718; +inp[23453] = 0; +inp[23454] = 1071515910; +inp[23455] = 0; +inp[23456] = 1071385118; +inp[23457] = 0; +inp[23458] = 1071254341; +inp[23459] = 0; +inp[23460] = 1071123581; +inp[23461] = 0; +inp[23462] = 1070992836; +inp[23463] = 0; +inp[23464] = 1070862108; +inp[23465] = 0; +inp[23466] = 1070731396; +inp[23467] = 0; +inp[23468] = 1070600699; +inp[23469] = 0; +inp[23470] = 1070470018; +inp[23471] = 0; +inp[23472] = 1070339354; +inp[23473] = 0; +inp[23474] = 1070208705; +inp[23475] = 0; +inp[23476] = 1070078072; +inp[23477] = 0; +inp[23478] = 1069947456; +inp[23479] = 0; +inp[23480] = 1069816855; +inp[23481] = 0; +inp[23482] = 1069686270; +inp[23483] = 0; +inp[23484] = 1069555701; +inp[23485] = 0; +inp[23486] = 1069425148; +inp[23487] = 0; +inp[23488] = 1069294611; +inp[23489] = 0; +inp[23490] = 1069164090; +inp[23491] = 0; +inp[23492] = 1069033584; +inp[23493] = 0; +inp[23494] = 1068903095; +inp[23495] = 0; +inp[23496] = 1068772622; +inp[23497] = 0; +inp[23498] = 1068642164; +inp[23499] = 0; +inp[23500] = 1068511723; +inp[23501] = 0; +inp[23502] = 1068381297; +inp[23503] = 0; +inp[23504] = 1068250887; +inp[23505] = 0; +inp[23506] = 1068120494; +inp[23507] = 0; +inp[23508] = 1067990116; +inp[23509] = 0; +inp[23510] = 1067859754; +inp[23511] = 0; +inp[23512] = 1067729408; +inp[23513] = 0; +inp[23514] = 1067599078; +inp[23515] = 0; +inp[23516] = 1067468764; +inp[23517] = 0; +inp[23518] = 1067338465; +inp[23519] = 0; +inp[23520] = 1067208183; +inp[23521] = 0; +inp[23522] = 1067077916; +inp[23523] = 0; +inp[23524] = 1066947666; +inp[23525] = 0; +inp[23526] = 1066817431; +inp[23527] = 0; +inp[23528] = 1066687212; +inp[23529] = 0; +inp[23530] = 1066557009; +inp[23531] = 0; +inp[23532] = 1066426822; +inp[23533] = 0; +inp[23534] = 1066296651; +inp[23535] = 0; +inp[23536] = 1066166496; +inp[23537] = 0; +inp[23538] = 1066036357; +inp[23539] = 0; +inp[23540] = 1065906233; +inp[23541] = 0; +inp[23542] = 1065776126; +inp[23543] = 0; +inp[23544] = 1065646034; +inp[23545] = 0; +inp[23546] = 1065515958; +inp[23547] = 0; +inp[23548] = 1065385898; +inp[23549] = 0; +inp[23550] = 1065255854; +inp[23551] = 0; +inp[23552] = 1065125826; +inp[23553] = 0; +inp[23554] = 1064995814; +inp[23555] = 0; +inp[23556] = 1064865817; +inp[23557] = 0; +inp[23558] = 1064735837; +inp[23559] = 0; +inp[23560] = 1064605872; +inp[23561] = 0; +inp[23562] = 1064475923; +inp[23563] = 0; +inp[23564] = 1064345990; +inp[23565] = 0; +inp[23566] = 1064216073; +inp[23567] = 0; +inp[23568] = 1064086172; +inp[23569] = 0; +inp[23570] = 1063956286; +inp[23571] = 0; +inp[23572] = 1063826417; +inp[23573] = 0; +inp[23574] = 1063696563; +inp[23575] = 0; +inp[23576] = 1063566725; +inp[23577] = 0; +inp[23578] = 1063436903; +inp[23579] = 0; +inp[23580] = 1063307097; +inp[23581] = 0; +inp[23582] = 1063177307; +inp[23583] = 0; +inp[23584] = 1063047532; +inp[23585] = 0; +inp[23586] = 1062917774; +inp[23587] = 0; +inp[23588] = 1062788031; +inp[23589] = 0; +inp[23590] = 1062658304; +inp[23591] = 0; +inp[23592] = 1062528593; +inp[23593] = 0; +inp[23594] = 1062398898; +inp[23595] = 0; +inp[23596] = 1062269218; +inp[23597] = 0; +inp[23598] = 1062139555; +inp[23599] = 0; +inp[23600] = 1062009907; +inp[23601] = 0; +inp[23602] = 1061880275; +inp[23603] = 0; +inp[23604] = 1061750659; +inp[23605] = 0; +inp[23606] = 1061621058; +inp[23607] = 0; +inp[23608] = 1061491474; +inp[23609] = 0; +inp[23610] = 1061361905; +inp[23611] = 0; +inp[23612] = 1061232352; +inp[23613] = 0; +inp[23614] = 1061102815; +inp[23615] = 0; +inp[23616] = 1060973294; +inp[23617] = 0; +inp[23618] = 1060843789; +inp[23619] = 0; +inp[23620] = 1060714299; +inp[23621] = 0; +inp[23622] = 1060584825; +inp[23623] = 0; +inp[23624] = 1060455367; +inp[23625] = 0; +inp[23626] = 1060325925; +inp[23627] = 0; +inp[23628] = 1060196498; +inp[23629] = 0; +inp[23630] = 1060067088; +inp[23631] = 0; +inp[23632] = 1059937693; +inp[23633] = 0; +inp[23634] = 1059808314; +inp[23635] = 0; +inp[23636] = 1059678951; +inp[23637] = 0; +inp[23638] = 1059549603; +inp[23639] = 0; +inp[23640] = 1059420272; +inp[23641] = 0; +inp[23642] = 1059290956; +inp[23643] = 0; +inp[23644] = 1059161656; +inp[23645] = 0; +inp[23646] = 1059032371; +inp[23647] = 0; +inp[23648] = 1058903103; +inp[23649] = 0; +inp[23650] = 1058773850; +inp[23651] = 0; +inp[23652] = 1058644613; +inp[23653] = 0; +inp[23654] = 1058515392; +inp[23655] = 0; +inp[23656] = 1058386187; +inp[23657] = 0; +inp[23658] = 1058256997; +inp[23659] = 0; +inp[23660] = 1058127823; +inp[23661] = 0; +inp[23662] = 1057998665; +inp[23663] = 0; +inp[23664] = 1057869523; +inp[23665] = 0; +inp[23666] = 1057740396; +inp[23667] = 0; +inp[23668] = 1057611285; +inp[23669] = 0; +inp[23670] = 1057482190; +inp[23671] = 0; +inp[23672] = 1057353111; +inp[23673] = 0; +inp[23674] = 1057224047; +inp[23675] = 0; +inp[23676] = 1057094999; +inp[23677] = 0; +inp[23678] = 1056965967; +inp[23679] = 0; +inp[23680] = 1056836951; +inp[23681] = 0; +inp[23682] = 1056707951; +inp[23683] = 0; +inp[23684] = 1056578966; +inp[23685] = 0; +inp[23686] = 1056449997; +inp[23687] = 0; +inp[23688] = 1056321043; +inp[23689] = 0; +inp[23690] = 1056192106; +inp[23691] = 0; +inp[23692] = 1056063184; +inp[23693] = 0; +inp[23694] = 1055934278; +inp[23695] = 0; +inp[23696] = 1055805388; +inp[23697] = 0; +inp[23698] = 1055676513; +inp[23699] = 0; +inp[23700] = 1055547654; +inp[23701] = 0; +inp[23702] = 1055418811; +inp[23703] = 0; +inp[23704] = 1055289983; +inp[23705] = 0; +inp[23706] = 1055161172; +inp[23707] = 0; +inp[23708] = 1055032376; +inp[23709] = 0; +inp[23710] = 1054903595; +inp[23711] = 0; +inp[23712] = 1054774831; +inp[23713] = 0; +inp[23714] = 1054646082; +inp[23715] = 0; +inp[23716] = 1054517349; +inp[23717] = 0; +inp[23718] = 1054388632; +inp[23719] = 0; +inp[23720] = 1054259930; +inp[23721] = 0; +inp[23722] = 1054131244; +inp[23723] = 0; +inp[23724] = 1054002574; +inp[23725] = 0; +inp[23726] = 1053873919; +inp[23727] = 0; +inp[23728] = 1053745280; +inp[23729] = 0; +inp[23730] = 1053616657; +inp[23731] = 0; +inp[23732] = 1053488050; +inp[23733] = 0; +inp[23734] = 1053359458; +inp[23735] = 0; +inp[23736] = 1053230882; +inp[23737] = 0; +inp[23738] = 1053102321; +inp[23739] = 0; +inp[23740] = 1052973777; +inp[23741] = 0; +inp[23742] = 1052845248; +inp[23743] = 0; +inp[23744] = 1052716734; +inp[23745] = 0; +inp[23746] = 1052588237; +inp[23747] = 0; +inp[23748] = 1052459755; +inp[23749] = 0; +inp[23750] = 1052331289; +inp[23751] = 0; +inp[23752] = 1052202838; +inp[23753] = 0; +inp[23754] = 1052074403; +inp[23755] = 0; +inp[23756] = 1051945984; +inp[23757] = 0; +inp[23758] = 1051817580; +inp[23759] = 0; +inp[23760] = 1051689192; +inp[23761] = 0; +inp[23762] = 1051560820; +inp[23763] = 0; +inp[23764] = 1051432464; +inp[23765] = 0; +inp[23766] = 1051304123; +inp[23767] = 0; +inp[23768] = 1051175798; +inp[23769] = 0; +inp[23770] = 1051047488; +inp[23771] = 0; +inp[23772] = 1050919194; +inp[23773] = 0; +inp[23774] = 1050790916; +inp[23775] = 0; +inp[23776] = 1050662654; +inp[23777] = 0; +inp[23778] = 1050534407; +inp[23779] = 0; +inp[23780] = 1050406175; +inp[23781] = 0; +inp[23782] = 1050277960; +inp[23783] = 0; +inp[23784] = 1050149760; +inp[23785] = 0; +inp[23786] = 1050021576; +inp[23787] = 0; +inp[23788] = 1049893407; +inp[23789] = 0; +inp[23790] = 1049765254; +inp[23791] = 0; +inp[23792] = 1049637117; +inp[23793] = 0; +inp[23794] = 1049508995; +inp[23795] = 0; +inp[23796] = 1049380889; +inp[23797] = 0; +inp[23798] = 1049252798; +inp[23799] = 0; +inp[23800] = 1049124724; +inp[23801] = 0; +inp[23802] = 1048996664; +inp[23803] = 0; +inp[23804] = 1048868621; +inp[23805] = 0; +inp[23806] = 1048740593; +inp[23807] = 0; +inp[23808] = 1048612581; +inp[23809] = 0; +inp[23810] = 1048484584; +inp[23811] = 0; +inp[23812] = 1048356603; +inp[23813] = 0; +inp[23814] = 1048228638; +inp[23815] = 0; +inp[23816] = 1048100688; +inp[23817] = 0; +inp[23818] = 1047972754; +inp[23819] = 0; +inp[23820] = 1047844835; +inp[23821] = 0; +inp[23822] = 1047716932; +inp[23823] = 0; +inp[23824] = 1047589045; +inp[23825] = 0; +inp[23826] = 1047461173; +inp[23827] = 0; +inp[23828] = 1047333317; +inp[23829] = 0; +inp[23830] = 1047205477; +inp[23831] = 0; +inp[23832] = 1047077652; +inp[23833] = 0; +inp[23834] = 1046949842; +inp[23835] = 0; +inp[23836] = 1046822049; +inp[23837] = 0; +inp[23838] = 1046694271; +inp[23839] = 0; +inp[23840] = 1046566508; +inp[23841] = 0; +inp[23842] = 1046438761; +inp[23843] = 0; +inp[23844] = 1046311030; +inp[23845] = 0; +inp[23846] = 1046183314; +inp[23847] = 0; +inp[23848] = 1046055614; +inp[23849] = 0; +inp[23850] = 1045927929; +inp[23851] = 0; +inp[23852] = 1045800261; +inp[23853] = 0; +inp[23854] = 1045672607; +inp[23855] = 0; +inp[23856] = 1045544969; +inp[23857] = 0; +inp[23858] = 1045417347; +inp[23859] = 0; +inp[23860] = 1045289741; +inp[23861] = 0; +inp[23862] = 1045162149; +inp[23863] = 0; +inp[23864] = 1045034574; +inp[23865] = 0; +inp[23866] = 1044907014; +inp[23867] = 0; +inp[23868] = 1044779470; +inp[23869] = 0; +inp[23870] = 1044651941; +inp[23871] = 0; +inp[23872] = 1044524428; +inp[23873] = 0; +inp[23874] = 1044396930; +inp[23875] = 0; +inp[23876] = 1044269448; +inp[23877] = 0; +inp[23878] = 1044141981; +inp[23879] = 0; +inp[23880] = 1044014531; +inp[23881] = 0; +inp[23882] = 1043887095; +inp[23883] = 0; +inp[23884] = 1043759675; +inp[23885] = 0; +inp[23886] = 1043632271; +inp[23887] = 0; +inp[23888] = 1043504882; +inp[23889] = 0; +inp[23890] = 1043377509; +inp[23891] = 0; +inp[23892] = 1043250151; +inp[23893] = 0; +inp[23894] = 1043122809; +inp[23895] = 0; +inp[23896] = 1042995483; +inp[23897] = 0; +inp[23898] = 1042868172; +inp[23899] = 0; +inp[23900] = 1042740876; +inp[23901] = 0; +inp[23902] = 1042613596; +inp[23903] = 0; +inp[23904] = 1042486332; +inp[23905] = 0; +inp[23906] = 1042359083; +inp[23907] = 0; +inp[23908] = 1042231850; +inp[23909] = 0; +inp[23910] = 1042104632; +inp[23911] = 0; +inp[23912] = 1041977430; +inp[23913] = 0; +inp[23914] = 1041850243; +inp[23915] = 0; +inp[23916] = 1041723072; +inp[23917] = 0; +inp[23918] = 1041595916; +inp[23919] = 0; +inp[23920] = 1041468776; +inp[23921] = 0; +inp[23922] = 1041341651; +inp[23923] = 0; +inp[23924] = 1041214542; +inp[23925] = 0; +inp[23926] = 1041087448; +inp[23927] = 0; +inp[23928] = 1040960370; +inp[23929] = 0; +inp[23930] = 1040833308; +inp[23931] = 0; +inp[23932] = 1073741824; +inp[23933] = 1073741824; +inp[23934] = 1073676289; +inp[23935] = 0; +inp[23936] = 1073610759; +inp[23937] = 0; +inp[23938] = 1073545233; +inp[23939] = 0; +inp[23940] = 1073479711; +inp[23941] = 0; +inp[23942] = 1073414193; +inp[23943] = 0; +inp[23944] = 1073348679; +inp[23945] = 0; +inp[23946] = 1073283169; +inp[23947] = 0; +inp[23948] = 1073217663; +inp[23949] = 0; +inp[23950] = 1073152161; +inp[23951] = 0; +inp[23952] = 1073086663; +inp[23953] = 0; +inp[23954] = 1073021169; +inp[23955] = 0; +inp[23956] = 1072955679; +inp[23957] = 0; +inp[23958] = 1072890193; +inp[23959] = 0; +inp[23960] = 1072824711; +inp[23961] = 0; +inp[23962] = 1072759233; +inp[23963] = 0; +inp[23964] = 1072693759; +inp[23965] = 0; +inp[23966] = 1072628289; +inp[23967] = 0; +inp[23968] = 1072562823; +inp[23969] = 0; +inp[23970] = 1072497361; +inp[23971] = 0; +inp[23972] = 1072431903; +inp[23973] = 0; +inp[23974] = 1072366449; +inp[23975] = 0; +inp[23976] = 1072300999; +inp[23977] = 0; +inp[23978] = 1072235553; +inp[23979] = 0; +inp[23980] = 1072170111; +inp[23981] = 0; +inp[23982] = 1072104673; +inp[23983] = 0; +inp[23984] = 1072039239; +inp[23985] = 0; +inp[23986] = 1071973809; +inp[23987] = 0; +inp[23988] = 1071908383; +inp[23989] = 0; +inp[23990] = 1071842961; +inp[23991] = 0; +inp[23992] = 1071777542; +inp[23993] = 0; +inp[23994] = 1071712128; +inp[23995] = 0; +inp[23996] = 1071646718; +inp[23997] = 0; +inp[23998] = 1071581312; +inp[23999] = 0; +inp[24000] = 1071515910; +inp[24001] = 0; +inp[24002] = 1071450512; +inp[24003] = 0; +inp[24004] = 1071385118; +inp[24005] = 0; +inp[24006] = 1071319727; +inp[24007] = 0; +inp[24008] = 1071254341; +inp[24009] = 0; +inp[24010] = 1071188959; +inp[24011] = 0; +inp[24012] = 1071123581; +inp[24013] = 0; +inp[24014] = 1071058207; +inp[24015] = 0; +inp[24016] = 1070992836; +inp[24017] = 0; +inp[24018] = 1070927470; +inp[24019] = 0; +inp[24020] = 1070862108; +inp[24021] = 0; +inp[24022] = 1070796750; +inp[24023] = 0; +inp[24024] = 1070731396; +inp[24025] = 0; +inp[24026] = 1070666045; +inp[24027] = 0; +inp[24028] = 1070600699; +inp[24029] = 0; +inp[24030] = 1070535357; +inp[24031] = 0; +inp[24032] = 1070470018; +inp[24033] = 0; +inp[24034] = 1070404684; +inp[24035] = 0; +inp[24036] = 1070339354; +inp[24037] = 0; +inp[24038] = 1070274027; +inp[24039] = 0; +inp[24040] = 1070208705; +inp[24041] = 0; +inp[24042] = 1070143387; +inp[24043] = 0; +inp[24044] = 1070078072; +inp[24045] = 0; +inp[24046] = 1070012762; +inp[24047] = 0; +inp[24048] = 1069947456; +inp[24049] = 0; +inp[24050] = 1069882153; +inp[24051] = 0; +inp[24052] = 1069816855; +inp[24053] = 0; +inp[24054] = 1069751560; +inp[24055] = 0; +inp[24056] = 1069686270; +inp[24057] = 0; +inp[24058] = 1069620983; +inp[24059] = 0; +inp[24060] = 1069555701; +inp[24061] = 0; +inp[24062] = 1069490422; +inp[24063] = 0; +inp[24064] = 1069425148; +inp[24065] = 0; +inp[24066] = 1069359877; +inp[24067] = 0; +inp[24068] = 1069294611; +inp[24069] = 0; +inp[24070] = 1069229348; +inp[24071] = 0; +inp[24072] = 1069164090; +inp[24073] = 0; +inp[24074] = 1069098835; +inp[24075] = 0; +inp[24076] = 1069033584; +inp[24077] = 0; +inp[24078] = 1068968338; +inp[24079] = 0; +inp[24080] = 1068903095; +inp[24081] = 0; +inp[24082] = 1068837856; +inp[24083] = 0; +inp[24084] = 1068772622; +inp[24085] = 0; +inp[24086] = 1068707391; +inp[24087] = 0; +inp[24088] = 1068642164; +inp[24089] = 0; +inp[24090] = 1068576941; +inp[24091] = 0; +inp[24092] = 1068511723; +inp[24093] = 0; +inp[24094] = 1068446508; +inp[24095] = 0; +inp[24096] = 1068381297; +inp[24097] = 0; +inp[24098] = 1068316090; +inp[24099] = 0; +inp[24100] = 1068250887; +inp[24101] = 0; +inp[24102] = 1068185689; +inp[24103] = 0; +inp[24104] = 1068120494; +inp[24105] = 0; +inp[24106] = 1068055303; +inp[24107] = 0; +inp[24108] = 1067990116; +inp[24109] = 0; +inp[24110] = 1067924933; +inp[24111] = 0; +inp[24112] = 1067859754; +inp[24113] = 0; +inp[24114] = 1067794579; +inp[24115] = 0; +inp[24116] = 1067729408; +inp[24117] = 0; +inp[24118] = 1067664241; +inp[24119] = 0; +inp[24120] = 1067599078; +inp[24121] = 0; +inp[24122] = 1067533919; +inp[24123] = 0; +inp[24124] = 1067468764; +inp[24125] = 0; +inp[24126] = 1067403612; +inp[24127] = 0; +inp[24128] = 1067338465; +inp[24129] = 0; +inp[24130] = 1067273322; +inp[24131] = 0; +inp[24132] = 1067208183; +inp[24133] = 0; +inp[24134] = 1067143048; +inp[24135] = 0; +inp[24136] = 1067077916; +inp[24137] = 0; +inp[24138] = 1067012789; +inp[24139] = 0; +inp[24140] = 1066947666; +inp[24141] = 0; +inp[24142] = 1066882546; +inp[24143] = 0; +inp[24144] = 1066817431; +inp[24145] = 0; +inp[24146] = 1066752320; +inp[24147] = 0; +inp[24148] = 1066687212; +inp[24149] = 0; +inp[24150] = 1066622109; +inp[24151] = 0; +inp[24152] = 1066557009; +inp[24153] = 0; +inp[24154] = 1066491914; +inp[24155] = 0; +inp[24156] = 1066426822; +inp[24157] = 0; +inp[24158] = 1066361735; +inp[24159] = 0; +inp[24160] = 1066296651; +inp[24161] = 0; +inp[24162] = 1066231572; +inp[24163] = 0; +inp[24164] = 1066166496; +inp[24165] = 0; +inp[24166] = 1066101424; +inp[24167] = 0; +inp[24168] = 1066036357; +inp[24169] = 0; +inp[24170] = 1065971293; +inp[24171] = 0; +inp[24172] = 1065906233; +inp[24173] = 0; +inp[24174] = 1065841178; +inp[24175] = 0; +inp[24176] = 1065776126; +inp[24177] = 0; +inp[24178] = 1065711078; +inp[24179] = 0; +inp[24180] = 1065646034; +inp[24181] = 0; +inp[24182] = 1065580994; +inp[24183] = 0; +inp[24184] = 1065515958; +inp[24185] = 0; +inp[24186] = 1065450926; +inp[24187] = 0; +inp[24188] = 1065385898; +inp[24189] = 0; +inp[24190] = 1065320874; +inp[24191] = 0; +inp[24192] = 1065255854; +inp[24193] = 0; +inp[24194] = 1065190838; +inp[24195] = 0; +inp[24196] = 1065125826; +inp[24197] = 0; +inp[24198] = 1065060818; +inp[24199] = 0; +inp[24200] = 1064995814; +inp[24201] = 0; +inp[24202] = 1064930814; +inp[24203] = 0; +inp[24204] = 1064865817; +inp[24205] = 0; +inp[24206] = 1064800825; +inp[24207] = 0; +inp[24208] = 1064735837; +inp[24209] = 0; +inp[24210] = 1064670852; +inp[24211] = 0; +inp[24212] = 1064605872; +inp[24213] = 0; +inp[24214] = 1064540896; +inp[24215] = 0; +inp[24216] = 1064475923; +inp[24217] = 0; +inp[24218] = 1064410955; +inp[24219] = 0; +inp[24220] = 1064345990; +inp[24221] = 0; +inp[24222] = 1064281030; +inp[24223] = 0; +inp[24224] = 1064216073; +inp[24225] = 0; +inp[24226] = 1064151121; +inp[24227] = 0; +inp[24228] = 1064086172; +inp[24229] = 0; +inp[24230] = 1064021227; +inp[24231] = 0; +inp[24232] = 1063956286; +inp[24233] = 0; +inp[24234] = 1063891350; +inp[24235] = 0; +inp[24236] = 1063826417; +inp[24237] = 0; +inp[24238] = 1063761488; +inp[24239] = 0; +inp[24240] = 1063696563; +inp[24241] = 0; +inp[24242] = 1063631642; +inp[24243] = 0; +inp[24244] = 1063566725; +inp[24245] = 0; +inp[24246] = 1063501812; +inp[24247] = 0; +inp[24248] = 1063436903; +inp[24249] = 0; +inp[24250] = 1063371998; +inp[24251] = 0; +inp[24252] = 1063307097; +inp[24253] = 0; +inp[24254] = 1063242200; +inp[24255] = 0; +inp[24256] = 1063177307; +inp[24257] = 0; +inp[24258] = 1063112418; +inp[24259] = 0; +inp[24260] = 1063047532; +inp[24261] = 0; +inp[24262] = 1062982651; +inp[24263] = 0; +inp[24264] = 1062917774; +inp[24265] = 0; +inp[24266] = 1062852900; +inp[24267] = 0; +inp[24268] = 1062788031; +inp[24269] = 0; +inp[24270] = 1062723166; +inp[24271] = 0; +inp[24272] = 1062658304; +inp[24273] = 0; +inp[24274] = 1062593447; +inp[24275] = 0; +inp[24276] = 1062528593; +inp[24277] = 0; +inp[24278] = 1062463743; +inp[24279] = 0; +inp[24280] = 1062398898; +inp[24281] = 0; +inp[24282] = 1062334056; +inp[24283] = 0; +inp[24284] = 1062269218; +inp[24285] = 0; +inp[24286] = 1062204384; +inp[24287] = 0; +inp[24288] = 1062139555; +inp[24289] = 0; +inp[24290] = 1062074729; +inp[24291] = 0; +inp[24292] = 1062009907; +inp[24293] = 0; +inp[24294] = 1061945089; +inp[24295] = 0; +inp[24296] = 1061880275; +inp[24297] = 0; +inp[24298] = 1061815465; +inp[24299] = 0; +inp[24300] = 1061750659; +inp[24301] = 0; +inp[24302] = 1061685857; +inp[24303] = 0; +inp[24304] = 1061621058; +inp[24305] = 0; +inp[24306] = 1061556264; +inp[24307] = 0; +inp[24308] = 1061491474; +inp[24309] = 0; +inp[24310] = 1061426688; +inp[24311] = 0; +inp[24312] = 1061361905; +inp[24313] = 0; +inp[24314] = 1061297127; +inp[24315] = 0; +inp[24316] = 1061232352; +inp[24317] = 0; +inp[24318] = 1061167582; +inp[24319] = 0; +inp[24320] = 1061102815; +inp[24321] = 0; +inp[24322] = 1061038053; +inp[24323] = 0; +inp[24324] = 1060973294; +inp[24325] = 0; +inp[24326] = 1060908539; +inp[24327] = 0; +inp[24328] = 1060843789; +inp[24329] = 0; +inp[24330] = 1060779042; +inp[24331] = 0; +inp[24332] = 1060714299; +inp[24333] = 0; +inp[24334] = 1060649560; +inp[24335] = 0; +inp[24336] = 1060584825; +inp[24337] = 0; +inp[24338] = 1060520094; +inp[24339] = 0; +inp[24340] = 1060455367; +inp[24341] = 0; +inp[24342] = 1060390644; +inp[24343] = 0; +inp[24344] = 1060325925; +inp[24345] = 0; +inp[24346] = 1060261210; +inp[24347] = 0; +inp[24348] = 1060196498; +inp[24349] = 0; +inp[24350] = 1060131791; +inp[24351] = 0; +inp[24352] = 1060067088; +inp[24353] = 0; +inp[24354] = 1060002388; +inp[24355] = 0; +inp[24356] = 1059937693; +inp[24357] = 0; +inp[24358] = 1059873002; +inp[24359] = 0; +inp[24360] = 1059808314; +inp[24361] = 0; +inp[24362] = 1059743630; +inp[24363] = 0; +inp[24364] = 1059678951; +inp[24365] = 0; +inp[24366] = 1059614275; +inp[24367] = 0; +inp[24368] = 1059549603; +inp[24369] = 0; +inp[24370] = 1059484936; +inp[24371] = 0; +inp[24372] = 1059420272; +inp[24373] = 0; +inp[24374] = 1059355612; +inp[24375] = 0; +inp[24376] = 1059290956; +inp[24377] = 0; +inp[24378] = 1059226304; +inp[24379] = 0; +inp[24380] = 1059161656; +inp[24381] = 0; +inp[24382] = 1059097012; +inp[24383] = 0; +inp[24384] = 1059032371; +inp[24385] = 0; +inp[24386] = 1058967735; +inp[24387] = 0; +inp[24388] = 1058903103; +inp[24389] = 0; +inp[24390] = 1058838475; +inp[24391] = 0; +inp[24392] = 1058773850; +inp[24393] = 0; +inp[24394] = 1058709230; +inp[24395] = 0; +inp[24396] = 1058644613; +inp[24397] = 0; +inp[24398] = 1058580001; +inp[24399] = 0; +inp[24400] = 1058515392; +inp[24401] = 0; +inp[24402] = 1058450787; +inp[24403] = 0; +inp[24404] = 1058386187; +inp[24405] = 0; +inp[24406] = 1058321590; +inp[24407] = 0; +inp[24408] = 1058256997; +inp[24409] = 0; +inp[24410] = 1058192408; +inp[24411] = 0; +inp[24412] = 1058127823; +inp[24413] = 0; +inp[24414] = 1058063242; +inp[24415] = 0; +inp[24416] = 1057998665; +inp[24417] = 0; +inp[24418] = 1057934092; +inp[24419] = 0; +inp[24420] = 1057869523; +inp[24421] = 0; +inp[24422] = 1057804957; +inp[24423] = 0; +inp[24424] = 1057740396; +inp[24425] = 0; +inp[24426] = 1057675839; +inp[24427] = 0; +inp[24428] = 1057611285; +inp[24429] = 0; +inp[24430] = 1057546736; +inp[24431] = 0; +inp[24432] = 1057482190; +inp[24433] = 0; +inp[24434] = 1057417649; +inp[24435] = 0; +inp[24436] = 1057353111; +inp[24437] = 0; +inp[24438] = 1057288577; +inp[24439] = 0; +inp[24440] = 1057224047; +inp[24441] = 0; +inp[24442] = 1057159521; +inp[24443] = 0; +inp[24444] = 1073741824; +inp[24445] = 1073741824; +inp[24446] = 1073709056; +inp[24447] = 0; +inp[24448] = 1073676289; +inp[24449] = 0; +inp[24450] = 1073643524; +inp[24451] = 0; +inp[24452] = 1073610759; +inp[24453] = 0; +inp[24454] = 1073577996; +inp[24455] = 0; +inp[24456] = 1073545233; +inp[24457] = 0; +inp[24458] = 1073512472; +inp[24459] = 0; +inp[24460] = 1073479711; +inp[24461] = 0; +inp[24462] = 1073446952; +inp[24463] = 0; +inp[24464] = 1073414193; +inp[24465] = 0; +inp[24466] = 1073381436; +inp[24467] = 0; +inp[24468] = 1073348679; +inp[24469] = 0; +inp[24470] = 1073315924; +inp[24471] = 0; +inp[24472] = 1073283169; +inp[24473] = 0; +inp[24474] = 1073250416; +inp[24475] = 0; +inp[24476] = 1073217663; +inp[24477] = 0; +inp[24478] = 1073184912; +inp[24479] = 0; +inp[24480] = 1073152161; +inp[24481] = 0; +inp[24482] = 1073119412; +inp[24483] = 0; +inp[24484] = 1073086663; +inp[24485] = 0; +inp[24486] = 1073053916; +inp[24487] = 0; +inp[24488] = 1073021169; +inp[24489] = 0; +inp[24490] = 1072988424; +inp[24491] = 0; +inp[24492] = 1072955679; +inp[24493] = 0; +inp[24494] = 1072922936; +inp[24495] = 0; +inp[24496] = 1072890193; +inp[24497] = 0; +inp[24498] = 1072857452; +inp[24499] = 0; +inp[24500] = 1072824711; +inp[24501] = 0; +inp[24502] = 1072791972; +inp[24503] = 0; +inp[24504] = 1072759233; +inp[24505] = 0; +inp[24506] = 1072726496; +inp[24507] = 0; +inp[24508] = 1072693759; +inp[24509] = 0; +inp[24510] = 1072661024; +inp[24511] = 0; +inp[24512] = 1072628289; +inp[24513] = 0; +inp[24514] = 1072595556; +inp[24515] = 0; +inp[24516] = 1072562823; +inp[24517] = 0; +inp[24518] = 1072530092; +inp[24519] = 0; +inp[24520] = 1072497361; +inp[24521] = 0; +inp[24522] = 1072464632; +inp[24523] = 0; +inp[24524] = 1072431903; +inp[24525] = 0; +inp[24526] = 1072399176; +inp[24527] = 0; +inp[24528] = 1072366449; +inp[24529] = 0; +inp[24530] = 1072333724; +inp[24531] = 0; +inp[24532] = 1072300999; +inp[24533] = 0; +inp[24534] = 1072268276; +inp[24535] = 0; +inp[24536] = 1072235553; +inp[24537] = 0; +inp[24538] = 1072202831; +inp[24539] = 0; +inp[24540] = 1072170111; +inp[24541] = 0; +inp[24542] = 1072137391; +inp[24543] = 0; +inp[24544] = 1072104673; +inp[24545] = 0; +inp[24546] = 1072071955; +inp[24547] = 0; +inp[24548] = 1072039239; +inp[24549] = 0; +inp[24550] = 1072006523; +inp[24551] = 0; +inp[24552] = 1071973809; +inp[24553] = 0; +inp[24554] = 1071941095; +inp[24555] = 0; +inp[24556] = 1071908383; +inp[24557] = 0; +inp[24558] = 1071875671; +inp[24559] = 0; +inp[24560] = 1071842961; +inp[24561] = 0; +inp[24562] = 1071810251; +inp[24563] = 0; +inp[24564] = 1071777542; +inp[24565] = 0; +inp[24566] = 1071744835; +inp[24567] = 0; +inp[24568] = 1071712128; +inp[24569] = 0; +inp[24570] = 1071679423; +inp[24571] = 0; +inp[24572] = 1071646718; +inp[24573] = 0; +inp[24574] = 1071614015; +inp[24575] = 0; +inp[24576] = 1071581312; +inp[24577] = 0; +inp[24578] = 1071548610; +inp[24579] = 0; +inp[24580] = 1071515910; +inp[24581] = 0; +inp[24582] = 1071483210; +inp[24583] = 0; +inp[24584] = 1071450512; +inp[24585] = 0; +inp[24586] = 1071417814; +inp[24587] = 0; +inp[24588] = 1071385118; +inp[24589] = 0; +inp[24590] = 1071352422; +inp[24591] = 0; +inp[24592] = 1071319727; +inp[24593] = 0; +inp[24594] = 1071287034; +inp[24595] = 0; +inp[24596] = 1071254341; +inp[24597] = 0; +inp[24598] = 1071221650; +inp[24599] = 0; +inp[24600] = 1071188959; +inp[24601] = 0; +inp[24602] = 1071156269; +inp[24603] = 0; +inp[24604] = 1071123581; +inp[24605] = 0; +inp[24606] = 1071090893; +inp[24607] = 0; +inp[24608] = 1071058207; +inp[24609] = 0; +inp[24610] = 1071025521; +inp[24611] = 0; +inp[24612] = 1070992836; +inp[24613] = 0; +inp[24614] = 1070960153; +inp[24615] = 0; +inp[24616] = 1070927470; +inp[24617] = 0; +inp[24618] = 1070894789; +inp[24619] = 0; +inp[24620] = 1070862108; +inp[24621] = 0; +inp[24622] = 1070829428; +inp[24623] = 0; +inp[24624] = 1070796750; +inp[24625] = 0; +inp[24626] = 1070764072; +inp[24627] = 0; +inp[24628] = 1070731396; +inp[24629] = 0; +inp[24630] = 1070698720; +inp[24631] = 0; +inp[24632] = 1070666045; +inp[24633] = 0; +inp[24634] = 1070633372; +inp[24635] = 0; +inp[24636] = 1070600699; +inp[24637] = 0; +inp[24638] = 1070568027; +inp[24639] = 0; +inp[24640] = 1070535357; +inp[24641] = 0; +inp[24642] = 1070502687; +inp[24643] = 0; +inp[24644] = 1070470018; +inp[24645] = 0; +inp[24646] = 1070437351; +inp[24647] = 0; +inp[24648] = 1070404684; +inp[24649] = 0; +inp[24650] = 1070372018; +inp[24651] = 0; +inp[24652] = 1070339354; +inp[24653] = 0; +inp[24654] = 1070306690; +inp[24655] = 0; +inp[24656] = 1070274027; +inp[24657] = 0; +inp[24658] = 1070241366; +inp[24659] = 0; +inp[24660] = 1070208705; +inp[24661] = 0; +inp[24662] = 1070176045; +inp[24663] = 0; +inp[24664] = 1070143387; +inp[24665] = 0; +inp[24666] = 1070110729; +inp[24667] = 0; +inp[24668] = 1070078072; +inp[24669] = 0; +inp[24670] = 1070045417; +inp[24671] = 0; +inp[24672] = 1070012762; +inp[24673] = 0; +inp[24674] = 1069980108; +inp[24675] = 0; +inp[24676] = 1069947456; +inp[24677] = 0; +inp[24678] = 1069914804; +inp[24679] = 0; +inp[24680] = 1069882153; +inp[24681] = 0; +inp[24682] = 1069849503; +inp[24683] = 0; +inp[24684] = 1069816855; +inp[24685] = 0; +inp[24686] = 1069784207; +inp[24687] = 0; +inp[24688] = 1069751560; +inp[24689] = 0; +inp[24690] = 1069718915; +inp[24691] = 0; +inp[24692] = 1069686270; +inp[24693] = 0; +inp[24694] = 1069653626; +inp[24695] = 0; +inp[24696] = 1069620983; +inp[24697] = 0; +inp[24698] = 1069588342; +inp[24699] = 0; +inp[24700] = 1069555701; +inp[24701] = 0; +inp[24702] = 1069523061; +inp[24703] = 0; +inp[24704] = 1069490422; +inp[24705] = 0; +inp[24706] = 1069457785; +inp[24707] = 0; +inp[24708] = 1069425148; +inp[24709] = 0; +inp[24710] = 1069392512; +inp[24711] = 0; +inp[24712] = 1069359877; +inp[24713] = 0; +inp[24714] = 1069327243; +inp[24715] = 0; +inp[24716] = 1069294611; +inp[24717] = 0; +inp[24718] = 1069261979; +inp[24719] = 0; +inp[24720] = 1069229348; +inp[24721] = 0; +inp[24722] = 1069196718; +inp[24723] = 0; +inp[24724] = 1069164090; +inp[24725] = 0; +inp[24726] = 1069131462; +inp[24727] = 0; +inp[24728] = 1069098835; +inp[24729] = 0; +inp[24730] = 1069066209; +inp[24731] = 0; +inp[24732] = 1069033584; +inp[24733] = 0; +inp[24734] = 1069000961; +inp[24735] = 0; +inp[24736] = 1068968338; +inp[24737] = 0; +inp[24738] = 1068935716; +inp[24739] = 0; +inp[24740] = 1068903095; +inp[24741] = 0; +inp[24742] = 1068870475; +inp[24743] = 0; +inp[24744] = 1068837856; +inp[24745] = 0; +inp[24746] = 1068805239; +inp[24747] = 0; +inp[24748] = 1068772622; +inp[24749] = 0; +inp[24750] = 1068740006; +inp[24751] = 0; +inp[24752] = 1068707391; +inp[24753] = 0; +inp[24754] = 1068674777; +inp[24755] = 0; +inp[24756] = 1068642164; +inp[24757] = 0; +inp[24758] = 1068609552; +inp[24759] = 0; +inp[24760] = 1068576941; +inp[24761] = 0; +inp[24762] = 1068544332; +inp[24763] = 0; +inp[24764] = 1068511723; +inp[24765] = 0; +inp[24766] = 1068479115; +inp[24767] = 0; +inp[24768] = 1068446508; +inp[24769] = 0; +inp[24770] = 1068413902; +inp[24771] = 0; +inp[24772] = 1068381297; +inp[24773] = 0; +inp[24774] = 1068348693; +inp[24775] = 0; +inp[24776] = 1068316090; +inp[24777] = 0; +inp[24778] = 1068283488; +inp[24779] = 0; +inp[24780] = 1068250887; +inp[24781] = 0; +inp[24782] = 1068218287; +inp[24783] = 0; +inp[24784] = 1068185689; +inp[24785] = 0; +inp[24786] = 1068153091; +inp[24787] = 0; +inp[24788] = 1068120494; +inp[24789] = 0; +inp[24790] = 1068087898; +inp[24791] = 0; +inp[24792] = 1068055303; +inp[24793] = 0; +inp[24794] = 1068022709; +inp[24795] = 0; +inp[24796] = 1067990116; +inp[24797] = 0; +inp[24798] = 1067957524; +inp[24799] = 0; +inp[24800] = 1067924933; +inp[24801] = 0; +inp[24802] = 1067892343; +inp[24803] = 0; +inp[24804] = 1067859754; +inp[24805] = 0; +inp[24806] = 1067827166; +inp[24807] = 0; +inp[24808] = 1067794579; +inp[24809] = 0; +inp[24810] = 1067761993; +inp[24811] = 0; +inp[24812] = 1067729408; +inp[24813] = 0; +inp[24814] = 1067696824; +inp[24815] = 0; +inp[24816] = 1067664241; +inp[24817] = 0; +inp[24818] = 1067631659; +inp[24819] = 0; +inp[24820] = 1067599078; +inp[24821] = 0; +inp[24822] = 1067566498; +inp[24823] = 0; +inp[24824] = 1067533919; +inp[24825] = 0; +inp[24826] = 1067501341; +inp[24827] = 0; +inp[24828] = 1067468764; +inp[24829] = 0; +inp[24830] = 1067436187; +inp[24831] = 0; +inp[24832] = 1067403612; +inp[24833] = 0; +inp[24834] = 1067371038; +inp[24835] = 0; +inp[24836] = 1067338465; +inp[24837] = 0; +inp[24838] = 1067305893; +inp[24839] = 0; +inp[24840] = 1067273322; +inp[24841] = 0; +inp[24842] = 1067240752; +inp[24843] = 0; +inp[24844] = 1067208183; +inp[24845] = 0; +inp[24846] = 1067175615; +inp[24847] = 0; +inp[24848] = 1067143048; +inp[24849] = 0; +inp[24850] = 1067110482; +inp[24851] = 0; +inp[24852] = 1067077916; +inp[24853] = 0; +inp[24854] = 1067045352; +inp[24855] = 0; +inp[24856] = 1067012789; +inp[24857] = 0; +inp[24858] = 1066980227; +inp[24859] = 0; +inp[24860] = 1066947666; +inp[24861] = 0; +inp[24862] = 1066915106; +inp[24863] = 0; +inp[24864] = 1066882546; +inp[24865] = 0; +inp[24866] = 1066849988; +inp[24867] = 0; +inp[24868] = 1066817431; +inp[24869] = 0; +inp[24870] = 1066784875; +inp[24871] = 0; +inp[24872] = 1066752320; +inp[24873] = 0; +inp[24874] = 1066719766; +inp[24875] = 0; +inp[24876] = 1066687212; +inp[24877] = 0; +inp[24878] = 1066654660; +inp[24879] = 0; +inp[24880] = 1066622109; +inp[24881] = 0; +inp[24882] = 1066589559; +inp[24883] = 0; +inp[24884] = 1066557009; +inp[24885] = 0; +inp[24886] = 1066524461; +inp[24887] = 0; +inp[24888] = 1066491914; +inp[24889] = 0; +inp[24890] = 1066459368; +inp[24891] = 0; +inp[24892] = 1066426822; +inp[24893] = 0; +inp[24894] = 1066394278; +inp[24895] = 0; +inp[24896] = 1066361735; +inp[24897] = 0; +inp[24898] = 1066329193; +inp[24899] = 0; +inp[24900] = 1066296651; +inp[24901] = 0; +inp[24902] = 1066264111; +inp[24903] = 0; +inp[24904] = 1066231572; +inp[24905] = 0; +inp[24906] = 1066199033; +inp[24907] = 0; +inp[24908] = 1066166496; +inp[24909] = 0; +inp[24910] = 1066133960; +inp[24911] = 0; +inp[24912] = 1066101424; +inp[24913] = 0; +inp[24914] = 1066068890; +inp[24915] = 0; +inp[24916] = 1066036357; +inp[24917] = 0; +inp[24918] = 1066003824; +inp[24919] = 0; +inp[24920] = 1065971293; +inp[24921] = 0; +inp[24922] = 1065938763; +inp[24923] = 0; +inp[24924] = 1065906233; +inp[24925] = 0; +inp[24926] = 1065873705; +inp[24927] = 0; +inp[24928] = 1065841178; +inp[24929] = 0; +inp[24930] = 1065808651; +inp[24931] = 0; +inp[24932] = 1065776126; +inp[24933] = 0; +inp[24934] = 1065743601; +inp[24935] = 0; +inp[24936] = 1065711078; +inp[24937] = 0; +inp[24938] = 1065678555; +inp[24939] = 0; +inp[24940] = 1065646034; +inp[24941] = 0; +inp[24942] = 1065613514; +inp[24943] = 0; +inp[24944] = 1065580994; +inp[24945] = 0; +inp[24946] = 1065548476; +inp[24947] = 0; +inp[24948] = 1065515958; +inp[24949] = 0; +inp[24950] = 1065483442; +inp[24951] = 0; +inp[24952] = 1065450926; +inp[24953] = 0; +inp[24954] = 1065418412; +inp[24955] = 0; +inp[24956] = 1073741824; +inp[24957] = 1073741824; +inp[24958] = 1073725440; +inp[24959] = 0; +inp[24960] = 1073709056; +inp[24961] = 0; +inp[24962] = 1073692673; +inp[24963] = 0; +inp[24964] = 1073676289; +inp[24965] = 0; +inp[24966] = 1073659907; +inp[24967] = 0; +inp[24968] = 1073643524; +inp[24969] = 0; +inp[24970] = 1073627142; +inp[24971] = 0; +inp[24972] = 1073610759; +inp[24973] = 0; +inp[24974] = 1073594378; +inp[24975] = 0; +inp[24976] = 1073577996; +inp[24977] = 0; +inp[24978] = 1073561615; +inp[24979] = 0; +inp[24980] = 1073545233; +inp[24981] = 0; +inp[24982] = 1073528853; +inp[24983] = 0; +inp[24984] = 1073512472; +inp[24985] = 0; +inp[24986] = 1073496092; +inp[24987] = 0; +inp[24988] = 1073479711; +inp[24989] = 0; +inp[24990] = 1073463332; +inp[24991] = 0; +inp[24992] = 1073446952; +inp[24993] = 0; +inp[24994] = 1073430573; +inp[24995] = 0; +inp[24996] = 1073414193; +inp[24997] = 0; +inp[24998] = 1073397815; +inp[24999] = 0; +inp[25000] = 1073381436; +inp[25001] = 0; +inp[25002] = 1073365058; +inp[25003] = 0; +inp[25004] = 1073348679; +inp[25005] = 0; +inp[25006] = 1073332302; +inp[25007] = 0; +inp[25008] = 1073315924; +inp[25009] = 0; +inp[25010] = 1073299547; +inp[25011] = 0; +inp[25012] = 1073283169; +inp[25013] = 0; +inp[25014] = 1073266793; +inp[25015] = 0; +inp[25016] = 1073250416; +inp[25017] = 0; +inp[25018] = 1073234040; +inp[25019] = 0; +inp[25020] = 1073217663; +inp[25021] = 0; +inp[25022] = 1073201288; +inp[25023] = 0; +inp[25024] = 1073184912; +inp[25025] = 0; +inp[25026] = 1073168537; +inp[25027] = 0; +inp[25028] = 1073152161; +inp[25029] = 0; +inp[25030] = 1073135787; +inp[25031] = 0; +inp[25032] = 1073119412; +inp[25033] = 0; +inp[25034] = 1073103038; +inp[25035] = 0; +inp[25036] = 1073086663; +inp[25037] = 0; +inp[25038] = 1073070290; +inp[25039] = 0; +inp[25040] = 1073053916; +inp[25041] = 0; +inp[25042] = 1073037543; +inp[25043] = 0; +inp[25044] = 1073021169; +inp[25045] = 0; +inp[25046] = 1073004797; +inp[25047] = 0; +inp[25048] = 1072988424; +inp[25049] = 0; +inp[25050] = 1072972052; +inp[25051] = 0; +inp[25052] = 1072955679; +inp[25053] = 0; +inp[25054] = 1072939308; +inp[25055] = 0; +inp[25056] = 1072922936; +inp[25057] = 0; +inp[25058] = 1072906565; +inp[25059] = 0; +inp[25060] = 1072890193; +inp[25061] = 0; +inp[25062] = 1072873823; +inp[25063] = 0; +inp[25064] = 1072857452; +inp[25065] = 0; +inp[25066] = 1072841082; +inp[25067] = 0; +inp[25068] = 1072824711; +inp[25069] = 0; +inp[25070] = 1072808342; +inp[25071] = 0; +inp[25072] = 1072791972; +inp[25073] = 0; +inp[25074] = 1072775602; +inp[25075] = 0; +inp[25076] = 1072759233; +inp[25077] = 0; +inp[25078] = 1072742864; +inp[25079] = 0; +inp[25080] = 1072726496; +inp[25081] = 0; +inp[25082] = 1072710127; +inp[25083] = 0; +inp[25084] = 1072693759; +inp[25085] = 0; +inp[25086] = 1072677391; +inp[25087] = 0; +inp[25088] = 1072661024; +inp[25089] = 0; +inp[25090] = 1072644656; +inp[25091] = 0; +inp[25092] = 1072628289; +inp[25093] = 0; +inp[25094] = 1072611922; +inp[25095] = 0; +inp[25096] = 1072595556; +inp[25097] = 0; +inp[25098] = 1072579189; +inp[25099] = 0; +inp[25100] = 1072562823; +inp[25101] = 0; +inp[25102] = 1072546457; +inp[25103] = 0; +inp[25104] = 1072530092; +inp[25105] = 0; +inp[25106] = 1072513726; +inp[25107] = 0; +inp[25108] = 1072497361; +inp[25109] = 0; +inp[25110] = 1072480996; +inp[25111] = 0; +inp[25112] = 1072464632; +inp[25113] = 0; +inp[25114] = 1072448267; +inp[25115] = 0; +inp[25116] = 1072431903; +inp[25117] = 0; +inp[25118] = 1072415539; +inp[25119] = 0; +inp[25120] = 1072399176; +inp[25121] = 0; +inp[25122] = 1072382812; +inp[25123] = 0; +inp[25124] = 1072366449; +inp[25125] = 0; +inp[25126] = 1072350086; +inp[25127] = 0; +inp[25128] = 1072333724; +inp[25129] = 0; +inp[25130] = 1072317361; +inp[25131] = 0; +inp[25132] = 1072300999; +inp[25133] = 0; +inp[25134] = 1072284637; +inp[25135] = 0; +inp[25136] = 1072268276; +inp[25137] = 0; +inp[25138] = 1072251914; +inp[25139] = 0; +inp[25140] = 1072235553; +inp[25141] = 0; +inp[25142] = 1072219192; +inp[25143] = 0; +inp[25144] = 1072202831; +inp[25145] = 0; +inp[25146] = 1072186471; +inp[25147] = 0; +inp[25148] = 1072170111; +inp[25149] = 0; +inp[25150] = 1072153751; +inp[25151] = 0; +inp[25152] = 1072137391; +inp[25153] = 0; +inp[25154] = 1072121032; +inp[25155] = 0; +inp[25156] = 1072104673; +inp[25157] = 0; +inp[25158] = 1072088314; +inp[25159] = 0; +inp[25160] = 1072071955; +inp[25161] = 0; +inp[25162] = 1072055597; +inp[25163] = 0; +inp[25164] = 1072039239; +inp[25165] = 0; +inp[25166] = 1072022881; +inp[25167] = 0; +inp[25168] = 1072006523; +inp[25169] = 0; +inp[25170] = 1071990166; +inp[25171] = 0; +inp[25172] = 1071973809; +inp[25173] = 0; +inp[25174] = 1071957452; +inp[25175] = 0; +inp[25176] = 1071941095; +inp[25177] = 0; +inp[25178] = 1071924739; +inp[25179] = 0; +inp[25180] = 1071908383; +inp[25181] = 0; +inp[25182] = 1071892027; +inp[25183] = 0; +inp[25184] = 1071875671; +inp[25185] = 0; +inp[25186] = 1071859316; +inp[25187] = 0; +inp[25188] = 1071842961; +inp[25189] = 0; +inp[25190] = 1071826606; +inp[25191] = 0; +inp[25192] = 1071810251; +inp[25193] = 0; +inp[25194] = 1071793897; +inp[25195] = 0; +inp[25196] = 1071777542; +inp[25197] = 0; +inp[25198] = 1071761188; +inp[25199] = 0; +inp[25200] = 1071744835; +inp[25201] = 0; +inp[25202] = 1071728481; +inp[25203] = 0; +inp[25204] = 1071712128; +inp[25205] = 0; +inp[25206] = 1071695775; +inp[25207] = 0; +inp[25208] = 1071679423; +inp[25209] = 0; +inp[25210] = 1071663070; +inp[25211] = 0; +inp[25212] = 1071646718; +inp[25213] = 0; +inp[25214] = 1071630366; +inp[25215] = 0; +inp[25216] = 1071614015; +inp[25217] = 0; +inp[25218] = 1071597663; +inp[25219] = 0; +inp[25220] = 1071581312; +inp[25221] = 0; +inp[25222] = 1071564961; +inp[25223] = 0; +inp[25224] = 1071548610; +inp[25225] = 0; +inp[25226] = 1071532260; +inp[25227] = 0; +inp[25228] = 1071515910; +inp[25229] = 0; +inp[25230] = 1071499560; +inp[25231] = 0; +inp[25232] = 1071483210; +inp[25233] = 0; +inp[25234] = 1071466861; +inp[25235] = 0; +inp[25236] = 1071450512; +inp[25237] = 0; +inp[25238] = 1071434163; +inp[25239] = 0; +inp[25240] = 1071417814; +inp[25241] = 0; +inp[25242] = 1071401466; +inp[25243] = 0; +inp[25244] = 1071385118; +inp[25245] = 0; +inp[25246] = 1071368770; +inp[25247] = 0; +inp[25248] = 1071352422; +inp[25249] = 0; +inp[25250] = 1071336075; +inp[25251] = 0; +inp[25252] = 1071319727; +inp[25253] = 0; +inp[25254] = 1071303381; +inp[25255] = 0; +inp[25256] = 1071287034; +inp[25257] = 0; +inp[25258] = 1071270687; +inp[25259] = 0; +inp[25260] = 1071254341; +inp[25261] = 0; +inp[25262] = 1071237995; +inp[25263] = 0; +inp[25264] = 1071221650; +inp[25265] = 0; +inp[25266] = 1071205304; +inp[25267] = 0; +inp[25268] = 1071188959; +inp[25269] = 0; +inp[25270] = 1071172614; +inp[25271] = 0; +inp[25272] = 1071156269; +inp[25273] = 0; +inp[25274] = 1071139925; +inp[25275] = 0; +inp[25276] = 1071123581; +inp[25277] = 0; +inp[25278] = 1071107237; +inp[25279] = 0; +inp[25280] = 1071090893; +inp[25281] = 0; +inp[25282] = 1071074550; +inp[25283] = 0; +inp[25284] = 1071058207; +inp[25285] = 0; +inp[25286] = 1071041864; +inp[25287] = 0; +inp[25288] = 1071025521; +inp[25289] = 0; +inp[25290] = 1071009179; +inp[25291] = 0; +inp[25292] = 1070992836; +inp[25293] = 0; +inp[25294] = 1070976495; +inp[25295] = 0; +inp[25296] = 1070960153; +inp[25297] = 0; +inp[25298] = 1070943811; +inp[25299] = 0; +inp[25300] = 1070927470; +inp[25301] = 0; +inp[25302] = 1070911129; +inp[25303] = 0; +inp[25304] = 1070894789; +inp[25305] = 0; +inp[25306] = 1070878448; +inp[25307] = 0; +inp[25308] = 1070862108; +inp[25309] = 0; +inp[25310] = 1070845768; +inp[25311] = 0; +inp[25312] = 1070829428; +inp[25313] = 0; +inp[25314] = 1070813089; +inp[25315] = 0; +inp[25316] = 1070796750; +inp[25317] = 0; +inp[25318] = 1070780411; +inp[25319] = 0; +inp[25320] = 1070764072; +inp[25321] = 0; +inp[25322] = 1070747734; +inp[25323] = 0; +inp[25324] = 1070731396; +inp[25325] = 0; +inp[25326] = 1070715058; +inp[25327] = 0; +inp[25328] = 1070698720; +inp[25329] = 0; +inp[25330] = 1070682382; +inp[25331] = 0; +inp[25332] = 1070666045; +inp[25333] = 0; +inp[25334] = 1070649708; +inp[25335] = 0; +inp[25336] = 1070633372; +inp[25337] = 0; +inp[25338] = 1070617035; +inp[25339] = 0; +inp[25340] = 1070600699; +inp[25341] = 0; +inp[25342] = 1070584363; +inp[25343] = 0; +inp[25344] = 1070568027; +inp[25345] = 0; +inp[25346] = 1070551692; +inp[25347] = 0; +inp[25348] = 1070535357; +inp[25349] = 0; +inp[25350] = 1070519022; +inp[25351] = 0; +inp[25352] = 1070502687; +inp[25353] = 0; +inp[25354] = 1070486353; +inp[25355] = 0; +inp[25356] = 1070470018; +inp[25357] = 0; +inp[25358] = 1070453684; +inp[25359] = 0; +inp[25360] = 1070437351; +inp[25361] = 0; +inp[25362] = 1070421017; +inp[25363] = 0; +inp[25364] = 1070404684; +inp[25365] = 0; +inp[25366] = 1070388351; +inp[25367] = 0; +inp[25368] = 1070372018; +inp[25369] = 0; +inp[25370] = 1070355686; +inp[25371] = 0; +inp[25372] = 1070339354; +inp[25373] = 0; +inp[25374] = 1070323022; +inp[25375] = 0; +inp[25376] = 1070306690; +inp[25377] = 0; +inp[25378] = 1070290359; +inp[25379] = 0; +inp[25380] = 1070274027; +inp[25381] = 0; +inp[25382] = 1070257696; +inp[25383] = 0; +inp[25384] = 1070241366; +inp[25385] = 0; +inp[25386] = 1070225035; +inp[25387] = 0; +inp[25388] = 1070208705; +inp[25389] = 0; +inp[25390] = 1070192375; +inp[25391] = 0; +inp[25392] = 1070176045; +inp[25393] = 0; +inp[25394] = 1070159716; +inp[25395] = 0; +inp[25396] = 1070143387; +inp[25397] = 0; +inp[25398] = 1070127058; +inp[25399] = 0; +inp[25400] = 1070110729; +inp[25401] = 0; +inp[25402] = 1070094401; +inp[25403] = 0; +inp[25404] = 1070078072; +inp[25405] = 0; +inp[25406] = 1070061744; +inp[25407] = 0; +inp[25408] = 1070045417; +inp[25409] = 0; +inp[25410] = 1070029089; +inp[25411] = 0; +inp[25412] = 1070012762; +inp[25413] = 0; +inp[25414] = 1069996435; +inp[25415] = 0; +inp[25416] = 1069980108; +inp[25417] = 0; +inp[25418] = 1069963782; +inp[25419] = 0; +inp[25420] = 1069947456; +inp[25421] = 0; +inp[25422] = 1069931130; +inp[25423] = 0; +inp[25424] = 1069914804; +inp[25425] = 0; +inp[25426] = 1069898478; +inp[25427] = 0; +inp[25428] = 1069882153; +inp[25429] = 0; +inp[25430] = 1069865828; +inp[25431] = 0; +inp[25432] = 1069849503; +inp[25433] = 0; +inp[25434] = 1069833179; +inp[25435] = 0; +inp[25436] = 1069816855; +inp[25437] = 0; +inp[25438] = 1069800531; +inp[25439] = 0; +inp[25440] = 1069784207; +inp[25441] = 0; +inp[25442] = 1069767884; +inp[25443] = 0; +inp[25444] = 1069751560; +inp[25445] = 0; +inp[25446] = 1069735237; +inp[25447] = 0; +inp[25448] = 1069718915; +inp[25449] = 0; +inp[25450] = 1069702592; +inp[25451] = 0; +inp[25452] = 1069686270; +inp[25453] = 0; +inp[25454] = 1069669948; +inp[25455] = 0; +inp[25456] = 1069653626; +inp[25457] = 0; +inp[25458] = 1069637305; +inp[25459] = 0; +inp[25460] = 1069620983; +inp[25461] = 0; +inp[25462] = 1069604662; +inp[25463] = 0; +inp[25464] = 1069588342; +inp[25465] = 0; +inp[25466] = 1069572021; +inp[25467] = 0; +inp[25468] = 1073741824; +inp[25469] = 1073741824; +inp[25470] = 1073733632; +inp[25471] = 0; +inp[25472] = 1073725440; +inp[25473] = 0; +inp[25474] = 1073717248; +inp[25475] = 0; +inp[25476] = 1073709056; +inp[25477] = 0; +inp[25478] = 1073700864; +inp[25479] = 0; +inp[25480] = 1073692673; +inp[25481] = 0; +inp[25482] = 1073684481; +inp[25483] = 0; +inp[25484] = 1073676289; +inp[25485] = 0; +inp[25486] = 1073668098; +inp[25487] = 0; +inp[25488] = 1073659907; +inp[25489] = 0; +inp[25490] = 1073651715; +inp[25491] = 0; +inp[25492] = 1073643524; +inp[25493] = 0; +inp[25494] = 1073635333; +inp[25495] = 0; +inp[25496] = 1073627142; +inp[25497] = 0; +inp[25498] = 1073618951; +inp[25499] = 0; +inp[25500] = 1073610759; +inp[25501] = 0; +inp[25502] = 1073602569; +inp[25503] = 0; +inp[25504] = 1073594378; +inp[25505] = 0; +inp[25506] = 1073586187; +inp[25507] = 0; +inp[25508] = 1073577996; +inp[25509] = 0; +inp[25510] = 1073569805; +inp[25511] = 0; +inp[25512] = 1073561615; +inp[25513] = 0; +inp[25514] = 1073553424; +inp[25515] = 0; +inp[25516] = 1073545233; +inp[25517] = 0; +inp[25518] = 1073537043; +inp[25519] = 0; +inp[25520] = 1073528853; +inp[25521] = 0; +inp[25522] = 1073520662; +inp[25523] = 0; +inp[25524] = 1073512472; +inp[25525] = 0; +inp[25526] = 1073504282; +inp[25527] = 0; +inp[25528] = 1073496092; +inp[25529] = 0; +inp[25530] = 1073487902; +inp[25531] = 0; +inp[25532] = 1073479711; +inp[25533] = 0; +inp[25534] = 1073471522; +inp[25535] = 0; +inp[25536] = 1073463332; +inp[25537] = 0; +inp[25538] = 1073455142; +inp[25539] = 0; +inp[25540] = 1073446952; +inp[25541] = 0; +inp[25542] = 1073438762; +inp[25543] = 0; +inp[25544] = 1073430573; +inp[25545] = 0; +inp[25546] = 1073422383; +inp[25547] = 0; +inp[25548] = 1073414193; +inp[25549] = 0; +inp[25550] = 1073406004; +inp[25551] = 0; +inp[25552] = 1073397815; +inp[25553] = 0; +inp[25554] = 1073389625; +inp[25555] = 0; +inp[25556] = 1073381436; +inp[25557] = 0; +inp[25558] = 1073373247; +inp[25559] = 0; +inp[25560] = 1073365058; +inp[25561] = 0; +inp[25562] = 1073356869; +inp[25563] = 0; +inp[25564] = 1073348679; +inp[25565] = 0; +inp[25566] = 1073340491; +inp[25567] = 0; +inp[25568] = 1073332302; +inp[25569] = 0; +inp[25570] = 1073324113; +inp[25571] = 0; +inp[25572] = 1073315924; +inp[25573] = 0; +inp[25574] = 1073307735; +inp[25575] = 0; +inp[25576] = 1073299547; +inp[25577] = 0; +inp[25578] = 1073291358; +inp[25579] = 0; +inp[25580] = 1073283169; +inp[25581] = 0; +inp[25582] = 1073274981; +inp[25583] = 0; +inp[25584] = 1073266793; +inp[25585] = 0; +inp[25586] = 1073258604; +inp[25587] = 0; +inp[25588] = 1073250416; +inp[25589] = 0; +inp[25590] = 1073242228; +inp[25591] = 0; +inp[25592] = 1073234040; +inp[25593] = 0; +inp[25594] = 1073225852; +inp[25595] = 0; +inp[25596] = 1073217663; +inp[25597] = 0; +inp[25598] = 1073209476; +inp[25599] = 0; +inp[25600] = 1073201288; +inp[25601] = 0; +inp[25602] = 1073193100; +inp[25603] = 0; +inp[25604] = 1073184912; +inp[25605] = 0; +inp[25606] = 1073176724; +inp[25607] = 0; +inp[25608] = 1073168537; +inp[25609] = 0; +inp[25610] = 1073160349; +inp[25611] = 0; +inp[25612] = 1073152161; +inp[25613] = 0; +inp[25614] = 1073143974; +inp[25615] = 0; +inp[25616] = 1073135787; +inp[25617] = 0; +inp[25618] = 1073127599; +inp[25619] = 0; +inp[25620] = 1073119412; +inp[25621] = 0; +inp[25622] = 1073111225; +inp[25623] = 0; +inp[25624] = 1073103038; +inp[25625] = 0; +inp[25626] = 1073094850; +inp[25627] = 0; +inp[25628] = 1073086663; +inp[25629] = 0; +inp[25630] = 1073078476; +inp[25631] = 0; +inp[25632] = 1073070290; +inp[25633] = 0; +inp[25634] = 1073062103; +inp[25635] = 0; +inp[25636] = 1073053916; +inp[25637] = 0; +inp[25638] = 1073045729; +inp[25639] = 0; +inp[25640] = 1073037543; +inp[25641] = 0; +inp[25642] = 1073029356; +inp[25643] = 0; +inp[25644] = 1073021169; +inp[25645] = 0; +inp[25646] = 1073012983; +inp[25647] = 0; +inp[25648] = 1073004797; +inp[25649] = 0; +inp[25650] = 1072996610; +inp[25651] = 0; +inp[25652] = 1072988424; +inp[25653] = 0; +inp[25654] = 1072980238; +inp[25655] = 0; +inp[25656] = 1072972052; +inp[25657] = 0; +inp[25658] = 1072963865; +inp[25659] = 0; +inp[25660] = 1072955679; +inp[25661] = 0; +inp[25662] = 1072947493; +inp[25663] = 0; +inp[25664] = 1072939308; +inp[25665] = 0; +inp[25666] = 1072931122; +inp[25667] = 0; +inp[25668] = 1072922936; +inp[25669] = 0; +inp[25670] = 1072914750; +inp[25671] = 0; +inp[25672] = 1072906565; +inp[25673] = 0; +inp[25674] = 1072898379; +inp[25675] = 0; +inp[25676] = 1072890193; +inp[25677] = 0; +inp[25678] = 1072882008; +inp[25679] = 0; +inp[25680] = 1072873823; +inp[25681] = 0; +inp[25682] = 1072865637; +inp[25683] = 0; +inp[25684] = 1072857452; +inp[25685] = 0; +inp[25686] = 1072849267; +inp[25687] = 0; +inp[25688] = 1072841082; +inp[25689] = 0; +inp[25690] = 1072832896; +inp[25691] = 0; +inp[25692] = 1072824711; +inp[25693] = 0; +inp[25694] = 1072816526; +inp[25695] = 0; +inp[25696] = 1072808342; +inp[25697] = 0; +inp[25698] = 1072800157; +inp[25699] = 0; +inp[25700] = 1072791972; +inp[25701] = 0; +inp[25702] = 1072783787; +inp[25703] = 0; +inp[25704] = 1072775602; +inp[25705] = 0; +inp[25706] = 1072767418; +inp[25707] = 0; +inp[25708] = 1072759233; +inp[25709] = 0; +inp[25710] = 1072751049; +inp[25711] = 0; +inp[25712] = 1072742864; +inp[25713] = 0; +inp[25714] = 1072734680; +inp[25715] = 0; +inp[25716] = 1072726496; +inp[25717] = 0; +inp[25718] = 1072718312; +inp[25719] = 0; +inp[25720] = 1072710127; +inp[25721] = 0; +inp[25722] = 1072701943; +inp[25723] = 0; +inp[25724] = 1072693759; +inp[25725] = 0; +inp[25726] = 1072685575; +inp[25727] = 0; +inp[25728] = 1072677391; +inp[25729] = 0; +inp[25730] = 1072669208; +inp[25731] = 0; +inp[25732] = 1072661024; +inp[25733] = 0; +inp[25734] = 1072652840; +inp[25735] = 0; +inp[25736] = 1072644656; +inp[25737] = 0; +inp[25738] = 1072636473; +inp[25739] = 0; +inp[25740] = 1072628289; +inp[25741] = 0; +inp[25742] = 1072620106; +inp[25743] = 0; +inp[25744] = 1072611922; +inp[25745] = 0; +inp[25746] = 1072603739; +inp[25747] = 0; +inp[25748] = 1072595556; +inp[25749] = 0; +inp[25750] = 1072587373; +inp[25751] = 0; +inp[25752] = 1072579189; +inp[25753] = 0; +inp[25754] = 1072571006; +inp[25755] = 0; +inp[25756] = 1072562823; +inp[25757] = 0; +inp[25758] = 1072554640; +inp[25759] = 0; +inp[25760] = 1072546457; +inp[25761] = 0; +inp[25762] = 1072538275; +inp[25763] = 0; +inp[25764] = 1072530092; +inp[25765] = 0; +inp[25766] = 1072521909; +inp[25767] = 0; +inp[25768] = 1072513726; +inp[25769] = 0; +inp[25770] = 1072505544; +inp[25771] = 0; +inp[25772] = 1072497361; +inp[25773] = 0; +inp[25774] = 1072489179; +inp[25775] = 0; +inp[25776] = 1072480996; +inp[25777] = 0; +inp[25778] = 1072472814; +inp[25779] = 0; +inp[25780] = 1072464632; +inp[25781] = 0; +inp[25782] = 1072456449; +inp[25783] = 0; +inp[25784] = 1072448267; +inp[25785] = 0; +inp[25786] = 1072440085; +inp[25787] = 0; +inp[25788] = 1072431903; +inp[25789] = 0; +inp[25790] = 1072423721; +inp[25791] = 0; +inp[25792] = 1072415539; +inp[25793] = 0; +inp[25794] = 1072407357; +inp[25795] = 0; +inp[25796] = 1072399176; +inp[25797] = 0; +inp[25798] = 1072390994; +inp[25799] = 0; +inp[25800] = 1072382812; +inp[25801] = 0; +inp[25802] = 1072374631; +inp[25803] = 0; +inp[25804] = 1072366449; +inp[25805] = 0; +inp[25806] = 1072358268; +inp[25807] = 0; +inp[25808] = 1072350086; +inp[25809] = 0; +inp[25810] = 1072341905; +inp[25811] = 0; +inp[25812] = 1072333724; +inp[25813] = 0; +inp[25814] = 1072325542; +inp[25815] = 0; +inp[25816] = 1072317361; +inp[25817] = 0; +inp[25818] = 1072309180; +inp[25819] = 0; +inp[25820] = 1072300999; +inp[25821] = 0; +inp[25822] = 1072292818; +inp[25823] = 0; +inp[25824] = 1072284637; +inp[25825] = 0; +inp[25826] = 1072276456; +inp[25827] = 0; +inp[25828] = 1072268276; +inp[25829] = 0; +inp[25830] = 1072260095; +inp[25831] = 0; +inp[25832] = 1072251914; +inp[25833] = 0; +inp[25834] = 1072243734; +inp[25835] = 0; +inp[25836] = 1072235553; +inp[25837] = 0; +inp[25838] = 1072227373; +inp[25839] = 0; +inp[25840] = 1072219192; +inp[25841] = 0; +inp[25842] = 1072211012; +inp[25843] = 0; +inp[25844] = 1072202831; +inp[25845] = 0; +inp[25846] = 1072194651; +inp[25847] = 0; +inp[25848] = 1072186471; +inp[25849] = 0; +inp[25850] = 1072178291; +inp[25851] = 0; +inp[25852] = 1072170111; +inp[25853] = 0; +inp[25854] = 1072161931; +inp[25855] = 0; +inp[25856] = 1072153751; +inp[25857] = 0; +inp[25858] = 1072145571; +inp[25859] = 0; +inp[25860] = 1072137391; +inp[25861] = 0; +inp[25862] = 1072129212; +inp[25863] = 0; +inp[25864] = 1072121032; +inp[25865] = 0; +inp[25866] = 1072112852; +inp[25867] = 0; +inp[25868] = 1072104673; +inp[25869] = 0; +inp[25870] = 1072096493; +inp[25871] = 0; +inp[25872] = 1072088314; +inp[25873] = 0; +inp[25874] = 1072080135; +inp[25875] = 0; +inp[25876] = 1072071955; +inp[25877] = 0; +inp[25878] = 1072063776; +inp[25879] = 0; +inp[25880] = 1072055597; +inp[25881] = 0; +inp[25882] = 1072047418; +inp[25883] = 0; +inp[25884] = 1072039239; +inp[25885] = 0; +inp[25886] = 1072031060; +inp[25887] = 0; +inp[25888] = 1072022881; +inp[25889] = 0; +inp[25890] = 1072014702; +inp[25891] = 0; +inp[25892] = 1072006523; +inp[25893] = 0; +inp[25894] = 1071998345; +inp[25895] = 0; +inp[25896] = 1071990166; +inp[25897] = 0; +inp[25898] = 1071981987; +inp[25899] = 0; +inp[25900] = 1071973809; +inp[25901] = 0; +inp[25902] = 1071965630; +inp[25903] = 0; +inp[25904] = 1071957452; +inp[25905] = 0; +inp[25906] = 1071949273; +inp[25907] = 0; +inp[25908] = 1071941095; +inp[25909] = 0; +inp[25910] = 1071932917; +inp[25911] = 0; +inp[25912] = 1071924739; +inp[25913] = 0; +inp[25914] = 1071916561; +inp[25915] = 0; +inp[25916] = 1071908383; +inp[25917] = 0; +inp[25918] = 1071900205; +inp[25919] = 0; +inp[25920] = 1071892027; +inp[25921] = 0; +inp[25922] = 1071883849; +inp[25923] = 0; +inp[25924] = 1071875671; +inp[25925] = 0; +inp[25926] = 1071867493; +inp[25927] = 0; +inp[25928] = 1071859316; +inp[25929] = 0; +inp[25930] = 1071851138; +inp[25931] = 0; +inp[25932] = 1071842961; +inp[25933] = 0; +inp[25934] = 1071834783; +inp[25935] = 0; +inp[25936] = 1071826606; +inp[25937] = 0; +inp[25938] = 1071818428; +inp[25939] = 0; +inp[25940] = 1071810251; +inp[25941] = 0; +inp[25942] = 1071802074; +inp[25943] = 0; +inp[25944] = 1071793897; +inp[25945] = 0; +inp[25946] = 1071785719; +inp[25947] = 0; +inp[25948] = 1071777542; +inp[25949] = 0; +inp[25950] = 1071769365; +inp[25951] = 0; +inp[25952] = 1071761188; +inp[25953] = 0; +inp[25954] = 1071753012; +inp[25955] = 0; +inp[25956] = 1071744835; +inp[25957] = 0; +inp[25958] = 1071736658; +inp[25959] = 0; +inp[25960] = 1071728481; +inp[25961] = 0; +inp[25962] = 1071720305; +inp[25963] = 0; +inp[25964] = 1071712128; +inp[25965] = 0; +inp[25966] = 1071703952; +inp[25967] = 0; +inp[25968] = 1071695775; +inp[25969] = 0; +inp[25970] = 1071687599; +inp[25971] = 0; +inp[25972] = 1071679423; +inp[25973] = 0; +inp[25974] = 1071671246; +inp[25975] = 0; +inp[25976] = 1071663070; +inp[25977] = 0; +inp[25978] = 1071654894; +inp[25979] = 0; +inp[25980] = 1073741824; +inp[25981] = 1073741824; +inp[25982] = 1073737728; +inp[25983] = 0; +inp[25984] = 1073733632; +inp[25985] = 0; +inp[25986] = 1073729536; +inp[25987] = 0; +inp[25988] = 1073725440; +inp[25989] = 0; +inp[25990] = 1073721344; +inp[25991] = 0; +inp[25992] = 1073717248; +inp[25993] = 0; +inp[25994] = 1073713152; +inp[25995] = 0; +inp[25996] = 1073709056; +inp[25997] = 0; +inp[25998] = 1073704960; +inp[25999] = 0; +inp[26000] = 1073700864; +inp[26001] = 0; +inp[26002] = 1073696768; +inp[26003] = 0; +inp[26004] = 1073692673; +inp[26005] = 0; +inp[26006] = 1073688577; +inp[26007] = 0; +inp[26008] = 1073684481; +inp[26009] = 0; +inp[26010] = 1073680385; +inp[26011] = 0; +inp[26012] = 1073676289; +inp[26013] = 0; +inp[26014] = 1073672194; +inp[26015] = 0; +inp[26016] = 1073668098; +inp[26017] = 0; +inp[26018] = 1073664002; +inp[26019] = 0; +inp[26020] = 1073659907; +inp[26021] = 0; +inp[26022] = 1073655811; +inp[26023] = 0; +inp[26024] = 1073651715; +inp[26025] = 0; +inp[26026] = 1073647620; +inp[26027] = 0; +inp[26028] = 1073643524; +inp[26029] = 0; +inp[26030] = 1073639428; +inp[26031] = 0; +inp[26032] = 1073635333; +inp[26033] = 0; +inp[26034] = 1073631237; +inp[26035] = 0; +inp[26036] = 1073627142; +inp[26037] = 0; +inp[26038] = 1073623046; +inp[26039] = 0; +inp[26040] = 1073618951; +inp[26041] = 0; +inp[26042] = 1073614855; +inp[26043] = 0; +inp[26044] = 1073610759; +inp[26045] = 0; +inp[26046] = 1073606664; +inp[26047] = 0; +inp[26048] = 1073602569; +inp[26049] = 0; +inp[26050] = 1073598473; +inp[26051] = 0; +inp[26052] = 1073594378; +inp[26053] = 0; +inp[26054] = 1073590282; +inp[26055] = 0; +inp[26056] = 1073586187; +inp[26057] = 0; +inp[26058] = 1073582091; +inp[26059] = 0; +inp[26060] = 1073577996; +inp[26061] = 0; +inp[26062] = 1073573901; +inp[26063] = 0; +inp[26064] = 1073569805; +inp[26065] = 0; +inp[26066] = 1073565710; +inp[26067] = 0; +inp[26068] = 1073561615; +inp[26069] = 0; +inp[26070] = 1073557519; +inp[26071] = 0; +inp[26072] = 1073553424; +inp[26073] = 0; +inp[26074] = 1073549329; +inp[26075] = 0; +inp[26076] = 1073545233; +inp[26077] = 0; +inp[26078] = 1073541138; +inp[26079] = 0; +inp[26080] = 1073537043; +inp[26081] = 0; +inp[26082] = 1073532948; +inp[26083] = 0; +inp[26084] = 1073528853; +inp[26085] = 0; +inp[26086] = 1073524757; +inp[26087] = 0; +inp[26088] = 1073520662; +inp[26089] = 0; +inp[26090] = 1073516567; +inp[26091] = 0; +inp[26092] = 1073512472; +inp[26093] = 0; +inp[26094] = 1073508377; +inp[26095] = 0; +inp[26096] = 1073504282; +inp[26097] = 0; +inp[26098] = 1073500187; +inp[26099] = 0; +inp[26100] = 1073496092; +inp[26101] = 0; +inp[26102] = 1073491997; +inp[26103] = 0; +inp[26104] = 1073487902; +inp[26105] = 0; +inp[26106] = 1073483807; +inp[26107] = 0; +inp[26108] = 1073479711; +inp[26109] = 0; +inp[26110] = 1073475617; +inp[26111] = 0; +inp[26112] = 1073471522; +inp[26113] = 0; +inp[26114] = 1073467427; +inp[26115] = 0; +inp[26116] = 1073463332; +inp[26117] = 0; +inp[26118] = 1073459237; +inp[26119] = 0; +inp[26120] = 1073455142; +inp[26121] = 0; +inp[26122] = 1073451047; +inp[26123] = 0; +inp[26124] = 1073446952; +inp[26125] = 0; +inp[26126] = 1073442857; +inp[26127] = 0; +inp[26128] = 1073438762; +inp[26129] = 0; +inp[26130] = 1073434667; +inp[26131] = 0; +inp[26132] = 1073430573; +inp[26133] = 0; +inp[26134] = 1073426478; +inp[26135] = 0; +inp[26136] = 1073422383; +inp[26137] = 0; +inp[26138] = 1073418288; +inp[26139] = 0; +inp[26140] = 1073414193; +inp[26141] = 0; +inp[26142] = 1073410099; +inp[26143] = 0; +inp[26144] = 1073406004; +inp[26145] = 0; +inp[26146] = 1073401909; +inp[26147] = 0; +inp[26148] = 1073397815; +inp[26149] = 0; +inp[26150] = 1073393720; +inp[26151] = 0; +inp[26152] = 1073389625; +inp[26153] = 0; +inp[26154] = 1073385531; +inp[26155] = 0; +inp[26156] = 1073381436; +inp[26157] = 0; +inp[26158] = 1073377341; +inp[26159] = 0; +inp[26160] = 1073373247; +inp[26161] = 0; +inp[26162] = 1073369152; +inp[26163] = 0; +inp[26164] = 1073365058; +inp[26165] = 0; +inp[26166] = 1073360963; +inp[26167] = 0; +inp[26168] = 1073356869; +inp[26169] = 0; +inp[26170] = 1073352774; +inp[26171] = 0; +inp[26172] = 1073348679; +inp[26173] = 0; +inp[26174] = 1073344585; +inp[26175] = 0; +inp[26176] = 1073340491; +inp[26177] = 0; +inp[26178] = 1073336396; +inp[26179] = 0; +inp[26180] = 1073332302; +inp[26181] = 0; +inp[26182] = 1073328207; +inp[26183] = 0; +inp[26184] = 1073324113; +inp[26185] = 0; +inp[26186] = 1073320018; +inp[26187] = 0; +inp[26188] = 1073315924; +inp[26189] = 0; +inp[26190] = 1073311830; +inp[26191] = 0; +inp[26192] = 1073307735; +inp[26193] = 0; +inp[26194] = 1073303641; +inp[26195] = 0; +inp[26196] = 1073299547; +inp[26197] = 0; +inp[26198] = 1073295452; +inp[26199] = 0; +inp[26200] = 1073291358; +inp[26201] = 0; +inp[26202] = 1073287264; +inp[26203] = 0; +inp[26204] = 1073283169; +inp[26205] = 0; +inp[26206] = 1073279075; +inp[26207] = 0; +inp[26208] = 1073274981; +inp[26209] = 0; +inp[26210] = 1073270887; +inp[26211] = 0; +inp[26212] = 1073266793; +inp[26213] = 0; +inp[26214] = 1073262698; +inp[26215] = 0; +inp[26216] = 1073258604; +inp[26217] = 0; +inp[26218] = 1073254510; +inp[26219] = 0; +inp[26220] = 1073250416; +inp[26221] = 0; +inp[26222] = 1073246322; +inp[26223] = 0; +inp[26224] = 1073242228; +inp[26225] = 0; +inp[26226] = 1073238134; +inp[26227] = 0; +inp[26228] = 1073234040; +inp[26229] = 0; +inp[26230] = 1073229946; +inp[26231] = 0; +inp[26232] = 1073225852; +inp[26233] = 0; +inp[26234] = 1073221757; +inp[26235] = 0; +inp[26236] = 1073217663; +inp[26237] = 0; +inp[26238] = 1073213569; +inp[26239] = 0; +inp[26240] = 1073209476; +inp[26241] = 0; +inp[26242] = 1073205382; +inp[26243] = 0; +inp[26244] = 1073201288; +inp[26245] = 0; +inp[26246] = 1073197194; +inp[26247] = 0; +inp[26248] = 1073193100; +inp[26249] = 0; +inp[26250] = 1073189006; +inp[26251] = 0; +inp[26252] = 1073184912; +inp[26253] = 0; +inp[26254] = 1073180818; +inp[26255] = 0; +inp[26256] = 1073176724; +inp[26257] = 0; +inp[26258] = 1073172630; +inp[26259] = 0; +inp[26260] = 1073168537; +inp[26261] = 0; +inp[26262] = 1073164443; +inp[26263] = 0; +inp[26264] = 1073160349; +inp[26265] = 0; +inp[26266] = 1073156255; +inp[26267] = 0; +inp[26268] = 1073152161; +inp[26269] = 0; +inp[26270] = 1073148068; +inp[26271] = 0; +inp[26272] = 1073143974; +inp[26273] = 0; +inp[26274] = 1073139880; +inp[26275] = 0; +inp[26276] = 1073135787; +inp[26277] = 0; +inp[26278] = 1073131693; +inp[26279] = 0; +inp[26280] = 1073127599; +inp[26281] = 0; +inp[26282] = 1073123506; +inp[26283] = 0; +inp[26284] = 1073119412; +inp[26285] = 0; +inp[26286] = 1073115318; +inp[26287] = 0; +inp[26288] = 1073111225; +inp[26289] = 0; +inp[26290] = 1073107131; +inp[26291] = 0; +inp[26292] = 1073103038; +inp[26293] = 0; +inp[26294] = 1073098944; +inp[26295] = 0; +inp[26296] = 1073094850; +inp[26297] = 0; +inp[26298] = 1073090757; +inp[26299] = 0; +inp[26300] = 1073086663; +inp[26301] = 0; +inp[26302] = 1073082570; +inp[26303] = 0; +inp[26304] = 1073078476; +inp[26305] = 0; +inp[26306] = 1073074383; +inp[26307] = 0; +inp[26308] = 1073070290; +inp[26309] = 0; +inp[26310] = 1073066196; +inp[26311] = 0; +inp[26312] = 1073062103; +inp[26313] = 0; +inp[26314] = 1073058009; +inp[26315] = 0; +inp[26316] = 1073053916; +inp[26317] = 0; +inp[26318] = 1073049823; +inp[26319] = 0; +inp[26320] = 1073045729; +inp[26321] = 0; +inp[26322] = 1073041636; +inp[26323] = 0; +inp[26324] = 1073037543; +inp[26325] = 0; +inp[26326] = 1073033449; +inp[26327] = 0; +inp[26328] = 1073029356; +inp[26329] = 0; +inp[26330] = 1073025263; +inp[26331] = 0; +inp[26332] = 1073021169; +inp[26333] = 0; +inp[26334] = 1073017076; +inp[26335] = 0; +inp[26336] = 1073012983; +inp[26337] = 0; +inp[26338] = 1073008890; +inp[26339] = 0; +inp[26340] = 1073004797; +inp[26341] = 0; +inp[26342] = 1073000703; +inp[26343] = 0; +inp[26344] = 1072996610; +inp[26345] = 0; +inp[26346] = 1072992517; +inp[26347] = 0; +inp[26348] = 1072988424; +inp[26349] = 0; +inp[26350] = 1072984331; +inp[26351] = 0; +inp[26352] = 1072980238; +inp[26353] = 0; +inp[26354] = 1072976145; +inp[26355] = 0; +inp[26356] = 1072972052; +inp[26357] = 0; +inp[26358] = 1072967959; +inp[26359] = 0; +inp[26360] = 1072963865; +inp[26361] = 0; +inp[26362] = 1072959772; +inp[26363] = 0; +inp[26364] = 1072955679; +inp[26365] = 0; +inp[26366] = 1072951586; +inp[26367] = 0; +inp[26368] = 1072947493; +inp[26369] = 0; +inp[26370] = 1072943400; +inp[26371] = 0; +inp[26372] = 1072939308; +inp[26373] = 0; +inp[26374] = 1072935215; +inp[26375] = 0; +inp[26376] = 1072931122; +inp[26377] = 0; +inp[26378] = 1072927029; +inp[26379] = 0; +inp[26380] = 1072922936; +inp[26381] = 0; +inp[26382] = 1072918843; +inp[26383] = 0; +inp[26384] = 1072914750; +inp[26385] = 0; +inp[26386] = 1072910657; +inp[26387] = 0; +inp[26388] = 1072906565; +inp[26389] = 0; +inp[26390] = 1072902472; +inp[26391] = 0; +inp[26392] = 1072898379; +inp[26393] = 0; +inp[26394] = 1072894286; +inp[26395] = 0; +inp[26396] = 1072890193; +inp[26397] = 0; +inp[26398] = 1072886101; +inp[26399] = 0; +inp[26400] = 1072882008; +inp[26401] = 0; +inp[26402] = 1072877915; +inp[26403] = 0; +inp[26404] = 1072873823; +inp[26405] = 0; +inp[26406] = 1072869730; +inp[26407] = 0; +inp[26408] = 1072865637; +inp[26409] = 0; +inp[26410] = 1072861545; +inp[26411] = 0; +inp[26412] = 1072857452; +inp[26413] = 0; +inp[26414] = 1072853359; +inp[26415] = 0; +inp[26416] = 1072849267; +inp[26417] = 0; +inp[26418] = 1072845174; +inp[26419] = 0; +inp[26420] = 1072841082; +inp[26421] = 0; +inp[26422] = 1072836989; +inp[26423] = 0; +inp[26424] = 1072832896; +inp[26425] = 0; +inp[26426] = 1072828804; +inp[26427] = 0; +inp[26428] = 1072824711; +inp[26429] = 0; +inp[26430] = 1072820619; +inp[26431] = 0; +inp[26432] = 1072816526; +inp[26433] = 0; +inp[26434] = 1072812434; +inp[26435] = 0; +inp[26436] = 1072808342; +inp[26437] = 0; +inp[26438] = 1072804249; +inp[26439] = 0; +inp[26440] = 1072800157; +inp[26441] = 0; +inp[26442] = 1072796064; +inp[26443] = 0; +inp[26444] = 1072791972; +inp[26445] = 0; +inp[26446] = 1072787880; +inp[26447] = 0; +inp[26448] = 1072783787; +inp[26449] = 0; +inp[26450] = 1072779695; +inp[26451] = 0; +inp[26452] = 1072775602; +inp[26453] = 0; +inp[26454] = 1072771510; +inp[26455] = 0; +inp[26456] = 1072767418; +inp[26457] = 0; +inp[26458] = 1072763326; +inp[26459] = 0; +inp[26460] = 1072759233; +inp[26461] = 0; +inp[26462] = 1072755141; +inp[26463] = 0; +inp[26464] = 1072751049; +inp[26465] = 0; +inp[26466] = 1072746957; +inp[26467] = 0; +inp[26468] = 1072742864; +inp[26469] = 0; +inp[26470] = 1072738772; +inp[26471] = 0; +inp[26472] = 1072734680; +inp[26473] = 0; +inp[26474] = 1072730588; +inp[26475] = 0; +inp[26476] = 1072726496; +inp[26477] = 0; +inp[26478] = 1072722404; +inp[26479] = 0; +inp[26480] = 1072718312; +inp[26481] = 0; +inp[26482] = 1072714220; +inp[26483] = 0; +inp[26484] = 1072710127; +inp[26485] = 0; +inp[26486] = 1072706035; +inp[26487] = 0; +inp[26488] = 1072701943; +inp[26489] = 0; +inp[26490] = 1072697851; +inp[26491] = 0; +inp[26492] = 1073741824; +inp[26493] = 1073741824; +inp[26494] = 1073739776; +inp[26495] = 0; +inp[26496] = 1073737728; +inp[26497] = 0; +inp[26498] = 1073735680; +inp[26499] = 0; +inp[26500] = 1073733632; +inp[26501] = 0; +inp[26502] = 1073731584; +inp[26503] = 0; +inp[26504] = 1073729536; +inp[26505] = 0; +inp[26506] = 1073727488; +inp[26507] = 0; +inp[26508] = 1073725440; +inp[26509] = 0; +inp[26510] = 1073723392; +inp[26511] = 0; +inp[26512] = 1073721344; +inp[26513] = 0; +inp[26514] = 1073719296; +inp[26515] = 0; +inp[26516] = 1073717248; +inp[26517] = 0; +inp[26518] = 1073715200; +inp[26519] = 0; +inp[26520] = 1073713152; +inp[26521] = 0; +inp[26522] = 1073711104; +inp[26523] = 0; +inp[26524] = 1073709056; +inp[26525] = 0; +inp[26526] = 1073707008; +inp[26527] = 0; +inp[26528] = 1073704960; +inp[26529] = 0; +inp[26530] = 1073702912; +inp[26531] = 0; +inp[26532] = 1073700864; +inp[26533] = 0; +inp[26534] = 1073698816; +inp[26535] = 0; +inp[26536] = 1073696768; +inp[26537] = 0; +inp[26538] = 1073694721; +inp[26539] = 0; +inp[26540] = 1073692673; +inp[26541] = 0; +inp[26542] = 1073690625; +inp[26543] = 0; +inp[26544] = 1073688577; +inp[26545] = 0; +inp[26546] = 1073686529; +inp[26547] = 0; +inp[26548] = 1073684481; +inp[26549] = 0; +inp[26550] = 1073682433; +inp[26551] = 0; +inp[26552] = 1073680385; +inp[26553] = 0; +inp[26554] = 1073678337; +inp[26555] = 0; +inp[26556] = 1073676289; +inp[26557] = 0; +inp[26558] = 1073674242; +inp[26559] = 0; +inp[26560] = 1073672194; +inp[26561] = 0; +inp[26562] = 1073670146; +inp[26563] = 0; +inp[26564] = 1073668098; +inp[26565] = 0; +inp[26566] = 1073666050; +inp[26567] = 0; +inp[26568] = 1073664002; +inp[26569] = 0; +inp[26570] = 1073661954; +inp[26571] = 0; +inp[26572] = 1073659907; +inp[26573] = 0; +inp[26574] = 1073657859; +inp[26575] = 0; +inp[26576] = 1073655811; +inp[26577] = 0; +inp[26578] = 1073653763; +inp[26579] = 0; +inp[26580] = 1073651715; +inp[26581] = 0; +inp[26582] = 1073649667; +inp[26583] = 0; +inp[26584] = 1073647620; +inp[26585] = 0; +inp[26586] = 1073645572; +inp[26587] = 0; +inp[26588] = 1073643524; +inp[26589] = 0; +inp[26590] = 1073641476; +inp[26591] = 0; +inp[26592] = 1073639428; +inp[26593] = 0; +inp[26594] = 1073637381; +inp[26595] = 0; +inp[26596] = 1073635333; +inp[26597] = 0; +inp[26598] = 1073633285; +inp[26599] = 0; +inp[26600] = 1073631237; +inp[26601] = 0; +inp[26602] = 1073629189; +inp[26603] = 0; +inp[26604] = 1073627142; +inp[26605] = 0; +inp[26606] = 1073625094; +inp[26607] = 0; +inp[26608] = 1073623046; +inp[26609] = 0; +inp[26610] = 1073620998; +inp[26611] = 0; +inp[26612] = 1073618951; +inp[26613] = 0; +inp[26614] = 1073616903; +inp[26615] = 0; +inp[26616] = 1073614855; +inp[26617] = 0; +inp[26618] = 1073612807; +inp[26619] = 0; +inp[26620] = 1073610759; +inp[26621] = 0; +inp[26622] = 1073608712; +inp[26623] = 0; +inp[26624] = 1073606664; +inp[26625] = 0; +inp[26626] = 1073604616; +inp[26627] = 0; +inp[26628] = 1073602569; +inp[26629] = 0; +inp[26630] = 1073600521; +inp[26631] = 0; +inp[26632] = 1073598473; +inp[26633] = 0; +inp[26634] = 1073596425; +inp[26635] = 0; +inp[26636] = 1073594378; +inp[26637] = 0; +inp[26638] = 1073592330; +inp[26639] = 0; +inp[26640] = 1073590282; +inp[26641] = 0; +inp[26642] = 1073588234; +inp[26643] = 0; +inp[26644] = 1073586187; +inp[26645] = 0; +inp[26646] = 1073584139; +inp[26647] = 0; +inp[26648] = 1073582091; +inp[26649] = 0; +inp[26650] = 1073580044; +inp[26651] = 0; +inp[26652] = 1073577996; +inp[26653] = 0; +inp[26654] = 1073575948; +inp[26655] = 0; +inp[26656] = 1073573901; +inp[26657] = 0; +inp[26658] = 1073571853; +inp[26659] = 0; +inp[26660] = 1073569805; +inp[26661] = 0; +inp[26662] = 1073567758; +inp[26663] = 0; +inp[26664] = 1073565710; +inp[26665] = 0; +inp[26666] = 1073563662; +inp[26667] = 0; +inp[26668] = 1073561615; +inp[26669] = 0; +inp[26670] = 1073559567; +inp[26671] = 0; +inp[26672] = 1073557519; +inp[26673] = 0; +inp[26674] = 1073555472; +inp[26675] = 0; +inp[26676] = 1073553424; +inp[26677] = 0; +inp[26678] = 1073551376; +inp[26679] = 0; +inp[26680] = 1073549329; +inp[26681] = 0; +inp[26682] = 1073547281; +inp[26683] = 0; +inp[26684] = 1073545233; +inp[26685] = 0; +inp[26686] = 1073543186; +inp[26687] = 0; +inp[26688] = 1073541138; +inp[26689] = 0; +inp[26690] = 1073539091; +inp[26691] = 0; +inp[26692] = 1073537043; +inp[26693] = 0; +inp[26694] = 1073534995; +inp[26695] = 0; +inp[26696] = 1073532948; +inp[26697] = 0; +inp[26698] = 1073530900; +inp[26699] = 0; +inp[26700] = 1073528853; +inp[26701] = 0; +inp[26702] = 1073526805; +inp[26703] = 0; +inp[26704] = 1073524757; +inp[26705] = 0; +inp[26706] = 1073522710; +inp[26707] = 0; +inp[26708] = 1073520662; +inp[26709] = 0; +inp[26710] = 1073518615; +inp[26711] = 0; +inp[26712] = 1073516567; +inp[26713] = 0; +inp[26714] = 1073514520; +inp[26715] = 0; +inp[26716] = 1073512472; +inp[26717] = 0; +inp[26718] = 1073510424; +inp[26719] = 0; +inp[26720] = 1073508377; +inp[26721] = 0; +inp[26722] = 1073506329; +inp[26723] = 0; +inp[26724] = 1073504282; +inp[26725] = 0; +inp[26726] = 1073502234; +inp[26727] = 0; +inp[26728] = 1073500187; +inp[26729] = 0; +inp[26730] = 1073498139; +inp[26731] = 0; +inp[26732] = 1073496092; +inp[26733] = 0; +inp[26734] = 1073494044; +inp[26735] = 0; +inp[26736] = 1073491997; +inp[26737] = 0; +inp[26738] = 1073489949; +inp[26739] = 0; +inp[26740] = 1073487902; +inp[26741] = 0; +inp[26742] = 1073485854; +inp[26743] = 0; +inp[26744] = 1073483807; +inp[26745] = 0; +inp[26746] = 1073481759; +inp[26747] = 0; +inp[26748] = 1073479711; +inp[26749] = 0; +inp[26750] = 1073477664; +inp[26751] = 0; +inp[26752] = 1073475617; +inp[26753] = 0; +inp[26754] = 1073473569; +inp[26755] = 0; +inp[26756] = 1073471522; +inp[26757] = 0; +inp[26758] = 1073469474; +inp[26759] = 0; +inp[26760] = 1073467427; +inp[26761] = 0; +inp[26762] = 1073465379; +inp[26763] = 0; +inp[26764] = 1073463332; +inp[26765] = 0; +inp[26766] = 1073461284; +inp[26767] = 0; +inp[26768] = 1073459237; +inp[26769] = 0; +inp[26770] = 1073457189; +inp[26771] = 0; +inp[26772] = 1073455142; +inp[26773] = 0; +inp[26774] = 1073453094; +inp[26775] = 0; +inp[26776] = 1073451047; +inp[26777] = 0; +inp[26778] = 1073448999; +inp[26779] = 0; +inp[26780] = 1073446952; +inp[26781] = 0; +inp[26782] = 1073444905; +inp[26783] = 0; +inp[26784] = 1073442857; +inp[26785] = 0; +inp[26786] = 1073440810; +inp[26787] = 0; +inp[26788] = 1073438762; +inp[26789] = 0; +inp[26790] = 1073436715; +inp[26791] = 0; +inp[26792] = 1073434667; +inp[26793] = 0; +inp[26794] = 1073432620; +inp[26795] = 0; +inp[26796] = 1073430573; +inp[26797] = 0; +inp[26798] = 1073428525; +inp[26799] = 0; +inp[26800] = 1073426478; +inp[26801] = 0; +inp[26802] = 1073424430; +inp[26803] = 0; +inp[26804] = 1073422383; +inp[26805] = 0; +inp[26806] = 1073420336; +inp[26807] = 0; +inp[26808] = 1073418288; +inp[26809] = 0; +inp[26810] = 1073416241; +inp[26811] = 0; +inp[26812] = 1073414193; +inp[26813] = 0; +inp[26814] = 1073412146; +inp[26815] = 0; +inp[26816] = 1073410099; +inp[26817] = 0; +inp[26818] = 1073408051; +inp[26819] = 0; +inp[26820] = 1073406004; +inp[26821] = 0; +inp[26822] = 1073403957; +inp[26823] = 0; +inp[26824] = 1073401909; +inp[26825] = 0; +inp[26826] = 1073399862; +inp[26827] = 0; +inp[26828] = 1073397815; +inp[26829] = 0; +inp[26830] = 1073395767; +inp[26831] = 0; +inp[26832] = 1073393720; +inp[26833] = 0; +inp[26834] = 1073391673; +inp[26835] = 0; +inp[26836] = 1073389625; +inp[26837] = 0; +inp[26838] = 1073387578; +inp[26839] = 0; +inp[26840] = 1073385531; +inp[26841] = 0; +inp[26842] = 1073383483; +inp[26843] = 0; +inp[26844] = 1073381436; +inp[26845] = 0; +inp[26846] = 1073379389; +inp[26847] = 0; +inp[26848] = 1073377341; +inp[26849] = 0; +inp[26850] = 1073375294; +inp[26851] = 0; +inp[26852] = 1073373247; +inp[26853] = 0; +inp[26854] = 1073371199; +inp[26855] = 0; +inp[26856] = 1073369152; +inp[26857] = 0; +inp[26858] = 1073367105; +inp[26859] = 0; +inp[26860] = 1073365058; +inp[26861] = 0; +inp[26862] = 1073363010; +inp[26863] = 0; +inp[26864] = 1073360963; +inp[26865] = 0; +inp[26866] = 1073358916; +inp[26867] = 0; +inp[26868] = 1073356869; +inp[26869] = 0; +inp[26870] = 1073354821; +inp[26871] = 0; +inp[26872] = 1073352774; +inp[26873] = 0; +inp[26874] = 1073350727; +inp[26875] = 0; +inp[26876] = 1073348679; +inp[26877] = 0; +inp[26878] = 1073346632; +inp[26879] = 0; +inp[26880] = 1073344585; +inp[26881] = 0; +inp[26882] = 1073342538; +inp[26883] = 0; +inp[26884] = 1073340491; +inp[26885] = 0; +inp[26886] = 1073338443; +inp[26887] = 0; +inp[26888] = 1073336396; +inp[26889] = 0; +inp[26890] = 1073334349; +inp[26891] = 0; +inp[26892] = 1073332302; +inp[26893] = 0; +inp[26894] = 1073330254; +inp[26895] = 0; +inp[26896] = 1073328207; +inp[26897] = 0; +inp[26898] = 1073326160; +inp[26899] = 0; +inp[26900] = 1073324113; +inp[26901] = 0; +inp[26902] = 1073322066; +inp[26903] = 0; +inp[26904] = 1073320018; +inp[26905] = 0; +inp[26906] = 1073317971; +inp[26907] = 0; +inp[26908] = 1073315924; +inp[26909] = 0; +inp[26910] = 1073313877; +inp[26911] = 0; +inp[26912] = 1073311830; +inp[26913] = 0; +inp[26914] = 1073309782; +inp[26915] = 0; +inp[26916] = 1073307735; +inp[26917] = 0; +inp[26918] = 1073305688; +inp[26919] = 0; +inp[26920] = 1073303641; +inp[26921] = 0; +inp[26922] = 1073301594; +inp[26923] = 0; +inp[26924] = 1073299547; +inp[26925] = 0; +inp[26926] = 1073297499; +inp[26927] = 0; +inp[26928] = 1073295452; +inp[26929] = 0; +inp[26930] = 1073293405; +inp[26931] = 0; +inp[26932] = 1073291358; +inp[26933] = 0; +inp[26934] = 1073289311; +inp[26935] = 0; +inp[26936] = 1073287264; +inp[26937] = 0; +inp[26938] = 1073285217; +inp[26939] = 0; +inp[26940] = 1073283169; +inp[26941] = 0; +inp[26942] = 1073281122; +inp[26943] = 0; +inp[26944] = 1073279075; +inp[26945] = 0; +inp[26946] = 1073277028; +inp[26947] = 0; +inp[26948] = 1073274981; +inp[26949] = 0; +inp[26950] = 1073272934; +inp[26951] = 0; +inp[26952] = 1073270887; +inp[26953] = 0; +inp[26954] = 1073268840; +inp[26955] = 0; +inp[26956] = 1073266793; +inp[26957] = 0; +inp[26958] = 1073264746; +inp[26959] = 0; +inp[26960] = 1073262698; +inp[26961] = 0; +inp[26962] = 1073260651; +inp[26963] = 0; +inp[26964] = 1073258604; +inp[26965] = 0; +inp[26966] = 1073256557; +inp[26967] = 0; +inp[26968] = 1073254510; +inp[26969] = 0; +inp[26970] = 1073252463; +inp[26971] = 0; +inp[26972] = 1073250416; +inp[26973] = 0; +inp[26974] = 1073248369; +inp[26975] = 0; +inp[26976] = 1073246322; +inp[26977] = 0; +inp[26978] = 1073244275; +inp[26979] = 0; +inp[26980] = 1073242228; +inp[26981] = 0; +inp[26982] = 1073240181; +inp[26983] = 0; +inp[26984] = 1073238134; +inp[26985] = 0; +inp[26986] = 1073236087; +inp[26987] = 0; +inp[26988] = 1073234040; +inp[26989] = 0; +inp[26990] = 1073231993; +inp[26991] = 0; +inp[26992] = 1073229946; +inp[26993] = 0; +inp[26994] = 1073227899; +inp[26995] = 0; +inp[26996] = 1073225852; +inp[26997] = 0; +inp[26998] = 1073223804; +inp[26999] = 0; +inp[27000] = 1073221757; +inp[27001] = 0; +inp[27002] = 1073219710; +inp[27003] = 0; +inp[27004] = 1073741824; +inp[27005] = 1073741824; +inp[27006] = 1073740800; +inp[27007] = 0; +inp[27008] = 1073739776; +inp[27009] = 0; +inp[27010] = 1073738752; +inp[27011] = 0; +inp[27012] = 1073737728; +inp[27013] = 0; +inp[27014] = 1073736704; +inp[27015] = 0; +inp[27016] = 1073735680; +inp[27017] = 0; +inp[27018] = 1073734656; +inp[27019] = 0; +inp[27020] = 1073733632; +inp[27021] = 0; +inp[27022] = 1073732608; +inp[27023] = 0; +inp[27024] = 1073731584; +inp[27025] = 0; +inp[27026] = 1073730560; +inp[27027] = 0; +inp[27028] = 1073729536; +inp[27029] = 0; +inp[27030] = 1073728512; +inp[27031] = 0; +inp[27032] = 1073727488; +inp[27033] = 0; +inp[27034] = 1073726464; +inp[27035] = 0; +inp[27036] = 1073725440; +inp[27037] = 0; +inp[27038] = 1073724416; +inp[27039] = 0; +inp[27040] = 1073723392; +inp[27041] = 0; +inp[27042] = 1073722368; +inp[27043] = 0; +inp[27044] = 1073721344; +inp[27045] = 0; +inp[27046] = 1073720320; +inp[27047] = 0; +inp[27048] = 1073719296; +inp[27049] = 0; +inp[27050] = 1073718272; +inp[27051] = 0; +inp[27052] = 1073717248; +inp[27053] = 0; +inp[27054] = 1073716224; +inp[27055] = 0; +inp[27056] = 1073715200; +inp[27057] = 0; +inp[27058] = 1073714176; +inp[27059] = 0; +inp[27060] = 1073713152; +inp[27061] = 0; +inp[27062] = 1073712128; +inp[27063] = 0; +inp[27064] = 1073711104; +inp[27065] = 0; +inp[27066] = 1073710080; +inp[27067] = 0; +inp[27068] = 1073709056; +inp[27069] = 0; +inp[27070] = 1073708032; +inp[27071] = 0; +inp[27072] = 1073707008; +inp[27073] = 0; +inp[27074] = 1073705984; +inp[27075] = 0; +inp[27076] = 1073704960; +inp[27077] = 0; +inp[27078] = 1073703936; +inp[27079] = 0; +inp[27080] = 1073702912; +inp[27081] = 0; +inp[27082] = 1073701888; +inp[27083] = 0; +inp[27084] = 1073700864; +inp[27085] = 0; +inp[27086] = 1073699840; +inp[27087] = 0; +inp[27088] = 1073698816; +inp[27089] = 0; +inp[27090] = 1073697792; +inp[27091] = 0; +inp[27092] = 1073696768; +inp[27093] = 0; +inp[27094] = 1073695744; +inp[27095] = 0; +inp[27096] = 1073694721; +inp[27097] = 0; +inp[27098] = 1073693697; +inp[27099] = 0; +inp[27100] = 1073692673; +inp[27101] = 0; +inp[27102] = 1073691649; +inp[27103] = 0; +inp[27104] = 1073690625; +inp[27105] = 0; +inp[27106] = 1073689601; +inp[27107] = 0; +inp[27108] = 1073688577; +inp[27109] = 0; +inp[27110] = 1073687553; +inp[27111] = 0; +inp[27112] = 1073686529; +inp[27113] = 0; +inp[27114] = 1073685505; +inp[27115] = 0; +inp[27116] = 1073684481; +inp[27117] = 0; +inp[27118] = 1073683457; +inp[27119] = 0; +inp[27120] = 1073682433; +inp[27121] = 0; +inp[27122] = 1073681409; +inp[27123] = 0; +inp[27124] = 1073680385; +inp[27125] = 0; +inp[27126] = 1073679361; +inp[27127] = 0; +inp[27128] = 1073678337; +inp[27129] = 0; +inp[27130] = 1073677313; +inp[27131] = 0; +inp[27132] = 1073676289; +inp[27133] = 0; +inp[27134] = 1073675266; +inp[27135] = 0; +inp[27136] = 1073674242; +inp[27137] = 0; +inp[27138] = 1073673218; +inp[27139] = 0; +inp[27140] = 1073672194; +inp[27141] = 0; +inp[27142] = 1073671170; +inp[27143] = 0; +inp[27144] = 1073670146; +inp[27145] = 0; +inp[27146] = 1073669122; +inp[27147] = 0; +inp[27148] = 1073668098; +inp[27149] = 0; +inp[27150] = 1073667074; +inp[27151] = 0; +inp[27152] = 1073666050; +inp[27153] = 0; +inp[27154] = 1073665026; +inp[27155] = 0; +inp[27156] = 1073664002; +inp[27157] = 0; +inp[27158] = 1073662978; +inp[27159] = 0; +inp[27160] = 1073661954; +inp[27161] = 0; +inp[27162] = 1073660931; +inp[27163] = 0; +inp[27164] = 1073659907; +inp[27165] = 0; +inp[27166] = 1073658883; +inp[27167] = 0; +inp[27168] = 1073657859; +inp[27169] = 0; +inp[27170] = 1073656835; +inp[27171] = 0; +inp[27172] = 1073655811; +inp[27173] = 0; +inp[27174] = 1073654787; +inp[27175] = 0; +inp[27176] = 1073653763; +inp[27177] = 0; +inp[27178] = 1073652739; +inp[27179] = 0; +inp[27180] = 1073651715; +inp[27181] = 0; +inp[27182] = 1073650691; +inp[27183] = 0; +inp[27184] = 1073649667; +inp[27185] = 0; +inp[27186] = 1073648644; +inp[27187] = 0; +inp[27188] = 1073647620; +inp[27189] = 0; +inp[27190] = 1073646596; +inp[27191] = 0; +inp[27192] = 1073645572; +inp[27193] = 0; +inp[27194] = 1073644548; +inp[27195] = 0; +inp[27196] = 1073643524; +inp[27197] = 0; +inp[27198] = 1073642500; +inp[27199] = 0; +inp[27200] = 1073641476; +inp[27201] = 0; +inp[27202] = 1073640452; +inp[27203] = 0; +inp[27204] = 1073639428; +inp[27205] = 0; +inp[27206] = 1073638404; +inp[27207] = 0; +inp[27208] = 1073637381; +inp[27209] = 0; +inp[27210] = 1073636357; +inp[27211] = 0; +inp[27212] = 1073635333; +inp[27213] = 0; +inp[27214] = 1073634309; +inp[27215] = 0; +inp[27216] = 1073633285; +inp[27217] = 0; +inp[27218] = 1073632261; +inp[27219] = 0; +inp[27220] = 1073631237; +inp[27221] = 0; +inp[27222] = 1073630213; +inp[27223] = 0; +inp[27224] = 1073629189; +inp[27225] = 0; +inp[27226] = 1073628166; +inp[27227] = 0; +inp[27228] = 1073627142; +inp[27229] = 0; +inp[27230] = 1073626118; +inp[27231] = 0; +inp[27232] = 1073625094; +inp[27233] = 0; +inp[27234] = 1073624070; +inp[27235] = 0; +inp[27236] = 1073623046; +inp[27237] = 0; +inp[27238] = 1073622022; +inp[27239] = 0; +inp[27240] = 1073620998; +inp[27241] = 0; +inp[27242] = 1073619974; +inp[27243] = 0; +inp[27244] = 1073618951; +inp[27245] = 0; +inp[27246] = 1073617927; +inp[27247] = 0; +inp[27248] = 1073616903; +inp[27249] = 0; +inp[27250] = 1073615879; +inp[27251] = 0; +inp[27252] = 1073614855; +inp[27253] = 0; +inp[27254] = 1073613831; +inp[27255] = 0; +inp[27256] = 1073612807; +inp[27257] = 0; +inp[27258] = 1073611783; +inp[27259] = 0; +inp[27260] = 1073610759; +inp[27261] = 0; +inp[27262] = 1073609736; +inp[27263] = 0; +inp[27264] = 1073608712; +inp[27265] = 0; +inp[27266] = 1073607688; +inp[27267] = 0; +inp[27268] = 1073606664; +inp[27269] = 0; +inp[27270] = 1073605640; +inp[27271] = 0; +inp[27272] = 1073604616; +inp[27273] = 0; +inp[27274] = 1073603592; +inp[27275] = 0; +inp[27276] = 1073602569; +inp[27277] = 0; +inp[27278] = 1073601545; +inp[27279] = 0; +inp[27280] = 1073600521; +inp[27281] = 0; +inp[27282] = 1073599497; +inp[27283] = 0; +inp[27284] = 1073598473; +inp[27285] = 0; +inp[27286] = 1073597449; +inp[27287] = 0; +inp[27288] = 1073596425; +inp[27289] = 0; +inp[27290] = 1073595401; +inp[27291] = 0; +inp[27292] = 1073594378; +inp[27293] = 0; +inp[27294] = 1073593354; +inp[27295] = 0; +inp[27296] = 1073592330; +inp[27297] = 0; +inp[27298] = 1073591306; +inp[27299] = 0; +inp[27300] = 1073590282; +inp[27301] = 0; +inp[27302] = 1073589258; +inp[27303] = 0; +inp[27304] = 1073588234; +inp[27305] = 0; +inp[27306] = 1073587211; +inp[27307] = 0; +inp[27308] = 1073586187; +inp[27309] = 0; +inp[27310] = 1073585163; +inp[27311] = 0; +inp[27312] = 1073584139; +inp[27313] = 0; +inp[27314] = 1073583115; +inp[27315] = 0; +inp[27316] = 1073582091; +inp[27317] = 0; +inp[27318] = 1073581068; +inp[27319] = 0; +inp[27320] = 1073580044; +inp[27321] = 0; +inp[27322] = 1073579020; +inp[27323] = 0; +inp[27324] = 1073577996; +inp[27325] = 0; +inp[27326] = 1073576972; +inp[27327] = 0; +inp[27328] = 1073575948; +inp[27329] = 0; +inp[27330] = 1073574924; +inp[27331] = 0; +inp[27332] = 1073573901; +inp[27333] = 0; +inp[27334] = 1073572877; +inp[27335] = 0; +inp[27336] = 1073571853; +inp[27337] = 0; +inp[27338] = 1073570829; +inp[27339] = 0; +inp[27340] = 1073569805; +inp[27341] = 0; +inp[27342] = 1073568781; +inp[27343] = 0; +inp[27344] = 1073567758; +inp[27345] = 0; +inp[27346] = 1073566734; +inp[27347] = 0; +inp[27348] = 1073565710; +inp[27349] = 0; +inp[27350] = 1073564686; +inp[27351] = 0; +inp[27352] = 1073563662; +inp[27353] = 0; +inp[27354] = 1073562638; +inp[27355] = 0; +inp[27356] = 1073561615; +inp[27357] = 0; +inp[27358] = 1073560591; +inp[27359] = 0; +inp[27360] = 1073559567; +inp[27361] = 0; +inp[27362] = 1073558543; +inp[27363] = 0; +inp[27364] = 1073557519; +inp[27365] = 0; +inp[27366] = 1073556495; +inp[27367] = 0; +inp[27368] = 1073555472; +inp[27369] = 0; +inp[27370] = 1073554448; +inp[27371] = 0; +inp[27372] = 1073553424; +inp[27373] = 0; +inp[27374] = 1073552400; +inp[27375] = 0; +inp[27376] = 1073551376; +inp[27377] = 0; +inp[27378] = 1073550353; +inp[27379] = 0; +inp[27380] = 1073549329; +inp[27381] = 0; +inp[27382] = 1073548305; +inp[27383] = 0; +inp[27384] = 1073547281; +inp[27385] = 0; +inp[27386] = 1073546257; +inp[27387] = 0; +inp[27388] = 1073545233; +inp[27389] = 0; +inp[27390] = 1073544210; +inp[27391] = 0; +inp[27392] = 1073543186; +inp[27393] = 0; +inp[27394] = 1073542162; +inp[27395] = 0; +inp[27396] = 1073541138; +inp[27397] = 0; +inp[27398] = 1073540114; +inp[27399] = 0; +inp[27400] = 1073539091; +inp[27401] = 0; +inp[27402] = 1073538067; +inp[27403] = 0; +inp[27404] = 1073537043; +inp[27405] = 0; +inp[27406] = 1073536019; +inp[27407] = 0; +inp[27408] = 1073534995; +inp[27409] = 0; +inp[27410] = 1073533972; +inp[27411] = 0; +inp[27412] = 1073532948; +inp[27413] = 0; +inp[27414] = 1073531924; +inp[27415] = 0; +inp[27416] = 1073530900; +inp[27417] = 0; +inp[27418] = 1073529876; +inp[27419] = 0; +inp[27420] = 1073528853; +inp[27421] = 0; +inp[27422] = 1073527829; +inp[27423] = 0; +inp[27424] = 1073526805; +inp[27425] = 0; +inp[27426] = 1073525781; +inp[27427] = 0; +inp[27428] = 1073524757; +inp[27429] = 0; +inp[27430] = 1073523734; +inp[27431] = 0; +inp[27432] = 1073522710; +inp[27433] = 0; +inp[27434] = 1073521686; +inp[27435] = 0; +inp[27436] = 1073520662; +inp[27437] = 0; +inp[27438] = 1073519638; +inp[27439] = 0; +inp[27440] = 1073518615; +inp[27441] = 0; +inp[27442] = 1073517591; +inp[27443] = 0; +inp[27444] = 1073516567; +inp[27445] = 0; +inp[27446] = 1073515543; +inp[27447] = 0; +inp[27448] = 1073514520; +inp[27449] = 0; +inp[27450] = 1073513496; +inp[27451] = 0; +inp[27452] = 1073512472; +inp[27453] = 0; +inp[27454] = 1073511448; +inp[27455] = 0; +inp[27456] = 1073510424; +inp[27457] = 0; +inp[27458] = 1073509401; +inp[27459] = 0; +inp[27460] = 1073508377; +inp[27461] = 0; +inp[27462] = 1073507353; +inp[27463] = 0; +inp[27464] = 1073506329; +inp[27465] = 0; +inp[27466] = 1073505306; +inp[27467] = 0; +inp[27468] = 1073504282; +inp[27469] = 0; +inp[27470] = 1073503258; +inp[27471] = 0; +inp[27472] = 1073502234; +inp[27473] = 0; +inp[27474] = 1073501210; +inp[27475] = 0; +inp[27476] = 1073500187; +inp[27477] = 0; +inp[27478] = 1073499163; +inp[27479] = 0; +inp[27480] = 1073498139; +inp[27481] = 0; +inp[27482] = 1073497115; +inp[27483] = 0; +inp[27484] = 1073496092; +inp[27485] = 0; +inp[27486] = 1073495068; +inp[27487] = 0; +inp[27488] = 1073494044; +inp[27489] = 0; +inp[27490] = 1073493020; +inp[27491] = 0; +inp[27492] = 1073491997; +inp[27493] = 0; +inp[27494] = 1073490973; +inp[27495] = 0; +inp[27496] = 1073489949; +inp[27497] = 0; +inp[27498] = 1073488925; +inp[27499] = 0; +inp[27500] = 1073487902; +inp[27501] = 0; +inp[27502] = 1073486878; +inp[27503] = 0; +inp[27504] = 1073485854; +inp[27505] = 0; +inp[27506] = 1073484830; +inp[27507] = 0; +inp[27508] = 1073483807; +inp[27509] = 0; +inp[27510] = 1073482783; +inp[27511] = 0; +inp[27512] = 1073481759; +inp[27513] = 0; +inp[27514] = 1073480735; +inp[27515] = 0; +inp[27516] = 1073741824; +inp[27517] = 1073741824; +inp[27518] = 1073741312; +inp[27519] = 0; +inp[27520] = 1073740800; +inp[27521] = 0; +inp[27522] = 1073740288; +inp[27523] = 0; +inp[27524] = 1073739776; +inp[27525] = 0; +inp[27526] = 1073739264; +inp[27527] = 0; +inp[27528] = 1073738752; +inp[27529] = 0; +inp[27530] = 1073738240; +inp[27531] = 0; +inp[27532] = 1073737728; +inp[27533] = 0; +inp[27534] = 1073737216; +inp[27535] = 0; +inp[27536] = 1073736704; +inp[27537] = 0; +inp[27538] = 1073736192; +inp[27539] = 0; +inp[27540] = 1073735680; +inp[27541] = 0; +inp[27542] = 1073735168; +inp[27543] = 0; +inp[27544] = 1073734656; +inp[27545] = 0; +inp[27546] = 1073734144; +inp[27547] = 0; +inp[27548] = 1073733632; +inp[27549] = 0; +inp[27550] = 1073733120; +inp[27551] = 0; +inp[27552] = 1073732608; +inp[27553] = 0; +inp[27554] = 1073732096; +inp[27555] = 0; +inp[27556] = 1073731584; +inp[27557] = 0; +inp[27558] = 1073731072; +inp[27559] = 0; +inp[27560] = 1073730560; +inp[27561] = 0; +inp[27562] = 1073730048; +inp[27563] = 0; +inp[27564] = 1073729536; +inp[27565] = 0; +inp[27566] = 1073729024; +inp[27567] = 0; +inp[27568] = 1073728512; +inp[27569] = 0; +inp[27570] = 1073728000; +inp[27571] = 0; +inp[27572] = 1073727488; +inp[27573] = 0; +inp[27574] = 1073726976; +inp[27575] = 0; +inp[27576] = 1073726464; +inp[27577] = 0; +inp[27578] = 1073725952; +inp[27579] = 0; +inp[27580] = 1073725440; +inp[27581] = 0; +inp[27582] = 1073724928; +inp[27583] = 0; +inp[27584] = 1073724416; +inp[27585] = 0; +inp[27586] = 1073723904; +inp[27587] = 0; +inp[27588] = 1073723392; +inp[27589] = 0; +inp[27590] = 1073722880; +inp[27591] = 0; +inp[27592] = 1073722368; +inp[27593] = 0; +inp[27594] = 1073721856; +inp[27595] = 0; +inp[27596] = 1073721344; +inp[27597] = 0; +inp[27598] = 1073720832; +inp[27599] = 0; +inp[27600] = 1073720320; +inp[27601] = 0; +inp[27602] = 1073719808; +inp[27603] = 0; +inp[27604] = 1073719296; +inp[27605] = 0; +inp[27606] = 1073718784; +inp[27607] = 0; +inp[27608] = 1073718272; +inp[27609] = 0; +inp[27610] = 1073717760; +inp[27611] = 0; +inp[27612] = 1073717248; +inp[27613] = 0; +inp[27614] = 1073716736; +inp[27615] = 0; +inp[27616] = 1073716224; +inp[27617] = 0; +inp[27618] = 1073715712; +inp[27619] = 0; +inp[27620] = 1073715200; +inp[27621] = 0; +inp[27622] = 1073714688; +inp[27623] = 0; +inp[27624] = 1073714176; +inp[27625] = 0; +inp[27626] = 1073713664; +inp[27627] = 0; +inp[27628] = 1073713152; +inp[27629] = 0; +inp[27630] = 1073712640; +inp[27631] = 0; +inp[27632] = 1073712128; +inp[27633] = 0; +inp[27634] = 1073711616; +inp[27635] = 0; +inp[27636] = 1073711104; +inp[27637] = 0; +inp[27638] = 1073710592; +inp[27639] = 0; +inp[27640] = 1073710080; +inp[27641] = 0; +inp[27642] = 1073709568; +inp[27643] = 0; +inp[27644] = 1073709056; +inp[27645] = 0; +inp[27646] = 1073708544; +inp[27647] = 0; +inp[27648] = 1073708032; +inp[27649] = 0; +inp[27650] = 1073707520; +inp[27651] = 0; +inp[27652] = 1073707008; +inp[27653] = 0; +inp[27654] = 1073706496; +inp[27655] = 0; +inp[27656] = 1073705984; +inp[27657] = 0; +inp[27658] = 1073705472; +inp[27659] = 0; +inp[27660] = 1073704960; +inp[27661] = 0; +inp[27662] = 1073704448; +inp[27663] = 0; +inp[27664] = 1073703936; +inp[27665] = 0; +inp[27666] = 1073703424; +inp[27667] = 0; +inp[27668] = 1073702912; +inp[27669] = 0; +inp[27670] = 1073702400; +inp[27671] = 0; +inp[27672] = 1073701888; +inp[27673] = 0; +inp[27674] = 1073701376; +inp[27675] = 0; +inp[27676] = 1073700864; +inp[27677] = 0; +inp[27678] = 1073700352; +inp[27679] = 0; +inp[27680] = 1073699840; +inp[27681] = 0; +inp[27682] = 1073699328; +inp[27683] = 0; +inp[27684] = 1073698816; +inp[27685] = 0; +inp[27686] = 1073698304; +inp[27687] = 0; +inp[27688] = 1073697792; +inp[27689] = 0; +inp[27690] = 1073697280; +inp[27691] = 0; +inp[27692] = 1073696768; +inp[27693] = 0; +inp[27694] = 1073696256; +inp[27695] = 0; +inp[27696] = 1073695744; +inp[27697] = 0; +inp[27698] = 1073695233; +inp[27699] = 0; +inp[27700] = 1073694721; +inp[27701] = 0; +inp[27702] = 1073694209; +inp[27703] = 0; +inp[27704] = 1073693697; +inp[27705] = 0; +inp[27706] = 1073693185; +inp[27707] = 0; +inp[27708] = 1073692673; +inp[27709] = 0; +inp[27710] = 1073692161; +inp[27711] = 0; +inp[27712] = 1073691649; +inp[27713] = 0; +inp[27714] = 1073691137; +inp[27715] = 0; +inp[27716] = 1073690625; +inp[27717] = 0; +inp[27718] = 1073690113; +inp[27719] = 0; +inp[27720] = 1073689601; +inp[27721] = 0; +inp[27722] = 1073689089; +inp[27723] = 0; +inp[27724] = 1073688577; +inp[27725] = 0; +inp[27726] = 1073688065; +inp[27727] = 0; +inp[27728] = 1073687553; +inp[27729] = 0; +inp[27730] = 1073687041; +inp[27731] = 0; +inp[27732] = 1073686529; +inp[27733] = 0; +inp[27734] = 1073686017; +inp[27735] = 0; +inp[27736] = 1073685505; +inp[27737] = 0; +inp[27738] = 1073684993; +inp[27739] = 0; +inp[27740] = 1073684481; +inp[27741] = 0; +inp[27742] = 1073683969; +inp[27743] = 0; +inp[27744] = 1073683457; +inp[27745] = 0; +inp[27746] = 1073682945; +inp[27747] = 0; +inp[27748] = 1073682433; +inp[27749] = 0; +inp[27750] = 1073681921; +inp[27751] = 0; +inp[27752] = 1073681409; +inp[27753] = 0; +inp[27754] = 1073680897; +inp[27755] = 0; +inp[27756] = 1073680385; +inp[27757] = 0; +inp[27758] = 1073679873; +inp[27759] = 0; +inp[27760] = 1073679361; +inp[27761] = 0; +inp[27762] = 1073678849; +inp[27763] = 0; +inp[27764] = 1073678337; +inp[27765] = 0; +inp[27766] = 1073677825; +inp[27767] = 0; +inp[27768] = 1073677313; +inp[27769] = 0; +inp[27770] = 1073676801; +inp[27771] = 0; +inp[27772] = 1073676289; +inp[27773] = 0; +inp[27774] = 1073675778; +inp[27775] = 0; +inp[27776] = 1073675266; +inp[27777] = 0; +inp[27778] = 1073674754; +inp[27779] = 0; +inp[27780] = 1073674242; +inp[27781] = 0; +inp[27782] = 1073673730; +inp[27783] = 0; +inp[27784] = 1073673218; +inp[27785] = 0; +inp[27786] = 1073672706; +inp[27787] = 0; +inp[27788] = 1073672194; +inp[27789] = 0; +inp[27790] = 1073671682; +inp[27791] = 0; +inp[27792] = 1073671170; +inp[27793] = 0; +inp[27794] = 1073670658; +inp[27795] = 0; +inp[27796] = 1073670146; +inp[27797] = 0; +inp[27798] = 1073669634; +inp[27799] = 0; +inp[27800] = 1073669122; +inp[27801] = 0; +inp[27802] = 1073668610; +inp[27803] = 0; +inp[27804] = 1073668098; +inp[27805] = 0; +inp[27806] = 1073667586; +inp[27807] = 0; +inp[27808] = 1073667074; +inp[27809] = 0; +inp[27810] = 1073666562; +inp[27811] = 0; +inp[27812] = 1073666050; +inp[27813] = 0; +inp[27814] = 1073665538; +inp[27815] = 0; +inp[27816] = 1073665026; +inp[27817] = 0; +inp[27818] = 1073664514; +inp[27819] = 0; +inp[27820] = 1073664002; +inp[27821] = 0; +inp[27822] = 1073663490; +inp[27823] = 0; +inp[27824] = 1073662978; +inp[27825] = 0; +inp[27826] = 1073662466; +inp[27827] = 0; +inp[27828] = 1073661954; +inp[27829] = 0; +inp[27830] = 1073661443; +inp[27831] = 0; +inp[27832] = 1073660931; +inp[27833] = 0; +inp[27834] = 1073660419; +inp[27835] = 0; +inp[27836] = 1073659907; +inp[27837] = 0; +inp[27838] = 1073659395; +inp[27839] = 0; +inp[27840] = 1073658883; +inp[27841] = 0; +inp[27842] = 1073658371; +inp[27843] = 0; +inp[27844] = 1073657859; +inp[27845] = 0; +inp[27846] = 1073657347; +inp[27847] = 0; +inp[27848] = 1073656835; +inp[27849] = 0; +inp[27850] = 1073656323; +inp[27851] = 0; +inp[27852] = 1073655811; +inp[27853] = 0; +inp[27854] = 1073655299; +inp[27855] = 0; +inp[27856] = 1073654787; +inp[27857] = 0; +inp[27858] = 1073654275; +inp[27859] = 0; +inp[27860] = 1073653763; +inp[27861] = 0; +inp[27862] = 1073653251; +inp[27863] = 0; +inp[27864] = 1073652739; +inp[27865] = 0; +inp[27866] = 1073652227; +inp[27867] = 0; +inp[27868] = 1073651715; +inp[27869] = 0; +inp[27870] = 1073651203; +inp[27871] = 0; +inp[27872] = 1073650691; +inp[27873] = 0; +inp[27874] = 1073650179; +inp[27875] = 0; +inp[27876] = 1073649667; +inp[27877] = 0; +inp[27878] = 1073649155; +inp[27879] = 0; +inp[27880] = 1073648644; +inp[27881] = 0; +inp[27882] = 1073648132; +inp[27883] = 0; +inp[27884] = 1073647620; +inp[27885] = 0; +inp[27886] = 1073647108; +inp[27887] = 0; +inp[27888] = 1073646596; +inp[27889] = 0; +inp[27890] = 1073646084; +inp[27891] = 0; +inp[27892] = 1073645572; +inp[27893] = 0; +inp[27894] = 1073645060; +inp[27895] = 0; +inp[27896] = 1073644548; +inp[27897] = 0; +inp[27898] = 1073644036; +inp[27899] = 0; +inp[27900] = 1073643524; +inp[27901] = 0; +inp[27902] = 1073643012; +inp[27903] = 0; +inp[27904] = 1073642500; +inp[27905] = 0; +inp[27906] = 1073641988; +inp[27907] = 0; +inp[27908] = 1073641476; +inp[27909] = 0; +inp[27910] = 1073640964; +inp[27911] = 0; +inp[27912] = 1073640452; +inp[27913] = 0; +inp[27914] = 1073639940; +inp[27915] = 0; +inp[27916] = 1073639428; +inp[27917] = 0; +inp[27918] = 1073638916; +inp[27919] = 0; +inp[27920] = 1073638404; +inp[27921] = 0; +inp[27922] = 1073637893; +inp[27923] = 0; +inp[27924] = 1073637381; +inp[27925] = 0; +inp[27926] = 1073636869; +inp[27927] = 0; +inp[27928] = 1073636357; +inp[27929] = 0; +inp[27930] = 1073635845; +inp[27931] = 0; +inp[27932] = 1073635333; +inp[27933] = 0; +inp[27934] = 1073634821; +inp[27935] = 0; +inp[27936] = 1073634309; +inp[27937] = 0; +inp[27938] = 1073633797; +inp[27939] = 0; +inp[27940] = 1073633285; +inp[27941] = 0; +inp[27942] = 1073632773; +inp[27943] = 0; +inp[27944] = 1073632261; +inp[27945] = 0; +inp[27946] = 1073631749; +inp[27947] = 0; +inp[27948] = 1073631237; +inp[27949] = 0; +inp[27950] = 1073630725; +inp[27951] = 0; +inp[27952] = 1073630213; +inp[27953] = 0; +inp[27954] = 1073629701; +inp[27955] = 0; +inp[27956] = 1073629189; +inp[27957] = 0; +inp[27958] = 1073628677; +inp[27959] = 0; +inp[27960] = 1073628166; +inp[27961] = 0; +inp[27962] = 1073627654; +inp[27963] = 0; +inp[27964] = 1073627142; +inp[27965] = 0; +inp[27966] = 1073626630; +inp[27967] = 0; +inp[27968] = 1073626118; +inp[27969] = 0; +inp[27970] = 1073625606; +inp[27971] = 0; +inp[27972] = 1073625094; +inp[27973] = 0; +inp[27974] = 1073624582; +inp[27975] = 0; +inp[27976] = 1073624070; +inp[27977] = 0; +inp[27978] = 1073623558; +inp[27979] = 0; +inp[27980] = 1073623046; +inp[27981] = 0; +inp[27982] = 1073622534; +inp[27983] = 0; +inp[27984] = 1073622022; +inp[27985] = 0; +inp[27986] = 1073621510; +inp[27987] = 0; +inp[27988] = 1073620998; +inp[27989] = 0; +inp[27990] = 1073620486; +inp[27991] = 0; +inp[27992] = 1073619974; +inp[27993] = 0; +inp[27994] = 1073619462; +inp[27995] = 0; +inp[27996] = 1073618951; +inp[27997] = 0; +inp[27998] = 1073618439; +inp[27999] = 0; +inp[28000] = 1073617927; +inp[28001] = 0; +inp[28002] = 1073617415; +inp[28003] = 0; +inp[28004] = 1073616903; +inp[28005] = 0; +inp[28006] = 1073616391; +inp[28007] = 0; +inp[28008] = 1073615879; +inp[28009] = 0; +inp[28010] = 1073615367; +inp[28011] = 0; +inp[28012] = 1073614855; +inp[28013] = 0; +inp[28014] = 1073614343; +inp[28015] = 0; +inp[28016] = 1073613831; +inp[28017] = 0; +inp[28018] = 1073613319; +inp[28019] = 0; +inp[28020] = 1073612807; +inp[28021] = 0; +inp[28022] = 1073612295; +inp[28023] = 0; +inp[28024] = 1073611783; +inp[28025] = 0; +inp[28026] = 1073611271; +inp[28027] = 0; +inp[28028] = 1073741824; +inp[28029] = 1073741824; +inp[28030] = 1073741568; +inp[28031] = 0; +inp[28032] = 1073741312; +inp[28033] = 0; +inp[28034] = 1073741056; +inp[28035] = 0; +inp[28036] = 1073740800; +inp[28037] = 0; +inp[28038] = 1073740544; +inp[28039] = 0; +inp[28040] = 1073740288; +inp[28041] = 0; +inp[28042] = 1073740032; +inp[28043] = 0; +inp[28044] = 1073739776; +inp[28045] = 0; +inp[28046] = 1073739520; +inp[28047] = 0; +inp[28048] = 1073739264; +inp[28049] = 0; +inp[28050] = 1073739008; +inp[28051] = 0; +inp[28052] = 1073738752; +inp[28053] = 0; +inp[28054] = 1073738496; +inp[28055] = 0; +inp[28056] = 1073738240; +inp[28057] = 0; +inp[28058] = 1073737984; +inp[28059] = 0; +inp[28060] = 1073737728; +inp[28061] = 0; +inp[28062] = 1073737472; +inp[28063] = 0; +inp[28064] = 1073737216; +inp[28065] = 0; +inp[28066] = 1073736960; +inp[28067] = 0; +inp[28068] = 1073736704; +inp[28069] = 0; +inp[28070] = 1073736448; +inp[28071] = 0; +inp[28072] = 1073736192; +inp[28073] = 0; +inp[28074] = 1073735936; +inp[28075] = 0; +inp[28076] = 1073735680; +inp[28077] = 0; +inp[28078] = 1073735424; +inp[28079] = 0; +inp[28080] = 1073735168; +inp[28081] = 0; +inp[28082] = 1073734912; +inp[28083] = 0; +inp[28084] = 1073734656; +inp[28085] = 0; +inp[28086] = 1073734400; +inp[28087] = 0; +inp[28088] = 1073734144; +inp[28089] = 0; +inp[28090] = 1073733888; +inp[28091] = 0; +inp[28092] = 1073733632; +inp[28093] = 0; +inp[28094] = 1073733376; +inp[28095] = 0; +inp[28096] = 1073733120; +inp[28097] = 0; +inp[28098] = 1073732864; +inp[28099] = 0; +inp[28100] = 1073732608; +inp[28101] = 0; +inp[28102] = 1073732352; +inp[28103] = 0; +inp[28104] = 1073732096; +inp[28105] = 0; +inp[28106] = 1073731840; +inp[28107] = 0; +inp[28108] = 1073731584; +inp[28109] = 0; +inp[28110] = 1073731328; +inp[28111] = 0; +inp[28112] = 1073731072; +inp[28113] = 0; +inp[28114] = 1073730816; +inp[28115] = 0; +inp[28116] = 1073730560; +inp[28117] = 0; +inp[28118] = 1073730304; +inp[28119] = 0; +inp[28120] = 1073730048; +inp[28121] = 0; +inp[28122] = 1073729792; +inp[28123] = 0; +inp[28124] = 1073729536; +inp[28125] = 0; +inp[28126] = 1073729280; +inp[28127] = 0; +inp[28128] = 1073729024; +inp[28129] = 0; +inp[28130] = 1073728768; +inp[28131] = 0; +inp[28132] = 1073728512; +inp[28133] = 0; +inp[28134] = 1073728256; +inp[28135] = 0; +inp[28136] = 1073728000; +inp[28137] = 0; +inp[28138] = 1073727744; +inp[28139] = 0; +inp[28140] = 1073727488; +inp[28141] = 0; +inp[28142] = 1073727232; +inp[28143] = 0; +inp[28144] = 1073726976; +inp[28145] = 0; +inp[28146] = 1073726720; +inp[28147] = 0; +inp[28148] = 1073726464; +inp[28149] = 0; +inp[28150] = 1073726208; +inp[28151] = 0; +inp[28152] = 1073725952; +inp[28153] = 0; +inp[28154] = 1073725696; +inp[28155] = 0; +inp[28156] = 1073725440; +inp[28157] = 0; +inp[28158] = 1073725184; +inp[28159] = 0; +inp[28160] = 1073724928; +inp[28161] = 0; +inp[28162] = 1073724672; +inp[28163] = 0; +inp[28164] = 1073724416; +inp[28165] = 0; +inp[28166] = 1073724160; +inp[28167] = 0; +inp[28168] = 1073723904; +inp[28169] = 0; +inp[28170] = 1073723648; +inp[28171] = 0; +inp[28172] = 1073723392; +inp[28173] = 0; +inp[28174] = 1073723136; +inp[28175] = 0; +inp[28176] = 1073722880; +inp[28177] = 0; +inp[28178] = 1073722624; +inp[28179] = 0; +inp[28180] = 1073722368; +inp[28181] = 0; +inp[28182] = 1073722112; +inp[28183] = 0; +inp[28184] = 1073721856; +inp[28185] = 0; +inp[28186] = 1073721600; +inp[28187] = 0; +inp[28188] = 1073721344; +inp[28189] = 0; +inp[28190] = 1073721088; +inp[28191] = 0; +inp[28192] = 1073720832; +inp[28193] = 0; +inp[28194] = 1073720576; +inp[28195] = 0; +inp[28196] = 1073720320; +inp[28197] = 0; +inp[28198] = 1073720064; +inp[28199] = 0; +inp[28200] = 1073719808; +inp[28201] = 0; +inp[28202] = 1073719552; +inp[28203] = 0; +inp[28204] = 1073719296; +inp[28205] = 0; +inp[28206] = 1073719040; +inp[28207] = 0; +inp[28208] = 1073718784; +inp[28209] = 0; +inp[28210] = 1073718528; +inp[28211] = 0; +inp[28212] = 1073718272; +inp[28213] = 0; +inp[28214] = 1073718016; +inp[28215] = 0; +inp[28216] = 1073717760; +inp[28217] = 0; +inp[28218] = 1073717504; +inp[28219] = 0; +inp[28220] = 1073717248; +inp[28221] = 0; +inp[28222] = 1073716992; +inp[28223] = 0; +inp[28224] = 1073716736; +inp[28225] = 0; +inp[28226] = 1073716480; +inp[28227] = 0; +inp[28228] = 1073716224; +inp[28229] = 0; +inp[28230] = 1073715968; +inp[28231] = 0; +inp[28232] = 1073715712; +inp[28233] = 0; +inp[28234] = 1073715456; +inp[28235] = 0; +inp[28236] = 1073715200; +inp[28237] = 0; +inp[28238] = 1073714944; +inp[28239] = 0; +inp[28240] = 1073714688; +inp[28241] = 0; +inp[28242] = 1073714432; +inp[28243] = 0; +inp[28244] = 1073714176; +inp[28245] = 0; +inp[28246] = 1073713920; +inp[28247] = 0; +inp[28248] = 1073713664; +inp[28249] = 0; +inp[28250] = 1073713408; +inp[28251] = 0; +inp[28252] = 1073713152; +inp[28253] = 0; +inp[28254] = 1073712896; +inp[28255] = 0; +inp[28256] = 1073712640; +inp[28257] = 0; +inp[28258] = 1073712384; +inp[28259] = 0; +inp[28260] = 1073712128; +inp[28261] = 0; +inp[28262] = 1073711872; +inp[28263] = 0; +inp[28264] = 1073711616; +inp[28265] = 0; +inp[28266] = 1073711360; +inp[28267] = 0; +inp[28268] = 1073711104; +inp[28269] = 0; +inp[28270] = 1073710848; +inp[28271] = 0; +inp[28272] = 1073710592; +inp[28273] = 0; +inp[28274] = 1073710336; +inp[28275] = 0; +inp[28276] = 1073710080; +inp[28277] = 0; +inp[28278] = 1073709824; +inp[28279] = 0; +inp[28280] = 1073709568; +inp[28281] = 0; +inp[28282] = 1073709312; +inp[28283] = 0; +inp[28284] = 1073709056; +inp[28285] = 0; +inp[28286] = 1073708800; +inp[28287] = 0; +inp[28288] = 1073708544; +inp[28289] = 0; +inp[28290] = 1073708288; +inp[28291] = 0; +inp[28292] = 1073708032; +inp[28293] = 0; +inp[28294] = 1073707776; +inp[28295] = 0; +inp[28296] = 1073707520; +inp[28297] = 0; +inp[28298] = 1073707264; +inp[28299] = 0; +inp[28300] = 1073707008; +inp[28301] = 0; +inp[28302] = 1073706752; +inp[28303] = 0; +inp[28304] = 1073706496; +inp[28305] = 0; +inp[28306] = 1073706240; +inp[28307] = 0; +inp[28308] = 1073705984; +inp[28309] = 0; +inp[28310] = 1073705728; +inp[28311] = 0; +inp[28312] = 1073705472; +inp[28313] = 0; +inp[28314] = 1073705216; +inp[28315] = 0; +inp[28316] = 1073704960; +inp[28317] = 0; +inp[28318] = 1073704704; +inp[28319] = 0; +inp[28320] = 1073704448; +inp[28321] = 0; +inp[28322] = 1073704192; +inp[28323] = 0; +inp[28324] = 1073703936; +inp[28325] = 0; +inp[28326] = 1073703680; +inp[28327] = 0; +inp[28328] = 1073703424; +inp[28329] = 0; +inp[28330] = 1073703168; +inp[28331] = 0; +inp[28332] = 1073702912; +inp[28333] = 0; +inp[28334] = 1073702656; +inp[28335] = 0; +inp[28336] = 1073702400; +inp[28337] = 0; +inp[28338] = 1073702144; +inp[28339] = 0; +inp[28340] = 1073701888; +inp[28341] = 0; +inp[28342] = 1073701632; +inp[28343] = 0; +inp[28344] = 1073701376; +inp[28345] = 0; +inp[28346] = 1073701120; +inp[28347] = 0; +inp[28348] = 1073700864; +inp[28349] = 0; +inp[28350] = 1073700608; +inp[28351] = 0; +inp[28352] = 1073700352; +inp[28353] = 0; +inp[28354] = 1073700096; +inp[28355] = 0; +inp[28356] = 1073699840; +inp[28357] = 0; +inp[28358] = 1073699584; +inp[28359] = 0; +inp[28360] = 1073699328; +inp[28361] = 0; +inp[28362] = 1073699072; +inp[28363] = 0; +inp[28364] = 1073698816; +inp[28365] = 0; +inp[28366] = 1073698560; +inp[28367] = 0; +inp[28368] = 1073698304; +inp[28369] = 0; +inp[28370] = 1073698048; +inp[28371] = 0; +inp[28372] = 1073697792; +inp[28373] = 0; +inp[28374] = 1073697536; +inp[28375] = 0; +inp[28376] = 1073697280; +inp[28377] = 0; +inp[28378] = 1073697024; +inp[28379] = 0; +inp[28380] = 1073696768; +inp[28381] = 0; +inp[28382] = 1073696512; +inp[28383] = 0; +inp[28384] = 1073696256; +inp[28385] = 0; +inp[28386] = 1073696000; +inp[28387] = 0; +inp[28388] = 1073695744; +inp[28389] = 0; +inp[28390] = 1073695488; +inp[28391] = 0; +inp[28392] = 1073695233; +inp[28393] = 0; +inp[28394] = 1073694977; +inp[28395] = 0; +inp[28396] = 1073694721; +inp[28397] = 0; +inp[28398] = 1073694465; +inp[28399] = 0; +inp[28400] = 1073694209; +inp[28401] = 0; +inp[28402] = 1073693953; +inp[28403] = 0; +inp[28404] = 1073693697; +inp[28405] = 0; +inp[28406] = 1073693441; +inp[28407] = 0; +inp[28408] = 1073693185; +inp[28409] = 0; +inp[28410] = 1073692929; +inp[28411] = 0; +inp[28412] = 1073692673; +inp[28413] = 0; +inp[28414] = 1073692417; +inp[28415] = 0; +inp[28416] = 1073692161; +inp[28417] = 0; +inp[28418] = 1073691905; +inp[28419] = 0; +inp[28420] = 1073691649; +inp[28421] = 0; +inp[28422] = 1073691393; +inp[28423] = 0; +inp[28424] = 1073691137; +inp[28425] = 0; +inp[28426] = 1073690881; +inp[28427] = 0; +inp[28428] = 1073690625; +inp[28429] = 0; +inp[28430] = 1073690369; +inp[28431] = 0; +inp[28432] = 1073690113; +inp[28433] = 0; +inp[28434] = 1073689857; +inp[28435] = 0; +inp[28436] = 1073689601; +inp[28437] = 0; +inp[28438] = 1073689345; +inp[28439] = 0; +inp[28440] = 1073689089; +inp[28441] = 0; +inp[28442] = 1073688833; +inp[28443] = 0; +inp[28444] = 1073688577; +inp[28445] = 0; +inp[28446] = 1073688321; +inp[28447] = 0; +inp[28448] = 1073688065; +inp[28449] = 0; +inp[28450] = 1073687809; +inp[28451] = 0; +inp[28452] = 1073687553; +inp[28453] = 0; +inp[28454] = 1073687297; +inp[28455] = 0; +inp[28456] = 1073687041; +inp[28457] = 0; +inp[28458] = 1073686785; +inp[28459] = 0; +inp[28460] = 1073686529; +inp[28461] = 0; +inp[28462] = 1073686273; +inp[28463] = 0; +inp[28464] = 1073686017; +inp[28465] = 0; +inp[28466] = 1073685761; +inp[28467] = 0; +inp[28468] = 1073685505; +inp[28469] = 0; +inp[28470] = 1073685249; +inp[28471] = 0; +inp[28472] = 1073684993; +inp[28473] = 0; +inp[28474] = 1073684737; +inp[28475] = 0; +inp[28476] = 1073684481; +inp[28477] = 0; +inp[28478] = 1073684225; +inp[28479] = 0; +inp[28480] = 1073683969; +inp[28481] = 0; +inp[28482] = 1073683713; +inp[28483] = 0; +inp[28484] = 1073683457; +inp[28485] = 0; +inp[28486] = 1073683201; +inp[28487] = 0; +inp[28488] = 1073682945; +inp[28489] = 0; +inp[28490] = 1073682689; +inp[28491] = 0; +inp[28492] = 1073682433; +inp[28493] = 0; +inp[28494] = 1073682177; +inp[28495] = 0; +inp[28496] = 1073681921; +inp[28497] = 0; +inp[28498] = 1073681665; +inp[28499] = 0; +inp[28500] = 1073681409; +inp[28501] = 0; +inp[28502] = 1073681153; +inp[28503] = 0; +inp[28504] = 1073680897; +inp[28505] = 0; +inp[28506] = 1073680641; +inp[28507] = 0; +inp[28508] = 1073680385; +inp[28509] = 0; +inp[28510] = 1073680129; +inp[28511] = 0; +inp[28512] = 1073679873; +inp[28513] = 0; +inp[28514] = 1073679617; +inp[28515] = 0; +inp[28516] = 1073679361; +inp[28517] = 0; +inp[28518] = 1073679105; +inp[28519] = 0; +inp[28520] = 1073678849; +inp[28521] = 0; +inp[28522] = 1073678593; +inp[28523] = 0; +inp[28524] = 1073678337; +inp[28525] = 0; +inp[28526] = 1073678081; +inp[28527] = 0; +inp[28528] = 1073677825; +inp[28529] = 0; +inp[28530] = 1073677569; +inp[28531] = 0; +inp[28532] = 1073677313; +inp[28533] = 0; +inp[28534] = 1073677057; +inp[28535] = 0; +inp[28536] = 1073676801; +inp[28537] = 0; +inp[28538] = 1073676545; +inp[28539] = 0; +inp[28540] = 1073741824; +inp[28541] = 1073741824; +inp[28542] = 1073741696; +inp[28543] = 0; +inp[28544] = 1073741568; +inp[28545] = 0; +inp[28546] = 1073741440; +inp[28547] = 0; +inp[28548] = 1073741312; +inp[28549] = 0; +inp[28550] = 1073741184; +inp[28551] = 0; +inp[28552] = 1073741056; +inp[28553] = 0; +inp[28554] = 1073740928; +inp[28555] = 0; +inp[28556] = 1073740800; +inp[28557] = 0; +inp[28558] = 1073740672; +inp[28559] = 0; +inp[28560] = 1073740544; +inp[28561] = 0; +inp[28562] = 1073740416; +inp[28563] = 0; +inp[28564] = 1073740288; +inp[28565] = 0; +inp[28566] = 1073740160; +inp[28567] = 0; +inp[28568] = 1073740032; +inp[28569] = 0; +inp[28570] = 1073739904; +inp[28571] = 0; +inp[28572] = 1073739776; +inp[28573] = 0; +inp[28574] = 1073739648; +inp[28575] = 0; +inp[28576] = 1073739520; +inp[28577] = 0; +inp[28578] = 1073739392; +inp[28579] = 0; +inp[28580] = 1073739264; +inp[28581] = 0; +inp[28582] = 1073739136; +inp[28583] = 0; +inp[28584] = 1073739008; +inp[28585] = 0; +inp[28586] = 1073738880; +inp[28587] = 0; +inp[28588] = 1073738752; +inp[28589] = 0; +inp[28590] = 1073738624; +inp[28591] = 0; +inp[28592] = 1073738496; +inp[28593] = 0; +inp[28594] = 1073738368; +inp[28595] = 0; +inp[28596] = 1073738240; +inp[28597] = 0; +inp[28598] = 1073738112; +inp[28599] = 0; +inp[28600] = 1073737984; +inp[28601] = 0; +inp[28602] = 1073737856; +inp[28603] = 0; +inp[28604] = 1073737728; +inp[28605] = 0; +inp[28606] = 1073737600; +inp[28607] = 0; +inp[28608] = 1073737472; +inp[28609] = 0; +inp[28610] = 1073737344; +inp[28611] = 0; +inp[28612] = 1073737216; +inp[28613] = 0; +inp[28614] = 1073737088; +inp[28615] = 0; +inp[28616] = 1073736960; +inp[28617] = 0; +inp[28618] = 1073736832; +inp[28619] = 0; +inp[28620] = 1073736704; +inp[28621] = 0; +inp[28622] = 1073736576; +inp[28623] = 0; +inp[28624] = 1073736448; +inp[28625] = 0; +inp[28626] = 1073736320; +inp[28627] = 0; +inp[28628] = 1073736192; +inp[28629] = 0; +inp[28630] = 1073736064; +inp[28631] = 0; +inp[28632] = 1073735936; +inp[28633] = 0; +inp[28634] = 1073735808; +inp[28635] = 0; +inp[28636] = 1073735680; +inp[28637] = 0; +inp[28638] = 1073735552; +inp[28639] = 0; +inp[28640] = 1073735424; +inp[28641] = 0; +inp[28642] = 1073735296; +inp[28643] = 0; +inp[28644] = 1073735168; +inp[28645] = 0; +inp[28646] = 1073735040; +inp[28647] = 0; +inp[28648] = 1073734912; +inp[28649] = 0; +inp[28650] = 1073734784; +inp[28651] = 0; +inp[28652] = 1073734656; +inp[28653] = 0; +inp[28654] = 1073734528; +inp[28655] = 0; +inp[28656] = 1073734400; +inp[28657] = 0; +inp[28658] = 1073734272; +inp[28659] = 0; +inp[28660] = 1073734144; +inp[28661] = 0; +inp[28662] = 1073734016; +inp[28663] = 0; +inp[28664] = 1073733888; +inp[28665] = 0; +inp[28666] = 1073733760; +inp[28667] = 0; +inp[28668] = 1073733632; +inp[28669] = 0; +inp[28670] = 1073733504; +inp[28671] = 0; +inp[28672] = 1073733376; +inp[28673] = 0; +inp[28674] = 1073733248; +inp[28675] = 0; +inp[28676] = 1073733120; +inp[28677] = 0; +inp[28678] = 1073732992; +inp[28679] = 0; +inp[28680] = 1073732864; +inp[28681] = 0; +inp[28682] = 1073732736; +inp[28683] = 0; +inp[28684] = 1073732608; +inp[28685] = 0; +inp[28686] = 1073732480; +inp[28687] = 0; +inp[28688] = 1073732352; +inp[28689] = 0; +inp[28690] = 1073732224; +inp[28691] = 0; +inp[28692] = 1073732096; +inp[28693] = 0; +inp[28694] = 1073731968; +inp[28695] = 0; +inp[28696] = 1073731840; +inp[28697] = 0; +inp[28698] = 1073731712; +inp[28699] = 0; +inp[28700] = 1073731584; +inp[28701] = 0; +inp[28702] = 1073731456; +inp[28703] = 0; +inp[28704] = 1073731328; +inp[28705] = 0; +inp[28706] = 1073731200; +inp[28707] = 0; +inp[28708] = 1073731072; +inp[28709] = 0; +inp[28710] = 1073730944; +inp[28711] = 0; +inp[28712] = 1073730816; +inp[28713] = 0; +inp[28714] = 1073730688; +inp[28715] = 0; +inp[28716] = 1073730560; +inp[28717] = 0; +inp[28718] = 1073730432; +inp[28719] = 0; +inp[28720] = 1073730304; +inp[28721] = 0; +inp[28722] = 1073730176; +inp[28723] = 0; +inp[28724] = 1073730048; +inp[28725] = 0; +inp[28726] = 1073729920; +inp[28727] = 0; +inp[28728] = 1073729792; +inp[28729] = 0; +inp[28730] = 1073729664; +inp[28731] = 0; +inp[28732] = 1073729536; +inp[28733] = 0; +inp[28734] = 1073729408; +inp[28735] = 0; +inp[28736] = 1073729280; +inp[28737] = 0; +inp[28738] = 1073729152; +inp[28739] = 0; +inp[28740] = 1073729024; +inp[28741] = 0; +inp[28742] = 1073728896; +inp[28743] = 0; +inp[28744] = 1073728768; +inp[28745] = 0; +inp[28746] = 1073728640; +inp[28747] = 0; +inp[28748] = 1073728512; +inp[28749] = 0; +inp[28750] = 1073728384; +inp[28751] = 0; +inp[28752] = 1073728256; +inp[28753] = 0; +inp[28754] = 1073728128; +inp[28755] = 0; +inp[28756] = 1073728000; +inp[28757] = 0; +inp[28758] = 1073727872; +inp[28759] = 0; +inp[28760] = 1073727744; +inp[28761] = 0; +inp[28762] = 1073727616; +inp[28763] = 0; +inp[28764] = 1073727488; +inp[28765] = 0; +inp[28766] = 1073727360; +inp[28767] = 0; +inp[28768] = 1073727232; +inp[28769] = 0; +inp[28770] = 1073727104; +inp[28771] = 0; +inp[28772] = 1073726976; +inp[28773] = 0; +inp[28774] = 1073726848; +inp[28775] = 0; +inp[28776] = 1073726720; +inp[28777] = 0; +inp[28778] = 1073726592; +inp[28779] = 0; +inp[28780] = 1073726464; +inp[28781] = 0; +inp[28782] = 1073726336; +inp[28783] = 0; +inp[28784] = 1073726208; +inp[28785] = 0; +inp[28786] = 1073726080; +inp[28787] = 0; +inp[28788] = 1073725952; +inp[28789] = 0; +inp[28790] = 1073725824; +inp[28791] = 0; +inp[28792] = 1073725696; +inp[28793] = 0; +inp[28794] = 1073725568; +inp[28795] = 0; +inp[28796] = 1073725440; +inp[28797] = 0; +inp[28798] = 1073725312; +inp[28799] = 0; +inp[28800] = 1073725184; +inp[28801] = 0; +inp[28802] = 1073725056; +inp[28803] = 0; +inp[28804] = 1073724928; +inp[28805] = 0; +inp[28806] = 1073724800; +inp[28807] = 0; +inp[28808] = 1073724672; +inp[28809] = 0; +inp[28810] = 1073724544; +inp[28811] = 0; +inp[28812] = 1073724416; +inp[28813] = 0; +inp[28814] = 1073724288; +inp[28815] = 0; +inp[28816] = 1073724160; +inp[28817] = 0; +inp[28818] = 1073724032; +inp[28819] = 0; +inp[28820] = 1073723904; +inp[28821] = 0; +inp[28822] = 1073723776; +inp[28823] = 0; +inp[28824] = 1073723648; +inp[28825] = 0; +inp[28826] = 1073723520; +inp[28827] = 0; +inp[28828] = 1073723392; +inp[28829] = 0; +inp[28830] = 1073723264; +inp[28831] = 0; +inp[28832] = 1073723136; +inp[28833] = 0; +inp[28834] = 1073723008; +inp[28835] = 0; +inp[28836] = 1073722880; +inp[28837] = 0; +inp[28838] = 1073722752; +inp[28839] = 0; +inp[28840] = 1073722624; +inp[28841] = 0; +inp[28842] = 1073722496; +inp[28843] = 0; +inp[28844] = 1073722368; +inp[28845] = 0; +inp[28846] = 1073722240; +inp[28847] = 0; +inp[28848] = 1073722112; +inp[28849] = 0; +inp[28850] = 1073721984; +inp[28851] = 0; +inp[28852] = 1073721856; +inp[28853] = 0; +inp[28854] = 1073721728; +inp[28855] = 0; +inp[28856] = 1073721600; +inp[28857] = 0; +inp[28858] = 1073721472; +inp[28859] = 0; +inp[28860] = 1073721344; +inp[28861] = 0; +inp[28862] = 1073721216; +inp[28863] = 0; +inp[28864] = 1073721088; +inp[28865] = 0; +inp[28866] = 1073720960; +inp[28867] = 0; +inp[28868] = 1073720832; +inp[28869] = 0; +inp[28870] = 1073720704; +inp[28871] = 0; +inp[28872] = 1073720576; +inp[28873] = 0; +inp[28874] = 1073720448; +inp[28875] = 0; +inp[28876] = 1073720320; +inp[28877] = 0; +inp[28878] = 1073720192; +inp[28879] = 0; +inp[28880] = 1073720064; +inp[28881] = 0; +inp[28882] = 1073719936; +inp[28883] = 0; +inp[28884] = 1073719808; +inp[28885] = 0; +inp[28886] = 1073719680; +inp[28887] = 0; +inp[28888] = 1073719552; +inp[28889] = 0; +inp[28890] = 1073719424; +inp[28891] = 0; +inp[28892] = 1073719296; +inp[28893] = 0; +inp[28894] = 1073719168; +inp[28895] = 0; +inp[28896] = 1073719040; +inp[28897] = 0; +inp[28898] = 1073718912; +inp[28899] = 0; +inp[28900] = 1073718784; +inp[28901] = 0; +inp[28902] = 1073718656; +inp[28903] = 0; +inp[28904] = 1073718528; +inp[28905] = 0; +inp[28906] = 1073718400; +inp[28907] = 0; +inp[28908] = 1073718272; +inp[28909] = 0; +inp[28910] = 1073718144; +inp[28911] = 0; +inp[28912] = 1073718016; +inp[28913] = 0; +inp[28914] = 1073717888; +inp[28915] = 0; +inp[28916] = 1073717760; +inp[28917] = 0; +inp[28918] = 1073717632; +inp[28919] = 0; +inp[28920] = 1073717504; +inp[28921] = 0; +inp[28922] = 1073717376; +inp[28923] = 0; +inp[28924] = 1073717248; +inp[28925] = 0; +inp[28926] = 1073717120; +inp[28927] = 0; +inp[28928] = 1073716992; +inp[28929] = 0; +inp[28930] = 1073716864; +inp[28931] = 0; +inp[28932] = 1073716736; +inp[28933] = 0; +inp[28934] = 1073716608; +inp[28935] = 0; +inp[28936] = 1073716480; +inp[28937] = 0; +inp[28938] = 1073716352; +inp[28939] = 0; +inp[28940] = 1073716224; +inp[28941] = 0; +inp[28942] = 1073716096; +inp[28943] = 0; +inp[28944] = 1073715968; +inp[28945] = 0; +inp[28946] = 1073715840; +inp[28947] = 0; +inp[28948] = 1073715712; +inp[28949] = 0; +inp[28950] = 1073715584; +inp[28951] = 0; +inp[28952] = 1073715456; +inp[28953] = 0; +inp[28954] = 1073715328; +inp[28955] = 0; +inp[28956] = 1073715200; +inp[28957] = 0; +inp[28958] = 1073715072; +inp[28959] = 0; +inp[28960] = 1073714944; +inp[28961] = 0; +inp[28962] = 1073714816; +inp[28963] = 0; +inp[28964] = 1073714688; +inp[28965] = 0; +inp[28966] = 1073714560; +inp[28967] = 0; +inp[28968] = 1073714432; +inp[28969] = 0; +inp[28970] = 1073714304; +inp[28971] = 0; +inp[28972] = 1073714176; +inp[28973] = 0; +inp[28974] = 1073714048; +inp[28975] = 0; +inp[28976] = 1073713920; +inp[28977] = 0; +inp[28978] = 1073713792; +inp[28979] = 0; +inp[28980] = 1073713664; +inp[28981] = 0; +inp[28982] = 1073713536; +inp[28983] = 0; +inp[28984] = 1073713408; +inp[28985] = 0; +inp[28986] = 1073713280; +inp[28987] = 0; +inp[28988] = 1073713152; +inp[28989] = 0; +inp[28990] = 1073713024; +inp[28991] = 0; +inp[28992] = 1073712896; +inp[28993] = 0; +inp[28994] = 1073712768; +inp[28995] = 0; +inp[28996] = 1073712640; +inp[28997] = 0; +inp[28998] = 1073712512; +inp[28999] = 0; +inp[29000] = 1073712384; +inp[29001] = 0; +inp[29002] = 1073712256; +inp[29003] = 0; +inp[29004] = 1073712128; +inp[29005] = 0; +inp[29006] = 1073712000; +inp[29007] = 0; +inp[29008] = 1073711872; +inp[29009] = 0; +inp[29010] = 1073711744; +inp[29011] = 0; +inp[29012] = 1073711616; +inp[29013] = 0; +inp[29014] = 1073711488; +inp[29015] = 0; +inp[29016] = 1073711360; +inp[29017] = 0; +inp[29018] = 1073711232; +inp[29019] = 0; +inp[29020] = 1073711104; +inp[29021] = 0; +inp[29022] = 1073710976; +inp[29023] = 0; +inp[29024] = 1073710848; +inp[29025] = 0; +inp[29026] = 1073710720; +inp[29027] = 0; +inp[29028] = 1073710592; +inp[29029] = 0; +inp[29030] = 1073710464; +inp[29031] = 0; +inp[29032] = 1073710336; +inp[29033] = 0; +inp[29034] = 1073710208; +inp[29035] = 0; +inp[29036] = 1073710080; +inp[29037] = 0; +inp[29038] = 1073709952; +inp[29039] = 0; +inp[29040] = 1073709824; +inp[29041] = 0; +inp[29042] = 1073709696; +inp[29043] = 0; +inp[29044] = 1073709568; +inp[29045] = 0; +inp[29046] = 1073709440; +inp[29047] = 0; +inp[29048] = 1073709312; +inp[29049] = 0; +inp[29050] = 1073709184; +inp[29051] = 0; +inp[29052] = 1073741824; +inp[29053] = 1073741824; +inp[29054] = 1073741760; +inp[29055] = 0; +inp[29056] = 1073741696; +inp[29057] = 0; +inp[29058] = 1073741632; +inp[29059] = 0; +inp[29060] = 1073741568; +inp[29061] = 0; +inp[29062] = 1073741504; +inp[29063] = 0; +inp[29064] = 1073741440; +inp[29065] = 0; +inp[29066] = 1073741376; +inp[29067] = 0; +inp[29068] = 1073741312; +inp[29069] = 0; +inp[29070] = 1073741248; +inp[29071] = 0; +inp[29072] = 1073741184; +inp[29073] = 0; +inp[29074] = 1073741120; +inp[29075] = 0; +inp[29076] = 1073741056; +inp[29077] = 0; +inp[29078] = 1073740992; +inp[29079] = 0; +inp[29080] = 1073740928; +inp[29081] = 0; +inp[29082] = 1073740864; +inp[29083] = 0; +inp[29084] = 1073740800; +inp[29085] = 0; +inp[29086] = 1073740736; +inp[29087] = 0; +inp[29088] = 1073740672; +inp[29089] = 0; +inp[29090] = 1073740608; +inp[29091] = 0; +inp[29092] = 1073740544; +inp[29093] = 0; +inp[29094] = 1073740480; +inp[29095] = 0; +inp[29096] = 1073740416; +inp[29097] = 0; +inp[29098] = 1073740352; +inp[29099] = 0; +inp[29100] = 1073740288; +inp[29101] = 0; +inp[29102] = 1073740224; +inp[29103] = 0; +inp[29104] = 1073740160; +inp[29105] = 0; +inp[29106] = 1073740096; +inp[29107] = 0; +inp[29108] = 1073740032; +inp[29109] = 0; +inp[29110] = 1073739968; +inp[29111] = 0; +inp[29112] = 1073739904; +inp[29113] = 0; +inp[29114] = 1073739840; +inp[29115] = 0; +inp[29116] = 1073739776; +inp[29117] = 0; +inp[29118] = 1073739712; +inp[29119] = 0; +inp[29120] = 1073739648; +inp[29121] = 0; +inp[29122] = 1073739584; +inp[29123] = 0; +inp[29124] = 1073739520; +inp[29125] = 0; +inp[29126] = 1073739456; +inp[29127] = 0; +inp[29128] = 1073739392; +inp[29129] = 0; +inp[29130] = 1073739328; +inp[29131] = 0; +inp[29132] = 1073739264; +inp[29133] = 0; +inp[29134] = 1073739200; +inp[29135] = 0; +inp[29136] = 1073739136; +inp[29137] = 0; +inp[29138] = 1073739072; +inp[29139] = 0; +inp[29140] = 1073739008; +inp[29141] = 0; +inp[29142] = 1073738944; +inp[29143] = 0; +inp[29144] = 1073738880; +inp[29145] = 0; +inp[29146] = 1073738816; +inp[29147] = 0; +inp[29148] = 1073738752; +inp[29149] = 0; +inp[29150] = 1073738688; +inp[29151] = 0; +inp[29152] = 1073738624; +inp[29153] = 0; +inp[29154] = 1073738560; +inp[29155] = 0; +inp[29156] = 1073738496; +inp[29157] = 0; +inp[29158] = 1073738432; +inp[29159] = 0; +inp[29160] = 1073738368; +inp[29161] = 0; +inp[29162] = 1073738304; +inp[29163] = 0; +inp[29164] = 1073738240; +inp[29165] = 0; +inp[29166] = 1073738176; +inp[29167] = 0; +inp[29168] = 1073738112; +inp[29169] = 0; +inp[29170] = 1073738048; +inp[29171] = 0; +inp[29172] = 1073737984; +inp[29173] = 0; +inp[29174] = 1073737920; +inp[29175] = 0; +inp[29176] = 1073737856; +inp[29177] = 0; +inp[29178] = 1073737792; +inp[29179] = 0; +inp[29180] = 1073737728; +inp[29181] = 0; +inp[29182] = 1073737664; +inp[29183] = 0; +inp[29184] = 1073737600; +inp[29185] = 0; +inp[29186] = 1073737536; +inp[29187] = 0; +inp[29188] = 1073737472; +inp[29189] = 0; +inp[29190] = 1073737408; +inp[29191] = 0; +inp[29192] = 1073737344; +inp[29193] = 0; +inp[29194] = 1073737280; +inp[29195] = 0; +inp[29196] = 1073737216; +inp[29197] = 0; +inp[29198] = 1073737152; +inp[29199] = 0; +inp[29200] = 1073737088; +inp[29201] = 0; +inp[29202] = 1073737024; +inp[29203] = 0; +inp[29204] = 1073736960; +inp[29205] = 0; +inp[29206] = 1073736896; +inp[29207] = 0; +inp[29208] = 1073736832; +inp[29209] = 0; +inp[29210] = 1073736768; +inp[29211] = 0; +inp[29212] = 1073736704; +inp[29213] = 0; +inp[29214] = 1073736640; +inp[29215] = 0; +inp[29216] = 1073736576; +inp[29217] = 0; +inp[29218] = 1073736512; +inp[29219] = 0; +inp[29220] = 1073736448; +inp[29221] = 0; +inp[29222] = 1073736384; +inp[29223] = 0; +inp[29224] = 1073736320; +inp[29225] = 0; +inp[29226] = 1073736256; +inp[29227] = 0; +inp[29228] = 1073736192; +inp[29229] = 0; +inp[29230] = 1073736128; +inp[29231] = 0; +inp[29232] = 1073736064; +inp[29233] = 0; +inp[29234] = 1073736000; +inp[29235] = 0; +inp[29236] = 1073735936; +inp[29237] = 0; +inp[29238] = 1073735872; +inp[29239] = 0; +inp[29240] = 1073735808; +inp[29241] = 0; +inp[29242] = 1073735744; +inp[29243] = 0; +inp[29244] = 1073735680; +inp[29245] = 0; +inp[29246] = 1073735616; +inp[29247] = 0; +inp[29248] = 1073735552; +inp[29249] = 0; +inp[29250] = 1073735488; +inp[29251] = 0; +inp[29252] = 1073735424; +inp[29253] = 0; +inp[29254] = 1073735360; +inp[29255] = 0; +inp[29256] = 1073735296; +inp[29257] = 0; +inp[29258] = 1073735232; +inp[29259] = 0; +inp[29260] = 1073735168; +inp[29261] = 0; +inp[29262] = 1073735104; +inp[29263] = 0; +inp[29264] = 1073735040; +inp[29265] = 0; +inp[29266] = 1073734976; +inp[29267] = 0; +inp[29268] = 1073734912; +inp[29269] = 0; +inp[29270] = 1073734848; +inp[29271] = 0; +inp[29272] = 1073734784; +inp[29273] = 0; +inp[29274] = 1073734720; +inp[29275] = 0; +inp[29276] = 1073734656; +inp[29277] = 0; +inp[29278] = 1073734592; +inp[29279] = 0; +inp[29280] = 1073734528; +inp[29281] = 0; +inp[29282] = 1073734464; +inp[29283] = 0; +inp[29284] = 1073734400; +inp[29285] = 0; +inp[29286] = 1073734336; +inp[29287] = 0; +inp[29288] = 1073734272; +inp[29289] = 0; +inp[29290] = 1073734208; +inp[29291] = 0; +inp[29292] = 1073734144; +inp[29293] = 0; +inp[29294] = 1073734080; +inp[29295] = 0; +inp[29296] = 1073734016; +inp[29297] = 0; +inp[29298] = 1073733952; +inp[29299] = 0; +inp[29300] = 1073733888; +inp[29301] = 0; +inp[29302] = 1073733824; +inp[29303] = 0; +inp[29304] = 1073733760; +inp[29305] = 0; +inp[29306] = 1073733696; +inp[29307] = 0; +inp[29308] = 1073733632; +inp[29309] = 0; +inp[29310] = 1073733568; +inp[29311] = 0; +inp[29312] = 1073733504; +inp[29313] = 0; +inp[29314] = 1073733440; +inp[29315] = 0; +inp[29316] = 1073733376; +inp[29317] = 0; +inp[29318] = 1073733312; +inp[29319] = 0; +inp[29320] = 1073733248; +inp[29321] = 0; +inp[29322] = 1073733184; +inp[29323] = 0; +inp[29324] = 1073733120; +inp[29325] = 0; +inp[29326] = 1073733056; +inp[29327] = 0; +inp[29328] = 1073732992; +inp[29329] = 0; +inp[29330] = 1073732928; +inp[29331] = 0; +inp[29332] = 1073732864; +inp[29333] = 0; +inp[29334] = 1073732800; +inp[29335] = 0; +inp[29336] = 1073732736; +inp[29337] = 0; +inp[29338] = 1073732672; +inp[29339] = 0; +inp[29340] = 1073732608; +inp[29341] = 0; +inp[29342] = 1073732544; +inp[29343] = 0; +inp[29344] = 1073732480; +inp[29345] = 0; +inp[29346] = 1073732416; +inp[29347] = 0; +inp[29348] = 1073732352; +inp[29349] = 0; +inp[29350] = 1073732288; +inp[29351] = 0; +inp[29352] = 1073732224; +inp[29353] = 0; +inp[29354] = 1073732160; +inp[29355] = 0; +inp[29356] = 1073732096; +inp[29357] = 0; +inp[29358] = 1073732032; +inp[29359] = 0; +inp[29360] = 1073731968; +inp[29361] = 0; +inp[29362] = 1073731904; +inp[29363] = 0; +inp[29364] = 1073731840; +inp[29365] = 0; +inp[29366] = 1073731776; +inp[29367] = 0; +inp[29368] = 1073731712; +inp[29369] = 0; +inp[29370] = 1073731648; +inp[29371] = 0; +inp[29372] = 1073731584; +inp[29373] = 0; +inp[29374] = 1073731520; +inp[29375] = 0; +inp[29376] = 1073731456; +inp[29377] = 0; +inp[29378] = 1073731392; +inp[29379] = 0; +inp[29380] = 1073731328; +inp[29381] = 0; +inp[29382] = 1073731264; +inp[29383] = 0; +inp[29384] = 1073731200; +inp[29385] = 0; +inp[29386] = 1073731136; +inp[29387] = 0; +inp[29388] = 1073731072; +inp[29389] = 0; +inp[29390] = 1073731008; +inp[29391] = 0; +inp[29392] = 1073730944; +inp[29393] = 0; +inp[29394] = 1073730880; +inp[29395] = 0; +inp[29396] = 1073730816; +inp[29397] = 0; +inp[29398] = 1073730752; +inp[29399] = 0; +inp[29400] = 1073730688; +inp[29401] = 0; +inp[29402] = 1073730624; +inp[29403] = 0; +inp[29404] = 1073730560; +inp[29405] = 0; +inp[29406] = 1073730496; +inp[29407] = 0; +inp[29408] = 1073730432; +inp[29409] = 0; +inp[29410] = 1073730368; +inp[29411] = 0; +inp[29412] = 1073730304; +inp[29413] = 0; +inp[29414] = 1073730240; +inp[29415] = 0; +inp[29416] = 1073730176; +inp[29417] = 0; +inp[29418] = 1073730112; +inp[29419] = 0; +inp[29420] = 1073730048; +inp[29421] = 0; +inp[29422] = 1073729984; +inp[29423] = 0; +inp[29424] = 1073729920; +inp[29425] = 0; +inp[29426] = 1073729856; +inp[29427] = 0; +inp[29428] = 1073729792; +inp[29429] = 0; +inp[29430] = 1073729728; +inp[29431] = 0; +inp[29432] = 1073729664; +inp[29433] = 0; +inp[29434] = 1073729600; +inp[29435] = 0; +inp[29436] = 1073729536; +inp[29437] = 0; +inp[29438] = 1073729472; +inp[29439] = 0; +inp[29440] = 1073729408; +inp[29441] = 0; +inp[29442] = 1073729344; +inp[29443] = 0; +inp[29444] = 1073729280; +inp[29445] = 0; +inp[29446] = 1073729216; +inp[29447] = 0; +inp[29448] = 1073729152; +inp[29449] = 0; +inp[29450] = 1073729088; +inp[29451] = 0; +inp[29452] = 1073729024; +inp[29453] = 0; +inp[29454] = 1073728960; +inp[29455] = 0; +inp[29456] = 1073728896; +inp[29457] = 0; +inp[29458] = 1073728832; +inp[29459] = 0; +inp[29460] = 1073728768; +inp[29461] = 0; +inp[29462] = 1073728704; +inp[29463] = 0; +inp[29464] = 1073728640; +inp[29465] = 0; +inp[29466] = 1073728576; +inp[29467] = 0; +inp[29468] = 1073728512; +inp[29469] = 0; +inp[29470] = 1073728448; +inp[29471] = 0; +inp[29472] = 1073728384; +inp[29473] = 0; +inp[29474] = 1073728320; +inp[29475] = 0; +inp[29476] = 1073728256; +inp[29477] = 0; +inp[29478] = 1073728192; +inp[29479] = 0; +inp[29480] = 1073728128; +inp[29481] = 0; +inp[29482] = 1073728064; +inp[29483] = 0; +inp[29484] = 1073728000; +inp[29485] = 0; +inp[29486] = 1073727936; +inp[29487] = 0; +inp[29488] = 1073727872; +inp[29489] = 0; +inp[29490] = 1073727808; +inp[29491] = 0; +inp[29492] = 1073727744; +inp[29493] = 0; +inp[29494] = 1073727680; +inp[29495] = 0; +inp[29496] = 1073727616; +inp[29497] = 0; +inp[29498] = 1073727552; +inp[29499] = 0; +inp[29500] = 1073727488; +inp[29501] = 0; +inp[29502] = 1073727424; +inp[29503] = 0; +inp[29504] = 1073727360; +inp[29505] = 0; +inp[29506] = 1073727296; +inp[29507] = 0; +inp[29508] = 1073727232; +inp[29509] = 0; +inp[29510] = 1073727168; +inp[29511] = 0; +inp[29512] = 1073727104; +inp[29513] = 0; +inp[29514] = 1073727040; +inp[29515] = 0; +inp[29516] = 1073726976; +inp[29517] = 0; +inp[29518] = 1073726912; +inp[29519] = 0; +inp[29520] = 1073726848; +inp[29521] = 0; +inp[29522] = 1073726784; +inp[29523] = 0; +inp[29524] = 1073726720; +inp[29525] = 0; +inp[29526] = 1073726656; +inp[29527] = 0; +inp[29528] = 1073726592; +inp[29529] = 0; +inp[29530] = 1073726528; +inp[29531] = 0; +inp[29532] = 1073726464; +inp[29533] = 0; +inp[29534] = 1073726400; +inp[29535] = 0; +inp[29536] = 1073726336; +inp[29537] = 0; +inp[29538] = 1073726272; +inp[29539] = 0; +inp[29540] = 1073726208; +inp[29541] = 0; +inp[29542] = 1073726144; +inp[29543] = 0; +inp[29544] = 1073726080; +inp[29545] = 0; +inp[29546] = 1073726016; +inp[29547] = 0; +inp[29548] = 1073725952; +inp[29549] = 0; +inp[29550] = 1073725888; +inp[29551] = 0; +inp[29552] = 1073725824; +inp[29553] = 0; +inp[29554] = 1073725760; +inp[29555] = 0; +inp[29556] = 1073725696; +inp[29557] = 0; +inp[29558] = 1073725632; +inp[29559] = 0; +inp[29560] = 1073725568; +inp[29561] = 0; +inp[29562] = 1073725504; +inp[29563] = 0; +inp[29564] = 1073741824; +inp[29565] = 1073741824; +inp[29566] = 1073741792; +inp[29567] = 0; +inp[29568] = 1073741760; +inp[29569] = 0; +inp[29570] = 1073741728; +inp[29571] = 0; +inp[29572] = 1073741696; +inp[29573] = 0; +inp[29574] = 1073741664; +inp[29575] = 0; +inp[29576] = 1073741632; +inp[29577] = 0; +inp[29578] = 1073741600; +inp[29579] = 0; +inp[29580] = 1073741568; +inp[29581] = 0; +inp[29582] = 1073741536; +inp[29583] = 0; +inp[29584] = 1073741504; +inp[29585] = 0; +inp[29586] = 1073741472; +inp[29587] = 0; +inp[29588] = 1073741440; +inp[29589] = 0; +inp[29590] = 1073741408; +inp[29591] = 0; +inp[29592] = 1073741376; +inp[29593] = 0; +inp[29594] = 1073741344; +inp[29595] = 0; +inp[29596] = 1073741312; +inp[29597] = 0; +inp[29598] = 1073741280; +inp[29599] = 0; +inp[29600] = 1073741248; +inp[29601] = 0; +inp[29602] = 1073741216; +inp[29603] = 0; +inp[29604] = 1073741184; +inp[29605] = 0; +inp[29606] = 1073741152; +inp[29607] = 0; +inp[29608] = 1073741120; +inp[29609] = 0; +inp[29610] = 1073741088; +inp[29611] = 0; +inp[29612] = 1073741056; +inp[29613] = 0; +inp[29614] = 1073741024; +inp[29615] = 0; +inp[29616] = 1073740992; +inp[29617] = 0; +inp[29618] = 1073740960; +inp[29619] = 0; +inp[29620] = 1073740928; +inp[29621] = 0; +inp[29622] = 1073740896; +inp[29623] = 0; +inp[29624] = 1073740864; +inp[29625] = 0; +inp[29626] = 1073740832; +inp[29627] = 0; +inp[29628] = 1073740800; +inp[29629] = 0; +inp[29630] = 1073740768; +inp[29631] = 0; +inp[29632] = 1073740736; +inp[29633] = 0; +inp[29634] = 1073740704; +inp[29635] = 0; +inp[29636] = 1073740672; +inp[29637] = 0; +inp[29638] = 1073740640; +inp[29639] = 0; +inp[29640] = 1073740608; +inp[29641] = 0; +inp[29642] = 1073740576; +inp[29643] = 0; +inp[29644] = 1073740544; +inp[29645] = 0; +inp[29646] = 1073740512; +inp[29647] = 0; +inp[29648] = 1073740480; +inp[29649] = 0; +inp[29650] = 1073740448; +inp[29651] = 0; +inp[29652] = 1073740416; +inp[29653] = 0; +inp[29654] = 1073740384; +inp[29655] = 0; +inp[29656] = 1073740352; +inp[29657] = 0; +inp[29658] = 1073740320; +inp[29659] = 0; +inp[29660] = 1073740288; +inp[29661] = 0; +inp[29662] = 1073740256; +inp[29663] = 0; +inp[29664] = 1073740224; +inp[29665] = 0; +inp[29666] = 1073740192; +inp[29667] = 0; +inp[29668] = 1073740160; +inp[29669] = 0; +inp[29670] = 1073740128; +inp[29671] = 0; +inp[29672] = 1073740096; +inp[29673] = 0; +inp[29674] = 1073740064; +inp[29675] = 0; +inp[29676] = 1073740032; +inp[29677] = 0; +inp[29678] = 1073740000; +inp[29679] = 0; +inp[29680] = 1073739968; +inp[29681] = 0; +inp[29682] = 1073739936; +inp[29683] = 0; +inp[29684] = 1073739904; +inp[29685] = 0; +inp[29686] = 1073739872; +inp[29687] = 0; +inp[29688] = 1073739840; +inp[29689] = 0; +inp[29690] = 1073739808; +inp[29691] = 0; +inp[29692] = 1073739776; +inp[29693] = 0; +inp[29694] = 1073739744; +inp[29695] = 0; +inp[29696] = 1073739712; +inp[29697] = 0; +inp[29698] = 1073739680; +inp[29699] = 0; +inp[29700] = 1073739648; +inp[29701] = 0; +inp[29702] = 1073739616; +inp[29703] = 0; +inp[29704] = 1073739584; +inp[29705] = 0; +inp[29706] = 1073739552; +inp[29707] = 0; +inp[29708] = 1073739520; +inp[29709] = 0; +inp[29710] = 1073739488; +inp[29711] = 0; +inp[29712] = 1073739456; +inp[29713] = 0; +inp[29714] = 1073739424; +inp[29715] = 0; +inp[29716] = 1073739392; +inp[29717] = 0; +inp[29718] = 1073739360; +inp[29719] = 0; +inp[29720] = 1073739328; +inp[29721] = 0; +inp[29722] = 1073739296; +inp[29723] = 0; +inp[29724] = 1073739264; +inp[29725] = 0; +inp[29726] = 1073739232; +inp[29727] = 0; +inp[29728] = 1073739200; +inp[29729] = 0; +inp[29730] = 1073739168; +inp[29731] = 0; +inp[29732] = 1073739136; +inp[29733] = 0; +inp[29734] = 1073739104; +inp[29735] = 0; +inp[29736] = 1073739072; +inp[29737] = 0; +inp[29738] = 1073739040; +inp[29739] = 0; +inp[29740] = 1073739008; +inp[29741] = 0; +inp[29742] = 1073738976; +inp[29743] = 0; +inp[29744] = 1073738944; +inp[29745] = 0; +inp[29746] = 1073738912; +inp[29747] = 0; +inp[29748] = 1073738880; +inp[29749] = 0; +inp[29750] = 1073738848; +inp[29751] = 0; +inp[29752] = 1073738816; +inp[29753] = 0; +inp[29754] = 1073738784; +inp[29755] = 0; +inp[29756] = 1073738752; +inp[29757] = 0; +inp[29758] = 1073738720; +inp[29759] = 0; +inp[29760] = 1073738688; +inp[29761] = 0; +inp[29762] = 1073738656; +inp[29763] = 0; +inp[29764] = 1073738624; +inp[29765] = 0; +inp[29766] = 1073738592; +inp[29767] = 0; +inp[29768] = 1073738560; +inp[29769] = 0; +inp[29770] = 1073738528; +inp[29771] = 0; +inp[29772] = 1073738496; +inp[29773] = 0; +inp[29774] = 1073738464; +inp[29775] = 0; +inp[29776] = 1073738432; +inp[29777] = 0; +inp[29778] = 1073738400; +inp[29779] = 0; +inp[29780] = 1073738368; +inp[29781] = 0; +inp[29782] = 1073738336; +inp[29783] = 0; +inp[29784] = 1073738304; +inp[29785] = 0; +inp[29786] = 1073738272; +inp[29787] = 0; +inp[29788] = 1073738240; +inp[29789] = 0; +inp[29790] = 1073738208; +inp[29791] = 0; +inp[29792] = 1073738176; +inp[29793] = 0; +inp[29794] = 1073738144; +inp[29795] = 0; +inp[29796] = 1073738112; +inp[29797] = 0; +inp[29798] = 1073738080; +inp[29799] = 0; +inp[29800] = 1073738048; +inp[29801] = 0; +inp[29802] = 1073738016; +inp[29803] = 0; +inp[29804] = 1073737984; +inp[29805] = 0; +inp[29806] = 1073737952; +inp[29807] = 0; +inp[29808] = 1073737920; +inp[29809] = 0; +inp[29810] = 1073737888; +inp[29811] = 0; +inp[29812] = 1073737856; +inp[29813] = 0; +inp[29814] = 1073737824; +inp[29815] = 0; +inp[29816] = 1073737792; +inp[29817] = 0; +inp[29818] = 1073737760; +inp[29819] = 0; +inp[29820] = 1073737728; +inp[29821] = 0; +inp[29822] = 1073737696; +inp[29823] = 0; +inp[29824] = 1073737664; +inp[29825] = 0; +inp[29826] = 1073737632; +inp[29827] = 0; +inp[29828] = 1073737600; +inp[29829] = 0; +inp[29830] = 1073737568; +inp[29831] = 0; +inp[29832] = 1073737536; +inp[29833] = 0; +inp[29834] = 1073737504; +inp[29835] = 0; +inp[29836] = 1073737472; +inp[29837] = 0; +inp[29838] = 1073737440; +inp[29839] = 0; +inp[29840] = 1073737408; +inp[29841] = 0; +inp[29842] = 1073737376; +inp[29843] = 0; +inp[29844] = 1073737344; +inp[29845] = 0; +inp[29846] = 1073737312; +inp[29847] = 0; +inp[29848] = 1073737280; +inp[29849] = 0; +inp[29850] = 1073737248; +inp[29851] = 0; +inp[29852] = 1073737216; +inp[29853] = 0; +inp[29854] = 1073737184; +inp[29855] = 0; +inp[29856] = 1073737152; +inp[29857] = 0; +inp[29858] = 1073737120; +inp[29859] = 0; +inp[29860] = 1073737088; +inp[29861] = 0; +inp[29862] = 1073737056; +inp[29863] = 0; +inp[29864] = 1073737024; +inp[29865] = 0; +inp[29866] = 1073736992; +inp[29867] = 0; +inp[29868] = 1073736960; +inp[29869] = 0; +inp[29870] = 1073736928; +inp[29871] = 0; +inp[29872] = 1073736896; +inp[29873] = 0; +inp[29874] = 1073736864; +inp[29875] = 0; +inp[29876] = 1073736832; +inp[29877] = 0; +inp[29878] = 1073736800; +inp[29879] = 0; +inp[29880] = 1073736768; +inp[29881] = 0; +inp[29882] = 1073736736; +inp[29883] = 0; +inp[29884] = 1073736704; +inp[29885] = 0; +inp[29886] = 1073736672; +inp[29887] = 0; +inp[29888] = 1073736640; +inp[29889] = 0; +inp[29890] = 1073736608; +inp[29891] = 0; +inp[29892] = 1073736576; +inp[29893] = 0; +inp[29894] = 1073736544; +inp[29895] = 0; +inp[29896] = 1073736512; +inp[29897] = 0; +inp[29898] = 1073736480; +inp[29899] = 0; +inp[29900] = 1073736448; +inp[29901] = 0; +inp[29902] = 1073736416; +inp[29903] = 0; +inp[29904] = 1073736384; +inp[29905] = 0; +inp[29906] = 1073736352; +inp[29907] = 0; +inp[29908] = 1073736320; +inp[29909] = 0; +inp[29910] = 1073736288; +inp[29911] = 0; +inp[29912] = 1073736256; +inp[29913] = 0; +inp[29914] = 1073736224; +inp[29915] = 0; +inp[29916] = 1073736192; +inp[29917] = 0; +inp[29918] = 1073736160; +inp[29919] = 0; +inp[29920] = 1073736128; +inp[29921] = 0; +inp[29922] = 1073736096; +inp[29923] = 0; +inp[29924] = 1073736064; +inp[29925] = 0; +inp[29926] = 1073736032; +inp[29927] = 0; +inp[29928] = 1073736000; +inp[29929] = 0; +inp[29930] = 1073735968; +inp[29931] = 0; +inp[29932] = 1073735936; +inp[29933] = 0; +inp[29934] = 1073735904; +inp[29935] = 0; +inp[29936] = 1073735872; +inp[29937] = 0; +inp[29938] = 1073735840; +inp[29939] = 0; +inp[29940] = 1073735808; +inp[29941] = 0; +inp[29942] = 1073735776; +inp[29943] = 0; +inp[29944] = 1073735744; +inp[29945] = 0; +inp[29946] = 1073735712; +inp[29947] = 0; +inp[29948] = 1073735680; +inp[29949] = 0; +inp[29950] = 1073735648; +inp[29951] = 0; +inp[29952] = 1073735616; +inp[29953] = 0; +inp[29954] = 1073735584; +inp[29955] = 0; +inp[29956] = 1073735552; +inp[29957] = 0; +inp[29958] = 1073735520; +inp[29959] = 0; +inp[29960] = 1073735488; +inp[29961] = 0; +inp[29962] = 1073735456; +inp[29963] = 0; +inp[29964] = 1073735424; +inp[29965] = 0; +inp[29966] = 1073735392; +inp[29967] = 0; +inp[29968] = 1073735360; +inp[29969] = 0; +inp[29970] = 1073735328; +inp[29971] = 0; +inp[29972] = 1073735296; +inp[29973] = 0; +inp[29974] = 1073735264; +inp[29975] = 0; +inp[29976] = 1073735232; +inp[29977] = 0; +inp[29978] = 1073735200; +inp[29979] = 0; +inp[29980] = 1073735168; +inp[29981] = 0; +inp[29982] = 1073735136; +inp[29983] = 0; +inp[29984] = 1073735104; +inp[29985] = 0; +inp[29986] = 1073735072; +inp[29987] = 0; +inp[29988] = 1073735040; +inp[29989] = 0; +inp[29990] = 1073735008; +inp[29991] = 0; +inp[29992] = 1073734976; +inp[29993] = 0; +inp[29994] = 1073734944; +inp[29995] = 0; +inp[29996] = 1073734912; +inp[29997] = 0; +inp[29998] = 1073734880; +inp[29999] = 0; +inp[30000] = 1073734848; +inp[30001] = 0; +inp[30002] = 1073734816; +inp[30003] = 0; +inp[30004] = 1073734784; +inp[30005] = 0; +inp[30006] = 1073734752; +inp[30007] = 0; +inp[30008] = 1073734720; +inp[30009] = 0; +inp[30010] = 1073734688; +inp[30011] = 0; +inp[30012] = 1073734656; +inp[30013] = 0; +inp[30014] = 1073734624; +inp[30015] = 0; +inp[30016] = 1073734592; +inp[30017] = 0; +inp[30018] = 1073734560; +inp[30019] = 0; +inp[30020] = 1073734528; +inp[30021] = 0; +inp[30022] = 1073734496; +inp[30023] = 0; +inp[30024] = 1073734464; +inp[30025] = 0; +inp[30026] = 1073734432; +inp[30027] = 0; +inp[30028] = 1073734400; +inp[30029] = 0; +inp[30030] = 1073734368; +inp[30031] = 0; +inp[30032] = 1073734336; +inp[30033] = 0; +inp[30034] = 1073734304; +inp[30035] = 0; +inp[30036] = 1073734272; +inp[30037] = 0; +inp[30038] = 1073734240; +inp[30039] = 0; +inp[30040] = 1073734208; +inp[30041] = 0; +inp[30042] = 1073734176; +inp[30043] = 0; +inp[30044] = 1073734144; +inp[30045] = 0; +inp[30046] = 1073734112; +inp[30047] = 0; +inp[30048] = 1073734080; +inp[30049] = 0; +inp[30050] = 1073734048; +inp[30051] = 0; +inp[30052] = 1073734016; +inp[30053] = 0; +inp[30054] = 1073733984; +inp[30055] = 0; +inp[30056] = 1073733952; +inp[30057] = 0; +inp[30058] = 1073733920; +inp[30059] = 0; +inp[30060] = 1073733888; +inp[30061] = 0; +inp[30062] = 1073733856; +inp[30063] = 0; +inp[30064] = 1073733824; +inp[30065] = 0; +inp[30066] = 1073733792; +inp[30067] = 0; +inp[30068] = 1073733760; +inp[30069] = 0; +inp[30070] = 1073733728; +inp[30071] = 0; +inp[30072] = 1073733696; +inp[30073] = 0; +inp[30074] = 1073733664; +inp[30075] = 0; +inp[30076] = 1073741824; +inp[30077] = 1073741824; +inp[30078] = 1073741808; +inp[30079] = 0; +inp[30080] = 1073741792; +inp[30081] = 0; +inp[30082] = 1073741776; +inp[30083] = 0; +inp[30084] = 1073741760; +inp[30085] = 0; +inp[30086] = 1073741744; +inp[30087] = 0; +inp[30088] = 1073741728; +inp[30089] = 0; +inp[30090] = 1073741712; +inp[30091] = 0; +inp[30092] = 1073741696; +inp[30093] = 0; +inp[30094] = 1073741680; +inp[30095] = 0; +inp[30096] = 1073741664; +inp[30097] = 0; +inp[30098] = 1073741648; +inp[30099] = 0; +inp[30100] = 1073741632; +inp[30101] = 0; +inp[30102] = 1073741616; +inp[30103] = 0; +inp[30104] = 1073741600; +inp[30105] = 0; +inp[30106] = 1073741584; +inp[30107] = 0; +inp[30108] = 1073741568; +inp[30109] = 0; +inp[30110] = 1073741552; +inp[30111] = 0; +inp[30112] = 1073741536; +inp[30113] = 0; +inp[30114] = 1073741520; +inp[30115] = 0; +inp[30116] = 1073741504; +inp[30117] = 0; +inp[30118] = 1073741488; +inp[30119] = 0; +inp[30120] = 1073741472; +inp[30121] = 0; +inp[30122] = 1073741456; +inp[30123] = 0; +inp[30124] = 1073741440; +inp[30125] = 0; +inp[30126] = 1073741424; +inp[30127] = 0; +inp[30128] = 1073741408; +inp[30129] = 0; +inp[30130] = 1073741392; +inp[30131] = 0; +inp[30132] = 1073741376; +inp[30133] = 0; +inp[30134] = 1073741360; +inp[30135] = 0; +inp[30136] = 1073741344; +inp[30137] = 0; +inp[30138] = 1073741328; +inp[30139] = 0; +inp[30140] = 1073741312; +inp[30141] = 0; +inp[30142] = 1073741296; +inp[30143] = 0; +inp[30144] = 1073741280; +inp[30145] = 0; +inp[30146] = 1073741264; +inp[30147] = 0; +inp[30148] = 1073741248; +inp[30149] = 0; +inp[30150] = 1073741232; +inp[30151] = 0; +inp[30152] = 1073741216; +inp[30153] = 0; +inp[30154] = 1073741200; +inp[30155] = 0; +inp[30156] = 1073741184; +inp[30157] = 0; +inp[30158] = 1073741168; +inp[30159] = 0; +inp[30160] = 1073741152; +inp[30161] = 0; +inp[30162] = 1073741136; +inp[30163] = 0; +inp[30164] = 1073741120; +inp[30165] = 0; +inp[30166] = 1073741104; +inp[30167] = 0; +inp[30168] = 1073741088; +inp[30169] = 0; +inp[30170] = 1073741072; +inp[30171] = 0; +inp[30172] = 1073741056; +inp[30173] = 0; +inp[30174] = 1073741040; +inp[30175] = 0; +inp[30176] = 1073741024; +inp[30177] = 0; +inp[30178] = 1073741008; +inp[30179] = 0; +inp[30180] = 1073740992; +inp[30181] = 0; +inp[30182] = 1073740976; +inp[30183] = 0; +inp[30184] = 1073740960; +inp[30185] = 0; +inp[30186] = 1073740944; +inp[30187] = 0; +inp[30188] = 1073740928; +inp[30189] = 0; +inp[30190] = 1073740912; +inp[30191] = 0; +inp[30192] = 1073740896; +inp[30193] = 0; +inp[30194] = 1073740880; +inp[30195] = 0; +inp[30196] = 1073740864; +inp[30197] = 0; +inp[30198] = 1073740848; +inp[30199] = 0; +inp[30200] = 1073740832; +inp[30201] = 0; +inp[30202] = 1073740816; +inp[30203] = 0; +inp[30204] = 1073740800; +inp[30205] = 0; +inp[30206] = 1073740784; +inp[30207] = 0; +inp[30208] = 1073740768; +inp[30209] = 0; +inp[30210] = 1073740752; +inp[30211] = 0; +inp[30212] = 1073740736; +inp[30213] = 0; +inp[30214] = 1073740720; +inp[30215] = 0; +inp[30216] = 1073740704; +inp[30217] = 0; +inp[30218] = 1073740688; +inp[30219] = 0; +inp[30220] = 1073740672; +inp[30221] = 0; +inp[30222] = 1073740656; +inp[30223] = 0; +inp[30224] = 1073740640; +inp[30225] = 0; +inp[30226] = 1073740624; +inp[30227] = 0; +inp[30228] = 1073740608; +inp[30229] = 0; +inp[30230] = 1073740592; +inp[30231] = 0; +inp[30232] = 1073740576; +inp[30233] = 0; +inp[30234] = 1073740560; +inp[30235] = 0; +inp[30236] = 1073740544; +inp[30237] = 0; +inp[30238] = 1073740528; +inp[30239] = 0; +inp[30240] = 1073740512; +inp[30241] = 0; +inp[30242] = 1073740496; +inp[30243] = 0; +inp[30244] = 1073740480; +inp[30245] = 0; +inp[30246] = 1073740464; +inp[30247] = 0; +inp[30248] = 1073740448; +inp[30249] = 0; +inp[30250] = 1073740432; +inp[30251] = 0; +inp[30252] = 1073740416; +inp[30253] = 0; +inp[30254] = 1073740400; +inp[30255] = 0; +inp[30256] = 1073740384; +inp[30257] = 0; +inp[30258] = 1073740368; +inp[30259] = 0; +inp[30260] = 1073740352; +inp[30261] = 0; +inp[30262] = 1073740336; +inp[30263] = 0; +inp[30264] = 1073740320; +inp[30265] = 0; +inp[30266] = 1073740304; +inp[30267] = 0; +inp[30268] = 1073740288; +inp[30269] = 0; +inp[30270] = 1073740272; +inp[30271] = 0; +inp[30272] = 1073740256; +inp[30273] = 0; +inp[30274] = 1073740240; +inp[30275] = 0; +inp[30276] = 1073740224; +inp[30277] = 0; +inp[30278] = 1073740208; +inp[30279] = 0; +inp[30280] = 1073740192; +inp[30281] = 0; +inp[30282] = 1073740176; +inp[30283] = 0; +inp[30284] = 1073740160; +inp[30285] = 0; +inp[30286] = 1073740144; +inp[30287] = 0; +inp[30288] = 1073740128; +inp[30289] = 0; +inp[30290] = 1073740112; +inp[30291] = 0; +inp[30292] = 1073740096; +inp[30293] = 0; +inp[30294] = 1073740080; +inp[30295] = 0; +inp[30296] = 1073740064; +inp[30297] = 0; +inp[30298] = 1073740048; +inp[30299] = 0; +inp[30300] = 1073740032; +inp[30301] = 0; +inp[30302] = 1073740016; +inp[30303] = 0; +inp[30304] = 1073740000; +inp[30305] = 0; +inp[30306] = 1073739984; +inp[30307] = 0; +inp[30308] = 1073739968; +inp[30309] = 0; +inp[30310] = 1073739952; +inp[30311] = 0; +inp[30312] = 1073739936; +inp[30313] = 0; +inp[30314] = 1073739920; +inp[30315] = 0; +inp[30316] = 1073739904; +inp[30317] = 0; +inp[30318] = 1073739888; +inp[30319] = 0; +inp[30320] = 1073739872; +inp[30321] = 0; +inp[30322] = 1073739856; +inp[30323] = 0; +inp[30324] = 1073739840; +inp[30325] = 0; +inp[30326] = 1073739824; +inp[30327] = 0; +inp[30328] = 1073739808; +inp[30329] = 0; +inp[30330] = 1073739792; +inp[30331] = 0; +inp[30332] = 1073739776; +inp[30333] = 0; +inp[30334] = 1073739760; +inp[30335] = 0; +inp[30336] = 1073739744; +inp[30337] = 0; +inp[30338] = 1073739728; +inp[30339] = 0; +inp[30340] = 1073739712; +inp[30341] = 0; +inp[30342] = 1073739696; +inp[30343] = 0; +inp[30344] = 1073739680; +inp[30345] = 0; +inp[30346] = 1073739664; +inp[30347] = 0; +inp[30348] = 1073739648; +inp[30349] = 0; +inp[30350] = 1073739632; +inp[30351] = 0; +inp[30352] = 1073739616; +inp[30353] = 0; +inp[30354] = 1073739600; +inp[30355] = 0; +inp[30356] = 1073739584; +inp[30357] = 0; +inp[30358] = 1073739568; +inp[30359] = 0; +inp[30360] = 1073739552; +inp[30361] = 0; +inp[30362] = 1073739536; +inp[30363] = 0; +inp[30364] = 1073739520; +inp[30365] = 0; +inp[30366] = 1073739504; +inp[30367] = 0; +inp[30368] = 1073739488; +inp[30369] = 0; +inp[30370] = 1073739472; +inp[30371] = 0; +inp[30372] = 1073739456; +inp[30373] = 0; +inp[30374] = 1073739440; +inp[30375] = 0; +inp[30376] = 1073739424; +inp[30377] = 0; +inp[30378] = 1073739408; +inp[30379] = 0; +inp[30380] = 1073739392; +inp[30381] = 0; +inp[30382] = 1073739376; +inp[30383] = 0; +inp[30384] = 1073739360; +inp[30385] = 0; +inp[30386] = 1073739344; +inp[30387] = 0; +inp[30388] = 1073739328; +inp[30389] = 0; +inp[30390] = 1073739312; +inp[30391] = 0; +inp[30392] = 1073739296; +inp[30393] = 0; +inp[30394] = 1073739280; +inp[30395] = 0; +inp[30396] = 1073739264; +inp[30397] = 0; +inp[30398] = 1073739248; +inp[30399] = 0; +inp[30400] = 1073739232; +inp[30401] = 0; +inp[30402] = 1073739216; +inp[30403] = 0; +inp[30404] = 1073739200; +inp[30405] = 0; +inp[30406] = 1073739184; +inp[30407] = 0; +inp[30408] = 1073739168; +inp[30409] = 0; +inp[30410] = 1073739152; +inp[30411] = 0; +inp[30412] = 1073739136; +inp[30413] = 0; +inp[30414] = 1073739120; +inp[30415] = 0; +inp[30416] = 1073739104; +inp[30417] = 0; +inp[30418] = 1073739088; +inp[30419] = 0; +inp[30420] = 1073739072; +inp[30421] = 0; +inp[30422] = 1073739056; +inp[30423] = 0; +inp[30424] = 1073739040; +inp[30425] = 0; +inp[30426] = 1073739024; +inp[30427] = 0; +inp[30428] = 1073739008; +inp[30429] = 0; +inp[30430] = 1073738992; +inp[30431] = 0; +inp[30432] = 1073738976; +inp[30433] = 0; +inp[30434] = 1073738960; +inp[30435] = 0; +inp[30436] = 1073738944; +inp[30437] = 0; +inp[30438] = 1073738928; +inp[30439] = 0; +inp[30440] = 1073738912; +inp[30441] = 0; +inp[30442] = 1073738896; +inp[30443] = 0; +inp[30444] = 1073738880; +inp[30445] = 0; +inp[30446] = 1073738864; +inp[30447] = 0; +inp[30448] = 1073738848; +inp[30449] = 0; +inp[30450] = 1073738832; +inp[30451] = 0; +inp[30452] = 1073738816; +inp[30453] = 0; +inp[30454] = 1073738800; +inp[30455] = 0; +inp[30456] = 1073738784; +inp[30457] = 0; +inp[30458] = 1073738768; +inp[30459] = 0; +inp[30460] = 1073738752; +inp[30461] = 0; +inp[30462] = 1073738736; +inp[30463] = 0; +inp[30464] = 1073738720; +inp[30465] = 0; +inp[30466] = 1073738704; +inp[30467] = 0; +inp[30468] = 1073738688; +inp[30469] = 0; +inp[30470] = 1073738672; +inp[30471] = 0; +inp[30472] = 1073738656; +inp[30473] = 0; +inp[30474] = 1073738640; +inp[30475] = 0; +inp[30476] = 1073738624; +inp[30477] = 0; +inp[30478] = 1073738608; +inp[30479] = 0; +inp[30480] = 1073738592; +inp[30481] = 0; +inp[30482] = 1073738576; +inp[30483] = 0; +inp[30484] = 1073738560; +inp[30485] = 0; +inp[30486] = 1073738544; +inp[30487] = 0; +inp[30488] = 1073738528; +inp[30489] = 0; +inp[30490] = 1073738512; +inp[30491] = 0; +inp[30492] = 1073738496; +inp[30493] = 0; +inp[30494] = 1073738480; +inp[30495] = 0; +inp[30496] = 1073738464; +inp[30497] = 0; +inp[30498] = 1073738448; +inp[30499] = 0; +inp[30500] = 1073738432; +inp[30501] = 0; +inp[30502] = 1073738416; +inp[30503] = 0; +inp[30504] = 1073738400; +inp[30505] = 0; +inp[30506] = 1073738384; +inp[30507] = 0; +inp[30508] = 1073738368; +inp[30509] = 0; +inp[30510] = 1073738352; +inp[30511] = 0; +inp[30512] = 1073738336; +inp[30513] = 0; +inp[30514] = 1073738320; +inp[30515] = 0; +inp[30516] = 1073738304; +inp[30517] = 0; +inp[30518] = 1073738288; +inp[30519] = 0; +inp[30520] = 1073738272; +inp[30521] = 0; +inp[30522] = 1073738256; +inp[30523] = 0; +inp[30524] = 1073738240; +inp[30525] = 0; +inp[30526] = 1073738224; +inp[30527] = 0; +inp[30528] = 1073738208; +inp[30529] = 0; +inp[30530] = 1073738192; +inp[30531] = 0; +inp[30532] = 1073738176; +inp[30533] = 0; +inp[30534] = 1073738160; +inp[30535] = 0; +inp[30536] = 1073738144; +inp[30537] = 0; +inp[30538] = 1073738128; +inp[30539] = 0; +inp[30540] = 1073738112; +inp[30541] = 0; +inp[30542] = 1073738096; +inp[30543] = 0; +inp[30544] = 1073738080; +inp[30545] = 0; +inp[30546] = 1073738064; +inp[30547] = 0; +inp[30548] = 1073738048; +inp[30549] = 0; +inp[30550] = 1073738032; +inp[30551] = 0; +inp[30552] = 1073738016; +inp[30553] = 0; +inp[30554] = 1073738000; +inp[30555] = 0; +inp[30556] = 1073737984; +inp[30557] = 0; +inp[30558] = 1073737968; +inp[30559] = 0; +inp[30560] = 1073737952; +inp[30561] = 0; +inp[30562] = 1073737936; +inp[30563] = 0; +inp[30564] = 1073737920; +inp[30565] = 0; +inp[30566] = 1073737904; +inp[30567] = 0; +inp[30568] = 1073737888; +inp[30569] = 0; +inp[30570] = 1073737872; +inp[30571] = 0; +inp[30572] = 1073737856; +inp[30573] = 0; +inp[30574] = 1073737840; +inp[30575] = 0; +inp[30576] = 1073737824; +inp[30577] = 0; +inp[30578] = 1073737808; +inp[30579] = 0; +inp[30580] = 1073737792; +inp[30581] = 0; +inp[30582] = 1073737776; +inp[30583] = 0; +inp[30584] = 1073737760; +inp[30585] = 0; +inp[30586] = 1073737744; +inp[30587] = 0; +inp[30588] = 1073741824; +inp[30589] = 1073741824; +inp[30590] = 1073741816; +inp[30591] = 0; +inp[30592] = 1073741808; +inp[30593] = 0; +inp[30594] = 1073741800; +inp[30595] = 0; +inp[30596] = 1073741792; +inp[30597] = 0; +inp[30598] = 1073741784; +inp[30599] = 0; +inp[30600] = 1073741776; +inp[30601] = 0; +inp[30602] = 1073741768; +inp[30603] = 0; +inp[30604] = 1073741760; +inp[30605] = 0; +inp[30606] = 1073741752; +inp[30607] = 0; +inp[30608] = 1073741744; +inp[30609] = 0; +inp[30610] = 1073741736; +inp[30611] = 0; +inp[30612] = 1073741728; +inp[30613] = 0; +inp[30614] = 1073741720; +inp[30615] = 0; +inp[30616] = 1073741712; +inp[30617] = 0; +inp[30618] = 1073741704; +inp[30619] = 0; +inp[30620] = 1073741696; +inp[30621] = 0; +inp[30622] = 1073741688; +inp[30623] = 0; +inp[30624] = 1073741680; +inp[30625] = 0; +inp[30626] = 1073741672; +inp[30627] = 0; +inp[30628] = 1073741664; +inp[30629] = 0; +inp[30630] = 1073741656; +inp[30631] = 0; +inp[30632] = 1073741648; +inp[30633] = 0; +inp[30634] = 1073741640; +inp[30635] = 0; +inp[30636] = 1073741632; +inp[30637] = 0; +inp[30638] = 1073741624; +inp[30639] = 0; +inp[30640] = 1073741616; +inp[30641] = 0; +inp[30642] = 1073741608; +inp[30643] = 0; +inp[30644] = 1073741600; +inp[30645] = 0; +inp[30646] = 1073741592; +inp[30647] = 0; +inp[30648] = 1073741584; +inp[30649] = 0; +inp[30650] = 1073741576; +inp[30651] = 0; +inp[30652] = 1073741568; +inp[30653] = 0; +inp[30654] = 1073741560; +inp[30655] = 0; +inp[30656] = 1073741552; +inp[30657] = 0; +inp[30658] = 1073741544; +inp[30659] = 0; +inp[30660] = 1073741536; +inp[30661] = 0; +inp[30662] = 1073741528; +inp[30663] = 0; +inp[30664] = 1073741520; +inp[30665] = 0; +inp[30666] = 1073741512; +inp[30667] = 0; +inp[30668] = 1073741504; +inp[30669] = 0; +inp[30670] = 1073741496; +inp[30671] = 0; +inp[30672] = 1073741488; +inp[30673] = 0; +inp[30674] = 1073741480; +inp[30675] = 0; +inp[30676] = 1073741472; +inp[30677] = 0; +inp[30678] = 1073741464; +inp[30679] = 0; +inp[30680] = 1073741456; +inp[30681] = 0; +inp[30682] = 1073741448; +inp[30683] = 0; +inp[30684] = 1073741440; +inp[30685] = 0; +inp[30686] = 1073741432; +inp[30687] = 0; +inp[30688] = 1073741424; +inp[30689] = 0; +inp[30690] = 1073741416; +inp[30691] = 0; +inp[30692] = 1073741408; +inp[30693] = 0; +inp[30694] = 1073741400; +inp[30695] = 0; +inp[30696] = 1073741392; +inp[30697] = 0; +inp[30698] = 1073741384; +inp[30699] = 0; +inp[30700] = 1073741376; +inp[30701] = 0; +inp[30702] = 1073741368; +inp[30703] = 0; +inp[30704] = 1073741360; +inp[30705] = 0; +inp[30706] = 1073741352; +inp[30707] = 0; +inp[30708] = 1073741344; +inp[30709] = 0; +inp[30710] = 1073741336; +inp[30711] = 0; +inp[30712] = 1073741328; +inp[30713] = 0; +inp[30714] = 1073741320; +inp[30715] = 0; +inp[30716] = 1073741312; +inp[30717] = 0; +inp[30718] = 1073741304; +inp[30719] = 0; +inp[30720] = 1073741296; +inp[30721] = 0; +inp[30722] = 1073741288; +inp[30723] = 0; +inp[30724] = 1073741280; +inp[30725] = 0; +inp[30726] = 1073741272; +inp[30727] = 0; +inp[30728] = 1073741264; +inp[30729] = 0; +inp[30730] = 1073741256; +inp[30731] = 0; +inp[30732] = 1073741248; +inp[30733] = 0; +inp[30734] = 1073741240; +inp[30735] = 0; +inp[30736] = 1073741232; +inp[30737] = 0; +inp[30738] = 1073741224; +inp[30739] = 0; +inp[30740] = 1073741216; +inp[30741] = 0; +inp[30742] = 1073741208; +inp[30743] = 0; +inp[30744] = 1073741200; +inp[30745] = 0; +inp[30746] = 1073741192; +inp[30747] = 0; +inp[30748] = 1073741184; +inp[30749] = 0; +inp[30750] = 1073741176; +inp[30751] = 0; +inp[30752] = 1073741168; +inp[30753] = 0; +inp[30754] = 1073741160; +inp[30755] = 0; +inp[30756] = 1073741152; +inp[30757] = 0; +inp[30758] = 1073741144; +inp[30759] = 0; +inp[30760] = 1073741136; +inp[30761] = 0; +inp[30762] = 1073741128; +inp[30763] = 0; +inp[30764] = 1073741120; +inp[30765] = 0; +inp[30766] = 1073741112; +inp[30767] = 0; +inp[30768] = 1073741104; +inp[30769] = 0; +inp[30770] = 1073741096; +inp[30771] = 0; +inp[30772] = 1073741088; +inp[30773] = 0; +inp[30774] = 1073741080; +inp[30775] = 0; +inp[30776] = 1073741072; +inp[30777] = 0; +inp[30778] = 1073741064; +inp[30779] = 0; +inp[30780] = 1073741056; +inp[30781] = 0; +inp[30782] = 1073741048; +inp[30783] = 0; +inp[30784] = 1073741040; +inp[30785] = 0; +inp[30786] = 1073741032; +inp[30787] = 0; +inp[30788] = 1073741024; +inp[30789] = 0; +inp[30790] = 1073741016; +inp[30791] = 0; +inp[30792] = 1073741008; +inp[30793] = 0; +inp[30794] = 1073741000; +inp[30795] = 0; +inp[30796] = 1073740992; +inp[30797] = 0; +inp[30798] = 1073740984; +inp[30799] = 0; +inp[30800] = 1073740976; +inp[30801] = 0; +inp[30802] = 1073740968; +inp[30803] = 0; +inp[30804] = 1073740960; +inp[30805] = 0; +inp[30806] = 1073740952; +inp[30807] = 0; +inp[30808] = 1073740944; +inp[30809] = 0; +inp[30810] = 1073740936; +inp[30811] = 0; +inp[30812] = 1073740928; +inp[30813] = 0; +inp[30814] = 1073740920; +inp[30815] = 0; +inp[30816] = 1073740912; +inp[30817] = 0; +inp[30818] = 1073740904; +inp[30819] = 0; +inp[30820] = 1073740896; +inp[30821] = 0; +inp[30822] = 1073740888; +inp[30823] = 0; +inp[30824] = 1073740880; +inp[30825] = 0; +inp[30826] = 1073740872; +inp[30827] = 0; +inp[30828] = 1073740864; +inp[30829] = 0; +inp[30830] = 1073740856; +inp[30831] = 0; +inp[30832] = 1073740848; +inp[30833] = 0; +inp[30834] = 1073740840; +inp[30835] = 0; +inp[30836] = 1073740832; +inp[30837] = 0; +inp[30838] = 1073740824; +inp[30839] = 0; +inp[30840] = 1073740816; +inp[30841] = 0; +inp[30842] = 1073740808; +inp[30843] = 0; +inp[30844] = 1073740800; +inp[30845] = 0; +inp[30846] = 1073740792; +inp[30847] = 0; +inp[30848] = 1073740784; +inp[30849] = 0; +inp[30850] = 1073740776; +inp[30851] = 0; +inp[30852] = 1073740768; +inp[30853] = 0; +inp[30854] = 1073740760; +inp[30855] = 0; +inp[30856] = 1073740752; +inp[30857] = 0; +inp[30858] = 1073740744; +inp[30859] = 0; +inp[30860] = 1073740736; +inp[30861] = 0; +inp[30862] = 1073740728; +inp[30863] = 0; +inp[30864] = 1073740720; +inp[30865] = 0; +inp[30866] = 1073740712; +inp[30867] = 0; +inp[30868] = 1073740704; +inp[30869] = 0; +inp[30870] = 1073740696; +inp[30871] = 0; +inp[30872] = 1073740688; +inp[30873] = 0; +inp[30874] = 1073740680; +inp[30875] = 0; +inp[30876] = 1073740672; +inp[30877] = 0; +inp[30878] = 1073740664; +inp[30879] = 0; +inp[30880] = 1073740656; +inp[30881] = 0; +inp[30882] = 1073740648; +inp[30883] = 0; +inp[30884] = 1073740640; +inp[30885] = 0; +inp[30886] = 1073740632; +inp[30887] = 0; +inp[30888] = 1073740624; +inp[30889] = 0; +inp[30890] = 1073740616; +inp[30891] = 0; +inp[30892] = 1073740608; +inp[30893] = 0; +inp[30894] = 1073740600; +inp[30895] = 0; +inp[30896] = 1073740592; +inp[30897] = 0; +inp[30898] = 1073740584; +inp[30899] = 0; +inp[30900] = 1073740576; +inp[30901] = 0; +inp[30902] = 1073740568; +inp[30903] = 0; +inp[30904] = 1073740560; +inp[30905] = 0; +inp[30906] = 1073740552; +inp[30907] = 0; +inp[30908] = 1073740544; +inp[30909] = 0; +inp[30910] = 1073740536; +inp[30911] = 0; +inp[30912] = 1073740528; +inp[30913] = 0; +inp[30914] = 1073740520; +inp[30915] = 0; +inp[30916] = 1073740512; +inp[30917] = 0; +inp[30918] = 1073740504; +inp[30919] = 0; +inp[30920] = 1073740496; +inp[30921] = 0; +inp[30922] = 1073740488; +inp[30923] = 0; +inp[30924] = 1073740480; +inp[30925] = 0; +inp[30926] = 1073740472; +inp[30927] = 0; +inp[30928] = 1073740464; +inp[30929] = 0; +inp[30930] = 1073740456; +inp[30931] = 0; +inp[30932] = 1073740448; +inp[30933] = 0; +inp[30934] = 1073740440; +inp[30935] = 0; +inp[30936] = 1073740432; +inp[30937] = 0; +inp[30938] = 1073740424; +inp[30939] = 0; +inp[30940] = 1073740416; +inp[30941] = 0; +inp[30942] = 1073740408; +inp[30943] = 0; +inp[30944] = 1073740400; +inp[30945] = 0; +inp[30946] = 1073740392; +inp[30947] = 0; +inp[30948] = 1073740384; +inp[30949] = 0; +inp[30950] = 1073740376; +inp[30951] = 0; +inp[30952] = 1073740368; +inp[30953] = 0; +inp[30954] = 1073740360; +inp[30955] = 0; +inp[30956] = 1073740352; +inp[30957] = 0; +inp[30958] = 1073740344; +inp[30959] = 0; +inp[30960] = 1073740336; +inp[30961] = 0; +inp[30962] = 1073740328; +inp[30963] = 0; +inp[30964] = 1073740320; +inp[30965] = 0; +inp[30966] = 1073740312; +inp[30967] = 0; +inp[30968] = 1073740304; +inp[30969] = 0; +inp[30970] = 1073740296; +inp[30971] = 0; +inp[30972] = 1073740288; +inp[30973] = 0; +inp[30974] = 1073740280; +inp[30975] = 0; +inp[30976] = 1073740272; +inp[30977] = 0; +inp[30978] = 1073740264; +inp[30979] = 0; +inp[30980] = 1073740256; +inp[30981] = 0; +inp[30982] = 1073740248; +inp[30983] = 0; +inp[30984] = 1073740240; +inp[30985] = 0; +inp[30986] = 1073740232; +inp[30987] = 0; +inp[30988] = 1073740224; +inp[30989] = 0; +inp[30990] = 1073740216; +inp[30991] = 0; +inp[30992] = 1073740208; +inp[30993] = 0; +inp[30994] = 1073740200; +inp[30995] = 0; +inp[30996] = 1073740192; +inp[30997] = 0; +inp[30998] = 1073740184; +inp[30999] = 0; +inp[31000] = 1073740176; +inp[31001] = 0; +inp[31002] = 1073740168; +inp[31003] = 0; +inp[31004] = 1073740160; +inp[31005] = 0; +inp[31006] = 1073740152; +inp[31007] = 0; +inp[31008] = 1073740144; +inp[31009] = 0; +inp[31010] = 1073740136; +inp[31011] = 0; +inp[31012] = 1073740128; +inp[31013] = 0; +inp[31014] = 1073740120; +inp[31015] = 0; +inp[31016] = 1073740112; +inp[31017] = 0; +inp[31018] = 1073740104; +inp[31019] = 0; +inp[31020] = 1073740096; +inp[31021] = 0; +inp[31022] = 1073740088; +inp[31023] = 0; +inp[31024] = 1073740080; +inp[31025] = 0; +inp[31026] = 1073740072; +inp[31027] = 0; +inp[31028] = 1073740064; +inp[31029] = 0; +inp[31030] = 1073740056; +inp[31031] = 0; +inp[31032] = 1073740048; +inp[31033] = 0; +inp[31034] = 1073740040; +inp[31035] = 0; +inp[31036] = 1073740032; +inp[31037] = 0; +inp[31038] = 1073740024; +inp[31039] = 0; +inp[31040] = 1073740016; +inp[31041] = 0; +inp[31042] = 1073740008; +inp[31043] = 0; +inp[31044] = 1073740000; +inp[31045] = 0; +inp[31046] = 1073739992; +inp[31047] = 0; +inp[31048] = 1073739984; +inp[31049] = 0; +inp[31050] = 1073739976; +inp[31051] = 0; +inp[31052] = 1073739968; +inp[31053] = 0; +inp[31054] = 1073739960; +inp[31055] = 0; +inp[31056] = 1073739952; +inp[31057] = 0; +inp[31058] = 1073739944; +inp[31059] = 0; +inp[31060] = 1073739936; +inp[31061] = 0; +inp[31062] = 1073739928; +inp[31063] = 0; +inp[31064] = 1073739920; +inp[31065] = 0; +inp[31066] = 1073739912; +inp[31067] = 0; +inp[31068] = 1073739904; +inp[31069] = 0; +inp[31070] = 1073739896; +inp[31071] = 0; +inp[31072] = 1073739888; +inp[31073] = 0; +inp[31074] = 1073739880; +inp[31075] = 0; +inp[31076] = 1073739872; +inp[31077] = 0; +inp[31078] = 1073739864; +inp[31079] = 0; +inp[31080] = 1073739856; +inp[31081] = 0; +inp[31082] = 1073739848; +inp[31083] = 0; +inp[31084] = 1073739840; +inp[31085] = 0; +inp[31086] = 1073739832; +inp[31087] = 0; +inp[31088] = 1073739824; +inp[31089] = 0; +inp[31090] = 1073739816; +inp[31091] = 0; +inp[31092] = 1073739808; +inp[31093] = 0; +inp[31094] = 1073739800; +inp[31095] = 0; +inp[31096] = 1073739792; +inp[31097] = 0; +inp[31098] = 1073739784; +inp[31099] = 0; +inp[31100] = 1073741824; +inp[31101] = 1073741824; +inp[31102] = 1073741820; +inp[31103] = 0; +inp[31104] = 1073741816; +inp[31105] = 0; +inp[31106] = 1073741812; +inp[31107] = 0; +inp[31108] = 1073741808; +inp[31109] = 0; +inp[31110] = 1073741804; +inp[31111] = 0; +inp[31112] = 1073741800; +inp[31113] = 0; +inp[31114] = 1073741796; +inp[31115] = 0; +inp[31116] = 1073741792; +inp[31117] = 0; +inp[31118] = 1073741788; +inp[31119] = 0; +inp[31120] = 1073741784; +inp[31121] = 0; +inp[31122] = 1073741780; +inp[31123] = 0; +inp[31124] = 1073741776; +inp[31125] = 0; +inp[31126] = 1073741772; +inp[31127] = 0; +inp[31128] = 1073741768; +inp[31129] = 0; +inp[31130] = 1073741764; +inp[31131] = 0; +inp[31132] = 1073741760; +inp[31133] = 0; +inp[31134] = 1073741756; +inp[31135] = 0; +inp[31136] = 1073741752; +inp[31137] = 0; +inp[31138] = 1073741748; +inp[31139] = 0; +inp[31140] = 1073741744; +inp[31141] = 0; +inp[31142] = 1073741740; +inp[31143] = 0; +inp[31144] = 1073741736; +inp[31145] = 0; +inp[31146] = 1073741732; +inp[31147] = 0; +inp[31148] = 1073741728; +inp[31149] = 0; +inp[31150] = 1073741724; +inp[31151] = 0; +inp[31152] = 1073741720; +inp[31153] = 0; +inp[31154] = 1073741716; +inp[31155] = 0; +inp[31156] = 1073741712; +inp[31157] = 0; +inp[31158] = 1073741708; +inp[31159] = 0; +inp[31160] = 1073741704; +inp[31161] = 0; +inp[31162] = 1073741700; +inp[31163] = 0; +inp[31164] = 1073741696; +inp[31165] = 0; +inp[31166] = 1073741692; +inp[31167] = 0; +inp[31168] = 1073741688; +inp[31169] = 0; +inp[31170] = 1073741684; +inp[31171] = 0; +inp[31172] = 1073741680; +inp[31173] = 0; +inp[31174] = 1073741676; +inp[31175] = 0; +inp[31176] = 1073741672; +inp[31177] = 0; +inp[31178] = 1073741668; +inp[31179] = 0; +inp[31180] = 1073741664; +inp[31181] = 0; +inp[31182] = 1073741660; +inp[31183] = 0; +inp[31184] = 1073741656; +inp[31185] = 0; +inp[31186] = 1073741652; +inp[31187] = 0; +inp[31188] = 1073741648; +inp[31189] = 0; +inp[31190] = 1073741644; +inp[31191] = 0; +inp[31192] = 1073741640; +inp[31193] = 0; +inp[31194] = 1073741636; +inp[31195] = 0; +inp[31196] = 1073741632; +inp[31197] = 0; +inp[31198] = 1073741628; +inp[31199] = 0; +inp[31200] = 1073741624; +inp[31201] = 0; +inp[31202] = 1073741620; +inp[31203] = 0; +inp[31204] = 1073741616; +inp[31205] = 0; +inp[31206] = 1073741612; +inp[31207] = 0; +inp[31208] = 1073741608; +inp[31209] = 0; +inp[31210] = 1073741604; +inp[31211] = 0; +inp[31212] = 1073741600; +inp[31213] = 0; +inp[31214] = 1073741596; +inp[31215] = 0; +inp[31216] = 1073741592; +inp[31217] = 0; +inp[31218] = 1073741588; +inp[31219] = 0; +inp[31220] = 1073741584; +inp[31221] = 0; +inp[31222] = 1073741580; +inp[31223] = 0; +inp[31224] = 1073741576; +inp[31225] = 0; +inp[31226] = 1073741572; +inp[31227] = 0; +inp[31228] = 1073741568; +inp[31229] = 0; +inp[31230] = 1073741564; +inp[31231] = 0; +inp[31232] = 1073741560; +inp[31233] = 0; +inp[31234] = 1073741556; +inp[31235] = 0; +inp[31236] = 1073741552; +inp[31237] = 0; +inp[31238] = 1073741548; +inp[31239] = 0; +inp[31240] = 1073741544; +inp[31241] = 0; +inp[31242] = 1073741540; +inp[31243] = 0; +inp[31244] = 1073741536; +inp[31245] = 0; +inp[31246] = 1073741532; +inp[31247] = 0; +inp[31248] = 1073741528; +inp[31249] = 0; +inp[31250] = 1073741524; +inp[31251] = 0; +inp[31252] = 1073741520; +inp[31253] = 0; +inp[31254] = 1073741516; +inp[31255] = 0; +inp[31256] = 1073741512; +inp[31257] = 0; +inp[31258] = 1073741508; +inp[31259] = 0; +inp[31260] = 1073741504; +inp[31261] = 0; +inp[31262] = 1073741500; +inp[31263] = 0; +inp[31264] = 1073741496; +inp[31265] = 0; +inp[31266] = 1073741492; +inp[31267] = 0; +inp[31268] = 1073741488; +inp[31269] = 0; +inp[31270] = 1073741484; +inp[31271] = 0; +inp[31272] = 1073741480; +inp[31273] = 0; +inp[31274] = 1073741476; +inp[31275] = 0; +inp[31276] = 1073741472; +inp[31277] = 0; +inp[31278] = 1073741468; +inp[31279] = 0; +inp[31280] = 1073741464; +inp[31281] = 0; +inp[31282] = 1073741460; +inp[31283] = 0; +inp[31284] = 1073741456; +inp[31285] = 0; +inp[31286] = 1073741452; +inp[31287] = 0; +inp[31288] = 1073741448; +inp[31289] = 0; +inp[31290] = 1073741444; +inp[31291] = 0; +inp[31292] = 1073741440; +inp[31293] = 0; +inp[31294] = 1073741436; +inp[31295] = 0; +inp[31296] = 1073741432; +inp[31297] = 0; +inp[31298] = 1073741428; +inp[31299] = 0; +inp[31300] = 1073741424; +inp[31301] = 0; +inp[31302] = 1073741420; +inp[31303] = 0; +inp[31304] = 1073741416; +inp[31305] = 0; +inp[31306] = 1073741412; +inp[31307] = 0; +inp[31308] = 1073741408; +inp[31309] = 0; +inp[31310] = 1073741404; +inp[31311] = 0; +inp[31312] = 1073741400; +inp[31313] = 0; +inp[31314] = 1073741396; +inp[31315] = 0; +inp[31316] = 1073741392; +inp[31317] = 0; +inp[31318] = 1073741388; +inp[31319] = 0; +inp[31320] = 1073741384; +inp[31321] = 0; +inp[31322] = 1073741380; +inp[31323] = 0; +inp[31324] = 1073741376; +inp[31325] = 0; +inp[31326] = 1073741372; +inp[31327] = 0; +inp[31328] = 1073741368; +inp[31329] = 0; +inp[31330] = 1073741364; +inp[31331] = 0; +inp[31332] = 1073741360; +inp[31333] = 0; +inp[31334] = 1073741356; +inp[31335] = 0; +inp[31336] = 1073741352; +inp[31337] = 0; +inp[31338] = 1073741348; +inp[31339] = 0; +inp[31340] = 1073741344; +inp[31341] = 0; +inp[31342] = 1073741340; +inp[31343] = 0; +inp[31344] = 1073741336; +inp[31345] = 0; +inp[31346] = 1073741332; +inp[31347] = 0; +inp[31348] = 1073741328; +inp[31349] = 0; +inp[31350] = 1073741324; +inp[31351] = 0; +inp[31352] = 1073741320; +inp[31353] = 0; +inp[31354] = 1073741316; +inp[31355] = 0; +inp[31356] = 1073741312; +inp[31357] = 0; +inp[31358] = 1073741308; +inp[31359] = 0; +inp[31360] = 1073741304; +inp[31361] = 0; +inp[31362] = 1073741300; +inp[31363] = 0; +inp[31364] = 1073741296; +inp[31365] = 0; +inp[31366] = 1073741292; +inp[31367] = 0; +inp[31368] = 1073741288; +inp[31369] = 0; +inp[31370] = 1073741284; +inp[31371] = 0; +inp[31372] = 1073741280; +inp[31373] = 0; +inp[31374] = 1073741276; +inp[31375] = 0; +inp[31376] = 1073741272; +inp[31377] = 0; +inp[31378] = 1073741268; +inp[31379] = 0; +inp[31380] = 1073741264; +inp[31381] = 0; +inp[31382] = 1073741260; +inp[31383] = 0; +inp[31384] = 1073741256; +inp[31385] = 0; +inp[31386] = 1073741252; +inp[31387] = 0; +inp[31388] = 1073741248; +inp[31389] = 0; +inp[31390] = 1073741244; +inp[31391] = 0; +inp[31392] = 1073741240; +inp[31393] = 0; +inp[31394] = 1073741236; +inp[31395] = 0; +inp[31396] = 1073741232; +inp[31397] = 0; +inp[31398] = 1073741228; +inp[31399] = 0; +inp[31400] = 1073741224; +inp[31401] = 0; +inp[31402] = 1073741220; +inp[31403] = 0; +inp[31404] = 1073741216; +inp[31405] = 0; +inp[31406] = 1073741212; +inp[31407] = 0; +inp[31408] = 1073741208; +inp[31409] = 0; +inp[31410] = 1073741204; +inp[31411] = 0; +inp[31412] = 1073741200; +inp[31413] = 0; +inp[31414] = 1073741196; +inp[31415] = 0; +inp[31416] = 1073741192; +inp[31417] = 0; +inp[31418] = 1073741188; +inp[31419] = 0; +inp[31420] = 1073741184; +inp[31421] = 0; +inp[31422] = 1073741180; +inp[31423] = 0; +inp[31424] = 1073741176; +inp[31425] = 0; +inp[31426] = 1073741172; +inp[31427] = 0; +inp[31428] = 1073741168; +inp[31429] = 0; +inp[31430] = 1073741164; +inp[31431] = 0; +inp[31432] = 1073741160; +inp[31433] = 0; +inp[31434] = 1073741156; +inp[31435] = 0; +inp[31436] = 1073741152; +inp[31437] = 0; +inp[31438] = 1073741148; +inp[31439] = 0; +inp[31440] = 1073741144; +inp[31441] = 0; +inp[31442] = 1073741140; +inp[31443] = 0; +inp[31444] = 1073741136; +inp[31445] = 0; +inp[31446] = 1073741132; +inp[31447] = 0; +inp[31448] = 1073741128; +inp[31449] = 0; +inp[31450] = 1073741124; +inp[31451] = 0; +inp[31452] = 1073741120; +inp[31453] = 0; +inp[31454] = 1073741116; +inp[31455] = 0; +inp[31456] = 1073741112; +inp[31457] = 0; +inp[31458] = 1073741108; +inp[31459] = 0; +inp[31460] = 1073741104; +inp[31461] = 0; +inp[31462] = 1073741100; +inp[31463] = 0; +inp[31464] = 1073741096; +inp[31465] = 0; +inp[31466] = 1073741092; +inp[31467] = 0; +inp[31468] = 1073741088; +inp[31469] = 0; +inp[31470] = 1073741084; +inp[31471] = 0; +inp[31472] = 1073741080; +inp[31473] = 0; +inp[31474] = 1073741076; +inp[31475] = 0; +inp[31476] = 1073741072; +inp[31477] = 0; +inp[31478] = 1073741068; +inp[31479] = 0; +inp[31480] = 1073741064; +inp[31481] = 0; +inp[31482] = 1073741060; +inp[31483] = 0; +inp[31484] = 1073741056; +inp[31485] = 0; +inp[31486] = 1073741052; +inp[31487] = 0; +inp[31488] = 1073741048; +inp[31489] = 0; +inp[31490] = 1073741044; +inp[31491] = 0; +inp[31492] = 1073741040; +inp[31493] = 0; +inp[31494] = 1073741036; +inp[31495] = 0; +inp[31496] = 1073741032; +inp[31497] = 0; +inp[31498] = 1073741028; +inp[31499] = 0; +inp[31500] = 1073741024; +inp[31501] = 0; +inp[31502] = 1073741020; +inp[31503] = 0; +inp[31504] = 1073741016; +inp[31505] = 0; +inp[31506] = 1073741012; +inp[31507] = 0; +inp[31508] = 1073741008; +inp[31509] = 0; +inp[31510] = 1073741004; +inp[31511] = 0; +inp[31512] = 1073741000; +inp[31513] = 0; +inp[31514] = 1073740996; +inp[31515] = 0; +inp[31516] = 1073740992; +inp[31517] = 0; +inp[31518] = 1073740988; +inp[31519] = 0; +inp[31520] = 1073740984; +inp[31521] = 0; +inp[31522] = 1073740980; +inp[31523] = 0; +inp[31524] = 1073740976; +inp[31525] = 0; +inp[31526] = 1073740972; +inp[31527] = 0; +inp[31528] = 1073740968; +inp[31529] = 0; +inp[31530] = 1073740964; +inp[31531] = 0; +inp[31532] = 1073740960; +inp[31533] = 0; +inp[31534] = 1073740956; +inp[31535] = 0; +inp[31536] = 1073740952; +inp[31537] = 0; +inp[31538] = 1073740948; +inp[31539] = 0; +inp[31540] = 1073740944; +inp[31541] = 0; +inp[31542] = 1073740940; +inp[31543] = 0; +inp[31544] = 1073740936; +inp[31545] = 0; +inp[31546] = 1073740932; +inp[31547] = 0; +inp[31548] = 1073740928; +inp[31549] = 0; +inp[31550] = 1073740924; +inp[31551] = 0; +inp[31552] = 1073740920; +inp[31553] = 0; +inp[31554] = 1073740916; +inp[31555] = 0; +inp[31556] = 1073740912; +inp[31557] = 0; +inp[31558] = 1073740908; +inp[31559] = 0; +inp[31560] = 1073740904; +inp[31561] = 0; +inp[31562] = 1073740900; +inp[31563] = 0; +inp[31564] = 1073740896; +inp[31565] = 0; +inp[31566] = 1073740892; +inp[31567] = 0; +inp[31568] = 1073740888; +inp[31569] = 0; +inp[31570] = 1073740884; +inp[31571] = 0; +inp[31572] = 1073740880; +inp[31573] = 0; +inp[31574] = 1073740876; +inp[31575] = 0; +inp[31576] = 1073740872; +inp[31577] = 0; +inp[31578] = 1073740868; +inp[31579] = 0; +inp[31580] = 1073740864; +inp[31581] = 0; +inp[31582] = 1073740860; +inp[31583] = 0; +inp[31584] = 1073740856; +inp[31585] = 0; +inp[31586] = 1073740852; +inp[31587] = 0; +inp[31588] = 1073740848; +inp[31589] = 0; +inp[31590] = 1073740844; +inp[31591] = 0; +inp[31592] = 1073740840; +inp[31593] = 0; +inp[31594] = 1073740836; +inp[31595] = 0; +inp[31596] = 1073740832; +inp[31597] = 0; +inp[31598] = 1073740828; +inp[31599] = 0; +inp[31600] = 1073740824; +inp[31601] = 0; +inp[31602] = 1073740820; +inp[31603] = 0; +inp[31604] = 1073740816; +inp[31605] = 0; +inp[31606] = 1073740812; +inp[31607] = 0; +inp[31608] = 1073740808; +inp[31609] = 0; +inp[31610] = 1073740804; +inp[31611] = 0; +inp[31612] = 1073741824; +inp[31613] = 1073741824; +inp[31614] = 1073741822; +inp[31615] = 0; +inp[31616] = 1073741820; +inp[31617] = 0; +inp[31618] = 1073741818; +inp[31619] = 0; +inp[31620] = 1073741816; +inp[31621] = 0; +inp[31622] = 1073741814; +inp[31623] = 0; +inp[31624] = 1073741812; +inp[31625] = 0; +inp[31626] = 1073741810; +inp[31627] = 0; +inp[31628] = 1073741808; +inp[31629] = 0; +inp[31630] = 1073741806; +inp[31631] = 0; +inp[31632] = 1073741804; +inp[31633] = 0; +inp[31634] = 1073741802; +inp[31635] = 0; +inp[31636] = 1073741800; +inp[31637] = 0; +inp[31638] = 1073741798; +inp[31639] = 0; +inp[31640] = 1073741796; +inp[31641] = 0; +inp[31642] = 1073741794; +inp[31643] = 0; +inp[31644] = 1073741792; +inp[31645] = 0; +inp[31646] = 1073741790; +inp[31647] = 0; +inp[31648] = 1073741788; +inp[31649] = 0; +inp[31650] = 1073741786; +inp[31651] = 0; +inp[31652] = 1073741784; +inp[31653] = 0; +inp[31654] = 1073741782; +inp[31655] = 0; +inp[31656] = 1073741780; +inp[31657] = 0; +inp[31658] = 1073741778; +inp[31659] = 0; +inp[31660] = 1073741776; +inp[31661] = 0; +inp[31662] = 1073741774; +inp[31663] = 0; +inp[31664] = 1073741772; +inp[31665] = 0; +inp[31666] = 1073741770; +inp[31667] = 0; +inp[31668] = 1073741768; +inp[31669] = 0; +inp[31670] = 1073741766; +inp[31671] = 0; +inp[31672] = 1073741764; +inp[31673] = 0; +inp[31674] = 1073741762; +inp[31675] = 0; +inp[31676] = 1073741760; +inp[31677] = 0; +inp[31678] = 1073741758; +inp[31679] = 0; +inp[31680] = 1073741756; +inp[31681] = 0; +inp[31682] = 1073741754; +inp[31683] = 0; +inp[31684] = 1073741752; +inp[31685] = 0; +inp[31686] = 1073741750; +inp[31687] = 0; +inp[31688] = 1073741748; +inp[31689] = 0; +inp[31690] = 1073741746; +inp[31691] = 0; +inp[31692] = 1073741744; +inp[31693] = 0; +inp[31694] = 1073741742; +inp[31695] = 0; +inp[31696] = 1073741740; +inp[31697] = 0; +inp[31698] = 1073741738; +inp[31699] = 0; +inp[31700] = 1073741736; +inp[31701] = 0; +inp[31702] = 1073741734; +inp[31703] = 0; +inp[31704] = 1073741732; +inp[31705] = 0; +inp[31706] = 1073741730; +inp[31707] = 0; +inp[31708] = 1073741728; +inp[31709] = 0; +inp[31710] = 1073741726; +inp[31711] = 0; +inp[31712] = 1073741724; +inp[31713] = 0; +inp[31714] = 1073741722; +inp[31715] = 0; +inp[31716] = 1073741720; +inp[31717] = 0; +inp[31718] = 1073741718; +inp[31719] = 0; +inp[31720] = 1073741716; +inp[31721] = 0; +inp[31722] = 1073741714; +inp[31723] = 0; +inp[31724] = 1073741712; +inp[31725] = 0; +inp[31726] = 1073741710; +inp[31727] = 0; +inp[31728] = 1073741708; +inp[31729] = 0; +inp[31730] = 1073741706; +inp[31731] = 0; +inp[31732] = 1073741704; +inp[31733] = 0; +inp[31734] = 1073741702; +inp[31735] = 0; +inp[31736] = 1073741700; +inp[31737] = 0; +inp[31738] = 1073741698; +inp[31739] = 0; +inp[31740] = 1073741696; +inp[31741] = 0; +inp[31742] = 1073741694; +inp[31743] = 0; +inp[31744] = 1073741692; +inp[31745] = 0; +inp[31746] = 1073741690; +inp[31747] = 0; +inp[31748] = 1073741688; +inp[31749] = 0; +inp[31750] = 1073741686; +inp[31751] = 0; +inp[31752] = 1073741684; +inp[31753] = 0; +inp[31754] = 1073741682; +inp[31755] = 0; +inp[31756] = 1073741680; +inp[31757] = 0; +inp[31758] = 1073741678; +inp[31759] = 0; +inp[31760] = 1073741676; +inp[31761] = 0; +inp[31762] = 1073741674; +inp[31763] = 0; +inp[31764] = 1073741672; +inp[31765] = 0; +inp[31766] = 1073741670; +inp[31767] = 0; +inp[31768] = 1073741668; +inp[31769] = 0; +inp[31770] = 1073741666; +inp[31771] = 0; +inp[31772] = 1073741664; +inp[31773] = 0; +inp[31774] = 1073741662; +inp[31775] = 0; +inp[31776] = 1073741660; +inp[31777] = 0; +inp[31778] = 1073741658; +inp[31779] = 0; +inp[31780] = 1073741656; +inp[31781] = 0; +inp[31782] = 1073741654; +inp[31783] = 0; +inp[31784] = 1073741652; +inp[31785] = 0; +inp[31786] = 1073741650; +inp[31787] = 0; +inp[31788] = 1073741648; +inp[31789] = 0; +inp[31790] = 1073741646; +inp[31791] = 0; +inp[31792] = 1073741644; +inp[31793] = 0; +inp[31794] = 1073741642; +inp[31795] = 0; +inp[31796] = 1073741640; +inp[31797] = 0; +inp[31798] = 1073741638; +inp[31799] = 0; +inp[31800] = 1073741636; +inp[31801] = 0; +inp[31802] = 1073741634; +inp[31803] = 0; +inp[31804] = 1073741632; +inp[31805] = 0; +inp[31806] = 1073741630; +inp[31807] = 0; +inp[31808] = 1073741628; +inp[31809] = 0; +inp[31810] = 1073741626; +inp[31811] = 0; +inp[31812] = 1073741624; +inp[31813] = 0; +inp[31814] = 1073741622; +inp[31815] = 0; +inp[31816] = 1073741620; +inp[31817] = 0; +inp[31818] = 1073741618; +inp[31819] = 0; +inp[31820] = 1073741616; +inp[31821] = 0; +inp[31822] = 1073741614; +inp[31823] = 0; +inp[31824] = 1073741612; +inp[31825] = 0; +inp[31826] = 1073741610; +inp[31827] = 0; +inp[31828] = 1073741608; +inp[31829] = 0; +inp[31830] = 1073741606; +inp[31831] = 0; +inp[31832] = 1073741604; +inp[31833] = 0; +inp[31834] = 1073741602; +inp[31835] = 0; +inp[31836] = 1073741600; +inp[31837] = 0; +inp[31838] = 1073741598; +inp[31839] = 0; +inp[31840] = 1073741596; +inp[31841] = 0; +inp[31842] = 1073741594; +inp[31843] = 0; +inp[31844] = 1073741592; +inp[31845] = 0; +inp[31846] = 1073741590; +inp[31847] = 0; +inp[31848] = 1073741588; +inp[31849] = 0; +inp[31850] = 1073741586; +inp[31851] = 0; +inp[31852] = 1073741584; +inp[31853] = 0; +inp[31854] = 1073741582; +inp[31855] = 0; +inp[31856] = 1073741580; +inp[31857] = 0; +inp[31858] = 1073741578; +inp[31859] = 0; +inp[31860] = 1073741576; +inp[31861] = 0; +inp[31862] = 1073741574; +inp[31863] = 0; +inp[31864] = 1073741572; +inp[31865] = 0; +inp[31866] = 1073741570; +inp[31867] = 0; +inp[31868] = 1073741568; +inp[31869] = 0; +inp[31870] = 1073741566; +inp[31871] = 0; +inp[31872] = 1073741564; +inp[31873] = 0; +inp[31874] = 1073741562; +inp[31875] = 0; +inp[31876] = 1073741560; +inp[31877] = 0; +inp[31878] = 1073741558; +inp[31879] = 0; +inp[31880] = 1073741556; +inp[31881] = 0; +inp[31882] = 1073741554; +inp[31883] = 0; +inp[31884] = 1073741552; +inp[31885] = 0; +inp[31886] = 1073741550; +inp[31887] = 0; +inp[31888] = 1073741548; +inp[31889] = 0; +inp[31890] = 1073741546; +inp[31891] = 0; +inp[31892] = 1073741544; +inp[31893] = 0; +inp[31894] = 1073741542; +inp[31895] = 0; +inp[31896] = 1073741540; +inp[31897] = 0; +inp[31898] = 1073741538; +inp[31899] = 0; +inp[31900] = 1073741536; +inp[31901] = 0; +inp[31902] = 1073741534; +inp[31903] = 0; +inp[31904] = 1073741532; +inp[31905] = 0; +inp[31906] = 1073741530; +inp[31907] = 0; +inp[31908] = 1073741528; +inp[31909] = 0; +inp[31910] = 1073741526; +inp[31911] = 0; +inp[31912] = 1073741524; +inp[31913] = 0; +inp[31914] = 1073741522; +inp[31915] = 0; +inp[31916] = 1073741520; +inp[31917] = 0; +inp[31918] = 1073741518; +inp[31919] = 0; +inp[31920] = 1073741516; +inp[31921] = 0; +inp[31922] = 1073741514; +inp[31923] = 0; +inp[31924] = 1073741512; +inp[31925] = 0; +inp[31926] = 1073741510; +inp[31927] = 0; +inp[31928] = 1073741508; +inp[31929] = 0; +inp[31930] = 1073741506; +inp[31931] = 0; +inp[31932] = 1073741504; +inp[31933] = 0; +inp[31934] = 1073741502; +inp[31935] = 0; +inp[31936] = 1073741500; +inp[31937] = 0; +inp[31938] = 1073741498; +inp[31939] = 0; +inp[31940] = 1073741496; +inp[31941] = 0; +inp[31942] = 1073741494; +inp[31943] = 0; +inp[31944] = 1073741492; +inp[31945] = 0; +inp[31946] = 1073741490; +inp[31947] = 0; +inp[31948] = 1073741488; +inp[31949] = 0; +inp[31950] = 1073741486; +inp[31951] = 0; +inp[31952] = 1073741484; +inp[31953] = 0; +inp[31954] = 1073741482; +inp[31955] = 0; +inp[31956] = 1073741480; +inp[31957] = 0; +inp[31958] = 1073741478; +inp[31959] = 0; +inp[31960] = 1073741476; +inp[31961] = 0; +inp[31962] = 1073741474; +inp[31963] = 0; +inp[31964] = 1073741472; +inp[31965] = 0; +inp[31966] = 1073741470; +inp[31967] = 0; +inp[31968] = 1073741468; +inp[31969] = 0; +inp[31970] = 1073741466; +inp[31971] = 0; +inp[31972] = 1073741464; +inp[31973] = 0; +inp[31974] = 1073741462; +inp[31975] = 0; +inp[31976] = 1073741460; +inp[31977] = 0; +inp[31978] = 1073741458; +inp[31979] = 0; +inp[31980] = 1073741456; +inp[31981] = 0; +inp[31982] = 1073741454; +inp[31983] = 0; +inp[31984] = 1073741452; +inp[31985] = 0; +inp[31986] = 1073741450; +inp[31987] = 0; +inp[31988] = 1073741448; +inp[31989] = 0; +inp[31990] = 1073741446; +inp[31991] = 0; +inp[31992] = 1073741444; +inp[31993] = 0; +inp[31994] = 1073741442; +inp[31995] = 0; +inp[31996] = 1073741440; +inp[31997] = 0; +inp[31998] = 1073741438; +inp[31999] = 0; +inp[32000] = 1073741436; +inp[32001] = 0; +inp[32002] = 1073741434; +inp[32003] = 0; +inp[32004] = 1073741432; +inp[32005] = 0; +inp[32006] = 1073741430; +inp[32007] = 0; +inp[32008] = 1073741428; +inp[32009] = 0; +inp[32010] = 1073741426; +inp[32011] = 0; +inp[32012] = 1073741424; +inp[32013] = 0; +inp[32014] = 1073741422; +inp[32015] = 0; +inp[32016] = 1073741420; +inp[32017] = 0; +inp[32018] = 1073741418; +inp[32019] = 0; +inp[32020] = 1073741416; +inp[32021] = 0; +inp[32022] = 1073741414; +inp[32023] = 0; +inp[32024] = 1073741412; +inp[32025] = 0; +inp[32026] = 1073741410; +inp[32027] = 0; +inp[32028] = 1073741408; +inp[32029] = 0; +inp[32030] = 1073741406; +inp[32031] = 0; +inp[32032] = 1073741404; +inp[32033] = 0; +inp[32034] = 1073741402; +inp[32035] = 0; +inp[32036] = 1073741400; +inp[32037] = 0; +inp[32038] = 1073741398; +inp[32039] = 0; +inp[32040] = 1073741396; +inp[32041] = 0; +inp[32042] = 1073741394; +inp[32043] = 0; +inp[32044] = 1073741392; +inp[32045] = 0; +inp[32046] = 1073741390; +inp[32047] = 0; +inp[32048] = 1073741388; +inp[32049] = 0; +inp[32050] = 1073741386; +inp[32051] = 0; +inp[32052] = 1073741384; +inp[32053] = 0; +inp[32054] = 1073741382; +inp[32055] = 0; +inp[32056] = 1073741380; +inp[32057] = 0; +inp[32058] = 1073741378; +inp[32059] = 0; +inp[32060] = 1073741376; +inp[32061] = 0; +inp[32062] = 1073741374; +inp[32063] = 0; +inp[32064] = 1073741372; +inp[32065] = 0; +inp[32066] = 1073741370; +inp[32067] = 0; +inp[32068] = 1073741368; +inp[32069] = 0; +inp[32070] = 1073741366; +inp[32071] = 0; +inp[32072] = 1073741364; +inp[32073] = 0; +inp[32074] = 1073741362; +inp[32075] = 0; +inp[32076] = 1073741360; +inp[32077] = 0; +inp[32078] = 1073741358; +inp[32079] = 0; +inp[32080] = 1073741356; +inp[32081] = 0; +inp[32082] = 1073741354; +inp[32083] = 0; +inp[32084] = 1073741352; +inp[32085] = 0; +inp[32086] = 1073741350; +inp[32087] = 0; +inp[32088] = 1073741348; +inp[32089] = 0; +inp[32090] = 1073741346; +inp[32091] = 0; +inp[32092] = 1073741344; +inp[32093] = 0; +inp[32094] = 1073741342; +inp[32095] = 0; +inp[32096] = 1073741340; +inp[32097] = 0; +inp[32098] = 1073741338; +inp[32099] = 0; +inp[32100] = 1073741336; +inp[32101] = 0; +inp[32102] = 1073741334; +inp[32103] = 0; +inp[32104] = 1073741332; +inp[32105] = 0; +inp[32106] = 1073741330; +inp[32107] = 0; +inp[32108] = 1073741328; +inp[32109] = 0; +inp[32110] = 1073741326; +inp[32111] = 0; +inp[32112] = 1073741324; +inp[32113] = 0; +inp[32114] = 1073741322; +inp[32115] = 0; +inp[32116] = 1073741320; +inp[32117] = 0; +inp[32118] = 1073741318; +inp[32119] = 0; +inp[32120] = 1073741316; +inp[32121] = 0; +inp[32122] = 1073741314; +inp[32123] = 0; +inp[32124] = 1073741824; +inp[32125] = 1073741824; +inp[32126] = 1073741823; +inp[32127] = 0; +inp[32128] = 1073741822; +inp[32129] = 0; +inp[32130] = 1073741821; +inp[32131] = 0; +inp[32132] = 1073741820; +inp[32133] = 0; +inp[32134] = 1073741819; +inp[32135] = 0; +inp[32136] = 1073741818; +inp[32137] = 0; +inp[32138] = 1073741817; +inp[32139] = 0; +inp[32140] = 1073741816; +inp[32141] = 0; +inp[32142] = 1073741815; +inp[32143] = 0; +inp[32144] = 1073741814; +inp[32145] = 0; +inp[32146] = 1073741813; +inp[32147] = 0; +inp[32148] = 1073741812; +inp[32149] = 0; +inp[32150] = 1073741811; +inp[32151] = 0; +inp[32152] = 1073741810; +inp[32153] = 0; +inp[32154] = 1073741809; +inp[32155] = 0; +inp[32156] = 1073741808; +inp[32157] = 0; +inp[32158] = 1073741807; +inp[32159] = 0; +inp[32160] = 1073741806; +inp[32161] = 0; +inp[32162] = 1073741805; +inp[32163] = 0; +inp[32164] = 1073741804; +inp[32165] = 0; +inp[32166] = 1073741803; +inp[32167] = 0; +inp[32168] = 1073741802; +inp[32169] = 0; +inp[32170] = 1073741801; +inp[32171] = 0; +inp[32172] = 1073741800; +inp[32173] = 0; +inp[32174] = 1073741799; +inp[32175] = 0; +inp[32176] = 1073741798; +inp[32177] = 0; +inp[32178] = 1073741797; +inp[32179] = 0; +inp[32180] = 1073741796; +inp[32181] = 0; +inp[32182] = 1073741795; +inp[32183] = 0; +inp[32184] = 1073741794; +inp[32185] = 0; +inp[32186] = 1073741793; +inp[32187] = 0; +inp[32188] = 1073741792; +inp[32189] = 0; +inp[32190] = 1073741791; +inp[32191] = 0; +inp[32192] = 1073741790; +inp[32193] = 0; +inp[32194] = 1073741789; +inp[32195] = 0; +inp[32196] = 1073741788; +inp[32197] = 0; +inp[32198] = 1073741787; +inp[32199] = 0; +inp[32200] = 1073741786; +inp[32201] = 0; +inp[32202] = 1073741785; +inp[32203] = 0; +inp[32204] = 1073741784; +inp[32205] = 0; +inp[32206] = 1073741783; +inp[32207] = 0; +inp[32208] = 1073741782; +inp[32209] = 0; +inp[32210] = 1073741781; +inp[32211] = 0; +inp[32212] = 1073741780; +inp[32213] = 0; +inp[32214] = 1073741779; +inp[32215] = 0; +inp[32216] = 1073741778; +inp[32217] = 0; +inp[32218] = 1073741777; +inp[32219] = 0; +inp[32220] = 1073741776; +inp[32221] = 0; +inp[32222] = 1073741775; +inp[32223] = 0; +inp[32224] = 1073741774; +inp[32225] = 0; +inp[32226] = 1073741773; +inp[32227] = 0; +inp[32228] = 1073741772; +inp[32229] = 0; +inp[32230] = 1073741771; +inp[32231] = 0; +inp[32232] = 1073741770; +inp[32233] = 0; +inp[32234] = 1073741769; +inp[32235] = 0; +inp[32236] = 1073741768; +inp[32237] = 0; +inp[32238] = 1073741767; +inp[32239] = 0; +inp[32240] = 1073741766; +inp[32241] = 0; +inp[32242] = 1073741765; +inp[32243] = 0; +inp[32244] = 1073741764; +inp[32245] = 0; +inp[32246] = 1073741763; +inp[32247] = 0; +inp[32248] = 1073741762; +inp[32249] = 0; +inp[32250] = 1073741761; +inp[32251] = 0; +inp[32252] = 1073741760; +inp[32253] = 0; +inp[32254] = 1073741759; +inp[32255] = 0; +inp[32256] = 1073741758; +inp[32257] = 0; +inp[32258] = 1073741757; +inp[32259] = 0; +inp[32260] = 1073741756; +inp[32261] = 0; +inp[32262] = 1073741755; +inp[32263] = 0; +inp[32264] = 1073741754; +inp[32265] = 0; +inp[32266] = 1073741753; +inp[32267] = 0; +inp[32268] = 1073741752; +inp[32269] = 0; +inp[32270] = 1073741751; +inp[32271] = 0; +inp[32272] = 1073741750; +inp[32273] = 0; +inp[32274] = 1073741749; +inp[32275] = 0; +inp[32276] = 1073741748; +inp[32277] = 0; +inp[32278] = 1073741747; +inp[32279] = 0; +inp[32280] = 1073741746; +inp[32281] = 0; +inp[32282] = 1073741745; +inp[32283] = 0; +inp[32284] = 1073741744; +inp[32285] = 0; +inp[32286] = 1073741743; +inp[32287] = 0; +inp[32288] = 1073741742; +inp[32289] = 0; +inp[32290] = 1073741741; +inp[32291] = 0; +inp[32292] = 1073741740; +inp[32293] = 0; +inp[32294] = 1073741739; +inp[32295] = 0; +inp[32296] = 1073741738; +inp[32297] = 0; +inp[32298] = 1073741737; +inp[32299] = 0; +inp[32300] = 1073741736; +inp[32301] = 0; +inp[32302] = 1073741735; +inp[32303] = 0; +inp[32304] = 1073741734; +inp[32305] = 0; +inp[32306] = 1073741733; +inp[32307] = 0; +inp[32308] = 1073741732; +inp[32309] = 0; +inp[32310] = 1073741731; +inp[32311] = 0; +inp[32312] = 1073741730; +inp[32313] = 0; +inp[32314] = 1073741729; +inp[32315] = 0; +inp[32316] = 1073741728; +inp[32317] = 0; +inp[32318] = 1073741727; +inp[32319] = 0; +inp[32320] = 1073741726; +inp[32321] = 0; +inp[32322] = 1073741725; +inp[32323] = 0; +inp[32324] = 1073741724; +inp[32325] = 0; +inp[32326] = 1073741723; +inp[32327] = 0; +inp[32328] = 1073741722; +inp[32329] = 0; +inp[32330] = 1073741721; +inp[32331] = 0; +inp[32332] = 1073741720; +inp[32333] = 0; +inp[32334] = 1073741719; +inp[32335] = 0; +inp[32336] = 1073741718; +inp[32337] = 0; +inp[32338] = 1073741717; +inp[32339] = 0; +inp[32340] = 1073741716; +inp[32341] = 0; +inp[32342] = 1073741715; +inp[32343] = 0; +inp[32344] = 1073741714; +inp[32345] = 0; +inp[32346] = 1073741713; +inp[32347] = 0; +inp[32348] = 1073741712; +inp[32349] = 0; +inp[32350] = 1073741711; +inp[32351] = 0; +inp[32352] = 1073741710; +inp[32353] = 0; +inp[32354] = 1073741709; +inp[32355] = 0; +inp[32356] = 1073741708; +inp[32357] = 0; +inp[32358] = 1073741707; +inp[32359] = 0; +inp[32360] = 1073741706; +inp[32361] = 0; +inp[32362] = 1073741705; +inp[32363] = 0; +inp[32364] = 1073741704; +inp[32365] = 0; +inp[32366] = 1073741703; +inp[32367] = 0; +inp[32368] = 1073741702; +inp[32369] = 0; +inp[32370] = 1073741701; +inp[32371] = 0; +inp[32372] = 1073741700; +inp[32373] = 0; +inp[32374] = 1073741699; +inp[32375] = 0; +inp[32376] = 1073741698; +inp[32377] = 0; +inp[32378] = 1073741697; +inp[32379] = 0; +inp[32380] = 1073741696; +inp[32381] = 0; +inp[32382] = 1073741695; +inp[32383] = 0; +inp[32384] = 1073741694; +inp[32385] = 0; +inp[32386] = 1073741693; +inp[32387] = 0; +inp[32388] = 1073741692; +inp[32389] = 0; +inp[32390] = 1073741691; +inp[32391] = 0; +inp[32392] = 1073741690; +inp[32393] = 0; +inp[32394] = 1073741689; +inp[32395] = 0; +inp[32396] = 1073741688; +inp[32397] = 0; +inp[32398] = 1073741687; +inp[32399] = 0; +inp[32400] = 1073741686; +inp[32401] = 0; +inp[32402] = 1073741685; +inp[32403] = 0; +inp[32404] = 1073741684; +inp[32405] = 0; +inp[32406] = 1073741683; +inp[32407] = 0; +inp[32408] = 1073741682; +inp[32409] = 0; +inp[32410] = 1073741681; +inp[32411] = 0; +inp[32412] = 1073741680; +inp[32413] = 0; +inp[32414] = 1073741679; +inp[32415] = 0; +inp[32416] = 1073741678; +inp[32417] = 0; +inp[32418] = 1073741677; +inp[32419] = 0; +inp[32420] = 1073741676; +inp[32421] = 0; +inp[32422] = 1073741675; +inp[32423] = 0; +inp[32424] = 1073741674; +inp[32425] = 0; +inp[32426] = 1073741673; +inp[32427] = 0; +inp[32428] = 1073741672; +inp[32429] = 0; +inp[32430] = 1073741671; +inp[32431] = 0; +inp[32432] = 1073741670; +inp[32433] = 0; +inp[32434] = 1073741669; +inp[32435] = 0; +inp[32436] = 1073741668; +inp[32437] = 0; +inp[32438] = 1073741667; +inp[32439] = 0; +inp[32440] = 1073741666; +inp[32441] = 0; +inp[32442] = 1073741665; +inp[32443] = 0; +inp[32444] = 1073741664; +inp[32445] = 0; +inp[32446] = 1073741663; +inp[32447] = 0; +inp[32448] = 1073741662; +inp[32449] = 0; +inp[32450] = 1073741661; +inp[32451] = 0; +inp[32452] = 1073741660; +inp[32453] = 0; +inp[32454] = 1073741659; +inp[32455] = 0; +inp[32456] = 1073741658; +inp[32457] = 0; +inp[32458] = 1073741657; +inp[32459] = 0; +inp[32460] = 1073741656; +inp[32461] = 0; +inp[32462] = 1073741655; +inp[32463] = 0; +inp[32464] = 1073741654; +inp[32465] = 0; +inp[32466] = 1073741653; +inp[32467] = 0; +inp[32468] = 1073741652; +inp[32469] = 0; +inp[32470] = 1073741651; +inp[32471] = 0; +inp[32472] = 1073741650; +inp[32473] = 0; +inp[32474] = 1073741649; +inp[32475] = 0; +inp[32476] = 1073741648; +inp[32477] = 0; +inp[32478] = 1073741647; +inp[32479] = 0; +inp[32480] = 1073741646; +inp[32481] = 0; +inp[32482] = 1073741645; +inp[32483] = 0; +inp[32484] = 1073741644; +inp[32485] = 0; +inp[32486] = 1073741643; +inp[32487] = 0; +inp[32488] = 1073741642; +inp[32489] = 0; +inp[32490] = 1073741641; +inp[32491] = 0; +inp[32492] = 1073741640; +inp[32493] = 0; +inp[32494] = 1073741639; +inp[32495] = 0; +inp[32496] = 1073741638; +inp[32497] = 0; +inp[32498] = 1073741637; +inp[32499] = 0; +inp[32500] = 1073741636; +inp[32501] = 0; +inp[32502] = 1073741635; +inp[32503] = 0; +inp[32504] = 1073741634; +inp[32505] = 0; +inp[32506] = 1073741633; +inp[32507] = 0; +inp[32508] = 1073741632; +inp[32509] = 0; +inp[32510] = 1073741631; +inp[32511] = 0; +inp[32512] = 1073741630; +inp[32513] = 0; +inp[32514] = 1073741629; +inp[32515] = 0; +inp[32516] = 1073741628; +inp[32517] = 0; +inp[32518] = 1073741627; +inp[32519] = 0; +inp[32520] = 1073741626; +inp[32521] = 0; +inp[32522] = 1073741625; +inp[32523] = 0; +inp[32524] = 1073741624; +inp[32525] = 0; +inp[32526] = 1073741623; +inp[32527] = 0; +inp[32528] = 1073741622; +inp[32529] = 0; +inp[32530] = 1073741621; +inp[32531] = 0; +inp[32532] = 1073741620; +inp[32533] = 0; +inp[32534] = 1073741619; +inp[32535] = 0; +inp[32536] = 1073741618; +inp[32537] = 0; +inp[32538] = 1073741617; +inp[32539] = 0; +inp[32540] = 1073741616; +inp[32541] = 0; +inp[32542] = 1073741615; +inp[32543] = 0; +inp[32544] = 1073741614; +inp[32545] = 0; +inp[32546] = 1073741613; +inp[32547] = 0; +inp[32548] = 1073741612; +inp[32549] = 0; +inp[32550] = 1073741611; +inp[32551] = 0; +inp[32552] = 1073741610; +inp[32553] = 0; +inp[32554] = 1073741609; +inp[32555] = 0; +inp[32556] = 1073741608; +inp[32557] = 0; +inp[32558] = 1073741607; +inp[32559] = 0; +inp[32560] = 1073741606; +inp[32561] = 0; +inp[32562] = 1073741605; +inp[32563] = 0; +inp[32564] = 1073741604; +inp[32565] = 0; +inp[32566] = 1073741603; +inp[32567] = 0; +inp[32568] = 1073741602; +inp[32569] = 0; +inp[32570] = 1073741601; +inp[32571] = 0; +inp[32572] = 1073741600; +inp[32573] = 0; +inp[32574] = 1073741599; +inp[32575] = 0; +inp[32576] = 1073741598; +inp[32577] = 0; +inp[32578] = 1073741597; +inp[32579] = 0; +inp[32580] = 1073741596; +inp[32581] = 0; +inp[32582] = 1073741595; +inp[32583] = 0; +inp[32584] = 1073741594; +inp[32585] = 0; +inp[32586] = 1073741593; +inp[32587] = 0; +inp[32588] = 1073741592; +inp[32589] = 0; +inp[32590] = 1073741591; +inp[32591] = 0; +inp[32592] = 1073741590; +inp[32593] = 0; +inp[32594] = 1073741589; +inp[32595] = 0; +inp[32596] = 1073741588; +inp[32597] = 0; +inp[32598] = 1073741587; +inp[32599] = 0; +inp[32600] = 1073741586; +inp[32601] = 0; +inp[32602] = 1073741585; +inp[32603] = 0; +inp[32604] = 1073741584; +inp[32605] = 0; +inp[32606] = 1073741583; +inp[32607] = 0; +inp[32608] = 1073741582; +inp[32609] = 0; +inp[32610] = 1073741581; +inp[32611] = 0; +inp[32612] = 1073741580; +inp[32613] = 0; +inp[32614] = 1073741579; +inp[32615] = 0; +inp[32616] = 1073741578; +inp[32617] = 0; +inp[32618] = 1073741577; +inp[32619] = 0; +inp[32620] = 1073741576; +inp[32621] = 0; +inp[32622] = 1073741575; +inp[32623] = 0; +inp[32624] = 1073741574; +inp[32625] = 0; +inp[32626] = 1073741573; +inp[32627] = 0; +inp[32628] = 1073741572; +inp[32629] = 0; +inp[32630] = 1073741571; +inp[32631] = 0; +inp[32632] = 1073741570; +inp[32633] = 0; +inp[32634] = 1073741569; +inp[32635] = 0; +inp[32636] = 1073741824; +inp[32637] = 1073741824; +inp[32638] = 1073741823; +inp[32639] = 0; +inp[32640] = 1073741823; +inp[32641] = 0; +inp[32642] = 1073741822; +inp[32643] = 0; +inp[32644] = 1073741822; +inp[32645] = 0; +inp[32646] = 1073741821; +inp[32647] = 0; +inp[32648] = 1073741821; +inp[32649] = 0; +inp[32650] = 1073741820; +inp[32651] = 0; +inp[32652] = 1073741820; +inp[32653] = 0; +inp[32654] = 1073741819; +inp[32655] = 0; +inp[32656] = 1073741819; +inp[32657] = 0; +inp[32658] = 1073741818; +inp[32659] = 0; +inp[32660] = 1073741818; +inp[32661] = 0; +inp[32662] = 1073741817; +inp[32663] = 0; +inp[32664] = 1073741817; +inp[32665] = 0; +inp[32666] = 1073741816; +inp[32667] = 0; +inp[32668] = 1073741816; +inp[32669] = 0; +inp[32670] = 1073741815; +inp[32671] = 0; +inp[32672] = 1073741815; +inp[32673] = 0; +inp[32674] = 1073741814; +inp[32675] = 0; +inp[32676] = 1073741814; +inp[32677] = 0; +inp[32678] = 1073741813; +inp[32679] = 0; +inp[32680] = 1073741813; +inp[32681] = 0; +inp[32682] = 1073741812; +inp[32683] = 0; +inp[32684] = 1073741812; +inp[32685] = 0; +inp[32686] = 1073741811; +inp[32687] = 0; +inp[32688] = 1073741811; +inp[32689] = 0; +inp[32690] = 1073741810; +inp[32691] = 0; +inp[32692] = 1073741810; +inp[32693] = 0; +inp[32694] = 1073741809; +inp[32695] = 0; +inp[32696] = 1073741809; +inp[32697] = 0; +inp[32698] = 1073741808; +inp[32699] = 0; +inp[32700] = 1073741808; +inp[32701] = 0; +inp[32702] = 1073741807; +inp[32703] = 0; +inp[32704] = 1073741807; +inp[32705] = 0; +inp[32706] = 1073741806; +inp[32707] = 0; +inp[32708] = 1073741806; +inp[32709] = 0; +inp[32710] = 1073741805; +inp[32711] = 0; +inp[32712] = 1073741805; +inp[32713] = 0; +inp[32714] = 1073741804; +inp[32715] = 0; +inp[32716] = 1073741804; +inp[32717] = 0; +inp[32718] = 1073741803; +inp[32719] = 0; +inp[32720] = 1073741803; +inp[32721] = 0; +inp[32722] = 1073741802; +inp[32723] = 0; +inp[32724] = 1073741802; +inp[32725] = 0; +inp[32726] = 1073741801; +inp[32727] = 0; +inp[32728] = 1073741801; +inp[32729] = 0; +inp[32730] = 1073741800; +inp[32731] = 0; +inp[32732] = 1073741800; +inp[32733] = 0; +inp[32734] = 1073741799; +inp[32735] = 0; +inp[32736] = 1073741799; +inp[32737] = 0; +inp[32738] = 1073741798; +inp[32739] = 0; +inp[32740] = 1073741798; +inp[32741] = 0; +inp[32742] = 1073741797; +inp[32743] = 0; +inp[32744] = 1073741797; +inp[32745] = 0; +inp[32746] = 1073741796; +inp[32747] = 0; +inp[32748] = 1073741796; +inp[32749] = 0; +inp[32750] = 1073741795; +inp[32751] = 0; +inp[32752] = 1073741795; +inp[32753] = 0; +inp[32754] = 1073741794; +inp[32755] = 0; +inp[32756] = 1073741794; +inp[32757] = 0; +inp[32758] = 1073741793; +inp[32759] = 0; +inp[32760] = 1073741793; +inp[32761] = 0; +inp[32762] = 1073741792; +inp[32763] = 0; +inp[32764] = 1073741792; +inp[32765] = 0; +inp[32766] = 1073741791; +inp[32767] = 0; +inp[32768] = 1073741791; +inp[32769] = 0; +inp[32770] = 1073741790; +inp[32771] = 0; +inp[32772] = 1073741790; +inp[32773] = 0; +inp[32774] = 1073741789; +inp[32775] = 0; +inp[32776] = 1073741789; +inp[32777] = 0; +inp[32778] = 1073741788; +inp[32779] = 0; +inp[32780] = 1073741788; +inp[32781] = 0; +inp[32782] = 1073741787; +inp[32783] = 0; +inp[32784] = 1073741787; +inp[32785] = 0; +inp[32786] = 1073741786; +inp[32787] = 0; +inp[32788] = 1073741786; +inp[32789] = 0; +inp[32790] = 1073741785; +inp[32791] = 0; +inp[32792] = 1073741785; +inp[32793] = 0; +inp[32794] = 1073741784; +inp[32795] = 0; +inp[32796] = 1073741784; +inp[32797] = 0; +inp[32798] = 1073741783; +inp[32799] = 0; +inp[32800] = 1073741783; +inp[32801] = 0; +inp[32802] = 1073741782; +inp[32803] = 0; +inp[32804] = 1073741782; +inp[32805] = 0; +inp[32806] = 1073741781; +inp[32807] = 0; +inp[32808] = 1073741781; +inp[32809] = 0; +inp[32810] = 1073741780; +inp[32811] = 0; +inp[32812] = 1073741780; +inp[32813] = 0; +inp[32814] = 1073741779; +inp[32815] = 0; +inp[32816] = 1073741779; +inp[32817] = 0; +inp[32818] = 1073741778; +inp[32819] = 0; +inp[32820] = 1073741778; +inp[32821] = 0; +inp[32822] = 1073741777; +inp[32823] = 0; +inp[32824] = 1073741777; +inp[32825] = 0; +inp[32826] = 1073741776; +inp[32827] = 0; +inp[32828] = 1073741776; +inp[32829] = 0; +inp[32830] = 1073741775; +inp[32831] = 0; +inp[32832] = 1073741775; +inp[32833] = 0; +inp[32834] = 1073741774; +inp[32835] = 0; +inp[32836] = 1073741774; +inp[32837] = 0; +inp[32838] = 1073741773; +inp[32839] = 0; +inp[32840] = 1073741773; +inp[32841] = 0; +inp[32842] = 1073741772; +inp[32843] = 0; +inp[32844] = 1073741772; +inp[32845] = 0; +inp[32846] = 1073741771; +inp[32847] = 0; +inp[32848] = 1073741771; +inp[32849] = 0; +inp[32850] = 1073741770; +inp[32851] = 0; +inp[32852] = 1073741770; +inp[32853] = 0; +inp[32854] = 1073741769; +inp[32855] = 0; +inp[32856] = 1073741769; +inp[32857] = 0; +inp[32858] = 1073741768; +inp[32859] = 0; +inp[32860] = 1073741768; +inp[32861] = 0; +inp[32862] = 1073741767; +inp[32863] = 0; +inp[32864] = 1073741767; +inp[32865] = 0; +inp[32866] = 1073741766; +inp[32867] = 0; +inp[32868] = 1073741766; +inp[32869] = 0; +inp[32870] = 1073741765; +inp[32871] = 0; +inp[32872] = 1073741765; +inp[32873] = 0; +inp[32874] = 1073741764; +inp[32875] = 0; +inp[32876] = 1073741764; +inp[32877] = 0; +inp[32878] = 1073741763; +inp[32879] = 0; +inp[32880] = 1073741763; +inp[32881] = 0; +inp[32882] = 1073741762; +inp[32883] = 0; +inp[32884] = 1073741762; +inp[32885] = 0; +inp[32886] = 1073741761; +inp[32887] = 0; +inp[32888] = 1073741761; +inp[32889] = 0; +inp[32890] = 1073741760; +inp[32891] = 0; +inp[32892] = 1073741760; +inp[32893] = 0; +inp[32894] = 1073741759; +inp[32895] = 0; +inp[32896] = 1073741759; +inp[32897] = 0; +inp[32898] = 1073741758; +inp[32899] = 0; +inp[32900] = 1073741758; +inp[32901] = 0; +inp[32902] = 1073741757; +inp[32903] = 0; +inp[32904] = 1073741757; +inp[32905] = 0; +inp[32906] = 1073741756; +inp[32907] = 0; +inp[32908] = 1073741756; +inp[32909] = 0; +inp[32910] = 1073741755; +inp[32911] = 0; +inp[32912] = 1073741755; +inp[32913] = 0; +inp[32914] = 1073741754; +inp[32915] = 0; +inp[32916] = 1073741754; +inp[32917] = 0; +inp[32918] = 1073741753; +inp[32919] = 0; +inp[32920] = 1073741753; +inp[32921] = 0; +inp[32922] = 1073741752; +inp[32923] = 0; +inp[32924] = 1073741752; +inp[32925] = 0; +inp[32926] = 1073741751; +inp[32927] = 0; +inp[32928] = 1073741751; +inp[32929] = 0; +inp[32930] = 1073741750; +inp[32931] = 0; +inp[32932] = 1073741750; +inp[32933] = 0; +inp[32934] = 1073741749; +inp[32935] = 0; +inp[32936] = 1073741749; +inp[32937] = 0; +inp[32938] = 1073741748; +inp[32939] = 0; +inp[32940] = 1073741748; +inp[32941] = 0; +inp[32942] = 1073741747; +inp[32943] = 0; +inp[32944] = 1073741747; +inp[32945] = 0; +inp[32946] = 1073741746; +inp[32947] = 0; +inp[32948] = 1073741746; +inp[32949] = 0; +inp[32950] = 1073741745; +inp[32951] = 0; +inp[32952] = 1073741745; +inp[32953] = 0; +inp[32954] = 1073741744; +inp[32955] = 0; +inp[32956] = 1073741744; +inp[32957] = 0; +inp[32958] = 1073741743; +inp[32959] = 0; +inp[32960] = 1073741743; +inp[32961] = 0; +inp[32962] = 1073741742; +inp[32963] = 0; +inp[32964] = 1073741742; +inp[32965] = 0; +inp[32966] = 1073741741; +inp[32967] = 0; +inp[32968] = 1073741741; +inp[32969] = 0; +inp[32970] = 1073741740; +inp[32971] = 0; +inp[32972] = 1073741740; +inp[32973] = 0; +inp[32974] = 1073741739; +inp[32975] = 0; +inp[32976] = 1073741739; +inp[32977] = 0; +inp[32978] = 1073741738; +inp[32979] = 0; +inp[32980] = 1073741738; +inp[32981] = 0; +inp[32982] = 1073741737; +inp[32983] = 0; +inp[32984] = 1073741737; +inp[32985] = 0; +inp[32986] = 1073741736; +inp[32987] = 0; +inp[32988] = 1073741736; +inp[32989] = 0; +inp[32990] = 1073741735; +inp[32991] = 0; +inp[32992] = 1073741735; +inp[32993] = 0; +inp[32994] = 1073741734; +inp[32995] = 0; +inp[32996] = 1073741734; +inp[32997] = 0; +inp[32998] = 1073741733; +inp[32999] = 0; +inp[33000] = 1073741733; +inp[33001] = 0; +inp[33002] = 1073741732; +inp[33003] = 0; +inp[33004] = 1073741732; +inp[33005] = 0; +inp[33006] = 1073741731; +inp[33007] = 0; +inp[33008] = 1073741731; +inp[33009] = 0; +inp[33010] = 1073741730; +inp[33011] = 0; +inp[33012] = 1073741730; +inp[33013] = 0; +inp[33014] = 1073741729; +inp[33015] = 0; +inp[33016] = 1073741729; +inp[33017] = 0; +inp[33018] = 1073741728; +inp[33019] = 0; +inp[33020] = 1073741728; +inp[33021] = 0; +inp[33022] = 1073741727; +inp[33023] = 0; +inp[33024] = 1073741727; +inp[33025] = 0; +inp[33026] = 1073741726; +inp[33027] = 0; +inp[33028] = 1073741726; +inp[33029] = 0; +inp[33030] = 1073741725; +inp[33031] = 0; +inp[33032] = 1073741725; +inp[33033] = 0; +inp[33034] = 1073741724; +inp[33035] = 0; +inp[33036] = 1073741724; +inp[33037] = 0; +inp[33038] = 1073741723; +inp[33039] = 0; +inp[33040] = 1073741723; +inp[33041] = 0; +inp[33042] = 1073741722; +inp[33043] = 0; +inp[33044] = 1073741722; +inp[33045] = 0; +inp[33046] = 1073741721; +inp[33047] = 0; +inp[33048] = 1073741721; +inp[33049] = 0; +inp[33050] = 1073741720; +inp[33051] = 0; +inp[33052] = 1073741720; +inp[33053] = 0; +inp[33054] = 1073741719; +inp[33055] = 0; +inp[33056] = 1073741719; +inp[33057] = 0; +inp[33058] = 1073741718; +inp[33059] = 0; +inp[33060] = 1073741718; +inp[33061] = 0; +inp[33062] = 1073741717; +inp[33063] = 0; +inp[33064] = 1073741717; +inp[33065] = 0; +inp[33066] = 1073741716; +inp[33067] = 0; +inp[33068] = 1073741716; +inp[33069] = 0; +inp[33070] = 1073741715; +inp[33071] = 0; +inp[33072] = 1073741715; +inp[33073] = 0; +inp[33074] = 1073741714; +inp[33075] = 0; +inp[33076] = 1073741714; +inp[33077] = 0; +inp[33078] = 1073741713; +inp[33079] = 0; +inp[33080] = 1073741713; +inp[33081] = 0; +inp[33082] = 1073741712; +inp[33083] = 0; +inp[33084] = 1073741712; +inp[33085] = 0; +inp[33086] = 1073741711; +inp[33087] = 0; +inp[33088] = 1073741711; +inp[33089] = 0; +inp[33090] = 1073741710; +inp[33091] = 0; +inp[33092] = 1073741710; +inp[33093] = 0; +inp[33094] = 1073741709; +inp[33095] = 0; +inp[33096] = 1073741709; +inp[33097] = 0; +inp[33098] = 1073741708; +inp[33099] = 0; +inp[33100] = 1073741708; +inp[33101] = 0; +inp[33102] = 1073741707; +inp[33103] = 0; +inp[33104] = 1073741707; +inp[33105] = 0; +inp[33106] = 1073741706; +inp[33107] = 0; +inp[33108] = 1073741706; +inp[33109] = 0; +inp[33110] = 1073741705; +inp[33111] = 0; +inp[33112] = 1073741705; +inp[33113] = 0; +inp[33114] = 1073741704; +inp[33115] = 0; +inp[33116] = 1073741704; +inp[33117] = 0; +inp[33118] = 1073741703; +inp[33119] = 0; +inp[33120] = 1073741703; +inp[33121] = 0; +inp[33122] = 1073741702; +inp[33123] = 0; +inp[33124] = 1073741702; +inp[33125] = 0; +inp[33126] = 1073741701; +inp[33127] = 0; +inp[33128] = 1073741701; +inp[33129] = 0; +inp[33130] = 1073741700; +inp[33131] = 0; +inp[33132] = 1073741700; +inp[33133] = 0; +inp[33134] = 1073741699; +inp[33135] = 0; +inp[33136] = 1073741699; +inp[33137] = 0; +inp[33138] = 1073741698; +inp[33139] = 0; +inp[33140] = 1073741698; +inp[33141] = 0; +inp[33142] = 1073741697; +inp[33143] = 0; +inp[33144] = 1073741697; +inp[33145] = 0; +inp[33146] = 1073741696; +inp[33147] = 0; +inp[33148] = 1073741824; +inp[33149] = 1073741824; +inp[33150] = 1073741823; +inp[33151] = 0; +inp[33152] = 1073741823; +inp[33153] = 0; +inp[33154] = 1073741823; +inp[33155] = 0; +inp[33156] = 1073741823; +inp[33157] = 0; +inp[33158] = 1073741822; +inp[33159] = 0; +inp[33160] = 1073741822; +inp[33161] = 0; +inp[33162] = 1073741822; +inp[33163] = 0; +inp[33164] = 1073741822; +inp[33165] = 0; +inp[33166] = 1073741821; +inp[33167] = 0; +inp[33168] = 1073741821; +inp[33169] = 0; +inp[33170] = 1073741821; +inp[33171] = 0; +inp[33172] = 1073741821; +inp[33173] = 0; +inp[33174] = 1073741820; +inp[33175] = 0; +inp[33176] = 1073741820; +inp[33177] = 0; +inp[33178] = 1073741820; +inp[33179] = 0; +inp[33180] = 1073741820; +inp[33181] = 0; +inp[33182] = 1073741819; +inp[33183] = 0; +inp[33184] = 1073741819; +inp[33185] = 0; +inp[33186] = 1073741819; +inp[33187] = 0; +inp[33188] = 1073741819; +inp[33189] = 0; +inp[33190] = 1073741818; +inp[33191] = 0; +inp[33192] = 1073741818; +inp[33193] = 0; +inp[33194] = 1073741818; +inp[33195] = 0; +inp[33196] = 1073741818; +inp[33197] = 0; +inp[33198] = 1073741817; +inp[33199] = 0; +inp[33200] = 1073741817; +inp[33201] = 0; +inp[33202] = 1073741817; +inp[33203] = 0; +inp[33204] = 1073741817; +inp[33205] = 0; +inp[33206] = 1073741816; +inp[33207] = 0; +inp[33208] = 1073741816; +inp[33209] = 0; +inp[33210] = 1073741816; +inp[33211] = 0; +inp[33212] = 1073741816; +inp[33213] = 0; +inp[33214] = 1073741815; +inp[33215] = 0; +inp[33216] = 1073741815; +inp[33217] = 0; +inp[33218] = 1073741815; +inp[33219] = 0; +inp[33220] = 1073741815; +inp[33221] = 0; +inp[33222] = 1073741814; +inp[33223] = 0; +inp[33224] = 1073741814; +inp[33225] = 0; +inp[33226] = 1073741814; +inp[33227] = 0; +inp[33228] = 1073741814; +inp[33229] = 0; +inp[33230] = 1073741813; +inp[33231] = 0; +inp[33232] = 1073741813; +inp[33233] = 0; +inp[33234] = 1073741813; +inp[33235] = 0; +inp[33236] = 1073741813; +inp[33237] = 0; +inp[33238] = 1073741812; +inp[33239] = 0; +inp[33240] = 1073741812; +inp[33241] = 0; +inp[33242] = 1073741812; +inp[33243] = 0; +inp[33244] = 1073741812; +inp[33245] = 0; +inp[33246] = 1073741811; +inp[33247] = 0; +inp[33248] = 1073741811; +inp[33249] = 0; +inp[33250] = 1073741811; +inp[33251] = 0; +inp[33252] = 1073741811; +inp[33253] = 0; +inp[33254] = 1073741810; +inp[33255] = 0; +inp[33256] = 1073741810; +inp[33257] = 0; +inp[33258] = 1073741810; +inp[33259] = 0; +inp[33260] = 1073741810; +inp[33261] = 0; +inp[33262] = 1073741809; +inp[33263] = 0; +inp[33264] = 1073741809; +inp[33265] = 0; +inp[33266] = 1073741809; +inp[33267] = 0; +inp[33268] = 1073741809; +inp[33269] = 0; +inp[33270] = 1073741808; +inp[33271] = 0; +inp[33272] = 1073741808; +inp[33273] = 0; +inp[33274] = 1073741808; +inp[33275] = 0; +inp[33276] = 1073741808; +inp[33277] = 0; +inp[33278] = 1073741807; +inp[33279] = 0; +inp[33280] = 1073741807; +inp[33281] = 0; +inp[33282] = 1073741807; +inp[33283] = 0; +inp[33284] = 1073741807; +inp[33285] = 0; +inp[33286] = 1073741806; +inp[33287] = 0; +inp[33288] = 1073741806; +inp[33289] = 0; +inp[33290] = 1073741806; +inp[33291] = 0; +inp[33292] = 1073741806; +inp[33293] = 0; +inp[33294] = 1073741805; +inp[33295] = 0; +inp[33296] = 1073741805; +inp[33297] = 0; +inp[33298] = 1073741805; +inp[33299] = 0; +inp[33300] = 1073741805; +inp[33301] = 0; +inp[33302] = 1073741804; +inp[33303] = 0; +inp[33304] = 1073741804; +inp[33305] = 0; +inp[33306] = 1073741804; +inp[33307] = 0; +inp[33308] = 1073741804; +inp[33309] = 0; +inp[33310] = 1073741803; +inp[33311] = 0; +inp[33312] = 1073741803; +inp[33313] = 0; +inp[33314] = 1073741803; +inp[33315] = 0; +inp[33316] = 1073741803; +inp[33317] = 0; +inp[33318] = 1073741802; +inp[33319] = 0; +inp[33320] = 1073741802; +inp[33321] = 0; +inp[33322] = 1073741802; +inp[33323] = 0; +inp[33324] = 1073741802; +inp[33325] = 0; +inp[33326] = 1073741801; +inp[33327] = 0; +inp[33328] = 1073741801; +inp[33329] = 0; +inp[33330] = 1073741801; +inp[33331] = 0; +inp[33332] = 1073741801; +inp[33333] = 0; +inp[33334] = 1073741800; +inp[33335] = 0; +inp[33336] = 1073741800; +inp[33337] = 0; +inp[33338] = 1073741800; +inp[33339] = 0; +inp[33340] = 1073741800; +inp[33341] = 0; +inp[33342] = 1073741799; +inp[33343] = 0; +inp[33344] = 1073741799; +inp[33345] = 0; +inp[33346] = 1073741799; +inp[33347] = 0; +inp[33348] = 1073741799; +inp[33349] = 0; +inp[33350] = 1073741798; +inp[33351] = 0; +inp[33352] = 1073741798; +inp[33353] = 0; +inp[33354] = 1073741798; +inp[33355] = 0; +inp[33356] = 1073741798; +inp[33357] = 0; +inp[33358] = 1073741797; +inp[33359] = 0; +inp[33360] = 1073741797; +inp[33361] = 0; +inp[33362] = 1073741797; +inp[33363] = 0; +inp[33364] = 1073741797; +inp[33365] = 0; +inp[33366] = 1073741796; +inp[33367] = 0; +inp[33368] = 1073741796; +inp[33369] = 0; +inp[33370] = 1073741796; +inp[33371] = 0; +inp[33372] = 1073741796; +inp[33373] = 0; +inp[33374] = 1073741795; +inp[33375] = 0; +inp[33376] = 1073741795; +inp[33377] = 0; +inp[33378] = 1073741795; +inp[33379] = 0; +inp[33380] = 1073741795; +inp[33381] = 0; +inp[33382] = 1073741794; +inp[33383] = 0; +inp[33384] = 1073741794; +inp[33385] = 0; +inp[33386] = 1073741794; +inp[33387] = 0; +inp[33388] = 1073741794; +inp[33389] = 0; +inp[33390] = 1073741793; +inp[33391] = 0; +inp[33392] = 1073741793; +inp[33393] = 0; +inp[33394] = 1073741793; +inp[33395] = 0; +inp[33396] = 1073741793; +inp[33397] = 0; +inp[33398] = 1073741792; +inp[33399] = 0; +inp[33400] = 1073741792; +inp[33401] = 0; +inp[33402] = 1073741792; +inp[33403] = 0; +inp[33404] = 1073741792; +inp[33405] = 0; +inp[33406] = 1073741791; +inp[33407] = 0; +inp[33408] = 1073741791; +inp[33409] = 0; +inp[33410] = 1073741791; +inp[33411] = 0; +inp[33412] = 1073741791; +inp[33413] = 0; +inp[33414] = 1073741790; +inp[33415] = 0; +inp[33416] = 1073741790; +inp[33417] = 0; +inp[33418] = 1073741790; +inp[33419] = 0; +inp[33420] = 1073741790; +inp[33421] = 0; +inp[33422] = 1073741789; +inp[33423] = 0; +inp[33424] = 1073741789; +inp[33425] = 0; +inp[33426] = 1073741789; +inp[33427] = 0; +inp[33428] = 1073741789; +inp[33429] = 0; +inp[33430] = 1073741788; +inp[33431] = 0; +inp[33432] = 1073741788; +inp[33433] = 0; +inp[33434] = 1073741788; +inp[33435] = 0; +inp[33436] = 1073741788; +inp[33437] = 0; +inp[33438] = 1073741787; +inp[33439] = 0; +inp[33440] = 1073741787; +inp[33441] = 0; +inp[33442] = 1073741787; +inp[33443] = 0; +inp[33444] = 1073741787; +inp[33445] = 0; +inp[33446] = 1073741786; +inp[33447] = 0; +inp[33448] = 1073741786; +inp[33449] = 0; +inp[33450] = 1073741786; +inp[33451] = 0; +inp[33452] = 1073741786; +inp[33453] = 0; +inp[33454] = 1073741785; +inp[33455] = 0; +inp[33456] = 1073741785; +inp[33457] = 0; +inp[33458] = 1073741785; +inp[33459] = 0; +inp[33460] = 1073741785; +inp[33461] = 0; +inp[33462] = 1073741784; +inp[33463] = 0; +inp[33464] = 1073741784; +inp[33465] = 0; +inp[33466] = 1073741784; +inp[33467] = 0; +inp[33468] = 1073741784; +inp[33469] = 0; +inp[33470] = 1073741783; +inp[33471] = 0; +inp[33472] = 1073741783; +inp[33473] = 0; +inp[33474] = 1073741783; +inp[33475] = 0; +inp[33476] = 1073741783; +inp[33477] = 0; +inp[33478] = 1073741782; +inp[33479] = 0; +inp[33480] = 1073741782; +inp[33481] = 0; +inp[33482] = 1073741782; +inp[33483] = 0; +inp[33484] = 1073741782; +inp[33485] = 0; +inp[33486] = 1073741781; +inp[33487] = 0; +inp[33488] = 1073741781; +inp[33489] = 0; +inp[33490] = 1073741781; +inp[33491] = 0; +inp[33492] = 1073741781; +inp[33493] = 0; +inp[33494] = 1073741780; +inp[33495] = 0; +inp[33496] = 1073741780; +inp[33497] = 0; +inp[33498] = 1073741780; +inp[33499] = 0; +inp[33500] = 1073741780; +inp[33501] = 0; +inp[33502] = 1073741779; +inp[33503] = 0; +inp[33504] = 1073741779; +inp[33505] = 0; +inp[33506] = 1073741779; +inp[33507] = 0; +inp[33508] = 1073741779; +inp[33509] = 0; +inp[33510] = 1073741778; +inp[33511] = 0; +inp[33512] = 1073741778; +inp[33513] = 0; +inp[33514] = 1073741778; +inp[33515] = 0; +inp[33516] = 1073741778; +inp[33517] = 0; +inp[33518] = 1073741777; +inp[33519] = 0; +inp[33520] = 1073741777; +inp[33521] = 0; +inp[33522] = 1073741777; +inp[33523] = 0; +inp[33524] = 1073741777; +inp[33525] = 0; +inp[33526] = 1073741776; +inp[33527] = 0; +inp[33528] = 1073741776; +inp[33529] = 0; +inp[33530] = 1073741776; +inp[33531] = 0; +inp[33532] = 1073741776; +inp[33533] = 0; +inp[33534] = 1073741775; +inp[33535] = 0; +inp[33536] = 1073741775; +inp[33537] = 0; +inp[33538] = 1073741775; +inp[33539] = 0; +inp[33540] = 1073741775; +inp[33541] = 0; +inp[33542] = 1073741774; +inp[33543] = 0; +inp[33544] = 1073741774; +inp[33545] = 0; +inp[33546] = 1073741774; +inp[33547] = 0; +inp[33548] = 1073741774; +inp[33549] = 0; +inp[33550] = 1073741773; +inp[33551] = 0; +inp[33552] = 1073741773; +inp[33553] = 0; +inp[33554] = 1073741773; +inp[33555] = 0; +inp[33556] = 1073741773; +inp[33557] = 0; +inp[33558] = 1073741772; +inp[33559] = 0; +inp[33560] = 1073741772; +inp[33561] = 0; +inp[33562] = 1073741772; +inp[33563] = 0; +inp[33564] = 1073741772; +inp[33565] = 0; +inp[33566] = 1073741771; +inp[33567] = 0; +inp[33568] = 1073741771; +inp[33569] = 0; +inp[33570] = 1073741771; +inp[33571] = 0; +inp[33572] = 1073741771; +inp[33573] = 0; +inp[33574] = 1073741770; +inp[33575] = 0; +inp[33576] = 1073741770; +inp[33577] = 0; +inp[33578] = 1073741770; +inp[33579] = 0; +inp[33580] = 1073741770; +inp[33581] = 0; +inp[33582] = 1073741769; +inp[33583] = 0; +inp[33584] = 1073741769; +inp[33585] = 0; +inp[33586] = 1073741769; +inp[33587] = 0; +inp[33588] = 1073741769; +inp[33589] = 0; +inp[33590] = 1073741768; +inp[33591] = 0; +inp[33592] = 1073741768; +inp[33593] = 0; +inp[33594] = 1073741768; +inp[33595] = 0; +inp[33596] = 1073741768; +inp[33597] = 0; +inp[33598] = 1073741767; +inp[33599] = 0; +inp[33600] = 1073741767; +inp[33601] = 0; +inp[33602] = 1073741767; +inp[33603] = 0; +inp[33604] = 1073741767; +inp[33605] = 0; +inp[33606] = 1073741766; +inp[33607] = 0; +inp[33608] = 1073741766; +inp[33609] = 0; +inp[33610] = 1073741766; +inp[33611] = 0; +inp[33612] = 1073741766; +inp[33613] = 0; +inp[33614] = 1073741765; +inp[33615] = 0; +inp[33616] = 1073741765; +inp[33617] = 0; +inp[33618] = 1073741765; +inp[33619] = 0; +inp[33620] = 1073741765; +inp[33621] = 0; +inp[33622] = 1073741764; +inp[33623] = 0; +inp[33624] = 1073741764; +inp[33625] = 0; +inp[33626] = 1073741764; +inp[33627] = 0; +inp[33628] = 1073741764; +inp[33629] = 0; +inp[33630] = 1073741763; +inp[33631] = 0; +inp[33632] = 1073741763; +inp[33633] = 0; +inp[33634] = 1073741763; +inp[33635] = 0; +inp[33636] = 1073741763; +inp[33637] = 0; +inp[33638] = 1073741762; +inp[33639] = 0; +inp[33640] = 1073741762; +inp[33641] = 0; +inp[33642] = 1073741762; +inp[33643] = 0; +inp[33644] = 1073741762; +inp[33645] = 0; +inp[33646] = 1073741761; +inp[33647] = 0; +inp[33648] = 1073741761; +inp[33649] = 0; +inp[33650] = 1073741761; +inp[33651] = 0; +inp[33652] = 1073741761; +inp[33653] = 0; +inp[33654] = 1073741760; +inp[33655] = 0; +inp[33656] = 1073741760; +inp[33657] = 0; +inp[33658] = 1073741760; +inp[33659] = 0; +} + +(* <><><><><><> Auto-generated code end <><><><><><> *) + +(* <><><><><><><><>< *) +(* Library functions *) +(* <><><><><><><><>< *) + +(* All secret variables will have type int64_al and all public ones will be int32_pl. bwA will be bitwidth of variable A which is substitution *) +(* of TypeA and so on for B and C. bwTemp is the bitwidth of intermediate computation and is substitute for TypeTemp. *) + +(* x should be a power of 2 *) +def int32_pl log(int32_pl x) +{ + for i=[0:64] + { + if ((1L << i) == x) + { + return i; + }; + }; +} + +def int32_pl ceillog(int32_pl x) +{ + for i=[0:65] + { + if ((1L << i) >= x) + { + return i; + }; + }; +} + +def int32_pl ceildiv(int32_pl a, int32_pl b) +{ + int32_pl rem = a % b; + int32_pl ret = a / b; + if (((2*rem)/b) >= 1) + { + ret = ret + 1; + }; + return ret; +} + +(* If number from MSB to LSB is 00110001, then output can be 00100000 as a one-hot vector *) +def void msnzbgetvec(int32_pl NUMBITS, int32_pl batch, int64_al[batch] inp, int64_al[batch*NUMBITS] out) +{ + int64_al left; + int64_al right; + int64_al temp; + + for i=[0:batch] + { + out[i] = 0L; + for j=[0:NUMBITS] + { + left = (1L<<(NUMBITS-1-j)); + right = ((1L<<(NUMBITS-j)) - 1L); + temp = inp[i]; + out[i*NUMBITS + j] = ((temp >= left) && (temp <= right))?(1L):0L; + }; + }; +} + +(* If number from MSB to LSB is 00110001, then output is 5 *) +def void msnzb(int32_pl NUMBITS, int32_pl batch, int64_al[batch] inp, int64_al[batch] out) +{ + int64_al left; + int64_al right; + int64_al temp; + + for i=[0:batch] + { + out[i] = 0L; + for j=[0:NUMBITS] + { + left = (1L<= left) && (temp <= right))?(j+0L):(out[i]); + }; + }; +} + +(* MSB to LSB. MSB at index 0 *) +def void BitDecompose(int32_pl NUMBITS, int32_pl batch, int64_al[batch] inp, int64_al[batch*NUMBITS] outBits) +{ + bool_bl muxCondition; + for i=[0:batch] + { + for j=[0:NUMBITS] + { + muxCondition = ((inp[i] & (1L<<(NUMBITS-1-j))) == (1L<<(NUMBITS-1-j))); + outBits[i*NUMBITS + j] = (muxCondition)?1L:0L; + }; + }; +} + +(* Input a linear array of 2^LUTBITS elements *) +def void LookUpTableArithmeticMUX(int32_pl LUTBITS, int32_pl batch, int32_pl[1<= m *) + int32_pl[1<<(LUTBITS+2)] LUT; + int32_pl[1<> (bwA - 2 - m)) & mMask); + (* TODO call the batched version instead *) + LookUpTableArithmeticMUX(m, 1, LUTPar0, Am, YPar0); + LookUpTableArithmeticMUX(m, 1, LUTPar1, Am, YPar1); + muxCondition = (expParity == 1L); + Y = muxCondition?YPar1[0]:YPar0[0]; + X = muxCondition?(2L * shiftedA):(shiftedA); + (* Scale of XPrev is: (bwA - 2) + (m + 1) = bwA + m - 1 *) + + if(inverse){ + XPrev = Y; + } + else{ + XPrev = (X * Y); + (* make scale = sB *) + if ((bwA + m - 1) > sB) + { + XPrev = XPrev >> (bwA + m - 1 - sB); + } + else + { + XPrev = XPrev << (-1*(bwA + m - 1 - sB)); + }; + }; + + BPrev = X; + (* make scale = sB *) + if ((bwA - 2) > sB) + { + BPrev = BPrev >> (bwA - 2 - sB); + } + else + { + BPrev = BPrev << (-1*(bwA - 2 - sB)); + }; + + (* scale = m + 1 *) + YPrev = Y; + + (* Run iterations now *) + for j=[0:iter] + { + YSquare = YPrev * YPrev; + if (j == 0) + { + BCur = (YSquare * BPrev); + BCur = BCur >> ((2*m) + 2); + } + else + { + YSquare = YSquare >> (sB + 2); + BCur = BPrev * YSquare; + BCur = BCur >> sB; + }; + YCur = (((1L << (sB+1))*3)/2) - BCur; + XCur = XPrev * YCur; + if(inverse && (j == 0)){ + XCur = XCur >> (m + 2); + } + else{ + XCur = XCur >> (sB + 1); + }; + XPrev = XCur; + BPrev = BCur; + YPrev = YCur; + }; + if((iter > 0) || (!inverse)){ + B[i] = (XCur * sqrtAdjust); + B[i] = ((B[i]) >> sqrtAdjustScale); + } + else{ + B[i] = (XCur * sqrtAdjust); + B[i] = ((B[i]) >> (sqrtAdjustScale + 1)); + }; + B[i] = ((B[i]) >> (oldsB - sB)) & bMask; + }; +} + +def void div(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl sC, int32_pl bwA, int32_pl bwB, int32_pl bwC, int64_al[size] A, int64_al[size] B, int64_al[size] C) +{ + int32_pl m; + int32_pl temp; + int32_pl iter; + + if (sC <= 18) + { + m = ceildiv((sC-2), 2); + iter = 1; + } + else + { + temp = ceildiv(sC, 2); + m = ceildiv((temp-2), 2); + iter = 2; + }; + + int64_pl mMask = (1L << m) - 1; + int64_pl cMask = (1L << bwC) - 1; + int64_pl sMinusmMask = (1L << (sB-m)) - 1; + + (* Assumption: LUTBITS >= m *) + int32_pl[1<<(LUTBITS+2)] LUT; + int32_pl[1<> (sB - m)) & mMask; + + (* A0 scale = m+3 *) + (* A1 scale = 2m+2 *) + (* TODO call the batched version instead *) + LookUpTableArithmeticMUX(m, 1, LUTA0, Bm, A0); + LookUpTableArithmeticMUX(m, 1, LUTA1, Bm, A1); + + (* Q scale = sB *) + Q = B[i] & sMinusmMask; + + (* A0Q scale = m+3+sB *) + A0Q = (A0[0]) * Q; + + (* Reciprocal Approximation of B with precision sC *) + (* First make scale of A1 same as A0Q *) + Y = (((A1[0]) << (sB + 1 - m)) -_al A0Q) >> (sB + m + 3 - sC); + + e = (B[i] * Y) >> sB; + (* e0 = 2-e *) + e0 = (1L << (sC + 1)) - e; + a0 = (A[i] * Y) >> sA; + C[i] = (a0 * e0) >> sC; + C[i] = (C[i]) & cMask; + }; +} + +def void exp(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl demote, int32_pl bwA, int32_pl bwB, int64_al[size] A, int64_al[size] B) +{ + int32_pl sDemote = log(demote); + int32_pl digitSize = LUTBITS; + int32_pl numDigits = ceildiv(bwA, digitSize); + int32_pl lastDigitSize = bwA % digitSize; + int64_pl digitMask; + int32_pl m = digitSize; + int32_pl maxScale = 32; + (* Assumption: LUTBITS >= m *) + int32_pl LUTOffset = 0; + for i=[1:m] + { + LUTOffset = LUTOffset + ((maxScale+1)*(1<> (j*digitSize)) & digitMask; + Adigit[0] = Adigits[j]; + curScale = sA - (digitSize*j); + if (curScale < 0){ + negScale = 1; + } + else{ + negScale = 0; + }; + for k=[0:(1<> (30-sB); + }; + + (* TODO call the batched version instead *) + LookUpTableArithmeticMUX(m, 1, LUTA, Adigit, A0); + Adigits[j] = A0[0]; + }; + + int32_pl jvar = 1; + int32_pl kvar = 0; + + for j=[1:numDigits] + { + if (jvar < numDigits) + { + kvar = 0; + for k=[0:numDigits] + { + if ((kvar+jvar) < numDigits) + { + if ((kvar) < numDigits) + { + Adigits[kvar] = (Adigits[kvar+jvar] * Adigits[kvar]) >> sB; + }; + }; + if ((kvar) < numDigits) + { + kvar = kvar + (2*jvar); + }; + }; + jvar = jvar*2; + }; + }; + B[i] = Adigits[0] >> sDemote; + B[i] = (B[i]) & bMask; + + }; + +} + +def void SigmoidImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int64_al[size] A, int64_al[size] B) +{ + int64_al[size] negA; + int64_al[size] expNegA; + int64_al[size] sigNegA; + int64_al[size] den; + int64_al[size] all1; + for i=[0:(size)] + { + negA[i] = ((A[i])<0L)?_bl(A[i]):((-1L)*(A[i])); + }; + + exp(LUTBITS, size, sA, sB, 1, bwA, 32, negA, expNegA); + + for i=[0:(size)] + { + den[i] = ((expNegA[i]) == (1L<= 0L)?_bl(sigNegA[i]):(((expNegA[i]) * (sigNegA[i])) >> sB); + }; +} + +def void TanhImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int64_al[size] A, int64_al[size] B) +{ + int64_al[size] negA; + int64_al[size] expNeg2A; + int64_al[size] tanhNegA; + int64_al[size] den; + int64_al[size] num; + + for i=[0:(size)] + { + negA[i] = ((A[i])<0L)?_bl(A[i]):((-1L)*(A[i])); + }; + + exp(LUTBITS, size, sA - 1, sB, 1, bwA, bwB, negA, expNeg2A); + + for i=[0:(size)] + { + den[i] = ((expNeg2A[i]) == (1L<= 0L)?_bl(tanhNegA[i]):((-1L) * (tanhNegA[i])); + }; +} + +(* <><><><><><><><>< *) +(* Lib functions end *) +(* <><><><><><><><>< *) + + (**************************) def void ScaleUp(int32_pl s1, int64_al[s1] arr, int32_pl sf) diff --git a/Athos/TFEzPCLibrary/Library64_porthos.ezpc b/Athos/TFEzPCLibrary/Library64_porthos.ezpc index 3c0b31f1..19842108 100644 --- a/Athos/TFEzPCLibrary/Library64_porthos.ezpc +++ b/Athos/TFEzPCLibrary/Library64_porthos.ezpc @@ -126,3 +126,12 @@ extern void ConvTranspose3DWrapper(int32_pl N, int32_pl DPrime, int32_pl HPrime, int64_al[FD][FH][FW][CO][CI] filterArr, int32_pl consSF, int64_al[N][D][H][W][CO] outArr); + +def void TanhImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int64_al[size] A, int64_al[size] B) { +} + +def void SigmoidImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int64_al[size] A, int64_al[size] B) { +} + +def void SqrtImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int64_al[size] A, int64_al[size] B) { +} diff --git a/Athos/TFEzPCLibrary/Library64_sci.ezpc b/Athos/TFEzPCLibrary/Library64_sci.ezpc index 5a1a6b35..b6e94725 100644 --- a/Athos/TFEzPCLibrary/Library64_sci.ezpc +++ b/Athos/TFEzPCLibrary/Library64_sci.ezpc @@ -124,3 +124,21 @@ extern void ConvTranspose3DWrapper(int32_pl N, int32_pl DPrime, int32_pl HPrime, int64_al[N][DPrime][HPrime][WPrime][CI] inputArr, int64_al[FD][FH][FW][CO][CI] filterArr, int64_al[N][D][H][W][CO] outArr); + +extern void TanH(int32_pl one, int32_pl size, int32_pl scaleIn, int32_pl scaleOut, int32_pl bwA, int32_pl bwB, int64_al[size] A, int64_al[size] B); + +def void TanhImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int64_al[size] A, int64_al[size] B) { + TanH(1, size, sA, sB, bwA, bwB, A, B); +} + +extern void Sigmoid(int32_pl one, int32_pl size, int32_pl scaleIn, int32_pl scaleOut, int32_pl bwA, int32_pl bwB, int64_al[size] A, int64_al[size] B); + +def void SigmoidImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, int64_al[size] A, int64_al[size] B) { + Sigmoid(1, size, sA, sB, bwA, bwB, A, B); +} + +extern void Sqrt(int32_pl one, int32_pl size, int32_pl scaleIn, int32_pl scaleOut, int32_pl bwA, int32_pl bwB, bool_pl inverse, int64_al[size] A, int64_al[size] B); + +def void SqrtImpl(int32_pl LUTBITS, int32_pl size, int32_pl sA, int32_pl sB, int32_pl bwA, int32_pl bwB, bool_pl inverse, int64_al[size] A, int64_al[size] B) { + Sqrt(1, size, sA, sB, bwA, bwB, inverse, A, B); +} diff --git a/Athos/tests/conftest.py b/Athos/tests/conftest.py index b4a425c1..b98dd894 100644 --- a/Athos/tests/conftest.py +++ b/Athos/tests/conftest.py @@ -25,22 +25,22 @@ import tempfile import shutil import os +import sys def pytest_addoption(parser): parser.addoption( "--backend", action="store", - default="CPP", + choices=["CPP", "3PC", "2PC_HE", "2PC_OT"], help="backend : CPP | 2PC_HE | 2PC_OT | 3PC", + required=True, ) @pytest.fixture(scope="session") def backend(request): opt = request.config.getoption("--backend") - if opt not in ["CPP", "3PC", "2PC_HE", "2PC_OT"]: - opt = "CPP" return opt diff --git a/Athos/tests/tf/unittests/test_arith_binops.py b/Athos/tests/tf/unittests/test_arith_binops.py index b7ee6c33..0c1ffee6 100644 --- a/Athos/tests/tf/unittests/test_arith_binops.py +++ b/Athos/tests/tf/unittests/test_arith_binops.py @@ -171,16 +171,15 @@ def test_div(test_dir, backend, tfOp, a_val, divisor, dtype): reason="[matmul] expect atleast one param to belong to model" ), ), + ([1, 2], [2, 3], False, False, True), ], ) @pytest.mark.parametrize("dtype", [np.single]) def test_matmul( test_dir, backend, a_shape, b_shape, transpose_a, transpose_b, bisModel, dtype ): - if backend == "2PC_HE": - pytest.skip( - "Assertion error in 2PC_HE FCField::matrix_multiplication Assertion `num_cols == 1' failed." - ) + if backend == "2PC_HE" and a_shape[0] != 1: + pytest.skip("HE only supports vector matrix multiplication") graph = tf.Graph() a_inp = dtype(np.random.randn(*a_shape)) b_inp = dtype(np.random.randn(*b_shape)) diff --git a/Athos/tests/tf/unittests/test_non_linear.py b/Athos/tests/tf/unittests/test_non_linear.py index 83da5435..a9e6449e 100644 --- a/Athos/tests/tf/unittests/test_non_linear.py +++ b/Athos/tests/tf/unittests/test_non_linear.py @@ -34,7 +34,6 @@ from tests.utils import Config, Compiler, assert_almost_equal -@pytest.mark.skip(reason="[non-linear] Haven't made non-linear functionalities public") @pytest.mark.parametrize("a_shape", [[4, 4], [1], []]) @pytest.mark.parametrize("dtype", [np.single]) @pytest.mark.parametrize( @@ -48,8 +47,27 @@ ], ) def test_non_linear(test_dir, backend, tfOp, a_shape, dtype): + if backend not in ["2PC_OT", "CPP"] and tfOp in [ + tf.math.sqrt, + tf.math.rsqrt, + tf.math.sigmoid, + tf.math.tanh, + ]: + pytest.skip( + "Operation {op} not supported for backend {backend}".format( + op=tfOp.__name__, backend=backend + ) + ) + if a_shape == []: + pytest.skip( + "[Athos] Missing Support for tan/sig/sqrt/relu of scalar (0-d) variables" + ) + graph = tf.Graph() a_inp = dtype(np.random.randn(*a_shape)) + if tfOp in [tf.math.sqrt, tf.math.rsqrt]: + a_inp = np.abs(a_inp) + with graph.as_default(): a = tf.compat.v1.placeholder(tf.as_dtype(dtype), shape=a_inp.shape, name="a") output = tfOp(a, name="output") @@ -57,6 +75,7 @@ def test_non_linear(test_dir, backend, tfOp, a_shape, dtype): expected_output = sess.run(output, feed_dict={a: a_inp}) assert expected_output is not None config = Config(backend).add_input(a).add_output(output) + config.config["scale"] = 12 compiler = Compiler(graph, config, test_dir) mpc_output = compiler.compile_and_run([a_inp]) assert_almost_equal(tf_output=expected_output, mpc_tensor=mpc_output, precision=2) diff --git a/Athos/tests/utils.py b/Athos/tests/utils.py index bc975621..76be2681 100644 --- a/Athos/tests/utils.py +++ b/Athos/tests/utils.py @@ -75,7 +75,7 @@ def add_input(self, tensor_op): return self def add_output(self, tensor_op): - output_name = tensor_op.op.name + output_name = tensor_op.name outputs = self.config.get("output_tensors") if outputs == None: self.config["output_tensors"] = [output_name] @@ -169,13 +169,13 @@ def run(self, inputs, timeoutSeconds): util_dir = os.path.dirname(os.path.abspath(__file__)) sci_dir = os.path.join(util_dir, "..", "..", "SCI") port = 1234 - client_cmd = "{program} r=2 p={port} < {input} > {output}".format( + client_cmd = "{program} r=2 port={port} < {input} > {output}".format( program=self.program_path, port=port, input=inputs_scaled, output=raw_output, ) - server_cmd = "{program} r=1 p={port} < {input} > /dev/null".format( + server_cmd = "{program} r=1 port={port} < {input} > /dev/null".format( program=self.program_path, port=port, input=self.model_weight_path, diff --git a/EzPC/EzPC/codegensci.ml b/EzPC/EzPC/codegensci.ml index b598e61f..2f81d77e 100644 --- a/EzPC/EzPC/codegensci.ml +++ b/EzPC/EzPC/codegensci.ml @@ -259,6 +259,29 @@ let o_typ (t:typ) :comp = | Array (_,_, _) -> seq (o_typ_rec t) (o_str "*") | _ -> o_typ_rec t + +let o_basetyp_func_decl (t:base_type) :comp = + match t with + | UInt32 -> o_str "uint32_t" + | UInt64 -> o_str "uint64_t" + | Int32 -> o_str "int32_t" + | Int64 -> o_str "int64_t" + | Bool -> o_str "uint32_t" + +let rec o_typ_rec_func_decl (t:typ) :comp = + let uint32_basetype_str :string = "uint32_t" in + match t.data with + | Base (Int64, Some (Secret _)) -> o_str "uint64_t" + | Base (Int32, Some (Secret _)) -> o_str uint32_basetype_str + | Base (_, Some (Secret _)) -> failwith "Codegen: For secret shared variables, only int64 is allowed by this backend." + | Base (bt, _) -> o_basetyp_func_decl bt + | Array (quals,tt, _) -> seq (if quals |> List.mem Immutable then o_str "const " else o_null) (o_typ_rec tt) + +let o_typ_func_decl (t:typ) :comp = + match t.data with + | Array (_,_, _) -> seq (o_typ_rec t) (o_str "*") + | _ -> o_typ_rec_func_decl t + let o_ret_typ (t:ret_typ) :comp = match t with | Typ t -> o_typ t @@ -505,8 +528,8 @@ and o_codegen_stmt (g:gamma) (s:codegen_stmt) :comp * gamma = | _ -> failwith "o_codegen_stmt: impossible case" let o_binder (b:binder) :comp = - let o_typ (t:typ) :comp = o_typ t in - seq (b |> snd |> o_typ) (seq o_space (b |> fst |> o_var)) + let o_typ_func_decl (t:typ) :comp = o_typ_func_decl t in + seq (b |> snd |> o_typ_func_decl) (seq o_space (b |> fst |> o_var)) let o_global (g0:gamma) (d:global) :comp * gamma = match d.data with @@ -532,47 +555,20 @@ This is an autogenerated file, generated using the EzPC compiler.\n\ let porthos_prelude_string (hash_define_str:string) :string = let bitlen = Config.get_actual_bitlen () |> string_of_int in "\n\ -#define BITLEN_" -^ -bitlen -^ -"\n\ -#define " -^ -hash_define_str -^ -" -\n\ - -#include \"globals.h\"\n\ -#include \"functionalities_wrapper.h\"\n\ +#include \"library_fixed.h\"\n\ #include \n\ using namespace std;\n\ \n\ -template\n\ -T* make_array(size_t s1){\n\ - return new T[s1];\n\ -}\n\ -\n\ -template\n\ -T* make_array(size_t s1, size_t s2){\n\ - return new T[s1*s2];\n\ -}\n\ -\n\ -template\n\ -T* make_array(size_t s1, size_t s2, size_t s3){\n\ - return new T[s1*s2*s3];\n\ -}\n\ -\n\ -template\n\ -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){\n\ - return new T[s1*s2*s3*s4];\n\ -}\n\ +int party = 0;\n\ +int port = 32000;\n\ +string address = \"127.0.0.1\";\n\ +int num_threads = 4;\n\ +int32_t bitlength = " +^ +bitlen +^ +";\n\ \n\ -template\n\ -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){\n\ - return new T[s1*s2*s3*s4*s5];\n\ -}\n\ " let porthos_main_decl :string = @@ -585,100 +581,15 @@ int main(int argc, char** argv)\n\ let porthos_main_prelude_string :string = "\ ArgMapping amap;\n\ -int port = 32000;\n\ -string serverAddr = \"127.0.0.1\";\n\ -\n\ amap.arg(\"r\", party, \"Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2\");\n\ -amap.arg(\"p\", port, \"Port Number\");\n\ -amap.arg(\"ip\", serverAddr, \"IP Address of server (ALICE)\");\n\ +amap.arg(\"port\", port, \"Port Number\");\n\ +amap.arg(\"ip\", address, \"IP Address of server (ALICE)\");\n\ +amap.arg(\"nt\", num_threads, \"Number of Threads\");\n\ +amap.arg(\"ell\", bitlength, \"Uniform Bitwidth\");\n\ amap.parse(argc, argv);\n\ \n\ -assert(party==sci::ALICE || party==sci::BOB);\n\ -\n\ -checkIfUsingEigen();\n\ -for(int i=0;i(ioArr[i]);\n\ -prgInstanceArr[i] = new sci::PRG128();\n\ -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]);\n\ -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr);\n\ -if (i == 0) {\n\ -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength);\n\ -} \n\ -else if (i == 1) {\n\ -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength);\n\ -} \n\ -else if (i & 1) {\n\ -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false);\n\ -otpackArr[i]->copy(otpackArr[1]);\n\ -} \n\ -else {\n\ -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false);\n\ -otpackArr[i]->copy(otpackArr[0]);\n\ -}\n\ -}\n\ -\n\ -io = ioArr[0];\n\ -iknpOT = new sci::IKNP(io);\n\ -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good\n\ -kkot = new sci::KKOT(io);\n\ -prg128Instance = new sci::PRG128();\n\ -otpack = new sci::OTPack(io, party, baseForRelu, bitlength);\n\ -\n\ -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed);\n\ -\n\ -\n\ -#ifdef SCI_OT\n\ -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack);\n\ -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl);\n\ -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl);\n\ -#endif\n\ -\n\ -#ifdef SCI_HE\n\ -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack);\n\ -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl);\n\ -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl);\n\ -heConvImpl = new ConvField(party,io);\n\ -heFCImpl = new FCField(party,io);\n\ -heProdImpl = new ElemWiseProdField(party, io);\n\ -assertFieldRun();\n\ -#endif\n\ -#ifdef MULTITHREADED_NONLIN\n\ -#ifdef SCI_OT\n\ -for(int i = 0; i < numThreads; i++) {\n\ -if (i & 1) {\n\ -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]);\n\ -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]);\n\ -} \n\ -else {\n\ -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]);\n\ -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]);\n\ -}\n\ -}\n\ -#endif\n\ -#ifdef SCI_HE\n\ -for(int i = 0; i < numThreads; i++) {\n\ -if (i & 1) {\n\ -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]);\n\ -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]);\n\ -} \n\ -else {\n\ -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]);\n\ -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]);\n\ -}\n\ -}\n\ -#endif\n\ -#endif\n\ +assert(party==SERVER || party==CLIENT);\n\ \n\ -if (party==sci::ALICE){\n\ -iknpOT->setup_send();\n\ -iknpOTRoleReversed->setup_recv();\n\ -}\n\ -else if (party==sci::BOB){\n\ -iknpOT->setup_recv();\n\ -iknpOTRoleReversed->setup_send();\n\ -}\n\ -cout<<\"After base ots, communication = \"<<(io->counter)<<\" bytes\"<` on Linux. +SEAL and Eigen are included in `extern/` and are automatically compiled and installed if not found. The other packages can be installed directly using `sudo apt-get install ` on Linux. ## Compilation @@ -20,9 +20,8 @@ To compile the library: ``` mkdir build && cd build -cmake .. [-DBUILD_TESTS=ON] [-DBUILD_NETWORKS=ON] -make -// or make -j for faster compilation +cmake -DCMAKE_INSTALL_PREFIX=./install .. [-DBUILD_TESTS=ON] [-DBUILD_NETWORKS=ON] +cmake --build . --target install --parallel ``` ## Running Tests & Networks @@ -31,13 +30,13 @@ On successful compilation, the test and network binaries will be created in `bui Run the tests as follows to make sure everything works as intended: -`./ r=1 [p=port] & ./ r=2 [p=port]` +`./ r=1 [port=port] & ./ r=2 [port=port]` To run secure inference on networks: ``` -./ r=1 [p=port] < // Server -./ r=2 [ip=server_address] [p=port] < // Client +./ r=1 [port=port] < // Server +./ r=2 [ip=server_address] [port=port] < // Client ``` # Acknowledgements diff --git a/SCI/cmake/SCIConfig.cmake.in b/SCI/cmake/SCIConfig.cmake.in new file mode 100644 index 00000000..18c14450 --- /dev/null +++ b/SCI/cmake/SCIConfig.cmake.in @@ -0,0 +1,23 @@ +include(CMakeFindDependencyMacro) + +@PACKAGE_INIT@ + +set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}) +include("${CMAKE_CURRENT_LIST_DIR}/source_of_randomness.cmake") + +find_dependency(OpenSSL REQUIRED) +find_dependency(GMP REQUIRED) +find_dependency(Threads REQUIRED) + +set_and_check(INSTALL_DIR "@PACKAGE_INSTALL_DIR@") +find_dependency(Eigen3 REQUIRED PATHS "${INSTALL_DIR}") +find_dependency(SEAL REQUIRED PATHS "${INSTALL_DIR}") +find_dependency(OpenMP REQUIRED) + +# Add the targets file +include("${CMAKE_CURRENT_LIST_DIR}/SCITargets.cmake") + +if(USE_RANDOM_DEVICE) + target_compile_definitions(SCI-utils INTERFACE EMP_USE_RANDOM_DEVICE=1) +endif(USE_RANDOM_DEVICE) + diff --git a/SCI/cmake/install_EMP.cmake b/SCI/cmake/install_EMP.cmake new file mode 100644 index 00000000..5fdcbda0 --- /dev/null +++ b/SCI/cmake/install_EMP.cmake @@ -0,0 +1,49 @@ +if (NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/EMP/emp-tool/CMakeLists.txt") + find_package(Git REQUIRED) + message(STATUS "initialize Git submodule: extern/EMP/emp-tool") + execute_process(COMMAND git submodule update --init --recursive extern/EMP/emp-tool + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}") +endif () +execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory build + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/EMP/emp-tool") +execute_process(COMMAND ${CMAKE_COMMAND} -DTHREADING=ON + -DCMAKE_INSTALL_PREFIX=${PROJECT_SOURCE_DIR}/build .. + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/EMP/emp-tool/build") +execute_process(COMMAND make install + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/EMP/emp-tool/build") +find_package(emp-tool REQUIRED PATHS "${PROJECT_SOURCE_DIR}/build/" NO_DEFAULT_PATH) +message(STATUS "emp-tool installed: ${emp-tool_FOUND}") + +if (NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/EMP/emp-ot/CMakeLists.txt") + find_package(Git REQUIRED) + message(STATUS "initialize Git submodule: extern/EMP/emp-ot") + execute_process(COMMAND git submodule update --init --recursive extern/EMP/emp-ot + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}") +endif () +execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory build + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/EMP/emp-ot") +execute_process(COMMAND ${CMAKE_COMMAND} -DTHREADING=ON + -DCMAKE_INSTALL_PREFIX=${PROJECT_SOURCE_DIR}/build .. + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/EMP/emp-ot/build") +execute_process(COMMAND make install + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/EMP/emp-ot/build") +message(STATUS "${PROJECT_SOURCE_DIR}") +find_package(emp-ot REQUIRED PATHS "${PROJECT_SOURCE_DIR}/build/" NO_DEFAULT_PATH) +message(STATUS "emp-ot installed: ${emp-ot_FOUND}") + +if (NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/EMP/emp-sh2pc/CMakeLists.txt") + find_package(Git REQUIRED) + message(STATUS "initialize Git submodule: extern/EMP/emp-sh2pc") + execute_process(COMMAND git submodule update --init --recursive extern/EMP/emp-sh2pc + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}") +endif () +execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory build + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/EMP/emp-sh2pc") +execute_process(COMMAND ${CMAKE_COMMAND} -DTHREADING=ON + -DCMAKE_INSTALL_PREFIX=${PROJECT_SOURCE_DIR}/build .. + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/EMP/emp-sh2pc/build") +execute_process(COMMAND make install + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/EMP/emp-sh2pc/build") +message(STATUS "${PROJECT_SOURCE_DIR}") +find_package(emp-sh2pc REQUIRED PATHS "${PROJECT_SOURCE_DIR}/build/" NO_DEFAULT_PATH) +message(STATUS "emp-sh2pc installed: ${emp-sh2pc_FOUND}") diff --git a/SCI/cmake/install_Eigen3.cmake b/SCI/cmake/install_Eigen3.cmake new file mode 100644 index 00000000..3c5ee19a --- /dev/null +++ b/SCI/cmake/install_Eigen3.cmake @@ -0,0 +1,18 @@ +find_package(Eigen3 3.3 NO_MODULE QUIET) +if (NOT Eigen3_FOUND) + message(STATUS "Eigen 3.3 was not found: clone and install Eigen3 locally") + if (NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/eigen/CMakeLists.txt") + find_package(Git REQUIRED) + message(STATUS "initialize Git submodule: extern/eigen") + execute_process(COMMAND git submodule update --init --recursive extern/eigen + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}") + endif () + execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory build + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/eigen/") + execute_process(COMMAND ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=${PROJECT_SOURCE_DIR}/build .. + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/eigen/build") + execute_process(COMMAND ${CMAKE_COMMAND} --build .. --target install + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/eigen/build") + message(STATUS "${PROJECT_SOURCE_DIR}") + find_package(Eigen3 3.3 REQUIRED NO_MODULE PATHS "${PROJECT_SOURCE_DIR}/build/") +endif () diff --git a/SCI/networks/CMakeLists.txt b/SCI/networks/CMakeLists.txt index 9023a7c8..814d72b1 100644 --- a/SCI/networks/CMakeLists.txt +++ b/SCI/networks/CMakeLists.txt @@ -1,17 +1,25 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) -macro (add_network _name) - add_executable(${_name} "main_${_name}.cpp") - target_link_libraries(${_name} SCI-Protocols) +macro (add_network_OT _name) + add_executable(${_name}-OT "main_${_name}.cpp") + target_link_libraries(${_name}-OT SCI-OT) + target_compile_options(${_name}-OT PUBLIC "-Wno-parentheses-equality") +endmacro() + +macro (add_network_HE _name) + add_executable(${_name}-HE "main_${_name}.cpp") + target_link_libraries(${_name}-HE SCI-HE) + target_compile_options(${_name}-HE PUBLIC "-Wno-parentheses-equality") endmacro() # Networks -add_network(densenet121_field64) -add_network(densenet121_ring32) -add_network(resnet50_field64) -add_network(resnet50_ring32) -add_network(sqnet_ring32) -add_network(sqnet_field64) -add_network(minionn_ring32) -add_network(minionn_field64) -add_network(resnet32_cifar_field64) +add_network_HE(sqnet) +add_network_OT(sqnet) +add_network_HE(resnet50) +add_network_OT(resnet50) +add_network_HE(densenet121) +add_network_OT(densenet121) +add_network_HE(minionn) +add_network_OT(minionn) +add_network_HE(resnet32_cifar) +add_network_OT(resnet32_cifar) diff --git a/SCI/networks/main_densenet121.cpp b/SCI/networks/main_densenet121.cpp new file mode 100644 index 00000000..704c0e09 --- /dev/null +++ b/SCI/networks/main_densenet121.cpp @@ -0,0 +1,14064 @@ +/* +This is an autogenerated file, generated using the EzPC compiler. +*/ + +#include "library_fixed.h" +#include +using namespace std; + +int party = 0; +int port = 32000; +string address = "127.0.0.1"; +int num_threads = 4; +int32_t bitlength = 32; + +void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + SecretAdd(Arr2DIdxRowM(A, s1, s2, i1, i2), Arr1DIdxRowM(B, s2, i2)); + } + } +} + +void MatAdd2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = SecretAdd( + Arr2DIdxRowM(A, s1, s2, i1, i2), Arr2DIdxRowM(B, s1, s2, i1, i2)); + } + } +} + +void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr1DIdxRowM(B, s4, i4)); + } + } + } + } +} + +void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *A, + uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr4DIdxRowM(B, s1, s2, s3, s4, i1, i2, i3, i4)); + } + } + } + } +} + +void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr1DIdxRowM(B, s5, i5)); + } + } + } + } + } +} + +void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr5DIdxRowM(B, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5)); + } + } + } + } + } +} + +void CreateTensor1(int64_t s1, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(arr, s1, i1) = val; + } +} + +void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(arr, s1, s2, i1, i2) = val; + } + } +} + +void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = val; + } + } + } +} + +void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = val; + } + } + } + } +} + +void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(arr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = val; + } + } + } + } + } +} + +void CopyTensor1(int64_t s1, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(targetArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CopyTensor2(int64_t s1, int64_t s2, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(targetArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t *targetArr, + uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(targetArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *targetArr, uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(targetArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateIdentity11(int64_t s1, uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(newArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CreateIdentity22(int64_t s1, int64_t s2, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(newArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(newArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(newArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, + uint64_t *inArr, int64_t perDimSize, int64_t *beginIdx, + int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = + Arr2DIdxRowM(inArr, inps1, inps2, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j)); + } + } +} + +void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inArr, int64_t perDimSize, + int64_t *beginIdx, int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM( + inArr, inps1, inps2, inps3, inps4, inps5, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)2) + k), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)3) + l), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)4) + m)); + } + } + } + } + } +} + +void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, + uint64_t *inp1, int64_t inp2s1, int64_t inp2s2, uint64_t *inp2, + int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, (i1 - inp1s1), i2); + } + } else { + if ((i2 < inp1s2)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, i1, (i2 - inp1s2)); + } + } + } + } +} + +void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, + int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t *inp1, + int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, + uint64_t *inp2, int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = Arr4DIdxRowM( + inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, + (i1 - inp1s1), i2, i3, i4); + } + } else { + if ((axis == (int32_t)1)) { + if ((i2 < inp1s2)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, + (i2 - inp1s2), i3, i4); + } + } else { + if ((axis == (int32_t)2)) { + if ((i3 < inp1s3)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + (i3 - inp1s3), i4); + } + } else { + if ((i4 < inp1s4)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + i3, (i4 - inp1s4)); + } + } + } + } + } + } + } + } +} + +void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, + int64_t I2, int64_t I3, int64_t I4, uint64_t *inp, int64_t axis, + int64_t curCount, int64_t total, uint64_t *out) { + for (uint64_t o1 = (int32_t)0; o1 < O1; o1++) { + for (uint64_t o2 = (int32_t)0; o2 < O2; o2++) { + for (uint64_t o3 = (int32_t)0; o3 < O3; o3++) { + for (uint64_t o4 = (int32_t)0; o4 < O4; o4++) { + + int64_t i1 = o1; + + int64_t i2 = o2; + + int64_t i3 = o3; + + int64_t i4 = o4; + if ((axis == (int32_t)0)) { + i1 = (((I1 / total) * curCount) + o1); + } + if ((axis == (int32_t)1)) { + i2 = (((I2 / total) * curCount) + o2); + } + if ((axis == (int32_t)2)) { + i3 = (((I3 / total) * curCount) + o3); + } + if ((axis == (int32_t)3)) { + i4 = (((I4 / total) * curCount) + o4); + } + Arr4DIdxRowM(out, O1, O2, O3, O4, o1, o2, o3, o4) = + Arr4DIdxRowM(inp, I1, I2, I3, I4, i1, i2, i3, i4); + } + } + } + } +} + +void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CI, CO, fh, fw, ci, co); + } + } + } + } +} + +void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int32_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); + Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, reshapedIPRows, + reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideH, int64_t strideW, int64_t outH, + int64_t outW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t GIS = (CI / G); + + int64_t GOS = (CO / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t cog = (int32_t)0; cog < GOS; cog++) { + for (uint64_t cig = (int32_t)0; cig < GIS; cig++) { + for (uint64_t g = (int32_t)0; g < G; g++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + + uint64_t val = funcSSCons((int32_t)0); + + int64_t ci = ((GIS * g) + cig); + + int64_t co = ((GOS * g) + cog); + + int64_t curPosH = ((strideH * h) - zPadHLeft); + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + + int64_t curPosW = ((strideW * w) - zPadWLeft); + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && + (curPosH < H)) && + (curPosW < W))) { + val = SecretAdd( + val, + SecretMult(Arr4DIdxRowM(inputArr, N, H, W, CI, n, + curPosH, curPosW, ci), + Arr4DIdxRowM(filterArr, FH, FW, (CI / G), CO, + fh, fw, (ci / G), co))); + } + curPosW = (curPosW + (int32_t)1); + } + curPosH = (curPosH + (int32_t)1); + } + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co) = SecretAdd( + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co), val); + } + } + } + } + } + } +} + +void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, outH, outW, G, inputArr, + filterArr, outArr); +} + +void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + int64_t g, int64_t G, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t CIG = (CI / G); + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + + int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); + Arr2DIdxRowM(outputArr, (CO / G), ((FH * FW) * (CI / G)), co, + linIdx) = Arr4DIdxRowM(inputArr, FH, FW, (CI / G), CO, + fh, fw, ci, (co + startCO)); + } + } + } + } +} + +void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, int64_t g, int64_t G, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, + (co + startCO)) = + Arr2DIdxRowM(inputArr, (CO / G), ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, + int64_t FH, int64_t FW, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t g, int64_t G, + int64_t RRows, int64_t RCols, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + + int64_t CIG = (CI / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + + int64_t startCI = (g * CIG); + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int32_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + (ci + startCI)); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CIG) + (fw * CIG)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t CIG = (CI / G); + + int64_t reshapedFilterRows = (CO / G); + + int64_t reshapedFilterCols = ((FH * FW) * CIG); + + int64_t reshapedIPRows = ((FH * FW) * CIG); + + int64_t outH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t outW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * outH) * outW); + for (uint64_t g = (int32_t)0; g < G; g++) { + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = + make_array(reshapedFilterRows, reshapedIPCols); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); + Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, + zPadWLeft, zPadWRight, strideH, strideW, g, G, + reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + } +} + +void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, + int64_t CO, uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CI, CO, fd, fh, fw, ci, co); + } + } + } + } + } +} + +void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, + int64_t finalW, int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t d = (int32_t)0; d < finalD; d++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr5DIdxRowM(outputArr, N, finalD, finalH, finalW, CO, n, d, h, w, + co) = + Arr2DIdxRowM(inputArr, CO, (((N * finalD) * finalH) * finalW), + co, + ((((((n * finalD) * finalH) * finalW) + + ((d * finalH) * finalW)) + + (h * finalW)) + + w)); + } + } + } + } + } +} + +void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideD, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadDLeft); + + int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= D)) || + ((curPosH < (int32_t)0) || (curPosH >= H))) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int32_t)0); + } else { + val = Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, curPosD, + curPosH, curPosW, ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + + leftTopCornerD = (leftTopCornerD + strideD); + } + } +} + +void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, + int64_t strideH, int64_t strideW, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t newD = + ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = (((N * newD) * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); + Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); + fd++) { + for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); + fh++) { + for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); + fw++) { + + int64_t curPosD = (fd - zPadDLeft); + + int64_t curPosH = (fh - zPadHLeft); + + int64_t curPosW = (fw - zPadWLeft); + if (((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W))) { + + int64_t curFilterPosD = (fd - (d * strideD)); + + int64_t curFilterPosH = (fh - (h * strideH)); + + int64_t curFilterPosW = (fw - (w * strideW)); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CI, CO, + curFilterPosD, curFilterPosH, + curFilterPosW, ci, co))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, uint64_t *outArr) { + + int64_t outD = + ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, outD, outH, outW, inputArr, filterArr, + outArr); +} + +void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, + int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CO, CI, ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } +} + +void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FH, int64_t FW, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = funcSSCons((int32_t)0); + } else { + if ((((curPosH % strideH) == (int32_t)0) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = Arr4DIdxRowM(inputArr, N, HPrime, WPrime, CI, n, + idxInputH, idxInputW, ci); + } else { + val = funcSSCons((int32_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + } +} + +void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, + int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t reshapedIPCols = ((N * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, + zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CO, CI, + ((FD - (int32_t)1) - fd), ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } + } +} + +void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadTrDLeft); + + int64_t DPrimeTilde = + (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); + + int64_t extremeRightBottomCornerD = + ((DPrimeTilde - (int32_t)1) + zPadTrDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || + ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = funcSSCons((int32_t)0); + } else { + if (((((curPosD % strideD) == (int32_t)0) && + ((curPosH % strideH) == (int32_t)0)) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputD = (curPosD / strideD); + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = + Arr5DIdxRowM(inputArr, N, DPrime, HPrime, WPrime, CI, + n, idxInputD, idxInputH, idxInputW, ci); + } else { + val = funcSSCons((int32_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + + leftTopCornerD = (leftTopCornerD + (int32_t)1); + } + } +} + +void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t reshapedIPCols = (((N * D) * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose3DReshapeInput( + N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, + zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, + int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t fd = d; fd < (d + FD); fd++) { + for (uint64_t fh = h; fh < (h + FH); fh++) { + for (uint64_t fw = w; fw < (w + FW); fw++) { + + int64_t curPosD = ((fd - zPadDLeft) / strideD); + + int64_t curPosH = ((fh - zPadHLeft) / strideD); + + int64_t curPosW = ((fw - zPadWLeft) / strideD); + if ((((((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W)) && + (((fd - zPadDLeft) % strideD) == (int32_t)0)) && + (((fh - zPadHLeft) % strideH) == (int32_t)0)) && + (((fw - zPadWLeft) % strideW) == (int32_t)0))) { + + int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); + + int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); + + int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CO, CI, + curFilterPosD, curFilterPosH, + curFilterPosW, co, ci))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, + int64_t FW, int64_t CO, int64_t D, int64_t H, + int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, + zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, + zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, + D, H, W, inputArr, filterArr, outArr); +} + +void Transpose2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = Arr2DIdxRowM(inArr, s2, s1, j, i); + } + } +} + +void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, + int64_t inps2, int64_t inps3, int64_t inps4, uint64_t *inpArr, + int64_t pads1, int64_t pads2, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = + Arr4DIdxRowM(inpArr, inps1, inps2, inps3, inps4, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0))); + } else { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = + funcSSCons((int32_t)0); + } + } + } + } + } +} + +void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inpArr, int64_t pads1, int64_t pads2, + int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + + int64_t lbounds5 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)0); + + int64_t rbounds5excl = + (s5 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl)) && + (m >= lbounds5)) && + (m < rbounds5excl))) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM(inpArr, inps1, inps2, inps3, inps4, inps5, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0)), + (m - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)4, (int32_t)0))); + } else { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + funcSSCons((int32_t)0); + } + } + } + } + } + } +} + +void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, + int64_t i2, int64_t i3, int64_t i4, uint64_t *inpArr, + int64_t pads, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = Arr1DIdxRowM(paddings, pads, (int32_t)0); + + int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings, pads, (int32_t)4)); + + int64_t lbounds2 = Arr1DIdxRowM(paddings, pads, (int32_t)1); + + int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings, pads, (int32_t)5)); + + int64_t lbounds3 = Arr1DIdxRowM(paddings, pads, (int32_t)2); + + int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings, pads, (int32_t)6)); + + int64_t lbounds4 = Arr1DIdxRowM(paddings, pads, (int32_t)3); + + int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings, pads, (int32_t)7)); + for (uint64_t i = (int32_t)0; i < o1; i++) { + for (uint64_t j = (int32_t)0; j < o2; j++) { + for (uint64_t k = (int32_t)0; k < o3; k++) { + for (uint64_t l = (int32_t)0; l < o4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = + Arr4DIdxRowM(inpArr, i1, i2, i3, i4, + (i - Arr1DIdxRowM(paddings, pads, (int32_t)0)), + (j - Arr1DIdxRowM(paddings, pads, (int32_t)1)), + (k - Arr1DIdxRowM(paddings, pads, (int32_t)2)), + (l - Arr1DIdxRowM(paddings, pads, (int32_t)3))); + } else { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = + funcSSCons((int32_t)0); + } + } + } + } + } +} + +void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < ins1; i++) { + for (uint64_t j = (int32_t)0; j < ins2; j++) { + for (uint64_t k = (int32_t)0; k < ins3; k++) { + for (uint64_t l = (int32_t)0; l < ins4; l++) { + + int64_t linIdx = + ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + + (k * ins4)) + + l); + + int64_t outIdx1 = (linIdx / s2); + + int64_t outIdx2 = (linIdx % s2); + Arr2DIdxRowM(outArr, s1, s2, outIdx1, outIdx2) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i, j, k, l); + } + } + } + } +} + +void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *inArr, uint64_t *multArr, uint64_t *biasArr, + int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, + uint64_t *outputArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s4, i4); + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s4); + for (uint64_t ii = (int32_t)0; ii < s4; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s4, ii) = Arr1DIdxRowM(biasArr, s4, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outputArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s4, i4)); + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s4, biasArrScaledUp); +} + +void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *inArr, uint64_t *multArr, + uint64_t *biasArr, int64_t multExprScaleDownSf, + int64_t biasExprScaleUpSf, uint64_t *outputArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s5, i5); + } + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s5); + for (uint64_t ii = (int32_t)0; ii < s5; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s5, ii) = Arr1DIdxRowM(biasArr, s5, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outputArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s5, i5)); + } + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s5, biasArrScaledUp); +} + +void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t *arr1, uint64_t *arr2, + uint64_t *outArr) { + + int64_t inpSize = (s1 * s2); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr1, s1, s2, i1, i2); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr2, s1, s2, i1, i2); + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr1, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr2, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr1, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr2, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, int64_t *axes, + uint64_t *outputArr) { + + int64_t divisor = (inS2 * inS3); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = funcSSCons((int32_t)0); + for (uint64_t i = (int32_t)0; i < inS2; i++) { + for (uint64_t j = (int32_t)0; j < inS3; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i, j, i2)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, + int64_t axis1, int64_t axis2, uint64_t *outputArr) { + + int64_t divisor = (inS3 * inS4); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = funcSSCons((int32_t)0); + for (uint64_t i = (int32_t)0; i < inS3; i++) { + for (uint64_t j = (int32_t)0; j < inS4; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i2, i, j)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, + uint64_t *inArr, int64_t dim, uint64_t *outArr) { + ArgMax(inArrS1, inArrS2, inArr, outArr); +} + +void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + int64_t dim, uint64_t *outArr) { + + int64_t size = ((ins1 * ins2) * ins3); + + uint64_t *reshapedInArr = make_array(size, ins4); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr2DIdxRowM(reshapedInArr, size, ins4, linIdx, i4) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i1, i2, i3, i4); + } + } + } + } + ArgMax(size, ins4, reshapedInArr, reshapedOutArr); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr3DIdxRowM(outArr, outs1, outs2, outs3, i1, i2, i3) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + ClearMemSecret2(size, ins4, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf, uint64_t doTruncation) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *inArr, + uint64_t *outArr, int64_t sf, uint64_t doTruncation) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *inArr, uint64_t *outArr, int64_t sf, + uint64_t doTruncation) { + + int64_t size = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Floor2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Floor(size, reshapedInArr, reshapedOutArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void ScaleUp1(int64_t s1, uint64_t *arr, int64_t sf) { ScaleUp(s1, arr, sf); } + +void ScaleUp2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown1(int64_t s1, uint64_t *arr, int64_t sf) { + ScaleDown(s1, arr, sf); +} + +void ScaleDown2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +int main(int argc, char **argv) { + ArgMapping amap; + + amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); + amap.arg("port", port, "Port Number"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + amap.arg("nt", num_threads, "Number of Threads"); + amap.arg("ell", bitlength, "Uniform Bitwidth"); + amap.parse(argc, argv); + + assert(party == SERVER || party == CLIENT); + + uint64_t *tmp0 = + make_array((int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3); + /* Variable to read the clear value corresponding to the input variable tmp0 + * at (1930,1-1930,46) */ + uint64_t __tmp_in_tmp0; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)224; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)224; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)3; i3++) { + if ((party == CLIENT)) { + cin >> __tmp_in_tmp0; + } + Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, + i0, i1, i2, i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; + } + } + } + } + + uint64_t *tmp1 = + make_array((int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp1 + * at (1933,1-1933,43) */ + uint64_t __tmp_in_tmp1; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)7; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)7; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)3; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp1; + } + Arr4DIdxRowM(tmp1, (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; + } + } + } + } + + uint64_t *tmp2 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp2 + * at (1936,1-1936,34) */ + uint64_t __tmp_in_tmp2; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp2; + } + Arr1DIdxRowM(tmp2, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; + } + + uint64_t *tmp3 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp3 + * at (1939,1-1939,34) */ + uint64_t __tmp_in_tmp3; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp3; + } + Arr1DIdxRowM(tmp3, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp3 : 0; + } + + uint64_t *tmp4 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp4 + * at (1942,1-1942,34) */ + uint64_t __tmp_in_tmp4; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp4; + } + Arr1DIdxRowM(tmp4, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; + } + + uint64_t *tmp5 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp5 + * at (1945,1-1945,34) */ + uint64_t __tmp_in_tmp5; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp5; + } + Arr1DIdxRowM(tmp5, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp5 : 0; + } + + uint64_t *tmp6 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp6 + * at (1948,1-1948,34) */ + uint64_t __tmp_in_tmp6; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp6; + } + Arr1DIdxRowM(tmp6, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp6 : 0; + } + + uint64_t *tmp7 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp7 + * at (1951,1-1951,34) */ + uint64_t __tmp_in_tmp7; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp7; + } + Arr1DIdxRowM(tmp7, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp7 : 0; + } + + uint64_t *tmp8 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp8 + * at (1954,1-1954,34) */ + uint64_t __tmp_in_tmp8; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp8; + } + Arr1DIdxRowM(tmp8, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; + } + + uint64_t *tmp9 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp9 + * at (1957,1-1957,34) */ + uint64_t __tmp_in_tmp9; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp9; + } + Arr1DIdxRowM(tmp9, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; + } + + uint64_t *tmp10 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp10 + * at (1960,1-1960,46) */ + uint64_t __tmp_in_tmp10; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp10; + } + Arr4DIdxRowM(tmp10, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)128, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp10 : 0; + } + } + } + } + + uint64_t *tmp11 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp11 + * at (1963,1-1963,36) */ + uint64_t __tmp_in_tmp11; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp11; + } + Arr1DIdxRowM(tmp11, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp11 : 0; + } + + uint64_t *tmp12 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp12 + * at (1966,1-1966,36) */ + uint64_t __tmp_in_tmp12; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp12; + } + Arr1DIdxRowM(tmp12, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp12 : 0; + } + + uint64_t *tmp13 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp13 + * at (1969,1-1969,36) */ + uint64_t __tmp_in_tmp13; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp13; + } + Arr1DIdxRowM(tmp13, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp13 : 0; + } + + uint64_t *tmp14 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp14 + * at (1972,1-1972,36) */ + uint64_t __tmp_in_tmp14; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp14; + } + Arr1DIdxRowM(tmp14, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp14 : 0; + } + + uint64_t *tmp15 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp15 + * at (1975,1-1975,46) */ + uint64_t __tmp_in_tmp15; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp15; + } + Arr4DIdxRowM(tmp15, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp15 : 0; + } + } + } + } + + uint64_t *tmp16 = make_array((int32_t)96); + /* Variable to read the clear value corresponding to the input variable tmp16 + * at (1978,1-1978,35) */ + uint64_t __tmp_in_tmp16; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)96; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp16; + } + Arr1DIdxRowM(tmp16, (int32_t)96, i0) = + (party == SERVER) ? __tmp_in_tmp16 : 0; + } + + uint64_t *tmp17 = make_array((int32_t)96); + /* Variable to read the clear value corresponding to the input variable tmp17 + * at (1981,1-1981,35) */ + uint64_t __tmp_in_tmp17; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)96; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp17; + } + Arr1DIdxRowM(tmp17, (int32_t)96, i0) = + (party == SERVER) ? __tmp_in_tmp17 : 0; + } + + uint64_t *tmp18 = make_array((int32_t)96); + /* Variable to read the clear value corresponding to the input variable tmp18 + * at (1984,1-1984,35) */ + uint64_t __tmp_in_tmp18; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)96; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp18; + } + Arr1DIdxRowM(tmp18, (int32_t)96, i0) = + (party == SERVER) ? __tmp_in_tmp18 : 0; + } + + uint64_t *tmp19 = make_array((int32_t)96); + /* Variable to read the clear value corresponding to the input variable tmp19 + * at (1987,1-1987,35) */ + uint64_t __tmp_in_tmp19; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)96; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp19; + } + Arr1DIdxRowM(tmp19, (int32_t)96, i0) = + (party == SERVER) ? __tmp_in_tmp19 : 0; + } + + uint64_t *tmp20 = + make_array((int32_t)1, (int32_t)1, (int32_t)96, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp20 + * at (1990,1-1990,46) */ + uint64_t __tmp_in_tmp20; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)96; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp20; + } + Arr4DIdxRowM(tmp20, (int32_t)1, (int32_t)1, (int32_t)96, (int32_t)128, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp20 : 0; + } + } + } + } + + uint64_t *tmp21 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp21 + * at (1993,1-1993,36) */ + uint64_t __tmp_in_tmp21; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp21; + } + Arr1DIdxRowM(tmp21, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp21 : 0; + } + + uint64_t *tmp22 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp22 + * at (1996,1-1996,36) */ + uint64_t __tmp_in_tmp22; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp22; + } + Arr1DIdxRowM(tmp22, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp22 : 0; + } + + uint64_t *tmp23 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp23 + * at (1999,1-1999,36) */ + uint64_t __tmp_in_tmp23; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp23; + } + Arr1DIdxRowM(tmp23, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp23 : 0; + } + + uint64_t *tmp24 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp24 + * at (2002,1-2002,36) */ + uint64_t __tmp_in_tmp24; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp24; + } + Arr1DIdxRowM(tmp24, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp24 : 0; + } + + uint64_t *tmp25 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp25 + * at (2005,1-2005,46) */ + uint64_t __tmp_in_tmp25; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp25; + } + Arr4DIdxRowM(tmp25, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp25 : 0; + } + } + } + } + + uint64_t *tmp26 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp26 + * at (2008,1-2008,36) */ + uint64_t __tmp_in_tmp26; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp26; + } + Arr1DIdxRowM(tmp26, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp26 : 0; + } + + uint64_t *tmp27 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp27 + * at (2011,1-2011,36) */ + uint64_t __tmp_in_tmp27; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp27; + } + Arr1DIdxRowM(tmp27, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp27 : 0; + } + + uint64_t *tmp28 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp28 + * at (2014,1-2014,36) */ + uint64_t __tmp_in_tmp28; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp28; + } + Arr1DIdxRowM(tmp28, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp28 : 0; + } + + uint64_t *tmp29 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp29 + * at (2017,1-2017,36) */ + uint64_t __tmp_in_tmp29; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp29; + } + Arr1DIdxRowM(tmp29, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp29 : 0; + } + + uint64_t *tmp30 = + make_array((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp30 + * at (2020,1-2020,47) */ + uint64_t __tmp_in_tmp30; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp30; + } + Arr4DIdxRowM(tmp30, (int32_t)1, (int32_t)1, (int32_t)128, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp30 : 0; + } + } + } + } + + uint64_t *tmp31 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp31 + * at (2023,1-2023,36) */ + uint64_t __tmp_in_tmp31; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp31; + } + Arr1DIdxRowM(tmp31, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp31 : 0; + } + + uint64_t *tmp32 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp32 + * at (2026,1-2026,36) */ + uint64_t __tmp_in_tmp32; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp32; + } + Arr1DIdxRowM(tmp32, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp32 : 0; + } + + uint64_t *tmp33 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp33 + * at (2029,1-2029,36) */ + uint64_t __tmp_in_tmp33; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp33; + } + Arr1DIdxRowM(tmp33, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp33 : 0; + } + + uint64_t *tmp34 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp34 + * at (2032,1-2032,36) */ + uint64_t __tmp_in_tmp34; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp34; + } + Arr1DIdxRowM(tmp34, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp34 : 0; + } + + uint64_t *tmp35 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp35 + * at (2035,1-2035,46) */ + uint64_t __tmp_in_tmp35; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp35; + } + Arr4DIdxRowM(tmp35, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp35 : 0; + } + } + } + } + + uint64_t *tmp36 = make_array((int32_t)160); + /* Variable to read the clear value corresponding to the input variable tmp36 + * at (2038,1-2038,36) */ + uint64_t __tmp_in_tmp36; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp36; + } + Arr1DIdxRowM(tmp36, (int32_t)160, i0) = + (party == SERVER) ? __tmp_in_tmp36 : 0; + } + + uint64_t *tmp37 = make_array((int32_t)160); + /* Variable to read the clear value corresponding to the input variable tmp37 + * at (2041,1-2041,36) */ + uint64_t __tmp_in_tmp37; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp37; + } + Arr1DIdxRowM(tmp37, (int32_t)160, i0) = + (party == SERVER) ? __tmp_in_tmp37 : 0; + } + + uint64_t *tmp38 = make_array((int32_t)160); + /* Variable to read the clear value corresponding to the input variable tmp38 + * at (2044,1-2044,36) */ + uint64_t __tmp_in_tmp38; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp38; + } + Arr1DIdxRowM(tmp38, (int32_t)160, i0) = + (party == SERVER) ? __tmp_in_tmp38 : 0; + } + + uint64_t *tmp39 = make_array((int32_t)160); + /* Variable to read the clear value corresponding to the input variable tmp39 + * at (2047,1-2047,36) */ + uint64_t __tmp_in_tmp39; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp39; + } + Arr1DIdxRowM(tmp39, (int32_t)160, i0) = + (party == SERVER) ? __tmp_in_tmp39 : 0; + } + + uint64_t *tmp40 = + make_array((int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp40 + * at (2050,1-2050,47) */ + uint64_t __tmp_in_tmp40; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)160; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp40; + } + Arr4DIdxRowM(tmp40, (int32_t)1, (int32_t)1, (int32_t)160, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp40 : 0; + } + } + } + } + + uint64_t *tmp41 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp41 + * at (2053,1-2053,36) */ + uint64_t __tmp_in_tmp41; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp41; + } + Arr1DIdxRowM(tmp41, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp41 : 0; + } + + uint64_t *tmp42 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp42 + * at (2056,1-2056,36) */ + uint64_t __tmp_in_tmp42; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp42; + } + Arr1DIdxRowM(tmp42, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp42 : 0; + } + + uint64_t *tmp43 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp43 + * at (2059,1-2059,36) */ + uint64_t __tmp_in_tmp43; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp43; + } + Arr1DIdxRowM(tmp43, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp43 : 0; + } + + uint64_t *tmp44 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp44 + * at (2062,1-2062,36) */ + uint64_t __tmp_in_tmp44; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp44; + } + Arr1DIdxRowM(tmp44, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp44 : 0; + } + + uint64_t *tmp45 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp45 + * at (2065,1-2065,46) */ + uint64_t __tmp_in_tmp45; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp45; + } + Arr4DIdxRowM(tmp45, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp45 : 0; + } + } + } + } + + uint64_t *tmp46 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp46 + * at (2068,1-2068,36) */ + uint64_t __tmp_in_tmp46; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp46; + } + Arr1DIdxRowM(tmp46, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp46 : 0; + } + + uint64_t *tmp47 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp47 + * at (2071,1-2071,36) */ + uint64_t __tmp_in_tmp47; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp47; + } + Arr1DIdxRowM(tmp47, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp47 : 0; + } + + uint64_t *tmp48 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp48 + * at (2074,1-2074,36) */ + uint64_t __tmp_in_tmp48; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp48; + } + Arr1DIdxRowM(tmp48, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp48 : 0; + } + + uint64_t *tmp49 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp49 + * at (2077,1-2077,36) */ + uint64_t __tmp_in_tmp49; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp49; + } + Arr1DIdxRowM(tmp49, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp49 : 0; + } + + uint64_t *tmp50 = + make_array((int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp50 + * at (2080,1-2080,47) */ + uint64_t __tmp_in_tmp50; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)192; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp50; + } + Arr4DIdxRowM(tmp50, (int32_t)1, (int32_t)1, (int32_t)192, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp50 : 0; + } + } + } + } + + uint64_t *tmp51 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp51 + * at (2083,1-2083,36) */ + uint64_t __tmp_in_tmp51; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp51; + } + Arr1DIdxRowM(tmp51, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp51 : 0; + } + + uint64_t *tmp52 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp52 + * at (2086,1-2086,36) */ + uint64_t __tmp_in_tmp52; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp52; + } + Arr1DIdxRowM(tmp52, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp52 : 0; + } + + uint64_t *tmp53 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp53 + * at (2089,1-2089,36) */ + uint64_t __tmp_in_tmp53; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp53; + } + Arr1DIdxRowM(tmp53, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp53 : 0; + } + + uint64_t *tmp54 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp54 + * at (2092,1-2092,36) */ + uint64_t __tmp_in_tmp54; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp54; + } + Arr1DIdxRowM(tmp54, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp54 : 0; + } + + uint64_t *tmp55 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp55 + * at (2095,1-2095,46) */ + uint64_t __tmp_in_tmp55; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp55; + } + Arr4DIdxRowM(tmp55, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp55 : 0; + } + } + } + } + + uint64_t *tmp56 = make_array((int32_t)224); + /* Variable to read the clear value corresponding to the input variable tmp56 + * at (2098,1-2098,36) */ + uint64_t __tmp_in_tmp56; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp56; + } + Arr1DIdxRowM(tmp56, (int32_t)224, i0) = + (party == SERVER) ? __tmp_in_tmp56 : 0; + } + + uint64_t *tmp57 = make_array((int32_t)224); + /* Variable to read the clear value corresponding to the input variable tmp57 + * at (2101,1-2101,36) */ + uint64_t __tmp_in_tmp57; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp57; + } + Arr1DIdxRowM(tmp57, (int32_t)224, i0) = + (party == SERVER) ? __tmp_in_tmp57 : 0; + } + + uint64_t *tmp58 = make_array((int32_t)224); + /* Variable to read the clear value corresponding to the input variable tmp58 + * at (2104,1-2104,36) */ + uint64_t __tmp_in_tmp58; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp58; + } + Arr1DIdxRowM(tmp58, (int32_t)224, i0) = + (party == SERVER) ? __tmp_in_tmp58 : 0; + } + + uint64_t *tmp59 = make_array((int32_t)224); + /* Variable to read the clear value corresponding to the input variable tmp59 + * at (2107,1-2107,36) */ + uint64_t __tmp_in_tmp59; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp59; + } + Arr1DIdxRowM(tmp59, (int32_t)224, i0) = + (party == SERVER) ? __tmp_in_tmp59 : 0; + } + + uint64_t *tmp60 = + make_array((int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp60 + * at (2110,1-2110,47) */ + uint64_t __tmp_in_tmp60; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)224; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp60; + } + Arr4DIdxRowM(tmp60, (int32_t)1, (int32_t)1, (int32_t)224, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp60 : 0; + } + } + } + } + + uint64_t *tmp61 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp61 + * at (2113,1-2113,36) */ + uint64_t __tmp_in_tmp61; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp61; + } + Arr1DIdxRowM(tmp61, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp61 : 0; + } + + uint64_t *tmp62 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp62 + * at (2116,1-2116,36) */ + uint64_t __tmp_in_tmp62; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp62; + } + Arr1DIdxRowM(tmp62, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp62 : 0; + } + + uint64_t *tmp63 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp63 + * at (2119,1-2119,36) */ + uint64_t __tmp_in_tmp63; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp63; + } + Arr1DIdxRowM(tmp63, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp63 : 0; + } + + uint64_t *tmp64 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp64 + * at (2122,1-2122,36) */ + uint64_t __tmp_in_tmp64; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp64; + } + Arr1DIdxRowM(tmp64, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp64 : 0; + } + + uint64_t *tmp65 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp65 + * at (2125,1-2125,46) */ + uint64_t __tmp_in_tmp65; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp65; + } + Arr4DIdxRowM(tmp65, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp65 : 0; + } + } + } + } + + uint64_t *tmp66 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp66 + * at (2128,1-2128,36) */ + uint64_t __tmp_in_tmp66; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp66; + } + Arr1DIdxRowM(tmp66, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp66 : 0; + } + + uint64_t *tmp67 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp67 + * at (2131,1-2131,36) */ + uint64_t __tmp_in_tmp67; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp67; + } + Arr1DIdxRowM(tmp67, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp67 : 0; + } + + uint64_t *tmp68 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp68 + * at (2134,1-2134,36) */ + uint64_t __tmp_in_tmp68; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp68; + } + Arr1DIdxRowM(tmp68, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp68 : 0; + } + + uint64_t *tmp69 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp69 + * at (2137,1-2137,36) */ + uint64_t __tmp_in_tmp69; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp69; + } + Arr1DIdxRowM(tmp69, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp69 : 0; + } + + uint64_t *tmp70 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp70 + * at (2140,1-2140,47) */ + uint64_t __tmp_in_tmp70; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp70; + } + Arr4DIdxRowM(tmp70, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp70 : 0; + } + } + } + } + + uint64_t *tmp71 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp71 + * at (2143,1-2143,36) */ + uint64_t __tmp_in_tmp71; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp71; + } + Arr1DIdxRowM(tmp71, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp71 : 0; + } + + uint64_t *tmp72 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp72 + * at (2146,1-2146,36) */ + uint64_t __tmp_in_tmp72; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp72; + } + Arr1DIdxRowM(tmp72, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp72 : 0; + } + + uint64_t *tmp73 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp73 + * at (2149,1-2149,36) */ + uint64_t __tmp_in_tmp73; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp73; + } + Arr1DIdxRowM(tmp73, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp73 : 0; + } + + uint64_t *tmp74 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp74 + * at (2152,1-2152,36) */ + uint64_t __tmp_in_tmp74; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp74; + } + Arr1DIdxRowM(tmp74, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp74 : 0; + } + + uint64_t *tmp75 = + make_array((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp75 + * at (2155,1-2155,47) */ + uint64_t __tmp_in_tmp75; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp75; + } + Arr4DIdxRowM(tmp75, (int32_t)1, (int32_t)1, (int32_t)128, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp75 : 0; + } + } + } + } + + uint64_t *tmp76 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp76 + * at (2158,1-2158,36) */ + uint64_t __tmp_in_tmp76; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp76; + } + Arr1DIdxRowM(tmp76, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp76 : 0; + } + + uint64_t *tmp77 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp77 + * at (2161,1-2161,36) */ + uint64_t __tmp_in_tmp77; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp77; + } + Arr1DIdxRowM(tmp77, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp77 : 0; + } + + uint64_t *tmp78 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp78 + * at (2164,1-2164,36) */ + uint64_t __tmp_in_tmp78; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp78; + } + Arr1DIdxRowM(tmp78, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp78 : 0; + } + + uint64_t *tmp79 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp79 + * at (2167,1-2167,36) */ + uint64_t __tmp_in_tmp79; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp79; + } + Arr1DIdxRowM(tmp79, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp79 : 0; + } + + uint64_t *tmp80 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp80 + * at (2170,1-2170,46) */ + uint64_t __tmp_in_tmp80; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp80; + } + Arr4DIdxRowM(tmp80, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp80 : 0; + } + } + } + } + + uint64_t *tmp81 = make_array((int32_t)160); + /* Variable to read the clear value corresponding to the input variable tmp81 + * at (2173,1-2173,36) */ + uint64_t __tmp_in_tmp81; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp81; + } + Arr1DIdxRowM(tmp81, (int32_t)160, i0) = + (party == SERVER) ? __tmp_in_tmp81 : 0; + } + + uint64_t *tmp82 = make_array((int32_t)160); + /* Variable to read the clear value corresponding to the input variable tmp82 + * at (2176,1-2176,36) */ + uint64_t __tmp_in_tmp82; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp82; + } + Arr1DIdxRowM(tmp82, (int32_t)160, i0) = + (party == SERVER) ? __tmp_in_tmp82 : 0; + } + + uint64_t *tmp83 = make_array((int32_t)160); + /* Variable to read the clear value corresponding to the input variable tmp83 + * at (2179,1-2179,36) */ + uint64_t __tmp_in_tmp83; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp83; + } + Arr1DIdxRowM(tmp83, (int32_t)160, i0) = + (party == SERVER) ? __tmp_in_tmp83 : 0; + } + + uint64_t *tmp84 = make_array((int32_t)160); + /* Variable to read the clear value corresponding to the input variable tmp84 + * at (2182,1-2182,36) */ + uint64_t __tmp_in_tmp84; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp84; + } + Arr1DIdxRowM(tmp84, (int32_t)160, i0) = + (party == SERVER) ? __tmp_in_tmp84 : 0; + } + + uint64_t *tmp85 = + make_array((int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp85 + * at (2185,1-2185,47) */ + uint64_t __tmp_in_tmp85; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)160; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp85; + } + Arr4DIdxRowM(tmp85, (int32_t)1, (int32_t)1, (int32_t)160, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp85 : 0; + } + } + } + } + + uint64_t *tmp86 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp86 + * at (2188,1-2188,36) */ + uint64_t __tmp_in_tmp86; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp86; + } + Arr1DIdxRowM(tmp86, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp86 : 0; + } + + uint64_t *tmp87 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp87 + * at (2191,1-2191,36) */ + uint64_t __tmp_in_tmp87; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp87; + } + Arr1DIdxRowM(tmp87, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp87 : 0; + } + + uint64_t *tmp88 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp88 + * at (2194,1-2194,36) */ + uint64_t __tmp_in_tmp88; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp88; + } + Arr1DIdxRowM(tmp88, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp88 : 0; + } + + uint64_t *tmp89 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp89 + * at (2197,1-2197,36) */ + uint64_t __tmp_in_tmp89; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp89; + } + Arr1DIdxRowM(tmp89, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp89 : 0; + } + + uint64_t *tmp90 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp90 + * at (2200,1-2200,46) */ + uint64_t __tmp_in_tmp90; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp90; + } + Arr4DIdxRowM(tmp90, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp90 : 0; + } + } + } + } + + uint64_t *tmp91 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp91 + * at (2203,1-2203,36) */ + uint64_t __tmp_in_tmp91; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp91; + } + Arr1DIdxRowM(tmp91, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp91 : 0; + } + + uint64_t *tmp92 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp92 + * at (2206,1-2206,36) */ + uint64_t __tmp_in_tmp92; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp92; + } + Arr1DIdxRowM(tmp92, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp92 : 0; + } + + uint64_t *tmp93 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp93 + * at (2209,1-2209,36) */ + uint64_t __tmp_in_tmp93; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp93; + } + Arr1DIdxRowM(tmp93, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp93 : 0; + } + + uint64_t *tmp94 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp94 + * at (2212,1-2212,36) */ + uint64_t __tmp_in_tmp94; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp94; + } + Arr1DIdxRowM(tmp94, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp94 : 0; + } + + uint64_t *tmp95 = + make_array((int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp95 + * at (2215,1-2215,47) */ + uint64_t __tmp_in_tmp95; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)192; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp95; + } + Arr4DIdxRowM(tmp95, (int32_t)1, (int32_t)1, (int32_t)192, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp95 : 0; + } + } + } + } + + uint64_t *tmp96 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp96 + * at (2218,1-2218,36) */ + uint64_t __tmp_in_tmp96; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp96; + } + Arr1DIdxRowM(tmp96, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp96 : 0; + } + + uint64_t *tmp97 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp97 + * at (2221,1-2221,36) */ + uint64_t __tmp_in_tmp97; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp97; + } + Arr1DIdxRowM(tmp97, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp97 : 0; + } + + uint64_t *tmp98 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp98 + * at (2224,1-2224,36) */ + uint64_t __tmp_in_tmp98; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp98; + } + Arr1DIdxRowM(tmp98, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp98 : 0; + } + + uint64_t *tmp99 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp99 + * at (2227,1-2227,36) */ + uint64_t __tmp_in_tmp99; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp99; + } + Arr1DIdxRowM(tmp99, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp99 : 0; + } + + uint64_t *tmp100 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp100 + * at (2230,1-2230,47) */ + uint64_t __tmp_in_tmp100; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp100; + } + Arr4DIdxRowM(tmp100, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp100 : 0; + } + } + } + } + + uint64_t *tmp101 = make_array((int32_t)224); + /* Variable to read the clear value corresponding to the input variable tmp101 + * at (2233,1-2233,37) */ + uint64_t __tmp_in_tmp101; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp101; + } + Arr1DIdxRowM(tmp101, (int32_t)224, i0) = + (party == SERVER) ? __tmp_in_tmp101 : 0; + } + + uint64_t *tmp102 = make_array((int32_t)224); + /* Variable to read the clear value corresponding to the input variable tmp102 + * at (2236,1-2236,37) */ + uint64_t __tmp_in_tmp102; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp102; + } + Arr1DIdxRowM(tmp102, (int32_t)224, i0) = + (party == SERVER) ? __tmp_in_tmp102 : 0; + } + + uint64_t *tmp103 = make_array((int32_t)224); + /* Variable to read the clear value corresponding to the input variable tmp103 + * at (2239,1-2239,37) */ + uint64_t __tmp_in_tmp103; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp103; + } + Arr1DIdxRowM(tmp103, (int32_t)224, i0) = + (party == SERVER) ? __tmp_in_tmp103 : 0; + } + + uint64_t *tmp104 = make_array((int32_t)224); + /* Variable to read the clear value corresponding to the input variable tmp104 + * at (2242,1-2242,37) */ + uint64_t __tmp_in_tmp104; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp104; + } + Arr1DIdxRowM(tmp104, (int32_t)224, i0) = + (party == SERVER) ? __tmp_in_tmp104 : 0; + } + + uint64_t *tmp105 = + make_array((int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp105 + * at (2245,1-2245,48) */ + uint64_t __tmp_in_tmp105; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)224; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp105; + } + Arr4DIdxRowM(tmp105, (int32_t)1, (int32_t)1, (int32_t)224, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp105 : 0; + } + } + } + } + + uint64_t *tmp106 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp106 + * at (2248,1-2248,37) */ + uint64_t __tmp_in_tmp106; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp106; + } + Arr1DIdxRowM(tmp106, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp106 : 0; + } + + uint64_t *tmp107 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp107 + * at (2251,1-2251,37) */ + uint64_t __tmp_in_tmp107; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp107; + } + Arr1DIdxRowM(tmp107, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp107 : 0; + } + + uint64_t *tmp108 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp108 + * at (2254,1-2254,37) */ + uint64_t __tmp_in_tmp108; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp108; + } + Arr1DIdxRowM(tmp108, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp108 : 0; + } + + uint64_t *tmp109 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp109 + * at (2257,1-2257,37) */ + uint64_t __tmp_in_tmp109; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp109; + } + Arr1DIdxRowM(tmp109, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp109 : 0; + } + + uint64_t *tmp110 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp110 + * at (2260,1-2260,47) */ + uint64_t __tmp_in_tmp110; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp110; + } + Arr4DIdxRowM(tmp110, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp110 : 0; + } + } + } + } + + uint64_t *tmp111 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp111 + * at (2263,1-2263,37) */ + uint64_t __tmp_in_tmp111; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp111; + } + Arr1DIdxRowM(tmp111, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp111 : 0; + } + + uint64_t *tmp112 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp112 + * at (2266,1-2266,37) */ + uint64_t __tmp_in_tmp112; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp112; + } + Arr1DIdxRowM(tmp112, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp112 : 0; + } + + uint64_t *tmp113 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp113 + * at (2269,1-2269,37) */ + uint64_t __tmp_in_tmp113; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp113; + } + Arr1DIdxRowM(tmp113, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp113 : 0; + } + + uint64_t *tmp114 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp114 + * at (2272,1-2272,37) */ + uint64_t __tmp_in_tmp114; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp114; + } + Arr1DIdxRowM(tmp114, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp114 : 0; + } + + uint64_t *tmp115 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp115 + * at (2275,1-2275,48) */ + uint64_t __tmp_in_tmp115; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp115; + } + Arr4DIdxRowM(tmp115, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp115 : 0; + } + } + } + } + + uint64_t *tmp116 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp116 + * at (2278,1-2278,37) */ + uint64_t __tmp_in_tmp116; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp116; + } + Arr1DIdxRowM(tmp116, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp116 : 0; + } + + uint64_t *tmp117 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp117 + * at (2281,1-2281,37) */ + uint64_t __tmp_in_tmp117; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp117; + } + Arr1DIdxRowM(tmp117, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp117 : 0; + } + + uint64_t *tmp118 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp118 + * at (2284,1-2284,37) */ + uint64_t __tmp_in_tmp118; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp118; + } + Arr1DIdxRowM(tmp118, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp118 : 0; + } + + uint64_t *tmp119 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp119 + * at (2287,1-2287,37) */ + uint64_t __tmp_in_tmp119; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp119; + } + Arr1DIdxRowM(tmp119, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp119 : 0; + } + + uint64_t *tmp120 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp120 + * at (2290,1-2290,47) */ + uint64_t __tmp_in_tmp120; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp120; + } + Arr4DIdxRowM(tmp120, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp120 : 0; + } + } + } + } + + uint64_t *tmp121 = make_array((int32_t)288); + /* Variable to read the clear value corresponding to the input variable tmp121 + * at (2293,1-2293,37) */ + uint64_t __tmp_in_tmp121; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp121; + } + Arr1DIdxRowM(tmp121, (int32_t)288, i0) = + (party == SERVER) ? __tmp_in_tmp121 : 0; + } + + uint64_t *tmp122 = make_array((int32_t)288); + /* Variable to read the clear value corresponding to the input variable tmp122 + * at (2296,1-2296,37) */ + uint64_t __tmp_in_tmp122; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp122; + } + Arr1DIdxRowM(tmp122, (int32_t)288, i0) = + (party == SERVER) ? __tmp_in_tmp122 : 0; + } + + uint64_t *tmp123 = make_array((int32_t)288); + /* Variable to read the clear value corresponding to the input variable tmp123 + * at (2299,1-2299,37) */ + uint64_t __tmp_in_tmp123; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp123; + } + Arr1DIdxRowM(tmp123, (int32_t)288, i0) = + (party == SERVER) ? __tmp_in_tmp123 : 0; + } + + uint64_t *tmp124 = make_array((int32_t)288); + /* Variable to read the clear value corresponding to the input variable tmp124 + * at (2302,1-2302,37) */ + uint64_t __tmp_in_tmp124; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp124; + } + Arr1DIdxRowM(tmp124, (int32_t)288, i0) = + (party == SERVER) ? __tmp_in_tmp124 : 0; + } + + uint64_t *tmp125 = + make_array((int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp125 + * at (2305,1-2305,48) */ + uint64_t __tmp_in_tmp125; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)288; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp125; + } + Arr4DIdxRowM(tmp125, (int32_t)1, (int32_t)1, (int32_t)288, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp125 : 0; + } + } + } + } + + uint64_t *tmp126 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp126 + * at (2308,1-2308,37) */ + uint64_t __tmp_in_tmp126; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp126; + } + Arr1DIdxRowM(tmp126, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp126 : 0; + } + + uint64_t *tmp127 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp127 + * at (2311,1-2311,37) */ + uint64_t __tmp_in_tmp127; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp127; + } + Arr1DIdxRowM(tmp127, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp127 : 0; + } + + uint64_t *tmp128 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp128 + * at (2314,1-2314,37) */ + uint64_t __tmp_in_tmp128; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp128; + } + Arr1DIdxRowM(tmp128, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp128 : 0; + } + + uint64_t *tmp129 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp129 + * at (2317,1-2317,37) */ + uint64_t __tmp_in_tmp129; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp129; + } + Arr1DIdxRowM(tmp129, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp129 : 0; + } + + uint64_t *tmp130 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp130 + * at (2320,1-2320,47) */ + uint64_t __tmp_in_tmp130; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp130; + } + Arr4DIdxRowM(tmp130, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp130 : 0; + } + } + } + } + + uint64_t *tmp131 = make_array((int32_t)320); + /* Variable to read the clear value corresponding to the input variable tmp131 + * at (2323,1-2323,37) */ + uint64_t __tmp_in_tmp131; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp131; + } + Arr1DIdxRowM(tmp131, (int32_t)320, i0) = + (party == SERVER) ? __tmp_in_tmp131 : 0; + } + + uint64_t *tmp132 = make_array((int32_t)320); + /* Variable to read the clear value corresponding to the input variable tmp132 + * at (2326,1-2326,37) */ + uint64_t __tmp_in_tmp132; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp132; + } + Arr1DIdxRowM(tmp132, (int32_t)320, i0) = + (party == SERVER) ? __tmp_in_tmp132 : 0; + } + + uint64_t *tmp133 = make_array((int32_t)320); + /* Variable to read the clear value corresponding to the input variable tmp133 + * at (2329,1-2329,37) */ + uint64_t __tmp_in_tmp133; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp133; + } + Arr1DIdxRowM(tmp133, (int32_t)320, i0) = + (party == SERVER) ? __tmp_in_tmp133 : 0; + } + + uint64_t *tmp134 = make_array((int32_t)320); + /* Variable to read the clear value corresponding to the input variable tmp134 + * at (2332,1-2332,37) */ + uint64_t __tmp_in_tmp134; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp134; + } + Arr1DIdxRowM(tmp134, (int32_t)320, i0) = + (party == SERVER) ? __tmp_in_tmp134 : 0; + } + + uint64_t *tmp135 = + make_array((int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp135 + * at (2335,1-2335,48) */ + uint64_t __tmp_in_tmp135; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)320; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp135; + } + Arr4DIdxRowM(tmp135, (int32_t)1, (int32_t)1, (int32_t)320, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp135 : 0; + } + } + } + } + + uint64_t *tmp136 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp136 + * at (2338,1-2338,37) */ + uint64_t __tmp_in_tmp136; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp136; + } + Arr1DIdxRowM(tmp136, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp136 : 0; + } + + uint64_t *tmp137 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp137 + * at (2341,1-2341,37) */ + uint64_t __tmp_in_tmp137; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp137; + } + Arr1DIdxRowM(tmp137, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp137 : 0; + } + + uint64_t *tmp138 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp138 + * at (2344,1-2344,37) */ + uint64_t __tmp_in_tmp138; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp138; + } + Arr1DIdxRowM(tmp138, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp138 : 0; + } + + uint64_t *tmp139 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp139 + * at (2347,1-2347,37) */ + uint64_t __tmp_in_tmp139; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp139; + } + Arr1DIdxRowM(tmp139, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp139 : 0; + } + + uint64_t *tmp140 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp140 + * at (2350,1-2350,47) */ + uint64_t __tmp_in_tmp140; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp140; + } + Arr4DIdxRowM(tmp140, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp140 : 0; + } + } + } + } + + uint64_t *tmp141 = make_array((int32_t)352); + /* Variable to read the clear value corresponding to the input variable tmp141 + * at (2353,1-2353,37) */ + uint64_t __tmp_in_tmp141; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp141; + } + Arr1DIdxRowM(tmp141, (int32_t)352, i0) = + (party == SERVER) ? __tmp_in_tmp141 : 0; + } + + uint64_t *tmp142 = make_array((int32_t)352); + /* Variable to read the clear value corresponding to the input variable tmp142 + * at (2356,1-2356,37) */ + uint64_t __tmp_in_tmp142; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp142; + } + Arr1DIdxRowM(tmp142, (int32_t)352, i0) = + (party == SERVER) ? __tmp_in_tmp142 : 0; + } + + uint64_t *tmp143 = make_array((int32_t)352); + /* Variable to read the clear value corresponding to the input variable tmp143 + * at (2359,1-2359,37) */ + uint64_t __tmp_in_tmp143; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp143; + } + Arr1DIdxRowM(tmp143, (int32_t)352, i0) = + (party == SERVER) ? __tmp_in_tmp143 : 0; + } + + uint64_t *tmp144 = make_array((int32_t)352); + /* Variable to read the clear value corresponding to the input variable tmp144 + * at (2362,1-2362,37) */ + uint64_t __tmp_in_tmp144; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp144; + } + Arr1DIdxRowM(tmp144, (int32_t)352, i0) = + (party == SERVER) ? __tmp_in_tmp144 : 0; + } + + uint64_t *tmp145 = + make_array((int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp145 + * at (2365,1-2365,48) */ + uint64_t __tmp_in_tmp145; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)352; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp145; + } + Arr4DIdxRowM(tmp145, (int32_t)1, (int32_t)1, (int32_t)352, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp145 : 0; + } + } + } + } + + uint64_t *tmp146 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp146 + * at (2368,1-2368,37) */ + uint64_t __tmp_in_tmp146; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp146; + } + Arr1DIdxRowM(tmp146, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp146 : 0; + } + + uint64_t *tmp147 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp147 + * at (2371,1-2371,37) */ + uint64_t __tmp_in_tmp147; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp147; + } + Arr1DIdxRowM(tmp147, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp147 : 0; + } + + uint64_t *tmp148 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp148 + * at (2374,1-2374,37) */ + uint64_t __tmp_in_tmp148; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp148; + } + Arr1DIdxRowM(tmp148, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp148 : 0; + } + + uint64_t *tmp149 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp149 + * at (2377,1-2377,37) */ + uint64_t __tmp_in_tmp149; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp149; + } + Arr1DIdxRowM(tmp149, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp149 : 0; + } + + uint64_t *tmp150 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp150 + * at (2380,1-2380,47) */ + uint64_t __tmp_in_tmp150; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp150; + } + Arr4DIdxRowM(tmp150, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp150 : 0; + } + } + } + } + + uint64_t *tmp151 = make_array((int32_t)384); + /* Variable to read the clear value corresponding to the input variable tmp151 + * at (2383,1-2383,37) */ + uint64_t __tmp_in_tmp151; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp151; + } + Arr1DIdxRowM(tmp151, (int32_t)384, i0) = + (party == SERVER) ? __tmp_in_tmp151 : 0; + } + + uint64_t *tmp152 = make_array((int32_t)384); + /* Variable to read the clear value corresponding to the input variable tmp152 + * at (2386,1-2386,37) */ + uint64_t __tmp_in_tmp152; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp152; + } + Arr1DIdxRowM(tmp152, (int32_t)384, i0) = + (party == SERVER) ? __tmp_in_tmp152 : 0; + } + + uint64_t *tmp153 = make_array((int32_t)384); + /* Variable to read the clear value corresponding to the input variable tmp153 + * at (2389,1-2389,37) */ + uint64_t __tmp_in_tmp153; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp153; + } + Arr1DIdxRowM(tmp153, (int32_t)384, i0) = + (party == SERVER) ? __tmp_in_tmp153 : 0; + } + + uint64_t *tmp154 = make_array((int32_t)384); + /* Variable to read the clear value corresponding to the input variable tmp154 + * at (2392,1-2392,37) */ + uint64_t __tmp_in_tmp154; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp154; + } + Arr1DIdxRowM(tmp154, (int32_t)384, i0) = + (party == SERVER) ? __tmp_in_tmp154 : 0; + } + + uint64_t *tmp155 = + make_array((int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp155 + * at (2395,1-2395,48) */ + uint64_t __tmp_in_tmp155; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)384; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp155; + } + Arr4DIdxRowM(tmp155, (int32_t)1, (int32_t)1, (int32_t)384, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp155 : 0; + } + } + } + } + + uint64_t *tmp156 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp156 + * at (2398,1-2398,37) */ + uint64_t __tmp_in_tmp156; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp156; + } + Arr1DIdxRowM(tmp156, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp156 : 0; + } + + uint64_t *tmp157 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp157 + * at (2401,1-2401,37) */ + uint64_t __tmp_in_tmp157; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp157; + } + Arr1DIdxRowM(tmp157, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp157 : 0; + } + + uint64_t *tmp158 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp158 + * at (2404,1-2404,37) */ + uint64_t __tmp_in_tmp158; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp158; + } + Arr1DIdxRowM(tmp158, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp158 : 0; + } + + uint64_t *tmp159 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp159 + * at (2407,1-2407,37) */ + uint64_t __tmp_in_tmp159; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp159; + } + Arr1DIdxRowM(tmp159, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp159 : 0; + } + + uint64_t *tmp160 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp160 + * at (2410,1-2410,47) */ + uint64_t __tmp_in_tmp160; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp160; + } + Arr4DIdxRowM(tmp160, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp160 : 0; + } + } + } + } + + uint64_t *tmp161 = make_array((int32_t)416); + /* Variable to read the clear value corresponding to the input variable tmp161 + * at (2413,1-2413,37) */ + uint64_t __tmp_in_tmp161; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp161; + } + Arr1DIdxRowM(tmp161, (int32_t)416, i0) = + (party == SERVER) ? __tmp_in_tmp161 : 0; + } + + uint64_t *tmp162 = make_array((int32_t)416); + /* Variable to read the clear value corresponding to the input variable tmp162 + * at (2416,1-2416,37) */ + uint64_t __tmp_in_tmp162; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp162; + } + Arr1DIdxRowM(tmp162, (int32_t)416, i0) = + (party == SERVER) ? __tmp_in_tmp162 : 0; + } + + uint64_t *tmp163 = make_array((int32_t)416); + /* Variable to read the clear value corresponding to the input variable tmp163 + * at (2419,1-2419,37) */ + uint64_t __tmp_in_tmp163; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp163; + } + Arr1DIdxRowM(tmp163, (int32_t)416, i0) = + (party == SERVER) ? __tmp_in_tmp163 : 0; + } + + uint64_t *tmp164 = make_array((int32_t)416); + /* Variable to read the clear value corresponding to the input variable tmp164 + * at (2422,1-2422,37) */ + uint64_t __tmp_in_tmp164; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp164; + } + Arr1DIdxRowM(tmp164, (int32_t)416, i0) = + (party == SERVER) ? __tmp_in_tmp164 : 0; + } + + uint64_t *tmp165 = + make_array((int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp165 + * at (2425,1-2425,48) */ + uint64_t __tmp_in_tmp165; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)416; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp165; + } + Arr4DIdxRowM(tmp165, (int32_t)1, (int32_t)1, (int32_t)416, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp165 : 0; + } + } + } + } + + uint64_t *tmp166 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp166 + * at (2428,1-2428,37) */ + uint64_t __tmp_in_tmp166; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp166; + } + Arr1DIdxRowM(tmp166, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp166 : 0; + } + + uint64_t *tmp167 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp167 + * at (2431,1-2431,37) */ + uint64_t __tmp_in_tmp167; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp167; + } + Arr1DIdxRowM(tmp167, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp167 : 0; + } + + uint64_t *tmp168 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp168 + * at (2434,1-2434,37) */ + uint64_t __tmp_in_tmp168; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp168; + } + Arr1DIdxRowM(tmp168, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp168 : 0; + } + + uint64_t *tmp169 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp169 + * at (2437,1-2437,37) */ + uint64_t __tmp_in_tmp169; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp169; + } + Arr1DIdxRowM(tmp169, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp169 : 0; + } + + uint64_t *tmp170 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp170 + * at (2440,1-2440,47) */ + uint64_t __tmp_in_tmp170; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp170; + } + Arr4DIdxRowM(tmp170, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp170 : 0; + } + } + } + } + + uint64_t *tmp171 = make_array((int32_t)448); + /* Variable to read the clear value corresponding to the input variable tmp171 + * at (2443,1-2443,37) */ + uint64_t __tmp_in_tmp171; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp171; + } + Arr1DIdxRowM(tmp171, (int32_t)448, i0) = + (party == SERVER) ? __tmp_in_tmp171 : 0; + } + + uint64_t *tmp172 = make_array((int32_t)448); + /* Variable to read the clear value corresponding to the input variable tmp172 + * at (2446,1-2446,37) */ + uint64_t __tmp_in_tmp172; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp172; + } + Arr1DIdxRowM(tmp172, (int32_t)448, i0) = + (party == SERVER) ? __tmp_in_tmp172 : 0; + } + + uint64_t *tmp173 = make_array((int32_t)448); + /* Variable to read the clear value corresponding to the input variable tmp173 + * at (2449,1-2449,37) */ + uint64_t __tmp_in_tmp173; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp173; + } + Arr1DIdxRowM(tmp173, (int32_t)448, i0) = + (party == SERVER) ? __tmp_in_tmp173 : 0; + } + + uint64_t *tmp174 = make_array((int32_t)448); + /* Variable to read the clear value corresponding to the input variable tmp174 + * at (2452,1-2452,37) */ + uint64_t __tmp_in_tmp174; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp174; + } + Arr1DIdxRowM(tmp174, (int32_t)448, i0) = + (party == SERVER) ? __tmp_in_tmp174 : 0; + } + + uint64_t *tmp175 = + make_array((int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp175 + * at (2455,1-2455,48) */ + uint64_t __tmp_in_tmp175; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)448; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp175; + } + Arr4DIdxRowM(tmp175, (int32_t)1, (int32_t)1, (int32_t)448, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp175 : 0; + } + } + } + } + + uint64_t *tmp176 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp176 + * at (2458,1-2458,37) */ + uint64_t __tmp_in_tmp176; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp176; + } + Arr1DIdxRowM(tmp176, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp176 : 0; + } + + uint64_t *tmp177 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp177 + * at (2461,1-2461,37) */ + uint64_t __tmp_in_tmp177; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp177; + } + Arr1DIdxRowM(tmp177, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp177 : 0; + } + + uint64_t *tmp178 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp178 + * at (2464,1-2464,37) */ + uint64_t __tmp_in_tmp178; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp178; + } + Arr1DIdxRowM(tmp178, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp178 : 0; + } + + uint64_t *tmp179 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp179 + * at (2467,1-2467,37) */ + uint64_t __tmp_in_tmp179; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp179; + } + Arr1DIdxRowM(tmp179, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp179 : 0; + } + + uint64_t *tmp180 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp180 + * at (2470,1-2470,47) */ + uint64_t __tmp_in_tmp180; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp180; + } + Arr4DIdxRowM(tmp180, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp180 : 0; + } + } + } + } + + uint64_t *tmp181 = make_array((int32_t)480); + /* Variable to read the clear value corresponding to the input variable tmp181 + * at (2473,1-2473,37) */ + uint64_t __tmp_in_tmp181; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp181; + } + Arr1DIdxRowM(tmp181, (int32_t)480, i0) = + (party == SERVER) ? __tmp_in_tmp181 : 0; + } + + uint64_t *tmp182 = make_array((int32_t)480); + /* Variable to read the clear value corresponding to the input variable tmp182 + * at (2476,1-2476,37) */ + uint64_t __tmp_in_tmp182; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp182; + } + Arr1DIdxRowM(tmp182, (int32_t)480, i0) = + (party == SERVER) ? __tmp_in_tmp182 : 0; + } + + uint64_t *tmp183 = make_array((int32_t)480); + /* Variable to read the clear value corresponding to the input variable tmp183 + * at (2479,1-2479,37) */ + uint64_t __tmp_in_tmp183; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp183; + } + Arr1DIdxRowM(tmp183, (int32_t)480, i0) = + (party == SERVER) ? __tmp_in_tmp183 : 0; + } + + uint64_t *tmp184 = make_array((int32_t)480); + /* Variable to read the clear value corresponding to the input variable tmp184 + * at (2482,1-2482,37) */ + uint64_t __tmp_in_tmp184; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp184; + } + Arr1DIdxRowM(tmp184, (int32_t)480, i0) = + (party == SERVER) ? __tmp_in_tmp184 : 0; + } + + uint64_t *tmp185 = + make_array((int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp185 + * at (2485,1-2485,48) */ + uint64_t __tmp_in_tmp185; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)480; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp185; + } + Arr4DIdxRowM(tmp185, (int32_t)1, (int32_t)1, (int32_t)480, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp185 : 0; + } + } + } + } + + uint64_t *tmp186 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp186 + * at (2488,1-2488,37) */ + uint64_t __tmp_in_tmp186; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp186; + } + Arr1DIdxRowM(tmp186, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp186 : 0; + } + + uint64_t *tmp187 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp187 + * at (2491,1-2491,37) */ + uint64_t __tmp_in_tmp187; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp187; + } + Arr1DIdxRowM(tmp187, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp187 : 0; + } + + uint64_t *tmp188 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp188 + * at (2494,1-2494,37) */ + uint64_t __tmp_in_tmp188; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp188; + } + Arr1DIdxRowM(tmp188, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp188 : 0; + } + + uint64_t *tmp189 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp189 + * at (2497,1-2497,37) */ + uint64_t __tmp_in_tmp189; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp189; + } + Arr1DIdxRowM(tmp189, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp189 : 0; + } + + uint64_t *tmp190 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp190 + * at (2500,1-2500,47) */ + uint64_t __tmp_in_tmp190; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp190; + } + Arr4DIdxRowM(tmp190, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp190 : 0; + } + } + } + } + + uint64_t *tmp191 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp191 + * at (2503,1-2503,37) */ + uint64_t __tmp_in_tmp191; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp191; + } + Arr1DIdxRowM(tmp191, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp191 : 0; + } + + uint64_t *tmp192 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp192 + * at (2506,1-2506,37) */ + uint64_t __tmp_in_tmp192; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp192; + } + Arr1DIdxRowM(tmp192, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp192 : 0; + } + + uint64_t *tmp193 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp193 + * at (2509,1-2509,37) */ + uint64_t __tmp_in_tmp193; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp193; + } + Arr1DIdxRowM(tmp193, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp193 : 0; + } + + uint64_t *tmp194 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp194 + * at (2512,1-2512,37) */ + uint64_t __tmp_in_tmp194; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp194; + } + Arr1DIdxRowM(tmp194, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp194 : 0; + } + + uint64_t *tmp195 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp195 + * at (2515,1-2515,48) */ + uint64_t __tmp_in_tmp195; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp195; + } + Arr4DIdxRowM(tmp195, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp195 : 0; + } + } + } + } + + uint64_t *tmp196 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp196 + * at (2518,1-2518,37) */ + uint64_t __tmp_in_tmp196; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp196; + } + Arr1DIdxRowM(tmp196, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp196 : 0; + } + + uint64_t *tmp197 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp197 + * at (2521,1-2521,37) */ + uint64_t __tmp_in_tmp197; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp197; + } + Arr1DIdxRowM(tmp197, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp197 : 0; + } + + uint64_t *tmp198 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp198 + * at (2524,1-2524,37) */ + uint64_t __tmp_in_tmp198; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp198; + } + Arr1DIdxRowM(tmp198, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp198 : 0; + } + + uint64_t *tmp199 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp199 + * at (2527,1-2527,37) */ + uint64_t __tmp_in_tmp199; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp199; + } + Arr1DIdxRowM(tmp199, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp199 : 0; + } + + uint64_t *tmp200 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp200 + * at (2530,1-2530,48) */ + uint64_t __tmp_in_tmp200; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp200; + } + Arr4DIdxRowM(tmp200, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp200 : 0; + } + } + } + } + + uint64_t *tmp201 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp201 + * at (2533,1-2533,37) */ + uint64_t __tmp_in_tmp201; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp201; + } + Arr1DIdxRowM(tmp201, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp201 : 0; + } + + uint64_t *tmp202 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp202 + * at (2536,1-2536,37) */ + uint64_t __tmp_in_tmp202; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp202; + } + Arr1DIdxRowM(tmp202, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp202 : 0; + } + + uint64_t *tmp203 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp203 + * at (2539,1-2539,37) */ + uint64_t __tmp_in_tmp203; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp203; + } + Arr1DIdxRowM(tmp203, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp203 : 0; + } + + uint64_t *tmp204 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp204 + * at (2542,1-2542,37) */ + uint64_t __tmp_in_tmp204; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp204; + } + Arr1DIdxRowM(tmp204, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp204 : 0; + } + + uint64_t *tmp205 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp205 + * at (2545,1-2545,47) */ + uint64_t __tmp_in_tmp205; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp205; + } + Arr4DIdxRowM(tmp205, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp205 : 0; + } + } + } + } + + uint64_t *tmp206 = make_array((int32_t)288); + /* Variable to read the clear value corresponding to the input variable tmp206 + * at (2548,1-2548,37) */ + uint64_t __tmp_in_tmp206; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp206; + } + Arr1DIdxRowM(tmp206, (int32_t)288, i0) = + (party == SERVER) ? __tmp_in_tmp206 : 0; + } + + uint64_t *tmp207 = make_array((int32_t)288); + /* Variable to read the clear value corresponding to the input variable tmp207 + * at (2551,1-2551,37) */ + uint64_t __tmp_in_tmp207; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp207; + } + Arr1DIdxRowM(tmp207, (int32_t)288, i0) = + (party == SERVER) ? __tmp_in_tmp207 : 0; + } + + uint64_t *tmp208 = make_array((int32_t)288); + /* Variable to read the clear value corresponding to the input variable tmp208 + * at (2554,1-2554,37) */ + uint64_t __tmp_in_tmp208; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp208; + } + Arr1DIdxRowM(tmp208, (int32_t)288, i0) = + (party == SERVER) ? __tmp_in_tmp208 : 0; + } + + uint64_t *tmp209 = make_array((int32_t)288); + /* Variable to read the clear value corresponding to the input variable tmp209 + * at (2557,1-2557,37) */ + uint64_t __tmp_in_tmp209; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp209; + } + Arr1DIdxRowM(tmp209, (int32_t)288, i0) = + (party == SERVER) ? __tmp_in_tmp209 : 0; + } + + uint64_t *tmp210 = + make_array((int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp210 + * at (2560,1-2560,48) */ + uint64_t __tmp_in_tmp210; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)288; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp210; + } + Arr4DIdxRowM(tmp210, (int32_t)1, (int32_t)1, (int32_t)288, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp210 : 0; + } + } + } + } + + uint64_t *tmp211 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp211 + * at (2563,1-2563,37) */ + uint64_t __tmp_in_tmp211; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp211; + } + Arr1DIdxRowM(tmp211, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp211 : 0; + } + + uint64_t *tmp212 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp212 + * at (2566,1-2566,37) */ + uint64_t __tmp_in_tmp212; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp212; + } + Arr1DIdxRowM(tmp212, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp212 : 0; + } + + uint64_t *tmp213 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp213 + * at (2569,1-2569,37) */ + uint64_t __tmp_in_tmp213; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp213; + } + Arr1DIdxRowM(tmp213, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp213 : 0; + } + + uint64_t *tmp214 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp214 + * at (2572,1-2572,37) */ + uint64_t __tmp_in_tmp214; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp214; + } + Arr1DIdxRowM(tmp214, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp214 : 0; + } + + uint64_t *tmp215 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp215 + * at (2575,1-2575,47) */ + uint64_t __tmp_in_tmp215; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp215; + } + Arr4DIdxRowM(tmp215, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp215 : 0; + } + } + } + } + + uint64_t *tmp216 = make_array((int32_t)320); + /* Variable to read the clear value corresponding to the input variable tmp216 + * at (2578,1-2578,37) */ + uint64_t __tmp_in_tmp216; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp216; + } + Arr1DIdxRowM(tmp216, (int32_t)320, i0) = + (party == SERVER) ? __tmp_in_tmp216 : 0; + } + + uint64_t *tmp217 = make_array((int32_t)320); + /* Variable to read the clear value corresponding to the input variable tmp217 + * at (2581,1-2581,37) */ + uint64_t __tmp_in_tmp217; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp217; + } + Arr1DIdxRowM(tmp217, (int32_t)320, i0) = + (party == SERVER) ? __tmp_in_tmp217 : 0; + } + + uint64_t *tmp218 = make_array((int32_t)320); + /* Variable to read the clear value corresponding to the input variable tmp218 + * at (2584,1-2584,37) */ + uint64_t __tmp_in_tmp218; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp218; + } + Arr1DIdxRowM(tmp218, (int32_t)320, i0) = + (party == SERVER) ? __tmp_in_tmp218 : 0; + } + + uint64_t *tmp219 = make_array((int32_t)320); + /* Variable to read the clear value corresponding to the input variable tmp219 + * at (2587,1-2587,37) */ + uint64_t __tmp_in_tmp219; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp219; + } + Arr1DIdxRowM(tmp219, (int32_t)320, i0) = + (party == SERVER) ? __tmp_in_tmp219 : 0; + } + + uint64_t *tmp220 = + make_array((int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp220 + * at (2590,1-2590,48) */ + uint64_t __tmp_in_tmp220; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)320; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp220; + } + Arr4DIdxRowM(tmp220, (int32_t)1, (int32_t)1, (int32_t)320, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp220 : 0; + } + } + } + } + + uint64_t *tmp221 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp221 + * at (2593,1-2593,37) */ + uint64_t __tmp_in_tmp221; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp221; + } + Arr1DIdxRowM(tmp221, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp221 : 0; + } + + uint64_t *tmp222 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp222 + * at (2596,1-2596,37) */ + uint64_t __tmp_in_tmp222; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp222; + } + Arr1DIdxRowM(tmp222, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp222 : 0; + } + + uint64_t *tmp223 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp223 + * at (2599,1-2599,37) */ + uint64_t __tmp_in_tmp223; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp223; + } + Arr1DIdxRowM(tmp223, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp223 : 0; + } + + uint64_t *tmp224 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp224 + * at (2602,1-2602,37) */ + uint64_t __tmp_in_tmp224; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp224; + } + Arr1DIdxRowM(tmp224, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp224 : 0; + } + + uint64_t *tmp225 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp225 + * at (2605,1-2605,47) */ + uint64_t __tmp_in_tmp225; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp225; + } + Arr4DIdxRowM(tmp225, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp225 : 0; + } + } + } + } + + uint64_t *tmp226 = make_array((int32_t)352); + /* Variable to read the clear value corresponding to the input variable tmp226 + * at (2608,1-2608,37) */ + uint64_t __tmp_in_tmp226; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp226; + } + Arr1DIdxRowM(tmp226, (int32_t)352, i0) = + (party == SERVER) ? __tmp_in_tmp226 : 0; + } + + uint64_t *tmp227 = make_array((int32_t)352); + /* Variable to read the clear value corresponding to the input variable tmp227 + * at (2611,1-2611,37) */ + uint64_t __tmp_in_tmp227; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp227; + } + Arr1DIdxRowM(tmp227, (int32_t)352, i0) = + (party == SERVER) ? __tmp_in_tmp227 : 0; + } + + uint64_t *tmp228 = make_array((int32_t)352); + /* Variable to read the clear value corresponding to the input variable tmp228 + * at (2614,1-2614,37) */ + uint64_t __tmp_in_tmp228; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp228; + } + Arr1DIdxRowM(tmp228, (int32_t)352, i0) = + (party == SERVER) ? __tmp_in_tmp228 : 0; + } + + uint64_t *tmp229 = make_array((int32_t)352); + /* Variable to read the clear value corresponding to the input variable tmp229 + * at (2617,1-2617,37) */ + uint64_t __tmp_in_tmp229; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp229; + } + Arr1DIdxRowM(tmp229, (int32_t)352, i0) = + (party == SERVER) ? __tmp_in_tmp229 : 0; + } + + uint64_t *tmp230 = + make_array((int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp230 + * at (2620,1-2620,48) */ + uint64_t __tmp_in_tmp230; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)352; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp230; + } + Arr4DIdxRowM(tmp230, (int32_t)1, (int32_t)1, (int32_t)352, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp230 : 0; + } + } + } + } + + uint64_t *tmp231 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp231 + * at (2623,1-2623,37) */ + uint64_t __tmp_in_tmp231; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp231; + } + Arr1DIdxRowM(tmp231, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp231 : 0; + } + + uint64_t *tmp232 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp232 + * at (2626,1-2626,37) */ + uint64_t __tmp_in_tmp232; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp232; + } + Arr1DIdxRowM(tmp232, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp232 : 0; + } + + uint64_t *tmp233 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp233 + * at (2629,1-2629,37) */ + uint64_t __tmp_in_tmp233; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp233; + } + Arr1DIdxRowM(tmp233, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp233 : 0; + } + + uint64_t *tmp234 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp234 + * at (2632,1-2632,37) */ + uint64_t __tmp_in_tmp234; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp234; + } + Arr1DIdxRowM(tmp234, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp234 : 0; + } + + uint64_t *tmp235 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp235 + * at (2635,1-2635,47) */ + uint64_t __tmp_in_tmp235; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp235; + } + Arr4DIdxRowM(tmp235, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp235 : 0; + } + } + } + } + + uint64_t *tmp236 = make_array((int32_t)384); + /* Variable to read the clear value corresponding to the input variable tmp236 + * at (2638,1-2638,37) */ + uint64_t __tmp_in_tmp236; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp236; + } + Arr1DIdxRowM(tmp236, (int32_t)384, i0) = + (party == SERVER) ? __tmp_in_tmp236 : 0; + } + + uint64_t *tmp237 = make_array((int32_t)384); + /* Variable to read the clear value corresponding to the input variable tmp237 + * at (2641,1-2641,37) */ + uint64_t __tmp_in_tmp237; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp237; + } + Arr1DIdxRowM(tmp237, (int32_t)384, i0) = + (party == SERVER) ? __tmp_in_tmp237 : 0; + } + + uint64_t *tmp238 = make_array((int32_t)384); + /* Variable to read the clear value corresponding to the input variable tmp238 + * at (2644,1-2644,37) */ + uint64_t __tmp_in_tmp238; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp238; + } + Arr1DIdxRowM(tmp238, (int32_t)384, i0) = + (party == SERVER) ? __tmp_in_tmp238 : 0; + } + + uint64_t *tmp239 = make_array((int32_t)384); + /* Variable to read the clear value corresponding to the input variable tmp239 + * at (2647,1-2647,37) */ + uint64_t __tmp_in_tmp239; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp239; + } + Arr1DIdxRowM(tmp239, (int32_t)384, i0) = + (party == SERVER) ? __tmp_in_tmp239 : 0; + } + + uint64_t *tmp240 = + make_array((int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp240 + * at (2650,1-2650,48) */ + uint64_t __tmp_in_tmp240; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)384; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp240; + } + Arr4DIdxRowM(tmp240, (int32_t)1, (int32_t)1, (int32_t)384, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp240 : 0; + } + } + } + } + + uint64_t *tmp241 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp241 + * at (2653,1-2653,37) */ + uint64_t __tmp_in_tmp241; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp241; + } + Arr1DIdxRowM(tmp241, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp241 : 0; + } + + uint64_t *tmp242 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp242 + * at (2656,1-2656,37) */ + uint64_t __tmp_in_tmp242; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp242; + } + Arr1DIdxRowM(tmp242, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp242 : 0; + } + + uint64_t *tmp243 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp243 + * at (2659,1-2659,37) */ + uint64_t __tmp_in_tmp243; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp243; + } + Arr1DIdxRowM(tmp243, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp243 : 0; + } + + uint64_t *tmp244 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp244 + * at (2662,1-2662,37) */ + uint64_t __tmp_in_tmp244; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp244; + } + Arr1DIdxRowM(tmp244, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp244 : 0; + } + + uint64_t *tmp245 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp245 + * at (2665,1-2665,47) */ + uint64_t __tmp_in_tmp245; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp245; + } + Arr4DIdxRowM(tmp245, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp245 : 0; + } + } + } + } + + uint64_t *tmp246 = make_array((int32_t)416); + /* Variable to read the clear value corresponding to the input variable tmp246 + * at (2668,1-2668,37) */ + uint64_t __tmp_in_tmp246; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp246; + } + Arr1DIdxRowM(tmp246, (int32_t)416, i0) = + (party == SERVER) ? __tmp_in_tmp246 : 0; + } + + uint64_t *tmp247 = make_array((int32_t)416); + /* Variable to read the clear value corresponding to the input variable tmp247 + * at (2671,1-2671,37) */ + uint64_t __tmp_in_tmp247; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp247; + } + Arr1DIdxRowM(tmp247, (int32_t)416, i0) = + (party == SERVER) ? __tmp_in_tmp247 : 0; + } + + uint64_t *tmp248 = make_array((int32_t)416); + /* Variable to read the clear value corresponding to the input variable tmp248 + * at (2674,1-2674,37) */ + uint64_t __tmp_in_tmp248; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp248; + } + Arr1DIdxRowM(tmp248, (int32_t)416, i0) = + (party == SERVER) ? __tmp_in_tmp248 : 0; + } + + uint64_t *tmp249 = make_array((int32_t)416); + /* Variable to read the clear value corresponding to the input variable tmp249 + * at (2677,1-2677,37) */ + uint64_t __tmp_in_tmp249; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp249; + } + Arr1DIdxRowM(tmp249, (int32_t)416, i0) = + (party == SERVER) ? __tmp_in_tmp249 : 0; + } + + uint64_t *tmp250 = + make_array((int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp250 + * at (2680,1-2680,48) */ + uint64_t __tmp_in_tmp250; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)416; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp250; + } + Arr4DIdxRowM(tmp250, (int32_t)1, (int32_t)1, (int32_t)416, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp250 : 0; + } + } + } + } + + uint64_t *tmp251 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp251 + * at (2683,1-2683,37) */ + uint64_t __tmp_in_tmp251; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp251; + } + Arr1DIdxRowM(tmp251, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp251 : 0; + } + + uint64_t *tmp252 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp252 + * at (2686,1-2686,37) */ + uint64_t __tmp_in_tmp252; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp252; + } + Arr1DIdxRowM(tmp252, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp252 : 0; + } + + uint64_t *tmp253 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp253 + * at (2689,1-2689,37) */ + uint64_t __tmp_in_tmp253; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp253; + } + Arr1DIdxRowM(tmp253, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp253 : 0; + } + + uint64_t *tmp254 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp254 + * at (2692,1-2692,37) */ + uint64_t __tmp_in_tmp254; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp254; + } + Arr1DIdxRowM(tmp254, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp254 : 0; + } + + uint64_t *tmp255 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp255 + * at (2695,1-2695,47) */ + uint64_t __tmp_in_tmp255; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp255; + } + Arr4DIdxRowM(tmp255, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp255 : 0; + } + } + } + } + + uint64_t *tmp256 = make_array((int32_t)448); + /* Variable to read the clear value corresponding to the input variable tmp256 + * at (2698,1-2698,37) */ + uint64_t __tmp_in_tmp256; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp256; + } + Arr1DIdxRowM(tmp256, (int32_t)448, i0) = + (party == SERVER) ? __tmp_in_tmp256 : 0; + } + + uint64_t *tmp257 = make_array((int32_t)448); + /* Variable to read the clear value corresponding to the input variable tmp257 + * at (2701,1-2701,37) */ + uint64_t __tmp_in_tmp257; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp257; + } + Arr1DIdxRowM(tmp257, (int32_t)448, i0) = + (party == SERVER) ? __tmp_in_tmp257 : 0; + } + + uint64_t *tmp258 = make_array((int32_t)448); + /* Variable to read the clear value corresponding to the input variable tmp258 + * at (2704,1-2704,37) */ + uint64_t __tmp_in_tmp258; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp258; + } + Arr1DIdxRowM(tmp258, (int32_t)448, i0) = + (party == SERVER) ? __tmp_in_tmp258 : 0; + } + + uint64_t *tmp259 = make_array((int32_t)448); + /* Variable to read the clear value corresponding to the input variable tmp259 + * at (2707,1-2707,37) */ + uint64_t __tmp_in_tmp259; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp259; + } + Arr1DIdxRowM(tmp259, (int32_t)448, i0) = + (party == SERVER) ? __tmp_in_tmp259 : 0; + } + + uint64_t *tmp260 = + make_array((int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp260 + * at (2710,1-2710,48) */ + uint64_t __tmp_in_tmp260; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)448; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp260; + } + Arr4DIdxRowM(tmp260, (int32_t)1, (int32_t)1, (int32_t)448, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp260 : 0; + } + } + } + } + + uint64_t *tmp261 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp261 + * at (2713,1-2713,37) */ + uint64_t __tmp_in_tmp261; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp261; + } + Arr1DIdxRowM(tmp261, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp261 : 0; + } + + uint64_t *tmp262 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp262 + * at (2716,1-2716,37) */ + uint64_t __tmp_in_tmp262; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp262; + } + Arr1DIdxRowM(tmp262, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp262 : 0; + } + + uint64_t *tmp263 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp263 + * at (2719,1-2719,37) */ + uint64_t __tmp_in_tmp263; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp263; + } + Arr1DIdxRowM(tmp263, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp263 : 0; + } + + uint64_t *tmp264 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp264 + * at (2722,1-2722,37) */ + uint64_t __tmp_in_tmp264; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp264; + } + Arr1DIdxRowM(tmp264, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp264 : 0; + } + + uint64_t *tmp265 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp265 + * at (2725,1-2725,47) */ + uint64_t __tmp_in_tmp265; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp265; + } + Arr4DIdxRowM(tmp265, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp265 : 0; + } + } + } + } + + uint64_t *tmp266 = make_array((int32_t)480); + /* Variable to read the clear value corresponding to the input variable tmp266 + * at (2728,1-2728,37) */ + uint64_t __tmp_in_tmp266; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp266; + } + Arr1DIdxRowM(tmp266, (int32_t)480, i0) = + (party == SERVER) ? __tmp_in_tmp266 : 0; + } + + uint64_t *tmp267 = make_array((int32_t)480); + /* Variable to read the clear value corresponding to the input variable tmp267 + * at (2731,1-2731,37) */ + uint64_t __tmp_in_tmp267; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp267; + } + Arr1DIdxRowM(tmp267, (int32_t)480, i0) = + (party == SERVER) ? __tmp_in_tmp267 : 0; + } + + uint64_t *tmp268 = make_array((int32_t)480); + /* Variable to read the clear value corresponding to the input variable tmp268 + * at (2734,1-2734,37) */ + uint64_t __tmp_in_tmp268; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp268; + } + Arr1DIdxRowM(tmp268, (int32_t)480, i0) = + (party == SERVER) ? __tmp_in_tmp268 : 0; + } + + uint64_t *tmp269 = make_array((int32_t)480); + /* Variable to read the clear value corresponding to the input variable tmp269 + * at (2737,1-2737,37) */ + uint64_t __tmp_in_tmp269; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp269; + } + Arr1DIdxRowM(tmp269, (int32_t)480, i0) = + (party == SERVER) ? __tmp_in_tmp269 : 0; + } + + uint64_t *tmp270 = + make_array((int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp270 + * at (2740,1-2740,48) */ + uint64_t __tmp_in_tmp270; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)480; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp270; + } + Arr4DIdxRowM(tmp270, (int32_t)1, (int32_t)1, (int32_t)480, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp270 : 0; + } + } + } + } + + uint64_t *tmp271 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp271 + * at (2743,1-2743,37) */ + uint64_t __tmp_in_tmp271; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp271; + } + Arr1DIdxRowM(tmp271, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp271 : 0; + } + + uint64_t *tmp272 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp272 + * at (2746,1-2746,37) */ + uint64_t __tmp_in_tmp272; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp272; + } + Arr1DIdxRowM(tmp272, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp272 : 0; + } + + uint64_t *tmp273 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp273 + * at (2749,1-2749,37) */ + uint64_t __tmp_in_tmp273; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp273; + } + Arr1DIdxRowM(tmp273, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp273 : 0; + } + + uint64_t *tmp274 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp274 + * at (2752,1-2752,37) */ + uint64_t __tmp_in_tmp274; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp274; + } + Arr1DIdxRowM(tmp274, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp274 : 0; + } + + uint64_t *tmp275 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp275 + * at (2755,1-2755,47) */ + uint64_t __tmp_in_tmp275; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp275; + } + Arr4DIdxRowM(tmp275, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp275 : 0; + } + } + } + } + + uint64_t *tmp276 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp276 + * at (2758,1-2758,37) */ + uint64_t __tmp_in_tmp276; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp276; + } + Arr1DIdxRowM(tmp276, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp276 : 0; + } + + uint64_t *tmp277 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp277 + * at (2761,1-2761,37) */ + uint64_t __tmp_in_tmp277; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp277; + } + Arr1DIdxRowM(tmp277, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp277 : 0; + } + + uint64_t *tmp278 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp278 + * at (2764,1-2764,37) */ + uint64_t __tmp_in_tmp278; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp278; + } + Arr1DIdxRowM(tmp278, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp278 : 0; + } + + uint64_t *tmp279 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp279 + * at (2767,1-2767,37) */ + uint64_t __tmp_in_tmp279; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp279; + } + Arr1DIdxRowM(tmp279, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp279 : 0; + } + + uint64_t *tmp280 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp280 + * at (2770,1-2770,48) */ + uint64_t __tmp_in_tmp280; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp280; + } + Arr4DIdxRowM(tmp280, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp280 : 0; + } + } + } + } + + uint64_t *tmp281 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp281 + * at (2773,1-2773,37) */ + uint64_t __tmp_in_tmp281; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp281; + } + Arr1DIdxRowM(tmp281, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp281 : 0; + } + + uint64_t *tmp282 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp282 + * at (2776,1-2776,37) */ + uint64_t __tmp_in_tmp282; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp282; + } + Arr1DIdxRowM(tmp282, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp282 : 0; + } + + uint64_t *tmp283 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp283 + * at (2779,1-2779,37) */ + uint64_t __tmp_in_tmp283; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp283; + } + Arr1DIdxRowM(tmp283, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp283 : 0; + } + + uint64_t *tmp284 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp284 + * at (2782,1-2782,37) */ + uint64_t __tmp_in_tmp284; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp284; + } + Arr1DIdxRowM(tmp284, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp284 : 0; + } + + uint64_t *tmp285 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp285 + * at (2785,1-2785,47) */ + uint64_t __tmp_in_tmp285; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp285; + } + Arr4DIdxRowM(tmp285, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp285 : 0; + } + } + } + } + + uint64_t *tmp286 = make_array((int32_t)544); + /* Variable to read the clear value corresponding to the input variable tmp286 + * at (2788,1-2788,37) */ + uint64_t __tmp_in_tmp286; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp286; + } + Arr1DIdxRowM(tmp286, (int32_t)544, i0) = + (party == SERVER) ? __tmp_in_tmp286 : 0; + } + + uint64_t *tmp287 = make_array((int32_t)544); + /* Variable to read the clear value corresponding to the input variable tmp287 + * at (2791,1-2791,37) */ + uint64_t __tmp_in_tmp287; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp287; + } + Arr1DIdxRowM(tmp287, (int32_t)544, i0) = + (party == SERVER) ? __tmp_in_tmp287 : 0; + } + + uint64_t *tmp288 = make_array((int32_t)544); + /* Variable to read the clear value corresponding to the input variable tmp288 + * at (2794,1-2794,37) */ + uint64_t __tmp_in_tmp288; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp288; + } + Arr1DIdxRowM(tmp288, (int32_t)544, i0) = + (party == SERVER) ? __tmp_in_tmp288 : 0; + } + + uint64_t *tmp289 = make_array((int32_t)544); + /* Variable to read the clear value corresponding to the input variable tmp289 + * at (2797,1-2797,37) */ + uint64_t __tmp_in_tmp289; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp289; + } + Arr1DIdxRowM(tmp289, (int32_t)544, i0) = + (party == SERVER) ? __tmp_in_tmp289 : 0; + } + + uint64_t *tmp290 = + make_array((int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp290 + * at (2800,1-2800,48) */ + uint64_t __tmp_in_tmp290; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)544; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp290; + } + Arr4DIdxRowM(tmp290, (int32_t)1, (int32_t)1, (int32_t)544, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp290 : 0; + } + } + } + } + + uint64_t *tmp291 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp291 + * at (2803,1-2803,37) */ + uint64_t __tmp_in_tmp291; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp291; + } + Arr1DIdxRowM(tmp291, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp291 : 0; + } + + uint64_t *tmp292 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp292 + * at (2806,1-2806,37) */ + uint64_t __tmp_in_tmp292; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp292; + } + Arr1DIdxRowM(tmp292, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp292 : 0; + } + + uint64_t *tmp293 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp293 + * at (2809,1-2809,37) */ + uint64_t __tmp_in_tmp293; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp293; + } + Arr1DIdxRowM(tmp293, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp293 : 0; + } + + uint64_t *tmp294 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp294 + * at (2812,1-2812,37) */ + uint64_t __tmp_in_tmp294; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp294; + } + Arr1DIdxRowM(tmp294, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp294 : 0; + } + + uint64_t *tmp295 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp295 + * at (2815,1-2815,47) */ + uint64_t __tmp_in_tmp295; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp295; + } + Arr4DIdxRowM(tmp295, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp295 : 0; + } + } + } + } + + uint64_t *tmp296 = make_array((int32_t)576); + /* Variable to read the clear value corresponding to the input variable tmp296 + * at (2818,1-2818,37) */ + uint64_t __tmp_in_tmp296; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp296; + } + Arr1DIdxRowM(tmp296, (int32_t)576, i0) = + (party == SERVER) ? __tmp_in_tmp296 : 0; + } + + uint64_t *tmp297 = make_array((int32_t)576); + /* Variable to read the clear value corresponding to the input variable tmp297 + * at (2821,1-2821,37) */ + uint64_t __tmp_in_tmp297; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp297; + } + Arr1DIdxRowM(tmp297, (int32_t)576, i0) = + (party == SERVER) ? __tmp_in_tmp297 : 0; + } + + uint64_t *tmp298 = make_array((int32_t)576); + /* Variable to read the clear value corresponding to the input variable tmp298 + * at (2824,1-2824,37) */ + uint64_t __tmp_in_tmp298; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp298; + } + Arr1DIdxRowM(tmp298, (int32_t)576, i0) = + (party == SERVER) ? __tmp_in_tmp298 : 0; + } + + uint64_t *tmp299 = make_array((int32_t)576); + /* Variable to read the clear value corresponding to the input variable tmp299 + * at (2827,1-2827,37) */ + uint64_t __tmp_in_tmp299; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp299; + } + Arr1DIdxRowM(tmp299, (int32_t)576, i0) = + (party == SERVER) ? __tmp_in_tmp299 : 0; + } + + uint64_t *tmp300 = + make_array((int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp300 + * at (2830,1-2830,48) */ + uint64_t __tmp_in_tmp300; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)576; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp300; + } + Arr4DIdxRowM(tmp300, (int32_t)1, (int32_t)1, (int32_t)576, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp300 : 0; + } + } + } + } + + uint64_t *tmp301 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp301 + * at (2833,1-2833,37) */ + uint64_t __tmp_in_tmp301; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp301; + } + Arr1DIdxRowM(tmp301, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp301 : 0; + } + + uint64_t *tmp302 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp302 + * at (2836,1-2836,37) */ + uint64_t __tmp_in_tmp302; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp302; + } + Arr1DIdxRowM(tmp302, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp302 : 0; + } + + uint64_t *tmp303 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp303 + * at (2839,1-2839,37) */ + uint64_t __tmp_in_tmp303; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp303; + } + Arr1DIdxRowM(tmp303, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp303 : 0; + } + + uint64_t *tmp304 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp304 + * at (2842,1-2842,37) */ + uint64_t __tmp_in_tmp304; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp304; + } + Arr1DIdxRowM(tmp304, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp304 : 0; + } + + uint64_t *tmp305 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp305 + * at (2845,1-2845,47) */ + uint64_t __tmp_in_tmp305; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp305; + } + Arr4DIdxRowM(tmp305, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp305 : 0; + } + } + } + } + + uint64_t *tmp306 = make_array((int32_t)608); + /* Variable to read the clear value corresponding to the input variable tmp306 + * at (2848,1-2848,37) */ + uint64_t __tmp_in_tmp306; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp306; + } + Arr1DIdxRowM(tmp306, (int32_t)608, i0) = + (party == SERVER) ? __tmp_in_tmp306 : 0; + } + + uint64_t *tmp307 = make_array((int32_t)608); + /* Variable to read the clear value corresponding to the input variable tmp307 + * at (2851,1-2851,37) */ + uint64_t __tmp_in_tmp307; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp307; + } + Arr1DIdxRowM(tmp307, (int32_t)608, i0) = + (party == SERVER) ? __tmp_in_tmp307 : 0; + } + + uint64_t *tmp308 = make_array((int32_t)608); + /* Variable to read the clear value corresponding to the input variable tmp308 + * at (2854,1-2854,37) */ + uint64_t __tmp_in_tmp308; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp308; + } + Arr1DIdxRowM(tmp308, (int32_t)608, i0) = + (party == SERVER) ? __tmp_in_tmp308 : 0; + } + + uint64_t *tmp309 = make_array((int32_t)608); + /* Variable to read the clear value corresponding to the input variable tmp309 + * at (2857,1-2857,37) */ + uint64_t __tmp_in_tmp309; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp309; + } + Arr1DIdxRowM(tmp309, (int32_t)608, i0) = + (party == SERVER) ? __tmp_in_tmp309 : 0; + } + + uint64_t *tmp310 = + make_array((int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp310 + * at (2860,1-2860,48) */ + uint64_t __tmp_in_tmp310; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)608; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp310; + } + Arr4DIdxRowM(tmp310, (int32_t)1, (int32_t)1, (int32_t)608, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp310 : 0; + } + } + } + } + + uint64_t *tmp311 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp311 + * at (2863,1-2863,37) */ + uint64_t __tmp_in_tmp311; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp311; + } + Arr1DIdxRowM(tmp311, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp311 : 0; + } + + uint64_t *tmp312 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp312 + * at (2866,1-2866,37) */ + uint64_t __tmp_in_tmp312; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp312; + } + Arr1DIdxRowM(tmp312, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp312 : 0; + } + + uint64_t *tmp313 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp313 + * at (2869,1-2869,37) */ + uint64_t __tmp_in_tmp313; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp313; + } + Arr1DIdxRowM(tmp313, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp313 : 0; + } + + uint64_t *tmp314 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp314 + * at (2872,1-2872,37) */ + uint64_t __tmp_in_tmp314; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp314; + } + Arr1DIdxRowM(tmp314, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp314 : 0; + } + + uint64_t *tmp315 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp315 + * at (2875,1-2875,47) */ + uint64_t __tmp_in_tmp315; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp315; + } + Arr4DIdxRowM(tmp315, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp315 : 0; + } + } + } + } + + uint64_t *tmp316 = make_array((int32_t)640); + /* Variable to read the clear value corresponding to the input variable tmp316 + * at (2878,1-2878,37) */ + uint64_t __tmp_in_tmp316; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp316; + } + Arr1DIdxRowM(tmp316, (int32_t)640, i0) = + (party == SERVER) ? __tmp_in_tmp316 : 0; + } + + uint64_t *tmp317 = make_array((int32_t)640); + /* Variable to read the clear value corresponding to the input variable tmp317 + * at (2881,1-2881,37) */ + uint64_t __tmp_in_tmp317; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp317; + } + Arr1DIdxRowM(tmp317, (int32_t)640, i0) = + (party == SERVER) ? __tmp_in_tmp317 : 0; + } + + uint64_t *tmp318 = make_array((int32_t)640); + /* Variable to read the clear value corresponding to the input variable tmp318 + * at (2884,1-2884,37) */ + uint64_t __tmp_in_tmp318; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp318; + } + Arr1DIdxRowM(tmp318, (int32_t)640, i0) = + (party == SERVER) ? __tmp_in_tmp318 : 0; + } + + uint64_t *tmp319 = make_array((int32_t)640); + /* Variable to read the clear value corresponding to the input variable tmp319 + * at (2887,1-2887,37) */ + uint64_t __tmp_in_tmp319; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp319; + } + Arr1DIdxRowM(tmp319, (int32_t)640, i0) = + (party == SERVER) ? __tmp_in_tmp319 : 0; + } + + uint64_t *tmp320 = + make_array((int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp320 + * at (2890,1-2890,48) */ + uint64_t __tmp_in_tmp320; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)640; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp320; + } + Arr4DIdxRowM(tmp320, (int32_t)1, (int32_t)1, (int32_t)640, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp320 : 0; + } + } + } + } + + uint64_t *tmp321 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp321 + * at (2893,1-2893,37) */ + uint64_t __tmp_in_tmp321; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp321; + } + Arr1DIdxRowM(tmp321, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp321 : 0; + } + + uint64_t *tmp322 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp322 + * at (2896,1-2896,37) */ + uint64_t __tmp_in_tmp322; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp322; + } + Arr1DIdxRowM(tmp322, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp322 : 0; + } + + uint64_t *tmp323 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp323 + * at (2899,1-2899,37) */ + uint64_t __tmp_in_tmp323; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp323; + } + Arr1DIdxRowM(tmp323, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp323 : 0; + } + + uint64_t *tmp324 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp324 + * at (2902,1-2902,37) */ + uint64_t __tmp_in_tmp324; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp324; + } + Arr1DIdxRowM(tmp324, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp324 : 0; + } + + uint64_t *tmp325 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp325 + * at (2905,1-2905,47) */ + uint64_t __tmp_in_tmp325; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp325; + } + Arr4DIdxRowM(tmp325, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp325 : 0; + } + } + } + } + + uint64_t *tmp326 = make_array((int32_t)672); + /* Variable to read the clear value corresponding to the input variable tmp326 + * at (2908,1-2908,37) */ + uint64_t __tmp_in_tmp326; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp326; + } + Arr1DIdxRowM(tmp326, (int32_t)672, i0) = + (party == SERVER) ? __tmp_in_tmp326 : 0; + } + + uint64_t *tmp327 = make_array((int32_t)672); + /* Variable to read the clear value corresponding to the input variable tmp327 + * at (2911,1-2911,37) */ + uint64_t __tmp_in_tmp327; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp327; + } + Arr1DIdxRowM(tmp327, (int32_t)672, i0) = + (party == SERVER) ? __tmp_in_tmp327 : 0; + } + + uint64_t *tmp328 = make_array((int32_t)672); + /* Variable to read the clear value corresponding to the input variable tmp328 + * at (2914,1-2914,37) */ + uint64_t __tmp_in_tmp328; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp328; + } + Arr1DIdxRowM(tmp328, (int32_t)672, i0) = + (party == SERVER) ? __tmp_in_tmp328 : 0; + } + + uint64_t *tmp329 = make_array((int32_t)672); + /* Variable to read the clear value corresponding to the input variable tmp329 + * at (2917,1-2917,37) */ + uint64_t __tmp_in_tmp329; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp329; + } + Arr1DIdxRowM(tmp329, (int32_t)672, i0) = + (party == SERVER) ? __tmp_in_tmp329 : 0; + } + + uint64_t *tmp330 = + make_array((int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp330 + * at (2920,1-2920,48) */ + uint64_t __tmp_in_tmp330; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)672; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp330; + } + Arr4DIdxRowM(tmp330, (int32_t)1, (int32_t)1, (int32_t)672, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp330 : 0; + } + } + } + } + + uint64_t *tmp331 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp331 + * at (2923,1-2923,37) */ + uint64_t __tmp_in_tmp331; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp331; + } + Arr1DIdxRowM(tmp331, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp331 : 0; + } + + uint64_t *tmp332 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp332 + * at (2926,1-2926,37) */ + uint64_t __tmp_in_tmp332; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp332; + } + Arr1DIdxRowM(tmp332, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp332 : 0; + } + + uint64_t *tmp333 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp333 + * at (2929,1-2929,37) */ + uint64_t __tmp_in_tmp333; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp333; + } + Arr1DIdxRowM(tmp333, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp333 : 0; + } + + uint64_t *tmp334 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp334 + * at (2932,1-2932,37) */ + uint64_t __tmp_in_tmp334; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp334; + } + Arr1DIdxRowM(tmp334, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp334 : 0; + } + + uint64_t *tmp335 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp335 + * at (2935,1-2935,47) */ + uint64_t __tmp_in_tmp335; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp335; + } + Arr4DIdxRowM(tmp335, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp335 : 0; + } + } + } + } + + uint64_t *tmp336 = make_array((int32_t)704); + /* Variable to read the clear value corresponding to the input variable tmp336 + * at (2938,1-2938,37) */ + uint64_t __tmp_in_tmp336; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp336; + } + Arr1DIdxRowM(tmp336, (int32_t)704, i0) = + (party == SERVER) ? __tmp_in_tmp336 : 0; + } + + uint64_t *tmp337 = make_array((int32_t)704); + /* Variable to read the clear value corresponding to the input variable tmp337 + * at (2941,1-2941,37) */ + uint64_t __tmp_in_tmp337; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp337; + } + Arr1DIdxRowM(tmp337, (int32_t)704, i0) = + (party == SERVER) ? __tmp_in_tmp337 : 0; + } + + uint64_t *tmp338 = make_array((int32_t)704); + /* Variable to read the clear value corresponding to the input variable tmp338 + * at (2944,1-2944,37) */ + uint64_t __tmp_in_tmp338; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp338; + } + Arr1DIdxRowM(tmp338, (int32_t)704, i0) = + (party == SERVER) ? __tmp_in_tmp338 : 0; + } + + uint64_t *tmp339 = make_array((int32_t)704); + /* Variable to read the clear value corresponding to the input variable tmp339 + * at (2947,1-2947,37) */ + uint64_t __tmp_in_tmp339; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp339; + } + Arr1DIdxRowM(tmp339, (int32_t)704, i0) = + (party == SERVER) ? __tmp_in_tmp339 : 0; + } + + uint64_t *tmp340 = + make_array((int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp340 + * at (2950,1-2950,48) */ + uint64_t __tmp_in_tmp340; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)704; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp340; + } + Arr4DIdxRowM(tmp340, (int32_t)1, (int32_t)1, (int32_t)704, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp340 : 0; + } + } + } + } + + uint64_t *tmp341 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp341 + * at (2953,1-2953,37) */ + uint64_t __tmp_in_tmp341; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp341; + } + Arr1DIdxRowM(tmp341, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp341 : 0; + } + + uint64_t *tmp342 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp342 + * at (2956,1-2956,37) */ + uint64_t __tmp_in_tmp342; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp342; + } + Arr1DIdxRowM(tmp342, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp342 : 0; + } + + uint64_t *tmp343 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp343 + * at (2959,1-2959,37) */ + uint64_t __tmp_in_tmp343; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp343; + } + Arr1DIdxRowM(tmp343, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp343 : 0; + } + + uint64_t *tmp344 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp344 + * at (2962,1-2962,37) */ + uint64_t __tmp_in_tmp344; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp344; + } + Arr1DIdxRowM(tmp344, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp344 : 0; + } + + uint64_t *tmp345 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp345 + * at (2965,1-2965,47) */ + uint64_t __tmp_in_tmp345; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp345; + } + Arr4DIdxRowM(tmp345, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp345 : 0; + } + } + } + } + + uint64_t *tmp346 = make_array((int32_t)736); + /* Variable to read the clear value corresponding to the input variable tmp346 + * at (2968,1-2968,37) */ + uint64_t __tmp_in_tmp346; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp346; + } + Arr1DIdxRowM(tmp346, (int32_t)736, i0) = + (party == SERVER) ? __tmp_in_tmp346 : 0; + } + + uint64_t *tmp347 = make_array((int32_t)736); + /* Variable to read the clear value corresponding to the input variable tmp347 + * at (2971,1-2971,37) */ + uint64_t __tmp_in_tmp347; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp347; + } + Arr1DIdxRowM(tmp347, (int32_t)736, i0) = + (party == SERVER) ? __tmp_in_tmp347 : 0; + } + + uint64_t *tmp348 = make_array((int32_t)736); + /* Variable to read the clear value corresponding to the input variable tmp348 + * at (2974,1-2974,37) */ + uint64_t __tmp_in_tmp348; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp348; + } + Arr1DIdxRowM(tmp348, (int32_t)736, i0) = + (party == SERVER) ? __tmp_in_tmp348 : 0; + } + + uint64_t *tmp349 = make_array((int32_t)736); + /* Variable to read the clear value corresponding to the input variable tmp349 + * at (2977,1-2977,37) */ + uint64_t __tmp_in_tmp349; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp349; + } + Arr1DIdxRowM(tmp349, (int32_t)736, i0) = + (party == SERVER) ? __tmp_in_tmp349 : 0; + } + + uint64_t *tmp350 = + make_array((int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp350 + * at (2980,1-2980,48) */ + uint64_t __tmp_in_tmp350; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)736; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp350; + } + Arr4DIdxRowM(tmp350, (int32_t)1, (int32_t)1, (int32_t)736, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp350 : 0; + } + } + } + } + + uint64_t *tmp351 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp351 + * at (2983,1-2983,37) */ + uint64_t __tmp_in_tmp351; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp351; + } + Arr1DIdxRowM(tmp351, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp351 : 0; + } + + uint64_t *tmp352 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp352 + * at (2986,1-2986,37) */ + uint64_t __tmp_in_tmp352; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp352; + } + Arr1DIdxRowM(tmp352, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp352 : 0; + } + + uint64_t *tmp353 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp353 + * at (2989,1-2989,37) */ + uint64_t __tmp_in_tmp353; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp353; + } + Arr1DIdxRowM(tmp353, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp353 : 0; + } + + uint64_t *tmp354 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp354 + * at (2992,1-2992,37) */ + uint64_t __tmp_in_tmp354; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp354; + } + Arr1DIdxRowM(tmp354, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp354 : 0; + } + + uint64_t *tmp355 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp355 + * at (2995,1-2995,47) */ + uint64_t __tmp_in_tmp355; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp355; + } + Arr4DIdxRowM(tmp355, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp355 : 0; + } + } + } + } + + uint64_t *tmp356 = make_array((int32_t)768); + /* Variable to read the clear value corresponding to the input variable tmp356 + * at (2998,1-2998,37) */ + uint64_t __tmp_in_tmp356; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp356; + } + Arr1DIdxRowM(tmp356, (int32_t)768, i0) = + (party == SERVER) ? __tmp_in_tmp356 : 0; + } + + uint64_t *tmp357 = make_array((int32_t)768); + /* Variable to read the clear value corresponding to the input variable tmp357 + * at (3001,1-3001,37) */ + uint64_t __tmp_in_tmp357; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp357; + } + Arr1DIdxRowM(tmp357, (int32_t)768, i0) = + (party == SERVER) ? __tmp_in_tmp357 : 0; + } + + uint64_t *tmp358 = make_array((int32_t)768); + /* Variable to read the clear value corresponding to the input variable tmp358 + * at (3004,1-3004,37) */ + uint64_t __tmp_in_tmp358; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp358; + } + Arr1DIdxRowM(tmp358, (int32_t)768, i0) = + (party == SERVER) ? __tmp_in_tmp358 : 0; + } + + uint64_t *tmp359 = make_array((int32_t)768); + /* Variable to read the clear value corresponding to the input variable tmp359 + * at (3007,1-3007,37) */ + uint64_t __tmp_in_tmp359; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp359; + } + Arr1DIdxRowM(tmp359, (int32_t)768, i0) = + (party == SERVER) ? __tmp_in_tmp359 : 0; + } + + uint64_t *tmp360 = + make_array((int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp360 + * at (3010,1-3010,48) */ + uint64_t __tmp_in_tmp360; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)768; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp360; + } + Arr4DIdxRowM(tmp360, (int32_t)1, (int32_t)1, (int32_t)768, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp360 : 0; + } + } + } + } + + uint64_t *tmp361 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp361 + * at (3013,1-3013,37) */ + uint64_t __tmp_in_tmp361; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp361; + } + Arr1DIdxRowM(tmp361, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp361 : 0; + } + + uint64_t *tmp362 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp362 + * at (3016,1-3016,37) */ + uint64_t __tmp_in_tmp362; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp362; + } + Arr1DIdxRowM(tmp362, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp362 : 0; + } + + uint64_t *tmp363 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp363 + * at (3019,1-3019,37) */ + uint64_t __tmp_in_tmp363; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp363; + } + Arr1DIdxRowM(tmp363, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp363 : 0; + } + + uint64_t *tmp364 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp364 + * at (3022,1-3022,37) */ + uint64_t __tmp_in_tmp364; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp364; + } + Arr1DIdxRowM(tmp364, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp364 : 0; + } + + uint64_t *tmp365 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp365 + * at (3025,1-3025,47) */ + uint64_t __tmp_in_tmp365; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp365; + } + Arr4DIdxRowM(tmp365, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp365 : 0; + } + } + } + } + + uint64_t *tmp366 = make_array((int32_t)800); + /* Variable to read the clear value corresponding to the input variable tmp366 + * at (3028,1-3028,37) */ + uint64_t __tmp_in_tmp366; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp366; + } + Arr1DIdxRowM(tmp366, (int32_t)800, i0) = + (party == SERVER) ? __tmp_in_tmp366 : 0; + } + + uint64_t *tmp367 = make_array((int32_t)800); + /* Variable to read the clear value corresponding to the input variable tmp367 + * at (3031,1-3031,37) */ + uint64_t __tmp_in_tmp367; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp367; + } + Arr1DIdxRowM(tmp367, (int32_t)800, i0) = + (party == SERVER) ? __tmp_in_tmp367 : 0; + } + + uint64_t *tmp368 = make_array((int32_t)800); + /* Variable to read the clear value corresponding to the input variable tmp368 + * at (3034,1-3034,37) */ + uint64_t __tmp_in_tmp368; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp368; + } + Arr1DIdxRowM(tmp368, (int32_t)800, i0) = + (party == SERVER) ? __tmp_in_tmp368 : 0; + } + + uint64_t *tmp369 = make_array((int32_t)800); + /* Variable to read the clear value corresponding to the input variable tmp369 + * at (3037,1-3037,37) */ + uint64_t __tmp_in_tmp369; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp369; + } + Arr1DIdxRowM(tmp369, (int32_t)800, i0) = + (party == SERVER) ? __tmp_in_tmp369 : 0; + } + + uint64_t *tmp370 = + make_array((int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp370 + * at (3040,1-3040,48) */ + uint64_t __tmp_in_tmp370; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)800; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp370; + } + Arr4DIdxRowM(tmp370, (int32_t)1, (int32_t)1, (int32_t)800, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp370 : 0; + } + } + } + } + + uint64_t *tmp371 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp371 + * at (3043,1-3043,37) */ + uint64_t __tmp_in_tmp371; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp371; + } + Arr1DIdxRowM(tmp371, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp371 : 0; + } + + uint64_t *tmp372 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp372 + * at (3046,1-3046,37) */ + uint64_t __tmp_in_tmp372; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp372; + } + Arr1DIdxRowM(tmp372, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp372 : 0; + } + + uint64_t *tmp373 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp373 + * at (3049,1-3049,37) */ + uint64_t __tmp_in_tmp373; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp373; + } + Arr1DIdxRowM(tmp373, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp373 : 0; + } + + uint64_t *tmp374 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp374 + * at (3052,1-3052,37) */ + uint64_t __tmp_in_tmp374; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp374; + } + Arr1DIdxRowM(tmp374, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp374 : 0; + } + + uint64_t *tmp375 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp375 + * at (3055,1-3055,47) */ + uint64_t __tmp_in_tmp375; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp375; + } + Arr4DIdxRowM(tmp375, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp375 : 0; + } + } + } + } + + uint64_t *tmp376 = make_array((int32_t)832); + /* Variable to read the clear value corresponding to the input variable tmp376 + * at (3058,1-3058,37) */ + uint64_t __tmp_in_tmp376; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp376; + } + Arr1DIdxRowM(tmp376, (int32_t)832, i0) = + (party == SERVER) ? __tmp_in_tmp376 : 0; + } + + uint64_t *tmp377 = make_array((int32_t)832); + /* Variable to read the clear value corresponding to the input variable tmp377 + * at (3061,1-3061,37) */ + uint64_t __tmp_in_tmp377; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp377; + } + Arr1DIdxRowM(tmp377, (int32_t)832, i0) = + (party == SERVER) ? __tmp_in_tmp377 : 0; + } + + uint64_t *tmp378 = make_array((int32_t)832); + /* Variable to read the clear value corresponding to the input variable tmp378 + * at (3064,1-3064,37) */ + uint64_t __tmp_in_tmp378; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp378; + } + Arr1DIdxRowM(tmp378, (int32_t)832, i0) = + (party == SERVER) ? __tmp_in_tmp378 : 0; + } + + uint64_t *tmp379 = make_array((int32_t)832); + /* Variable to read the clear value corresponding to the input variable tmp379 + * at (3067,1-3067,37) */ + uint64_t __tmp_in_tmp379; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp379; + } + Arr1DIdxRowM(tmp379, (int32_t)832, i0) = + (party == SERVER) ? __tmp_in_tmp379 : 0; + } + + uint64_t *tmp380 = + make_array((int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp380 + * at (3070,1-3070,48) */ + uint64_t __tmp_in_tmp380; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)832; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp380; + } + Arr4DIdxRowM(tmp380, (int32_t)1, (int32_t)1, (int32_t)832, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp380 : 0; + } + } + } + } + + uint64_t *tmp381 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp381 + * at (3073,1-3073,37) */ + uint64_t __tmp_in_tmp381; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp381; + } + Arr1DIdxRowM(tmp381, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp381 : 0; + } + + uint64_t *tmp382 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp382 + * at (3076,1-3076,37) */ + uint64_t __tmp_in_tmp382; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp382; + } + Arr1DIdxRowM(tmp382, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp382 : 0; + } + + uint64_t *tmp383 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp383 + * at (3079,1-3079,37) */ + uint64_t __tmp_in_tmp383; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp383; + } + Arr1DIdxRowM(tmp383, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp383 : 0; + } + + uint64_t *tmp384 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp384 + * at (3082,1-3082,37) */ + uint64_t __tmp_in_tmp384; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp384; + } + Arr1DIdxRowM(tmp384, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp384 : 0; + } + + uint64_t *tmp385 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp385 + * at (3085,1-3085,47) */ + uint64_t __tmp_in_tmp385; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp385; + } + Arr4DIdxRowM(tmp385, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp385 : 0; + } + } + } + } + + uint64_t *tmp386 = make_array((int32_t)864); + /* Variable to read the clear value corresponding to the input variable tmp386 + * at (3088,1-3088,37) */ + uint64_t __tmp_in_tmp386; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp386; + } + Arr1DIdxRowM(tmp386, (int32_t)864, i0) = + (party == SERVER) ? __tmp_in_tmp386 : 0; + } + + uint64_t *tmp387 = make_array((int32_t)864); + /* Variable to read the clear value corresponding to the input variable tmp387 + * at (3091,1-3091,37) */ + uint64_t __tmp_in_tmp387; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp387; + } + Arr1DIdxRowM(tmp387, (int32_t)864, i0) = + (party == SERVER) ? __tmp_in_tmp387 : 0; + } + + uint64_t *tmp388 = make_array((int32_t)864); + /* Variable to read the clear value corresponding to the input variable tmp388 + * at (3094,1-3094,37) */ + uint64_t __tmp_in_tmp388; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp388; + } + Arr1DIdxRowM(tmp388, (int32_t)864, i0) = + (party == SERVER) ? __tmp_in_tmp388 : 0; + } + + uint64_t *tmp389 = make_array((int32_t)864); + /* Variable to read the clear value corresponding to the input variable tmp389 + * at (3097,1-3097,37) */ + uint64_t __tmp_in_tmp389; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp389; + } + Arr1DIdxRowM(tmp389, (int32_t)864, i0) = + (party == SERVER) ? __tmp_in_tmp389 : 0; + } + + uint64_t *tmp390 = + make_array((int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp390 + * at (3100,1-3100,48) */ + uint64_t __tmp_in_tmp390; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)864; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp390; + } + Arr4DIdxRowM(tmp390, (int32_t)1, (int32_t)1, (int32_t)864, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp390 : 0; + } + } + } + } + + uint64_t *tmp391 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp391 + * at (3103,1-3103,37) */ + uint64_t __tmp_in_tmp391; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp391; + } + Arr1DIdxRowM(tmp391, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp391 : 0; + } + + uint64_t *tmp392 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp392 + * at (3106,1-3106,37) */ + uint64_t __tmp_in_tmp392; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp392; + } + Arr1DIdxRowM(tmp392, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp392 : 0; + } + + uint64_t *tmp393 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp393 + * at (3109,1-3109,37) */ + uint64_t __tmp_in_tmp393; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp393; + } + Arr1DIdxRowM(tmp393, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp393 : 0; + } + + uint64_t *tmp394 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp394 + * at (3112,1-3112,37) */ + uint64_t __tmp_in_tmp394; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp394; + } + Arr1DIdxRowM(tmp394, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp394 : 0; + } + + uint64_t *tmp395 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp395 + * at (3115,1-3115,47) */ + uint64_t __tmp_in_tmp395; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp395; + } + Arr4DIdxRowM(tmp395, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp395 : 0; + } + } + } + } + + uint64_t *tmp396 = make_array((int32_t)896); + /* Variable to read the clear value corresponding to the input variable tmp396 + * at (3118,1-3118,37) */ + uint64_t __tmp_in_tmp396; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp396; + } + Arr1DIdxRowM(tmp396, (int32_t)896, i0) = + (party == SERVER) ? __tmp_in_tmp396 : 0; + } + + uint64_t *tmp397 = make_array((int32_t)896); + /* Variable to read the clear value corresponding to the input variable tmp397 + * at (3121,1-3121,37) */ + uint64_t __tmp_in_tmp397; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp397; + } + Arr1DIdxRowM(tmp397, (int32_t)896, i0) = + (party == SERVER) ? __tmp_in_tmp397 : 0; + } + + uint64_t *tmp398 = make_array((int32_t)896); + /* Variable to read the clear value corresponding to the input variable tmp398 + * at (3124,1-3124,37) */ + uint64_t __tmp_in_tmp398; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp398; + } + Arr1DIdxRowM(tmp398, (int32_t)896, i0) = + (party == SERVER) ? __tmp_in_tmp398 : 0; + } + + uint64_t *tmp399 = make_array((int32_t)896); + /* Variable to read the clear value corresponding to the input variable tmp399 + * at (3127,1-3127,37) */ + uint64_t __tmp_in_tmp399; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp399; + } + Arr1DIdxRowM(tmp399, (int32_t)896, i0) = + (party == SERVER) ? __tmp_in_tmp399 : 0; + } + + uint64_t *tmp400 = + make_array((int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp400 + * at (3130,1-3130,48) */ + uint64_t __tmp_in_tmp400; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)896; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp400; + } + Arr4DIdxRowM(tmp400, (int32_t)1, (int32_t)1, (int32_t)896, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp400 : 0; + } + } + } + } + + uint64_t *tmp401 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp401 + * at (3133,1-3133,37) */ + uint64_t __tmp_in_tmp401; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp401; + } + Arr1DIdxRowM(tmp401, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp401 : 0; + } + + uint64_t *tmp402 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp402 + * at (3136,1-3136,37) */ + uint64_t __tmp_in_tmp402; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp402; + } + Arr1DIdxRowM(tmp402, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp402 : 0; + } + + uint64_t *tmp403 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp403 + * at (3139,1-3139,37) */ + uint64_t __tmp_in_tmp403; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp403; + } + Arr1DIdxRowM(tmp403, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp403 : 0; + } + + uint64_t *tmp404 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp404 + * at (3142,1-3142,37) */ + uint64_t __tmp_in_tmp404; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp404; + } + Arr1DIdxRowM(tmp404, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp404 : 0; + } + + uint64_t *tmp405 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp405 + * at (3145,1-3145,47) */ + uint64_t __tmp_in_tmp405; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp405; + } + Arr4DIdxRowM(tmp405, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp405 : 0; + } + } + } + } + + uint64_t *tmp406 = make_array((int32_t)928); + /* Variable to read the clear value corresponding to the input variable tmp406 + * at (3148,1-3148,37) */ + uint64_t __tmp_in_tmp406; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp406; + } + Arr1DIdxRowM(tmp406, (int32_t)928, i0) = + (party == SERVER) ? __tmp_in_tmp406 : 0; + } + + uint64_t *tmp407 = make_array((int32_t)928); + /* Variable to read the clear value corresponding to the input variable tmp407 + * at (3151,1-3151,37) */ + uint64_t __tmp_in_tmp407; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp407; + } + Arr1DIdxRowM(tmp407, (int32_t)928, i0) = + (party == SERVER) ? __tmp_in_tmp407 : 0; + } + + uint64_t *tmp408 = make_array((int32_t)928); + /* Variable to read the clear value corresponding to the input variable tmp408 + * at (3154,1-3154,37) */ + uint64_t __tmp_in_tmp408; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp408; + } + Arr1DIdxRowM(tmp408, (int32_t)928, i0) = + (party == SERVER) ? __tmp_in_tmp408 : 0; + } + + uint64_t *tmp409 = make_array((int32_t)928); + /* Variable to read the clear value corresponding to the input variable tmp409 + * at (3157,1-3157,37) */ + uint64_t __tmp_in_tmp409; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp409; + } + Arr1DIdxRowM(tmp409, (int32_t)928, i0) = + (party == SERVER) ? __tmp_in_tmp409 : 0; + } + + uint64_t *tmp410 = + make_array((int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp410 + * at (3160,1-3160,48) */ + uint64_t __tmp_in_tmp410; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)928; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp410; + } + Arr4DIdxRowM(tmp410, (int32_t)1, (int32_t)1, (int32_t)928, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp410 : 0; + } + } + } + } + + uint64_t *tmp411 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp411 + * at (3163,1-3163,37) */ + uint64_t __tmp_in_tmp411; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp411; + } + Arr1DIdxRowM(tmp411, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp411 : 0; + } + + uint64_t *tmp412 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp412 + * at (3166,1-3166,37) */ + uint64_t __tmp_in_tmp412; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp412; + } + Arr1DIdxRowM(tmp412, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp412 : 0; + } + + uint64_t *tmp413 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp413 + * at (3169,1-3169,37) */ + uint64_t __tmp_in_tmp413; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp413; + } + Arr1DIdxRowM(tmp413, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp413 : 0; + } + + uint64_t *tmp414 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp414 + * at (3172,1-3172,37) */ + uint64_t __tmp_in_tmp414; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp414; + } + Arr1DIdxRowM(tmp414, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp414 : 0; + } + + uint64_t *tmp415 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp415 + * at (3175,1-3175,47) */ + uint64_t __tmp_in_tmp415; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp415; + } + Arr4DIdxRowM(tmp415, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp415 : 0; + } + } + } + } + + uint64_t *tmp416 = make_array((int32_t)960); + /* Variable to read the clear value corresponding to the input variable tmp416 + * at (3178,1-3178,37) */ + uint64_t __tmp_in_tmp416; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp416; + } + Arr1DIdxRowM(tmp416, (int32_t)960, i0) = + (party == SERVER) ? __tmp_in_tmp416 : 0; + } + + uint64_t *tmp417 = make_array((int32_t)960); + /* Variable to read the clear value corresponding to the input variable tmp417 + * at (3181,1-3181,37) */ + uint64_t __tmp_in_tmp417; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp417; + } + Arr1DIdxRowM(tmp417, (int32_t)960, i0) = + (party == SERVER) ? __tmp_in_tmp417 : 0; + } + + uint64_t *tmp418 = make_array((int32_t)960); + /* Variable to read the clear value corresponding to the input variable tmp418 + * at (3184,1-3184,37) */ + uint64_t __tmp_in_tmp418; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp418; + } + Arr1DIdxRowM(tmp418, (int32_t)960, i0) = + (party == SERVER) ? __tmp_in_tmp418 : 0; + } + + uint64_t *tmp419 = make_array((int32_t)960); + /* Variable to read the clear value corresponding to the input variable tmp419 + * at (3187,1-3187,37) */ + uint64_t __tmp_in_tmp419; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp419; + } + Arr1DIdxRowM(tmp419, (int32_t)960, i0) = + (party == SERVER) ? __tmp_in_tmp419 : 0; + } + + uint64_t *tmp420 = + make_array((int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp420 + * at (3190,1-3190,48) */ + uint64_t __tmp_in_tmp420; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)960; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp420; + } + Arr4DIdxRowM(tmp420, (int32_t)1, (int32_t)1, (int32_t)960, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp420 : 0; + } + } + } + } + + uint64_t *tmp421 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp421 + * at (3193,1-3193,37) */ + uint64_t __tmp_in_tmp421; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp421; + } + Arr1DIdxRowM(tmp421, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp421 : 0; + } + + uint64_t *tmp422 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp422 + * at (3196,1-3196,37) */ + uint64_t __tmp_in_tmp422; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp422; + } + Arr1DIdxRowM(tmp422, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp422 : 0; + } + + uint64_t *tmp423 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp423 + * at (3199,1-3199,37) */ + uint64_t __tmp_in_tmp423; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp423; + } + Arr1DIdxRowM(tmp423, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp423 : 0; + } + + uint64_t *tmp424 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp424 + * at (3202,1-3202,37) */ + uint64_t __tmp_in_tmp424; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp424; + } + Arr1DIdxRowM(tmp424, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp424 : 0; + } + + uint64_t *tmp425 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp425 + * at (3205,1-3205,47) */ + uint64_t __tmp_in_tmp425; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp425; + } + Arr4DIdxRowM(tmp425, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp425 : 0; + } + } + } + } + + uint64_t *tmp426 = make_array((int32_t)992); + /* Variable to read the clear value corresponding to the input variable tmp426 + * at (3208,1-3208,37) */ + uint64_t __tmp_in_tmp426; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp426; + } + Arr1DIdxRowM(tmp426, (int32_t)992, i0) = + (party == SERVER) ? __tmp_in_tmp426 : 0; + } + + uint64_t *tmp427 = make_array((int32_t)992); + /* Variable to read the clear value corresponding to the input variable tmp427 + * at (3211,1-3211,37) */ + uint64_t __tmp_in_tmp427; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp427; + } + Arr1DIdxRowM(tmp427, (int32_t)992, i0) = + (party == SERVER) ? __tmp_in_tmp427 : 0; + } + + uint64_t *tmp428 = make_array((int32_t)992); + /* Variable to read the clear value corresponding to the input variable tmp428 + * at (3214,1-3214,37) */ + uint64_t __tmp_in_tmp428; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp428; + } + Arr1DIdxRowM(tmp428, (int32_t)992, i0) = + (party == SERVER) ? __tmp_in_tmp428 : 0; + } + + uint64_t *tmp429 = make_array((int32_t)992); + /* Variable to read the clear value corresponding to the input variable tmp429 + * at (3217,1-3217,37) */ + uint64_t __tmp_in_tmp429; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp429; + } + Arr1DIdxRowM(tmp429, (int32_t)992, i0) = + (party == SERVER) ? __tmp_in_tmp429 : 0; + } + + uint64_t *tmp430 = + make_array((int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp430 + * at (3220,1-3220,48) */ + uint64_t __tmp_in_tmp430; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)992; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp430; + } + Arr4DIdxRowM(tmp430, (int32_t)1, (int32_t)1, (int32_t)992, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp430 : 0; + } + } + } + } + + uint64_t *tmp431 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp431 + * at (3223,1-3223,37) */ + uint64_t __tmp_in_tmp431; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp431; + } + Arr1DIdxRowM(tmp431, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp431 : 0; + } + + uint64_t *tmp432 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp432 + * at (3226,1-3226,37) */ + uint64_t __tmp_in_tmp432; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp432; + } + Arr1DIdxRowM(tmp432, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp432 : 0; + } + + uint64_t *tmp433 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp433 + * at (3229,1-3229,37) */ + uint64_t __tmp_in_tmp433; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp433; + } + Arr1DIdxRowM(tmp433, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp433 : 0; + } + + uint64_t *tmp434 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp434 + * at (3232,1-3232,37) */ + uint64_t __tmp_in_tmp434; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp434; + } + Arr1DIdxRowM(tmp434, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp434 : 0; + } + + uint64_t *tmp435 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp435 + * at (3235,1-3235,47) */ + uint64_t __tmp_in_tmp435; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp435; + } + Arr4DIdxRowM(tmp435, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp435 : 0; + } + } + } + } + + uint64_t *tmp436 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp436 + * at (3238,1-3238,38) */ + uint64_t __tmp_in_tmp436; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp436; + } + Arr1DIdxRowM(tmp436, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp436 : 0; + } + + uint64_t *tmp437 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp437 + * at (3241,1-3241,38) */ + uint64_t __tmp_in_tmp437; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp437; + } + Arr1DIdxRowM(tmp437, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp437 : 0; + } + + uint64_t *tmp438 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp438 + * at (3244,1-3244,38) */ + uint64_t __tmp_in_tmp438; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp438; + } + Arr1DIdxRowM(tmp438, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp438 : 0; + } + + uint64_t *tmp439 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp439 + * at (3247,1-3247,38) */ + uint64_t __tmp_in_tmp439; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp439; + } + Arr1DIdxRowM(tmp439, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp439 : 0; + } + + uint64_t *tmp440 = + make_array((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp440 + * at (3250,1-3250,49) */ + uint64_t __tmp_in_tmp440; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp440; + } + Arr4DIdxRowM(tmp440, (int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp440 : 0; + } + } + } + } + + uint64_t *tmp441 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp441 + * at (3253,1-3253,37) */ + uint64_t __tmp_in_tmp441; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp441; + } + Arr1DIdxRowM(tmp441, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp441 : 0; + } + + uint64_t *tmp442 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp442 + * at (3256,1-3256,37) */ + uint64_t __tmp_in_tmp442; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp442; + } + Arr1DIdxRowM(tmp442, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp442 : 0; + } + + uint64_t *tmp443 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp443 + * at (3259,1-3259,37) */ + uint64_t __tmp_in_tmp443; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp443; + } + Arr1DIdxRowM(tmp443, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp443 : 0; + } + + uint64_t *tmp444 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp444 + * at (3262,1-3262,37) */ + uint64_t __tmp_in_tmp444; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp444; + } + Arr1DIdxRowM(tmp444, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp444 : 0; + } + + uint64_t *tmp445 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp445 + * at (3265,1-3265,48) */ + uint64_t __tmp_in_tmp445; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp445; + } + Arr4DIdxRowM(tmp445, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp445 : 0; + } + } + } + } + + uint64_t *tmp446 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp446 + * at (3268,1-3268,37) */ + uint64_t __tmp_in_tmp446; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp446; + } + Arr1DIdxRowM(tmp446, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp446 : 0; + } + + uint64_t *tmp447 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp447 + * at (3271,1-3271,37) */ + uint64_t __tmp_in_tmp447; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp447; + } + Arr1DIdxRowM(tmp447, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp447 : 0; + } + + uint64_t *tmp448 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp448 + * at (3274,1-3274,37) */ + uint64_t __tmp_in_tmp448; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp448; + } + Arr1DIdxRowM(tmp448, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp448 : 0; + } + + uint64_t *tmp449 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp449 + * at (3277,1-3277,37) */ + uint64_t __tmp_in_tmp449; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp449; + } + Arr1DIdxRowM(tmp449, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp449 : 0; + } + + uint64_t *tmp450 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp450 + * at (3280,1-3280,47) */ + uint64_t __tmp_in_tmp450; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp450; + } + Arr4DIdxRowM(tmp450, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp450 : 0; + } + } + } + } + + uint64_t *tmp451 = make_array((int32_t)544); + /* Variable to read the clear value corresponding to the input variable tmp451 + * at (3283,1-3283,37) */ + uint64_t __tmp_in_tmp451; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp451; + } + Arr1DIdxRowM(tmp451, (int32_t)544, i0) = + (party == SERVER) ? __tmp_in_tmp451 : 0; + } + + uint64_t *tmp452 = make_array((int32_t)544); + /* Variable to read the clear value corresponding to the input variable tmp452 + * at (3286,1-3286,37) */ + uint64_t __tmp_in_tmp452; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp452; + } + Arr1DIdxRowM(tmp452, (int32_t)544, i0) = + (party == SERVER) ? __tmp_in_tmp452 : 0; + } + + uint64_t *tmp453 = make_array((int32_t)544); + /* Variable to read the clear value corresponding to the input variable tmp453 + * at (3289,1-3289,37) */ + uint64_t __tmp_in_tmp453; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp453; + } + Arr1DIdxRowM(tmp453, (int32_t)544, i0) = + (party == SERVER) ? __tmp_in_tmp453 : 0; + } + + uint64_t *tmp454 = make_array((int32_t)544); + /* Variable to read the clear value corresponding to the input variable tmp454 + * at (3292,1-3292,37) */ + uint64_t __tmp_in_tmp454; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp454; + } + Arr1DIdxRowM(tmp454, (int32_t)544, i0) = + (party == SERVER) ? __tmp_in_tmp454 : 0; + } + + uint64_t *tmp455 = + make_array((int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp455 + * at (3295,1-3295,48) */ + uint64_t __tmp_in_tmp455; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)544; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp455; + } + Arr4DIdxRowM(tmp455, (int32_t)1, (int32_t)1, (int32_t)544, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp455 : 0; + } + } + } + } + + uint64_t *tmp456 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp456 + * at (3298,1-3298,37) */ + uint64_t __tmp_in_tmp456; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp456; + } + Arr1DIdxRowM(tmp456, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp456 : 0; + } + + uint64_t *tmp457 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp457 + * at (3301,1-3301,37) */ + uint64_t __tmp_in_tmp457; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp457; + } + Arr1DIdxRowM(tmp457, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp457 : 0; + } + + uint64_t *tmp458 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp458 + * at (3304,1-3304,37) */ + uint64_t __tmp_in_tmp458; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp458; + } + Arr1DIdxRowM(tmp458, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp458 : 0; + } + + uint64_t *tmp459 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp459 + * at (3307,1-3307,37) */ + uint64_t __tmp_in_tmp459; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp459; + } + Arr1DIdxRowM(tmp459, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp459 : 0; + } + + uint64_t *tmp460 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp460 + * at (3310,1-3310,47) */ + uint64_t __tmp_in_tmp460; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp460; + } + Arr4DIdxRowM(tmp460, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp460 : 0; + } + } + } + } + + uint64_t *tmp461 = make_array((int32_t)576); + /* Variable to read the clear value corresponding to the input variable tmp461 + * at (3313,1-3313,37) */ + uint64_t __tmp_in_tmp461; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp461; + } + Arr1DIdxRowM(tmp461, (int32_t)576, i0) = + (party == SERVER) ? __tmp_in_tmp461 : 0; + } + + uint64_t *tmp462 = make_array((int32_t)576); + /* Variable to read the clear value corresponding to the input variable tmp462 + * at (3316,1-3316,37) */ + uint64_t __tmp_in_tmp462; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp462; + } + Arr1DIdxRowM(tmp462, (int32_t)576, i0) = + (party == SERVER) ? __tmp_in_tmp462 : 0; + } + + uint64_t *tmp463 = make_array((int32_t)576); + /* Variable to read the clear value corresponding to the input variable tmp463 + * at (3319,1-3319,37) */ + uint64_t __tmp_in_tmp463; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp463; + } + Arr1DIdxRowM(tmp463, (int32_t)576, i0) = + (party == SERVER) ? __tmp_in_tmp463 : 0; + } + + uint64_t *tmp464 = make_array((int32_t)576); + /* Variable to read the clear value corresponding to the input variable tmp464 + * at (3322,1-3322,37) */ + uint64_t __tmp_in_tmp464; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp464; + } + Arr1DIdxRowM(tmp464, (int32_t)576, i0) = + (party == SERVER) ? __tmp_in_tmp464 : 0; + } + + uint64_t *tmp465 = + make_array((int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp465 + * at (3325,1-3325,48) */ + uint64_t __tmp_in_tmp465; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)576; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp465; + } + Arr4DIdxRowM(tmp465, (int32_t)1, (int32_t)1, (int32_t)576, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp465 : 0; + } + } + } + } + + uint64_t *tmp466 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp466 + * at (3328,1-3328,37) */ + uint64_t __tmp_in_tmp466; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp466; + } + Arr1DIdxRowM(tmp466, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp466 : 0; + } + + uint64_t *tmp467 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp467 + * at (3331,1-3331,37) */ + uint64_t __tmp_in_tmp467; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp467; + } + Arr1DIdxRowM(tmp467, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp467 : 0; + } + + uint64_t *tmp468 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp468 + * at (3334,1-3334,37) */ + uint64_t __tmp_in_tmp468; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp468; + } + Arr1DIdxRowM(tmp468, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp468 : 0; + } + + uint64_t *tmp469 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp469 + * at (3337,1-3337,37) */ + uint64_t __tmp_in_tmp469; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp469; + } + Arr1DIdxRowM(tmp469, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp469 : 0; + } + + uint64_t *tmp470 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp470 + * at (3340,1-3340,47) */ + uint64_t __tmp_in_tmp470; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp470; + } + Arr4DIdxRowM(tmp470, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp470 : 0; + } + } + } + } + + uint64_t *tmp471 = make_array((int32_t)608); + /* Variable to read the clear value corresponding to the input variable tmp471 + * at (3343,1-3343,37) */ + uint64_t __tmp_in_tmp471; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp471; + } + Arr1DIdxRowM(tmp471, (int32_t)608, i0) = + (party == SERVER) ? __tmp_in_tmp471 : 0; + } + + uint64_t *tmp472 = make_array((int32_t)608); + /* Variable to read the clear value corresponding to the input variable tmp472 + * at (3346,1-3346,37) */ + uint64_t __tmp_in_tmp472; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp472; + } + Arr1DIdxRowM(tmp472, (int32_t)608, i0) = + (party == SERVER) ? __tmp_in_tmp472 : 0; + } + + uint64_t *tmp473 = make_array((int32_t)608); + /* Variable to read the clear value corresponding to the input variable tmp473 + * at (3349,1-3349,37) */ + uint64_t __tmp_in_tmp473; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp473; + } + Arr1DIdxRowM(tmp473, (int32_t)608, i0) = + (party == SERVER) ? __tmp_in_tmp473 : 0; + } + + uint64_t *tmp474 = make_array((int32_t)608); + /* Variable to read the clear value corresponding to the input variable tmp474 + * at (3352,1-3352,37) */ + uint64_t __tmp_in_tmp474; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp474; + } + Arr1DIdxRowM(tmp474, (int32_t)608, i0) = + (party == SERVER) ? __tmp_in_tmp474 : 0; + } + + uint64_t *tmp475 = + make_array((int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp475 + * at (3355,1-3355,48) */ + uint64_t __tmp_in_tmp475; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)608; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp475; + } + Arr4DIdxRowM(tmp475, (int32_t)1, (int32_t)1, (int32_t)608, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp475 : 0; + } + } + } + } + + uint64_t *tmp476 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp476 + * at (3358,1-3358,37) */ + uint64_t __tmp_in_tmp476; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp476; + } + Arr1DIdxRowM(tmp476, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp476 : 0; + } + + uint64_t *tmp477 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp477 + * at (3361,1-3361,37) */ + uint64_t __tmp_in_tmp477; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp477; + } + Arr1DIdxRowM(tmp477, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp477 : 0; + } + + uint64_t *tmp478 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp478 + * at (3364,1-3364,37) */ + uint64_t __tmp_in_tmp478; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp478; + } + Arr1DIdxRowM(tmp478, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp478 : 0; + } + + uint64_t *tmp479 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp479 + * at (3367,1-3367,37) */ + uint64_t __tmp_in_tmp479; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp479; + } + Arr1DIdxRowM(tmp479, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp479 : 0; + } + + uint64_t *tmp480 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp480 + * at (3370,1-3370,47) */ + uint64_t __tmp_in_tmp480; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp480; + } + Arr4DIdxRowM(tmp480, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp480 : 0; + } + } + } + } + + uint64_t *tmp481 = make_array((int32_t)640); + /* Variable to read the clear value corresponding to the input variable tmp481 + * at (3373,1-3373,37) */ + uint64_t __tmp_in_tmp481; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp481; + } + Arr1DIdxRowM(tmp481, (int32_t)640, i0) = + (party == SERVER) ? __tmp_in_tmp481 : 0; + } + + uint64_t *tmp482 = make_array((int32_t)640); + /* Variable to read the clear value corresponding to the input variable tmp482 + * at (3376,1-3376,37) */ + uint64_t __tmp_in_tmp482; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp482; + } + Arr1DIdxRowM(tmp482, (int32_t)640, i0) = + (party == SERVER) ? __tmp_in_tmp482 : 0; + } + + uint64_t *tmp483 = make_array((int32_t)640); + /* Variable to read the clear value corresponding to the input variable tmp483 + * at (3379,1-3379,37) */ + uint64_t __tmp_in_tmp483; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp483; + } + Arr1DIdxRowM(tmp483, (int32_t)640, i0) = + (party == SERVER) ? __tmp_in_tmp483 : 0; + } + + uint64_t *tmp484 = make_array((int32_t)640); + /* Variable to read the clear value corresponding to the input variable tmp484 + * at (3382,1-3382,37) */ + uint64_t __tmp_in_tmp484; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp484; + } + Arr1DIdxRowM(tmp484, (int32_t)640, i0) = + (party == SERVER) ? __tmp_in_tmp484 : 0; + } + + uint64_t *tmp485 = + make_array((int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp485 + * at (3385,1-3385,48) */ + uint64_t __tmp_in_tmp485; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)640; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp485; + } + Arr4DIdxRowM(tmp485, (int32_t)1, (int32_t)1, (int32_t)640, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp485 : 0; + } + } + } + } + + uint64_t *tmp486 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp486 + * at (3388,1-3388,37) */ + uint64_t __tmp_in_tmp486; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp486; + } + Arr1DIdxRowM(tmp486, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp486 : 0; + } + + uint64_t *tmp487 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp487 + * at (3391,1-3391,37) */ + uint64_t __tmp_in_tmp487; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp487; + } + Arr1DIdxRowM(tmp487, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp487 : 0; + } + + uint64_t *tmp488 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp488 + * at (3394,1-3394,37) */ + uint64_t __tmp_in_tmp488; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp488; + } + Arr1DIdxRowM(tmp488, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp488 : 0; + } + + uint64_t *tmp489 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp489 + * at (3397,1-3397,37) */ + uint64_t __tmp_in_tmp489; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp489; + } + Arr1DIdxRowM(tmp489, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp489 : 0; + } + + uint64_t *tmp490 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp490 + * at (3400,1-3400,47) */ + uint64_t __tmp_in_tmp490; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp490; + } + Arr4DIdxRowM(tmp490, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp490 : 0; + } + } + } + } + + uint64_t *tmp491 = make_array((int32_t)672); + /* Variable to read the clear value corresponding to the input variable tmp491 + * at (3403,1-3403,37) */ + uint64_t __tmp_in_tmp491; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp491; + } + Arr1DIdxRowM(tmp491, (int32_t)672, i0) = + (party == SERVER) ? __tmp_in_tmp491 : 0; + } + + uint64_t *tmp492 = make_array((int32_t)672); + /* Variable to read the clear value corresponding to the input variable tmp492 + * at (3406,1-3406,37) */ + uint64_t __tmp_in_tmp492; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp492; + } + Arr1DIdxRowM(tmp492, (int32_t)672, i0) = + (party == SERVER) ? __tmp_in_tmp492 : 0; + } + + uint64_t *tmp493 = make_array((int32_t)672); + /* Variable to read the clear value corresponding to the input variable tmp493 + * at (3409,1-3409,37) */ + uint64_t __tmp_in_tmp493; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp493; + } + Arr1DIdxRowM(tmp493, (int32_t)672, i0) = + (party == SERVER) ? __tmp_in_tmp493 : 0; + } + + uint64_t *tmp494 = make_array((int32_t)672); + /* Variable to read the clear value corresponding to the input variable tmp494 + * at (3412,1-3412,37) */ + uint64_t __tmp_in_tmp494; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp494; + } + Arr1DIdxRowM(tmp494, (int32_t)672, i0) = + (party == SERVER) ? __tmp_in_tmp494 : 0; + } + + uint64_t *tmp495 = + make_array((int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp495 + * at (3415,1-3415,48) */ + uint64_t __tmp_in_tmp495; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)672; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp495; + } + Arr4DIdxRowM(tmp495, (int32_t)1, (int32_t)1, (int32_t)672, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp495 : 0; + } + } + } + } + + uint64_t *tmp496 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp496 + * at (3418,1-3418,37) */ + uint64_t __tmp_in_tmp496; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp496; + } + Arr1DIdxRowM(tmp496, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp496 : 0; + } + + uint64_t *tmp497 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp497 + * at (3421,1-3421,37) */ + uint64_t __tmp_in_tmp497; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp497; + } + Arr1DIdxRowM(tmp497, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp497 : 0; + } + + uint64_t *tmp498 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp498 + * at (3424,1-3424,37) */ + uint64_t __tmp_in_tmp498; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp498; + } + Arr1DIdxRowM(tmp498, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp498 : 0; + } + + uint64_t *tmp499 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp499 + * at (3427,1-3427,37) */ + uint64_t __tmp_in_tmp499; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp499; + } + Arr1DIdxRowM(tmp499, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp499 : 0; + } + + uint64_t *tmp500 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp500 + * at (3430,1-3430,47) */ + uint64_t __tmp_in_tmp500; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp500; + } + Arr4DIdxRowM(tmp500, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp500 : 0; + } + } + } + } + + uint64_t *tmp501 = make_array((int32_t)704); + /* Variable to read the clear value corresponding to the input variable tmp501 + * at (3433,1-3433,37) */ + uint64_t __tmp_in_tmp501; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp501; + } + Arr1DIdxRowM(tmp501, (int32_t)704, i0) = + (party == SERVER) ? __tmp_in_tmp501 : 0; + } + + uint64_t *tmp502 = make_array((int32_t)704); + /* Variable to read the clear value corresponding to the input variable tmp502 + * at (3436,1-3436,37) */ + uint64_t __tmp_in_tmp502; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp502; + } + Arr1DIdxRowM(tmp502, (int32_t)704, i0) = + (party == SERVER) ? __tmp_in_tmp502 : 0; + } + + uint64_t *tmp503 = make_array((int32_t)704); + /* Variable to read the clear value corresponding to the input variable tmp503 + * at (3439,1-3439,37) */ + uint64_t __tmp_in_tmp503; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp503; + } + Arr1DIdxRowM(tmp503, (int32_t)704, i0) = + (party == SERVER) ? __tmp_in_tmp503 : 0; + } + + uint64_t *tmp504 = make_array((int32_t)704); + /* Variable to read the clear value corresponding to the input variable tmp504 + * at (3442,1-3442,37) */ + uint64_t __tmp_in_tmp504; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp504; + } + Arr1DIdxRowM(tmp504, (int32_t)704, i0) = + (party == SERVER) ? __tmp_in_tmp504 : 0; + } + + uint64_t *tmp505 = + make_array((int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp505 + * at (3445,1-3445,48) */ + uint64_t __tmp_in_tmp505; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)704; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp505; + } + Arr4DIdxRowM(tmp505, (int32_t)1, (int32_t)1, (int32_t)704, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp505 : 0; + } + } + } + } + + uint64_t *tmp506 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp506 + * at (3448,1-3448,37) */ + uint64_t __tmp_in_tmp506; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp506; + } + Arr1DIdxRowM(tmp506, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp506 : 0; + } + + uint64_t *tmp507 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp507 + * at (3451,1-3451,37) */ + uint64_t __tmp_in_tmp507; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp507; + } + Arr1DIdxRowM(tmp507, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp507 : 0; + } + + uint64_t *tmp508 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp508 + * at (3454,1-3454,37) */ + uint64_t __tmp_in_tmp508; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp508; + } + Arr1DIdxRowM(tmp508, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp508 : 0; + } + + uint64_t *tmp509 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp509 + * at (3457,1-3457,37) */ + uint64_t __tmp_in_tmp509; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp509; + } + Arr1DIdxRowM(tmp509, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp509 : 0; + } + + uint64_t *tmp510 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp510 + * at (3460,1-3460,47) */ + uint64_t __tmp_in_tmp510; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp510; + } + Arr4DIdxRowM(tmp510, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp510 : 0; + } + } + } + } + + uint64_t *tmp511 = make_array((int32_t)736); + /* Variable to read the clear value corresponding to the input variable tmp511 + * at (3463,1-3463,37) */ + uint64_t __tmp_in_tmp511; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp511; + } + Arr1DIdxRowM(tmp511, (int32_t)736, i0) = + (party == SERVER) ? __tmp_in_tmp511 : 0; + } + + uint64_t *tmp512 = make_array((int32_t)736); + /* Variable to read the clear value corresponding to the input variable tmp512 + * at (3466,1-3466,37) */ + uint64_t __tmp_in_tmp512; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp512; + } + Arr1DIdxRowM(tmp512, (int32_t)736, i0) = + (party == SERVER) ? __tmp_in_tmp512 : 0; + } + + uint64_t *tmp513 = make_array((int32_t)736); + /* Variable to read the clear value corresponding to the input variable tmp513 + * at (3469,1-3469,37) */ + uint64_t __tmp_in_tmp513; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp513; + } + Arr1DIdxRowM(tmp513, (int32_t)736, i0) = + (party == SERVER) ? __tmp_in_tmp513 : 0; + } + + uint64_t *tmp514 = make_array((int32_t)736); + /* Variable to read the clear value corresponding to the input variable tmp514 + * at (3472,1-3472,37) */ + uint64_t __tmp_in_tmp514; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp514; + } + Arr1DIdxRowM(tmp514, (int32_t)736, i0) = + (party == SERVER) ? __tmp_in_tmp514 : 0; + } + + uint64_t *tmp515 = + make_array((int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp515 + * at (3475,1-3475,48) */ + uint64_t __tmp_in_tmp515; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)736; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp515; + } + Arr4DIdxRowM(tmp515, (int32_t)1, (int32_t)1, (int32_t)736, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp515 : 0; + } + } + } + } + + uint64_t *tmp516 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp516 + * at (3478,1-3478,37) */ + uint64_t __tmp_in_tmp516; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp516; + } + Arr1DIdxRowM(tmp516, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp516 : 0; + } + + uint64_t *tmp517 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp517 + * at (3481,1-3481,37) */ + uint64_t __tmp_in_tmp517; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp517; + } + Arr1DIdxRowM(tmp517, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp517 : 0; + } + + uint64_t *tmp518 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp518 + * at (3484,1-3484,37) */ + uint64_t __tmp_in_tmp518; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp518; + } + Arr1DIdxRowM(tmp518, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp518 : 0; + } + + uint64_t *tmp519 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp519 + * at (3487,1-3487,37) */ + uint64_t __tmp_in_tmp519; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp519; + } + Arr1DIdxRowM(tmp519, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp519 : 0; + } + + uint64_t *tmp520 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp520 + * at (3490,1-3490,47) */ + uint64_t __tmp_in_tmp520; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp520; + } + Arr4DIdxRowM(tmp520, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp520 : 0; + } + } + } + } + + uint64_t *tmp521 = make_array((int32_t)768); + /* Variable to read the clear value corresponding to the input variable tmp521 + * at (3493,1-3493,37) */ + uint64_t __tmp_in_tmp521; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp521; + } + Arr1DIdxRowM(tmp521, (int32_t)768, i0) = + (party == SERVER) ? __tmp_in_tmp521 : 0; + } + + uint64_t *tmp522 = make_array((int32_t)768); + /* Variable to read the clear value corresponding to the input variable tmp522 + * at (3496,1-3496,37) */ + uint64_t __tmp_in_tmp522; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp522; + } + Arr1DIdxRowM(tmp522, (int32_t)768, i0) = + (party == SERVER) ? __tmp_in_tmp522 : 0; + } + + uint64_t *tmp523 = make_array((int32_t)768); + /* Variable to read the clear value corresponding to the input variable tmp523 + * at (3499,1-3499,37) */ + uint64_t __tmp_in_tmp523; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp523; + } + Arr1DIdxRowM(tmp523, (int32_t)768, i0) = + (party == SERVER) ? __tmp_in_tmp523 : 0; + } + + uint64_t *tmp524 = make_array((int32_t)768); + /* Variable to read the clear value corresponding to the input variable tmp524 + * at (3502,1-3502,37) */ + uint64_t __tmp_in_tmp524; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp524; + } + Arr1DIdxRowM(tmp524, (int32_t)768, i0) = + (party == SERVER) ? __tmp_in_tmp524 : 0; + } + + uint64_t *tmp525 = + make_array((int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp525 + * at (3505,1-3505,48) */ + uint64_t __tmp_in_tmp525; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)768; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp525; + } + Arr4DIdxRowM(tmp525, (int32_t)1, (int32_t)1, (int32_t)768, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp525 : 0; + } + } + } + } + + uint64_t *tmp526 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp526 + * at (3508,1-3508,37) */ + uint64_t __tmp_in_tmp526; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp526; + } + Arr1DIdxRowM(tmp526, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp526 : 0; + } + + uint64_t *tmp527 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp527 + * at (3511,1-3511,37) */ + uint64_t __tmp_in_tmp527; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp527; + } + Arr1DIdxRowM(tmp527, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp527 : 0; + } + + uint64_t *tmp528 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp528 + * at (3514,1-3514,37) */ + uint64_t __tmp_in_tmp528; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp528; + } + Arr1DIdxRowM(tmp528, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp528 : 0; + } + + uint64_t *tmp529 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp529 + * at (3517,1-3517,37) */ + uint64_t __tmp_in_tmp529; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp529; + } + Arr1DIdxRowM(tmp529, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp529 : 0; + } + + uint64_t *tmp530 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp530 + * at (3520,1-3520,47) */ + uint64_t __tmp_in_tmp530; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp530; + } + Arr4DIdxRowM(tmp530, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp530 : 0; + } + } + } + } + + uint64_t *tmp531 = make_array((int32_t)800); + /* Variable to read the clear value corresponding to the input variable tmp531 + * at (3523,1-3523,37) */ + uint64_t __tmp_in_tmp531; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp531; + } + Arr1DIdxRowM(tmp531, (int32_t)800, i0) = + (party == SERVER) ? __tmp_in_tmp531 : 0; + } + + uint64_t *tmp532 = make_array((int32_t)800); + /* Variable to read the clear value corresponding to the input variable tmp532 + * at (3526,1-3526,37) */ + uint64_t __tmp_in_tmp532; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp532; + } + Arr1DIdxRowM(tmp532, (int32_t)800, i0) = + (party == SERVER) ? __tmp_in_tmp532 : 0; + } + + uint64_t *tmp533 = make_array((int32_t)800); + /* Variable to read the clear value corresponding to the input variable tmp533 + * at (3529,1-3529,37) */ + uint64_t __tmp_in_tmp533; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp533; + } + Arr1DIdxRowM(tmp533, (int32_t)800, i0) = + (party == SERVER) ? __tmp_in_tmp533 : 0; + } + + uint64_t *tmp534 = make_array((int32_t)800); + /* Variable to read the clear value corresponding to the input variable tmp534 + * at (3532,1-3532,37) */ + uint64_t __tmp_in_tmp534; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp534; + } + Arr1DIdxRowM(tmp534, (int32_t)800, i0) = + (party == SERVER) ? __tmp_in_tmp534 : 0; + } + + uint64_t *tmp535 = + make_array((int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp535 + * at (3535,1-3535,48) */ + uint64_t __tmp_in_tmp535; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)800; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp535; + } + Arr4DIdxRowM(tmp535, (int32_t)1, (int32_t)1, (int32_t)800, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp535 : 0; + } + } + } + } + + uint64_t *tmp536 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp536 + * at (3538,1-3538,37) */ + uint64_t __tmp_in_tmp536; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp536; + } + Arr1DIdxRowM(tmp536, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp536 : 0; + } + + uint64_t *tmp537 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp537 + * at (3541,1-3541,37) */ + uint64_t __tmp_in_tmp537; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp537; + } + Arr1DIdxRowM(tmp537, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp537 : 0; + } + + uint64_t *tmp538 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp538 + * at (3544,1-3544,37) */ + uint64_t __tmp_in_tmp538; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp538; + } + Arr1DIdxRowM(tmp538, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp538 : 0; + } + + uint64_t *tmp539 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp539 + * at (3547,1-3547,37) */ + uint64_t __tmp_in_tmp539; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp539; + } + Arr1DIdxRowM(tmp539, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp539 : 0; + } + + uint64_t *tmp540 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp540 + * at (3550,1-3550,47) */ + uint64_t __tmp_in_tmp540; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp540; + } + Arr4DIdxRowM(tmp540, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp540 : 0; + } + } + } + } + + uint64_t *tmp541 = make_array((int32_t)832); + /* Variable to read the clear value corresponding to the input variable tmp541 + * at (3553,1-3553,37) */ + uint64_t __tmp_in_tmp541; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp541; + } + Arr1DIdxRowM(tmp541, (int32_t)832, i0) = + (party == SERVER) ? __tmp_in_tmp541 : 0; + } + + uint64_t *tmp542 = make_array((int32_t)832); + /* Variable to read the clear value corresponding to the input variable tmp542 + * at (3556,1-3556,37) */ + uint64_t __tmp_in_tmp542; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp542; + } + Arr1DIdxRowM(tmp542, (int32_t)832, i0) = + (party == SERVER) ? __tmp_in_tmp542 : 0; + } + + uint64_t *tmp543 = make_array((int32_t)832); + /* Variable to read the clear value corresponding to the input variable tmp543 + * at (3559,1-3559,37) */ + uint64_t __tmp_in_tmp543; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp543; + } + Arr1DIdxRowM(tmp543, (int32_t)832, i0) = + (party == SERVER) ? __tmp_in_tmp543 : 0; + } + + uint64_t *tmp544 = make_array((int32_t)832); + /* Variable to read the clear value corresponding to the input variable tmp544 + * at (3562,1-3562,37) */ + uint64_t __tmp_in_tmp544; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp544; + } + Arr1DIdxRowM(tmp544, (int32_t)832, i0) = + (party == SERVER) ? __tmp_in_tmp544 : 0; + } + + uint64_t *tmp545 = + make_array((int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp545 + * at (3565,1-3565,48) */ + uint64_t __tmp_in_tmp545; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)832; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp545; + } + Arr4DIdxRowM(tmp545, (int32_t)1, (int32_t)1, (int32_t)832, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp545 : 0; + } + } + } + } + + uint64_t *tmp546 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp546 + * at (3568,1-3568,37) */ + uint64_t __tmp_in_tmp546; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp546; + } + Arr1DIdxRowM(tmp546, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp546 : 0; + } + + uint64_t *tmp547 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp547 + * at (3571,1-3571,37) */ + uint64_t __tmp_in_tmp547; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp547; + } + Arr1DIdxRowM(tmp547, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp547 : 0; + } + + uint64_t *tmp548 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp548 + * at (3574,1-3574,37) */ + uint64_t __tmp_in_tmp548; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp548; + } + Arr1DIdxRowM(tmp548, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp548 : 0; + } + + uint64_t *tmp549 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp549 + * at (3577,1-3577,37) */ + uint64_t __tmp_in_tmp549; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp549; + } + Arr1DIdxRowM(tmp549, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp549 : 0; + } + + uint64_t *tmp550 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp550 + * at (3580,1-3580,47) */ + uint64_t __tmp_in_tmp550; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp550; + } + Arr4DIdxRowM(tmp550, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp550 : 0; + } + } + } + } + + uint64_t *tmp551 = make_array((int32_t)864); + /* Variable to read the clear value corresponding to the input variable tmp551 + * at (3583,1-3583,37) */ + uint64_t __tmp_in_tmp551; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp551; + } + Arr1DIdxRowM(tmp551, (int32_t)864, i0) = + (party == SERVER) ? __tmp_in_tmp551 : 0; + } + + uint64_t *tmp552 = make_array((int32_t)864); + /* Variable to read the clear value corresponding to the input variable tmp552 + * at (3586,1-3586,37) */ + uint64_t __tmp_in_tmp552; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp552; + } + Arr1DIdxRowM(tmp552, (int32_t)864, i0) = + (party == SERVER) ? __tmp_in_tmp552 : 0; + } + + uint64_t *tmp553 = make_array((int32_t)864); + /* Variable to read the clear value corresponding to the input variable tmp553 + * at (3589,1-3589,37) */ + uint64_t __tmp_in_tmp553; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp553; + } + Arr1DIdxRowM(tmp553, (int32_t)864, i0) = + (party == SERVER) ? __tmp_in_tmp553 : 0; + } + + uint64_t *tmp554 = make_array((int32_t)864); + /* Variable to read the clear value corresponding to the input variable tmp554 + * at (3592,1-3592,37) */ + uint64_t __tmp_in_tmp554; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp554; + } + Arr1DIdxRowM(tmp554, (int32_t)864, i0) = + (party == SERVER) ? __tmp_in_tmp554 : 0; + } + + uint64_t *tmp555 = + make_array((int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp555 + * at (3595,1-3595,48) */ + uint64_t __tmp_in_tmp555; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)864; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp555; + } + Arr4DIdxRowM(tmp555, (int32_t)1, (int32_t)1, (int32_t)864, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp555 : 0; + } + } + } + } + + uint64_t *tmp556 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp556 + * at (3598,1-3598,37) */ + uint64_t __tmp_in_tmp556; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp556; + } + Arr1DIdxRowM(tmp556, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp556 : 0; + } + + uint64_t *tmp557 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp557 + * at (3601,1-3601,37) */ + uint64_t __tmp_in_tmp557; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp557; + } + Arr1DIdxRowM(tmp557, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp557 : 0; + } + + uint64_t *tmp558 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp558 + * at (3604,1-3604,37) */ + uint64_t __tmp_in_tmp558; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp558; + } + Arr1DIdxRowM(tmp558, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp558 : 0; + } + + uint64_t *tmp559 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp559 + * at (3607,1-3607,37) */ + uint64_t __tmp_in_tmp559; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp559; + } + Arr1DIdxRowM(tmp559, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp559 : 0; + } + + uint64_t *tmp560 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp560 + * at (3610,1-3610,47) */ + uint64_t __tmp_in_tmp560; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp560; + } + Arr4DIdxRowM(tmp560, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp560 : 0; + } + } + } + } + + uint64_t *tmp561 = make_array((int32_t)896); + /* Variable to read the clear value corresponding to the input variable tmp561 + * at (3613,1-3613,37) */ + uint64_t __tmp_in_tmp561; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp561; + } + Arr1DIdxRowM(tmp561, (int32_t)896, i0) = + (party == SERVER) ? __tmp_in_tmp561 : 0; + } + + uint64_t *tmp562 = make_array((int32_t)896); + /* Variable to read the clear value corresponding to the input variable tmp562 + * at (3616,1-3616,37) */ + uint64_t __tmp_in_tmp562; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp562; + } + Arr1DIdxRowM(tmp562, (int32_t)896, i0) = + (party == SERVER) ? __tmp_in_tmp562 : 0; + } + + uint64_t *tmp563 = make_array((int32_t)896); + /* Variable to read the clear value corresponding to the input variable tmp563 + * at (3619,1-3619,37) */ + uint64_t __tmp_in_tmp563; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp563; + } + Arr1DIdxRowM(tmp563, (int32_t)896, i0) = + (party == SERVER) ? __tmp_in_tmp563 : 0; + } + + uint64_t *tmp564 = make_array((int32_t)896); + /* Variable to read the clear value corresponding to the input variable tmp564 + * at (3622,1-3622,37) */ + uint64_t __tmp_in_tmp564; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp564; + } + Arr1DIdxRowM(tmp564, (int32_t)896, i0) = + (party == SERVER) ? __tmp_in_tmp564 : 0; + } + + uint64_t *tmp565 = + make_array((int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp565 + * at (3625,1-3625,48) */ + uint64_t __tmp_in_tmp565; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)896; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp565; + } + Arr4DIdxRowM(tmp565, (int32_t)1, (int32_t)1, (int32_t)896, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp565 : 0; + } + } + } + } + + uint64_t *tmp566 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp566 + * at (3628,1-3628,37) */ + uint64_t __tmp_in_tmp566; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp566; + } + Arr1DIdxRowM(tmp566, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp566 : 0; + } + + uint64_t *tmp567 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp567 + * at (3631,1-3631,37) */ + uint64_t __tmp_in_tmp567; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp567; + } + Arr1DIdxRowM(tmp567, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp567 : 0; + } + + uint64_t *tmp568 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp568 + * at (3634,1-3634,37) */ + uint64_t __tmp_in_tmp568; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp568; + } + Arr1DIdxRowM(tmp568, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp568 : 0; + } + + uint64_t *tmp569 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp569 + * at (3637,1-3637,37) */ + uint64_t __tmp_in_tmp569; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp569; + } + Arr1DIdxRowM(tmp569, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp569 : 0; + } + + uint64_t *tmp570 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp570 + * at (3640,1-3640,47) */ + uint64_t __tmp_in_tmp570; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp570; + } + Arr4DIdxRowM(tmp570, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp570 : 0; + } + } + } + } + + uint64_t *tmp571 = make_array((int32_t)928); + /* Variable to read the clear value corresponding to the input variable tmp571 + * at (3643,1-3643,37) */ + uint64_t __tmp_in_tmp571; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp571; + } + Arr1DIdxRowM(tmp571, (int32_t)928, i0) = + (party == SERVER) ? __tmp_in_tmp571 : 0; + } + + uint64_t *tmp572 = make_array((int32_t)928); + /* Variable to read the clear value corresponding to the input variable tmp572 + * at (3646,1-3646,37) */ + uint64_t __tmp_in_tmp572; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp572; + } + Arr1DIdxRowM(tmp572, (int32_t)928, i0) = + (party == SERVER) ? __tmp_in_tmp572 : 0; + } + + uint64_t *tmp573 = make_array((int32_t)928); + /* Variable to read the clear value corresponding to the input variable tmp573 + * at (3649,1-3649,37) */ + uint64_t __tmp_in_tmp573; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp573; + } + Arr1DIdxRowM(tmp573, (int32_t)928, i0) = + (party == SERVER) ? __tmp_in_tmp573 : 0; + } + + uint64_t *tmp574 = make_array((int32_t)928); + /* Variable to read the clear value corresponding to the input variable tmp574 + * at (3652,1-3652,37) */ + uint64_t __tmp_in_tmp574; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp574; + } + Arr1DIdxRowM(tmp574, (int32_t)928, i0) = + (party == SERVER) ? __tmp_in_tmp574 : 0; + } + + uint64_t *tmp575 = + make_array((int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp575 + * at (3655,1-3655,48) */ + uint64_t __tmp_in_tmp575; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)928; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp575; + } + Arr4DIdxRowM(tmp575, (int32_t)1, (int32_t)1, (int32_t)928, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp575 : 0; + } + } + } + } + + uint64_t *tmp576 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp576 + * at (3658,1-3658,37) */ + uint64_t __tmp_in_tmp576; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp576; + } + Arr1DIdxRowM(tmp576, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp576 : 0; + } + + uint64_t *tmp577 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp577 + * at (3661,1-3661,37) */ + uint64_t __tmp_in_tmp577; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp577; + } + Arr1DIdxRowM(tmp577, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp577 : 0; + } + + uint64_t *tmp578 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp578 + * at (3664,1-3664,37) */ + uint64_t __tmp_in_tmp578; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp578; + } + Arr1DIdxRowM(tmp578, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp578 : 0; + } + + uint64_t *tmp579 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp579 + * at (3667,1-3667,37) */ + uint64_t __tmp_in_tmp579; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp579; + } + Arr1DIdxRowM(tmp579, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp579 : 0; + } + + uint64_t *tmp580 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp580 + * at (3670,1-3670,47) */ + uint64_t __tmp_in_tmp580; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp580; + } + Arr4DIdxRowM(tmp580, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp580 : 0; + } + } + } + } + + uint64_t *tmp581 = make_array((int32_t)960); + /* Variable to read the clear value corresponding to the input variable tmp581 + * at (3673,1-3673,37) */ + uint64_t __tmp_in_tmp581; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp581; + } + Arr1DIdxRowM(tmp581, (int32_t)960, i0) = + (party == SERVER) ? __tmp_in_tmp581 : 0; + } + + uint64_t *tmp582 = make_array((int32_t)960); + /* Variable to read the clear value corresponding to the input variable tmp582 + * at (3676,1-3676,37) */ + uint64_t __tmp_in_tmp582; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp582; + } + Arr1DIdxRowM(tmp582, (int32_t)960, i0) = + (party == SERVER) ? __tmp_in_tmp582 : 0; + } + + uint64_t *tmp583 = make_array((int32_t)960); + /* Variable to read the clear value corresponding to the input variable tmp583 + * at (3679,1-3679,37) */ + uint64_t __tmp_in_tmp583; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp583; + } + Arr1DIdxRowM(tmp583, (int32_t)960, i0) = + (party == SERVER) ? __tmp_in_tmp583 : 0; + } + + uint64_t *tmp584 = make_array((int32_t)960); + /* Variable to read the clear value corresponding to the input variable tmp584 + * at (3682,1-3682,37) */ + uint64_t __tmp_in_tmp584; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp584; + } + Arr1DIdxRowM(tmp584, (int32_t)960, i0) = + (party == SERVER) ? __tmp_in_tmp584 : 0; + } + + uint64_t *tmp585 = + make_array((int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp585 + * at (3685,1-3685,48) */ + uint64_t __tmp_in_tmp585; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)960; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp585; + } + Arr4DIdxRowM(tmp585, (int32_t)1, (int32_t)1, (int32_t)960, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp585 : 0; + } + } + } + } + + uint64_t *tmp586 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp586 + * at (3688,1-3688,37) */ + uint64_t __tmp_in_tmp586; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp586; + } + Arr1DIdxRowM(tmp586, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp586 : 0; + } + + uint64_t *tmp587 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp587 + * at (3691,1-3691,37) */ + uint64_t __tmp_in_tmp587; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp587; + } + Arr1DIdxRowM(tmp587, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp587 : 0; + } + + uint64_t *tmp588 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp588 + * at (3694,1-3694,37) */ + uint64_t __tmp_in_tmp588; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp588; + } + Arr1DIdxRowM(tmp588, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp588 : 0; + } + + uint64_t *tmp589 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp589 + * at (3697,1-3697,37) */ + uint64_t __tmp_in_tmp589; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp589; + } + Arr1DIdxRowM(tmp589, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp589 : 0; + } + + uint64_t *tmp590 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp590 + * at (3700,1-3700,47) */ + uint64_t __tmp_in_tmp590; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp590; + } + Arr4DIdxRowM(tmp590, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp590 : 0; + } + } + } + } + + uint64_t *tmp591 = make_array((int32_t)992); + /* Variable to read the clear value corresponding to the input variable tmp591 + * at (3703,1-3703,37) */ + uint64_t __tmp_in_tmp591; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp591; + } + Arr1DIdxRowM(tmp591, (int32_t)992, i0) = + (party == SERVER) ? __tmp_in_tmp591 : 0; + } + + uint64_t *tmp592 = make_array((int32_t)992); + /* Variable to read the clear value corresponding to the input variable tmp592 + * at (3706,1-3706,37) */ + uint64_t __tmp_in_tmp592; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp592; + } + Arr1DIdxRowM(tmp592, (int32_t)992, i0) = + (party == SERVER) ? __tmp_in_tmp592 : 0; + } + + uint64_t *tmp593 = make_array((int32_t)992); + /* Variable to read the clear value corresponding to the input variable tmp593 + * at (3709,1-3709,37) */ + uint64_t __tmp_in_tmp593; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp593; + } + Arr1DIdxRowM(tmp593, (int32_t)992, i0) = + (party == SERVER) ? __tmp_in_tmp593 : 0; + } + + uint64_t *tmp594 = make_array((int32_t)992); + /* Variable to read the clear value corresponding to the input variable tmp594 + * at (3712,1-3712,37) */ + uint64_t __tmp_in_tmp594; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp594; + } + Arr1DIdxRowM(tmp594, (int32_t)992, i0) = + (party == SERVER) ? __tmp_in_tmp594 : 0; + } + + uint64_t *tmp595 = + make_array((int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp595 + * at (3715,1-3715,48) */ + uint64_t __tmp_in_tmp595; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)992; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp595; + } + Arr4DIdxRowM(tmp595, (int32_t)1, (int32_t)1, (int32_t)992, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp595 : 0; + } + } + } + } + + uint64_t *tmp596 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp596 + * at (3718,1-3718,37) */ + uint64_t __tmp_in_tmp596; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp596; + } + Arr1DIdxRowM(tmp596, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp596 : 0; + } + + uint64_t *tmp597 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp597 + * at (3721,1-3721,37) */ + uint64_t __tmp_in_tmp597; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp597; + } + Arr1DIdxRowM(tmp597, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp597 : 0; + } + + uint64_t *tmp598 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp598 + * at (3724,1-3724,37) */ + uint64_t __tmp_in_tmp598; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp598; + } + Arr1DIdxRowM(tmp598, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp598 : 0; + } + + uint64_t *tmp599 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp599 + * at (3727,1-3727,37) */ + uint64_t __tmp_in_tmp599; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp599; + } + Arr1DIdxRowM(tmp599, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp599 : 0; + } + + uint64_t *tmp600 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp600 + * at (3730,1-3730,47) */ + uint64_t __tmp_in_tmp600; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp600; + } + Arr4DIdxRowM(tmp600, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)32, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp600 : 0; + } + } + } + } + + uint64_t *tmp601 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp601 + * at (3733,1-3733,38) */ + uint64_t __tmp_in_tmp601; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp601; + } + Arr1DIdxRowM(tmp601, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp601 : 0; + } + + uint64_t *tmp602 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp602 + * at (3736,1-3736,38) */ + uint64_t __tmp_in_tmp602; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp602; + } + Arr1DIdxRowM(tmp602, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp602 : 0; + } + + uint64_t *tmp603 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp603 + * at (3739,1-3739,38) */ + uint64_t __tmp_in_tmp603; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp603; + } + Arr1DIdxRowM(tmp603, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp603 : 0; + } + + uint64_t *tmp604 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp604 + * at (3742,1-3742,38) */ + uint64_t __tmp_in_tmp604; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp604; + } + Arr1DIdxRowM(tmp604, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp604 : 0; + } + + uint64_t *tmp605 = make_array((int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)1000); + /* Variable to read the clear value corresponding to the input variable tmp605 + * at (3745,1-3745,50) */ + uint64_t __tmp_in_tmp605; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1000; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp605; + } + Arr4DIdxRowM(tmp605, (int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)1000, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp605 : 0; + } + } + } + } + + uint64_t *tmp606 = make_array((int32_t)1000); + /* Variable to read the clear value corresponding to the input variable tmp606 + * at (3748,1-3748,38) */ + uint64_t __tmp_in_tmp606; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1000; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp606; + } + Arr1DIdxRowM(tmp606, (int32_t)1000, i0) = + (party == SERVER) ? __tmp_in_tmp606 : 0; + } + StartComputation(); + + uint64_t *tmp607 = + make_array((int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, (int32_t)7, + (int32_t)7, (int32_t)64, (int32_t)2, (int32_t)3, (int32_t)2, + (int32_t)3, (int32_t)2, (int32_t)2, tmp0, tmp1, tmp607); + ClearMemSecret4((int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, tmp0); + ClearMemSecret4((int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64, tmp1); + + uint64_t *tmp610 = + make_array((int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64); + ScaleDown4((int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp607, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, + tmp607, tmp2, tmp3, (int32_t)0, (int32_t)11, tmp610); + ClearMemSecret4((int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp607); + ClearMemSecret1((int32_t)64, tmp3); + ClearMemSecret1((int32_t)64, tmp2); + + uint64_t *tmp614 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + MaxPool((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, + (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)112, (int32_t)112, + (int32_t)64, tmp610, tmp614); + ClearMemSecret4((int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp610); + + uint64_t *tmp616 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp614, tmp616, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp614); + + uint64_t *tmp618 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp616, + tmp6, tmp7, (int32_t)0, (int32_t)11, tmp618); + ClearMemSecret1((int32_t)64, tmp6); + ClearMemSecret1((int32_t)64, tmp7); + + uint64_t *tmp621 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp618, tmp621, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp618); + + uint64_t *tmp623 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp621, tmp10, tmp623); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)128, tmp10); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp621); + + uint64_t *tmp626 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp623, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp623, + tmp11, tmp12, (int32_t)0, (int32_t)11, tmp626); + ClearMemSecret1((int32_t)128, tmp11); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp623); + ClearMemSecret1((int32_t)128, tmp12); + + uint64_t *tmp630 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp626, tmp630, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp626); + + uint64_t *tmp632 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp630, tmp15, tmp632); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp630); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp15); + + int64_t tmp635 = (int32_t)3; + + uint64_t *tmp636 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp632, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)64, tmp616, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)32, tmp632, tmp635, tmp636); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp616); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp632); + ClearMemPublic(tmp635); + + uint64_t *tmp640 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp636, + tmp16, tmp17, (int32_t)0, (int32_t)11, tmp640); + ClearMemSecret1((int32_t)96, tmp16); + ClearMemSecret1((int32_t)96, tmp17); + + uint64_t *tmp643 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp640, tmp643, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp640); + + uint64_t *tmp645 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp643, tmp20, tmp645); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp643); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)96, (int32_t)128, tmp20); + + uint64_t *tmp648 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp645, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp645, + tmp21, tmp22, (int32_t)0, (int32_t)11, tmp648); + ClearMemSecret1((int32_t)128, tmp21); + ClearMemSecret1((int32_t)128, tmp22); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp645); + + uint64_t *tmp652 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp648, tmp652, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp648); + + uint64_t *tmp654 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp652, tmp25, tmp654); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp652); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp25); + + int64_t tmp657 = (int32_t)3; + + uint64_t *tmp658 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp654, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)96, tmp636, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)32, tmp654, tmp657, tmp658); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp636); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp654); + ClearMemPublic(tmp657); + + uint64_t *tmp662 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp658, + tmp26, tmp27, (int32_t)0, (int32_t)11, tmp662); + ClearMemSecret1((int32_t)128, tmp27); + ClearMemSecret1((int32_t)128, tmp26); + + uint64_t *tmp665 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp662, tmp665, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp662); + + uint64_t *tmp667 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp665, tmp30, tmp667); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp665); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128, tmp30); + + uint64_t *tmp670 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp667, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp667, + tmp31, tmp32, (int32_t)0, (int32_t)11, tmp670); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp667); + ClearMemSecret1((int32_t)128, tmp32); + ClearMemSecret1((int32_t)128, tmp31); + + uint64_t *tmp674 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp670, tmp674, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp670); + + uint64_t *tmp676 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp674, tmp35, tmp676); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp35); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp674); + + int64_t tmp679 = (int32_t)3; + + uint64_t *tmp680 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp676, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)128, tmp658, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)32, tmp676, tmp679, tmp680); + ClearMemPublic(tmp679); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp676); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp658); + + uint64_t *tmp684 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp680, + tmp36, tmp37, (int32_t)0, (int32_t)11, tmp684); + ClearMemSecret1((int32_t)160, tmp37); + ClearMemSecret1((int32_t)160, tmp36); + + uint64_t *tmp687 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp684, tmp687, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp684); + + uint64_t *tmp689 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp687, tmp40, tmp689); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128, tmp40); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp687); + + uint64_t *tmp692 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp689, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp689, + tmp41, tmp42, (int32_t)0, (int32_t)11, tmp692); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp689); + ClearMemSecret1((int32_t)128, tmp42); + ClearMemSecret1((int32_t)128, tmp41); + + uint64_t *tmp696 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp692, tmp696, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp692); + + uint64_t *tmp698 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp696, tmp45, tmp698); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp45); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp696); + + int64_t tmp701 = (int32_t)3; + + uint64_t *tmp702 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp698, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)160, tmp680, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)32, tmp698, tmp701, tmp702); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp698); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp680); + ClearMemPublic(tmp701); + + uint64_t *tmp706 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp702, + tmp46, tmp47, (int32_t)0, (int32_t)11, tmp706); + ClearMemSecret1((int32_t)192, tmp47); + ClearMemSecret1((int32_t)192, tmp46); + + uint64_t *tmp709 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp706, tmp709, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp706); + + uint64_t *tmp711 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp709, tmp50, tmp711); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp709); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128, tmp50); + + uint64_t *tmp714 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp711, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp711, + tmp51, tmp52, (int32_t)0, (int32_t)11, tmp714); + ClearMemSecret1((int32_t)128, tmp52); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp711); + ClearMemSecret1((int32_t)128, tmp51); + + uint64_t *tmp718 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp714, tmp718, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp714); + + uint64_t *tmp720 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp718, tmp55, tmp720); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp55); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp718); + + int64_t tmp723 = (int32_t)3; + + uint64_t *tmp724 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp720, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)192, tmp702, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)32, tmp720, tmp723, tmp724); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp720); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp702); + ClearMemPublic(tmp723); + + uint64_t *tmp728 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp724, + tmp56, tmp57, (int32_t)0, (int32_t)11, tmp728); + ClearMemSecret1((int32_t)224, tmp56); + ClearMemSecret1((int32_t)224, tmp57); + + uint64_t *tmp731 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp728, tmp731, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp728); + + uint64_t *tmp733 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp731, tmp60, tmp733); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp731); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128, tmp60); + + uint64_t *tmp736 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp733, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp733, + tmp61, tmp62, (int32_t)0, (int32_t)11, tmp736); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp733); + ClearMemSecret1((int32_t)128, tmp61); + ClearMemSecret1((int32_t)128, tmp62); + + uint64_t *tmp740 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp736, tmp740, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp736); + + uint64_t *tmp742 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp740, tmp65, tmp742); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp65); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp740); + + int64_t tmp745 = (int32_t)3; + + uint64_t *tmp746 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp742, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)224, tmp724, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)32, tmp742, tmp745, tmp746); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp724); + ClearMemPublic(tmp745); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp742); + + uint64_t *tmp750 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp746, + tmp66, tmp67, (int32_t)0, (int32_t)11, tmp750); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp746); + ClearMemSecret1((int32_t)256, tmp66); + ClearMemSecret1((int32_t)256, tmp67); + + uint64_t *tmp754 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp750, tmp754, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp750); + + uint64_t *tmp756 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp754, tmp70, tmp756); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp754); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp70); + + uint64_t *tmp759 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + AvgPool((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)2, + (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)56, (int32_t)56, + (int32_t)128, tmp756, tmp759); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp756); + + uint64_t *tmp761 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759, + tmp71, tmp72, (int32_t)0, (int32_t)11, tmp761); + ClearMemSecret1((int32_t)128, tmp72); + ClearMemSecret1((int32_t)128, tmp71); + + uint64_t *tmp764 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp761, tmp764, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp761); + + uint64_t *tmp766 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp764, tmp75, tmp766); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp764); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128, tmp75); + + uint64_t *tmp769 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp766, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp766, + tmp76, tmp77, (int32_t)0, (int32_t)11, tmp769); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp766); + ClearMemSecret1((int32_t)128, tmp76); + ClearMemSecret1((int32_t)128, tmp77); + + uint64_t *tmp773 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp769, tmp773, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp769); + + uint64_t *tmp775 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp773, tmp80, tmp775); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp773); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp80); + + int64_t tmp778 = (int32_t)3; + + uint64_t *tmp779 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp775, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)128, tmp759, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp775, tmp778, tmp779); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759); + ClearMemPublic(tmp778); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp775); + + uint64_t *tmp783 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp779, + tmp81, tmp82, (int32_t)0, (int32_t)11, tmp783); + ClearMemSecret1((int32_t)160, tmp82); + ClearMemSecret1((int32_t)160, tmp81); + + uint64_t *tmp786 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp783, tmp786, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp783); + + uint64_t *tmp788 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp786, tmp85, tmp788); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128, tmp85); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp786); + + uint64_t *tmp791 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp788, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp788, + tmp86, tmp87, (int32_t)0, (int32_t)11, tmp791); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp788); + ClearMemSecret1((int32_t)128, tmp87); + ClearMemSecret1((int32_t)128, tmp86); + + uint64_t *tmp795 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp791, tmp795, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp791); + + uint64_t *tmp797 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp795, tmp90, tmp797); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp795); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp90); + + int64_t tmp800 = (int32_t)3; + + uint64_t *tmp801 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp797, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)160, tmp779, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp797, tmp800, tmp801); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp779); + ClearMemPublic(tmp800); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp797); + + uint64_t *tmp805 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp801, + tmp91, tmp92, (int32_t)0, (int32_t)11, tmp805); + ClearMemSecret1((int32_t)192, tmp92); + ClearMemSecret1((int32_t)192, tmp91); + + uint64_t *tmp808 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp805, tmp808, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp805); + + uint64_t *tmp810 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp808, tmp95, tmp810); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128, tmp95); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp808); + + uint64_t *tmp813 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp810, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp810, + tmp96, tmp97, (int32_t)0, (int32_t)11, tmp813); + ClearMemSecret1((int32_t)128, tmp96); + ClearMemSecret1((int32_t)128, tmp97); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp810); + + uint64_t *tmp817 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp813, tmp817, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp813); + + uint64_t *tmp819 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp817, tmp100, tmp819); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp100); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp817); + + int64_t tmp822 = (int32_t)3; + + uint64_t *tmp823 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp819, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)192, tmp801, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp819, tmp822, tmp823); + ClearMemPublic(tmp822); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp801); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp819); + + uint64_t *tmp827 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp823, + tmp101, tmp102, (int32_t)0, (int32_t)11, tmp827); + ClearMemSecret1((int32_t)224, tmp102); + ClearMemSecret1((int32_t)224, tmp101); + + uint64_t *tmp830 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp827, tmp830, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp827); + + uint64_t *tmp832 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp830, tmp105, tmp832); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128, tmp105); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp830); + + uint64_t *tmp835 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp832, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp832, + tmp106, tmp107, (int32_t)0, (int32_t)11, tmp835); + ClearMemSecret1((int32_t)128, tmp107); + ClearMemSecret1((int32_t)128, tmp106); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp832); + + uint64_t *tmp839 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp835, tmp839, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp835); + + uint64_t *tmp841 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp839, tmp110, tmp841); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp839); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp110); + + int64_t tmp844 = (int32_t)3; + + uint64_t *tmp845 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp841, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)224, tmp823, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp841, tmp844, tmp845); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp823); + ClearMemPublic(tmp844); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp841); + + uint64_t *tmp849 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp845, + tmp111, tmp112, (int32_t)0, (int32_t)11, tmp849); + ClearMemSecret1((int32_t)256, tmp111); + ClearMemSecret1((int32_t)256, tmp112); + + uint64_t *tmp852 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp849, tmp852, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp849); + + uint64_t *tmp854 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp852, tmp115, tmp854); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp115); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp852); + + uint64_t *tmp857 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp854, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp854, + tmp116, tmp117, (int32_t)0, (int32_t)11, tmp857); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp854); + ClearMemSecret1((int32_t)128, tmp116); + ClearMemSecret1((int32_t)128, tmp117); + + uint64_t *tmp861 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp857, tmp861, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp857); + + uint64_t *tmp863 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp861, tmp120, tmp863); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp861); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp120); + + int64_t tmp866 = (int32_t)3; + + uint64_t *tmp867 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp863, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)256, tmp845, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp863, tmp866, tmp867); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp863); + ClearMemPublic(tmp866); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp845); + + uint64_t *tmp871 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp867, + tmp121, tmp122, (int32_t)0, (int32_t)11, tmp871); + ClearMemSecret1((int32_t)288, tmp121); + ClearMemSecret1((int32_t)288, tmp122); + + uint64_t *tmp874 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp871, tmp874, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp871); + + uint64_t *tmp876 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp874, tmp125, tmp876); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp874); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128, tmp125); + + uint64_t *tmp879 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp876, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp876, + tmp126, tmp127, (int32_t)0, (int32_t)11, tmp879); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp876); + ClearMemSecret1((int32_t)128, tmp126); + ClearMemSecret1((int32_t)128, tmp127); + + uint64_t *tmp883 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp879, tmp883, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp879); + + uint64_t *tmp885 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp883, tmp130, tmp885); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp883); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp130); + + int64_t tmp888 = (int32_t)3; + + uint64_t *tmp889 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp885, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)288, tmp867, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp885, tmp888, tmp889); + ClearMemPublic(tmp888); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp867); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp885); + + uint64_t *tmp893 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp889, + tmp131, tmp132, (int32_t)0, (int32_t)11, tmp893); + ClearMemSecret1((int32_t)320, tmp131); + ClearMemSecret1((int32_t)320, tmp132); + + uint64_t *tmp896 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp893, tmp896, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp893); + + uint64_t *tmp898 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp896, tmp135, tmp898); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp896); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128, tmp135); + + uint64_t *tmp901 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp898, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp898, + tmp136, tmp137, (int32_t)0, (int32_t)11, tmp901); + ClearMemSecret1((int32_t)128, tmp137); + ClearMemSecret1((int32_t)128, tmp136); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp898); + + uint64_t *tmp905 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp901, tmp905, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp901); + + uint64_t *tmp907 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp905, tmp140, tmp907); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp140); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp905); + + int64_t tmp910 = (int32_t)3; + + uint64_t *tmp911 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp907, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)320, tmp889, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp907, tmp910, tmp911); + ClearMemPublic(tmp910); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp907); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp889); + + uint64_t *tmp915 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp911, + tmp141, tmp142, (int32_t)0, (int32_t)11, tmp915); + ClearMemSecret1((int32_t)352, tmp142); + ClearMemSecret1((int32_t)352, tmp141); + + uint64_t *tmp918 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp915, tmp918, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp915); + + uint64_t *tmp920 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp918, tmp145, tmp920); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp918); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128, tmp145); + + uint64_t *tmp923 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp920, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp920, + tmp146, tmp147, (int32_t)0, (int32_t)11, tmp923); + ClearMemSecret1((int32_t)128, tmp146); + ClearMemSecret1((int32_t)128, tmp147); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp920); + + uint64_t *tmp927 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp923, tmp927, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp923); + + uint64_t *tmp929 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp927, tmp150, tmp929); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp150); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp927); + + int64_t tmp932 = (int32_t)3; + + uint64_t *tmp933 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp929, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)352, tmp911, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp929, tmp932, tmp933); + ClearMemPublic(tmp932); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp929); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp911); + + uint64_t *tmp937 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp933, + tmp151, tmp152, (int32_t)0, (int32_t)11, tmp937); + ClearMemSecret1((int32_t)384, tmp152); + ClearMemSecret1((int32_t)384, tmp151); + + uint64_t *tmp940 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp937, tmp940, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp937); + + uint64_t *tmp942 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp940, tmp155, tmp942); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128, tmp155); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp940); + + uint64_t *tmp945 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp942, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp942, + tmp156, tmp157, (int32_t)0, (int32_t)11, tmp945); + ClearMemSecret1((int32_t)128, tmp156); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp942); + ClearMemSecret1((int32_t)128, tmp157); + + uint64_t *tmp949 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp945, tmp949, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp945); + + uint64_t *tmp951 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp949, tmp160, tmp951); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp949); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp160); + + int64_t tmp954 = (int32_t)3; + + uint64_t *tmp955 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp951, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)384, tmp933, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp951, tmp954, tmp955); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp951); + ClearMemPublic(tmp954); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp933); + + uint64_t *tmp959 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp955, + tmp161, tmp162, (int32_t)0, (int32_t)11, tmp959); + ClearMemSecret1((int32_t)416, tmp161); + ClearMemSecret1((int32_t)416, tmp162); + + uint64_t *tmp962 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp959, tmp962, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp959); + + uint64_t *tmp964 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp962, tmp165, tmp964); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp962); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128, tmp165); + + uint64_t *tmp967 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp964, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp964, + tmp166, tmp167, (int32_t)0, (int32_t)11, tmp967); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp964); + ClearMemSecret1((int32_t)128, tmp166); + ClearMemSecret1((int32_t)128, tmp167); + + uint64_t *tmp971 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp967, tmp971, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp967); + + uint64_t *tmp973 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp971, tmp170, tmp973); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp971); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp170); + + int64_t tmp976 = (int32_t)3; + + uint64_t *tmp977 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp973, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)416, tmp955, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp973, tmp976, tmp977); + ClearMemPublic(tmp976); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp955); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp973); + + uint64_t *tmp981 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp977, + tmp171, tmp172, (int32_t)0, (int32_t)11, tmp981); + ClearMemSecret1((int32_t)448, tmp172); + ClearMemSecret1((int32_t)448, tmp171); + + uint64_t *tmp984 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp981, tmp984, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp981); + + uint64_t *tmp986 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp984, tmp175, tmp986); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128, tmp175); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp984); + + uint64_t *tmp989 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp986, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp986, + tmp176, tmp177, (int32_t)0, (int32_t)11, tmp989); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp986); + ClearMemSecret1((int32_t)128, tmp176); + ClearMemSecret1((int32_t)128, tmp177); + + uint64_t *tmp993 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp989, tmp993, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp989); + + uint64_t *tmp995 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp993, tmp180, tmp995); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp180); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp993); + + int64_t tmp998 = (int32_t)3; + + uint64_t *tmp999 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp995, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)448, tmp977, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp995, tmp998, tmp999); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp977); + ClearMemPublic(tmp998); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp995); + + uint64_t *tmp1003 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp999, + tmp181, tmp182, (int32_t)0, (int32_t)11, tmp1003); + ClearMemSecret1((int32_t)480, tmp182); + ClearMemSecret1((int32_t)480, tmp181); + + uint64_t *tmp1006 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp1003, tmp1006, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp1003); + + uint64_t *tmp1008 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1006, tmp185, tmp1008); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128, tmp185); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp1006); + + uint64_t *tmp1011 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1008, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, + tmp1008, tmp186, tmp187, (int32_t)0, (int32_t)11, tmp1011); + ClearMemSecret1((int32_t)128, tmp186); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1008); + ClearMemSecret1((int32_t)128, tmp187); + + uint64_t *tmp1015 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1011, tmp1015, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1011); + + uint64_t *tmp1017 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1015, tmp190, tmp1017); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp190); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1015); + + int64_t tmp1020 = (int32_t)3; + + uint64_t *tmp1021 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp1017, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)480, tmp999, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)32, tmp1017, tmp1020, tmp1021); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp999); + ClearMemPublic(tmp1020); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp1017); + + uint64_t *tmp1025 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, + tmp1021, tmp191, tmp192, (int32_t)0, (int32_t)11, tmp1025); + ClearMemSecret1((int32_t)512, tmp192); + ClearMemSecret1((int32_t)512, tmp191); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1021); + + uint64_t *tmp1029 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1025, tmp1029, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1025); + + uint64_t *tmp1031 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1029, tmp195, tmp1031); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256, tmp195); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1029); + + uint64_t *tmp1034 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + AvgPool((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)2, + (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)28, (int32_t)28, + (int32_t)256, tmp1031, tmp1034); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp1031); + + uint64_t *tmp1036 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, + tmp1034, tmp196, tmp197, (int32_t)0, (int32_t)11, tmp1036); + ClearMemSecret1((int32_t)256, tmp197); + ClearMemSecret1((int32_t)256, tmp196); + + uint64_t *tmp1039 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1036, tmp1039, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1036); + + uint64_t *tmp1041 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1039, tmp200, tmp1041); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp200); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1039); + + uint64_t *tmp1044 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1041, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1041, tmp201, tmp202, (int32_t)0, (int32_t)11, tmp1044); + ClearMemSecret1((int32_t)128, tmp202); + ClearMemSecret1((int32_t)128, tmp201); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1041); + + uint64_t *tmp1048 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1044, tmp1048, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1044); + + uint64_t *tmp1050 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1048, tmp205, tmp1050); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1048); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp205); + + int64_t tmp1053 = (int32_t)3; + + uint64_t *tmp1054 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1050, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)256, tmp1034, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1050, tmp1053, tmp1054); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1050); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034); + ClearMemPublic(tmp1053); + + uint64_t *tmp1058 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, + tmp1054, tmp206, tmp207, (int32_t)0, (int32_t)11, tmp1058); + ClearMemSecret1((int32_t)288, tmp206); + ClearMemSecret1((int32_t)288, tmp207); + + uint64_t *tmp1061 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1058, tmp1061, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1058); + + uint64_t *tmp1063 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1061, tmp210, tmp1063); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128, tmp210); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1061); + + uint64_t *tmp1066 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1063, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1063, tmp211, tmp212, (int32_t)0, (int32_t)11, tmp1066); + ClearMemSecret1((int32_t)128, tmp211); + ClearMemSecret1((int32_t)128, tmp212); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1063); + + uint64_t *tmp1070 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1066, tmp1070, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1066); + + uint64_t *tmp1072 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1070, tmp215, tmp1072); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp215); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1070); + + int64_t tmp1075 = (int32_t)3; + + uint64_t *tmp1076 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1072, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)288, tmp1054, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1072, tmp1075, tmp1076); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1054); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1072); + ClearMemPublic(tmp1075); + + uint64_t *tmp1080 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, + tmp1076, tmp216, tmp217, (int32_t)0, (int32_t)11, tmp1080); + ClearMemSecret1((int32_t)320, tmp216); + ClearMemSecret1((int32_t)320, tmp217); + + uint64_t *tmp1083 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1080, tmp1083, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1080); + + uint64_t *tmp1085 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1083, tmp220, tmp1085); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128, tmp220); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1083); + + uint64_t *tmp1088 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1085, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1085, tmp221, tmp222, (int32_t)0, (int32_t)11, tmp1088); + ClearMemSecret1((int32_t)128, tmp221); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1085); + ClearMemSecret1((int32_t)128, tmp222); + + uint64_t *tmp1092 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1088, tmp1092, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1088); + + uint64_t *tmp1094 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1092, tmp225, tmp1094); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1092); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp225); + + int64_t tmp1097 = (int32_t)3; + + uint64_t *tmp1098 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1094, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)320, tmp1076, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1094, tmp1097, tmp1098); + ClearMemPublic(tmp1097); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1094); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1076); + + uint64_t *tmp1102 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, + tmp1098, tmp226, tmp227, (int32_t)0, (int32_t)11, tmp1102); + ClearMemSecret1((int32_t)352, tmp227); + ClearMemSecret1((int32_t)352, tmp226); + + uint64_t *tmp1105 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1102, tmp1105, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1102); + + uint64_t *tmp1107 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1105, tmp230, tmp1107); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128, tmp230); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1105); + + uint64_t *tmp1110 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1107, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1107, tmp231, tmp232, (int32_t)0, (int32_t)11, tmp1110); + ClearMemSecret1((int32_t)128, tmp231); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1107); + ClearMemSecret1((int32_t)128, tmp232); + + uint64_t *tmp1114 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1110, tmp1114, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1110); + + uint64_t *tmp1116 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1114, tmp235, tmp1116); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp235); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1114); + + int64_t tmp1119 = (int32_t)3; + + uint64_t *tmp1120 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1116, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)352, tmp1098, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1116, tmp1119, tmp1120); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1116); + ClearMemPublic(tmp1119); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1098); + + uint64_t *tmp1124 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, + tmp1120, tmp236, tmp237, (int32_t)0, (int32_t)11, tmp1124); + ClearMemSecret1((int32_t)384, tmp236); + ClearMemSecret1((int32_t)384, tmp237); + + uint64_t *tmp1127 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1124, tmp1127, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1124); + + uint64_t *tmp1129 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1127, tmp240, tmp1129); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128, tmp240); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1127); + + uint64_t *tmp1132 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1129, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1129, tmp241, tmp242, (int32_t)0, (int32_t)11, tmp1132); + ClearMemSecret1((int32_t)128, tmp242); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1129); + ClearMemSecret1((int32_t)128, tmp241); + + uint64_t *tmp1136 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1132, tmp1136, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1132); + + uint64_t *tmp1138 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1136, tmp245, tmp1138); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1136); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp245); + + int64_t tmp1141 = (int32_t)3; + + uint64_t *tmp1142 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1138, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)384, tmp1120, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1138, tmp1141, tmp1142); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1138); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1120); + ClearMemPublic(tmp1141); + + uint64_t *tmp1146 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, + tmp1142, tmp246, tmp247, (int32_t)0, (int32_t)11, tmp1146); + ClearMemSecret1((int32_t)416, tmp246); + ClearMemSecret1((int32_t)416, tmp247); + + uint64_t *tmp1149 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1146, tmp1149, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1146); + + uint64_t *tmp1151 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1149, tmp250, tmp1151); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128, tmp250); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1149); + + uint64_t *tmp1154 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1151, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1151, tmp251, tmp252, (int32_t)0, (int32_t)11, tmp1154); + ClearMemSecret1((int32_t)128, tmp251); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1151); + ClearMemSecret1((int32_t)128, tmp252); + + uint64_t *tmp1158 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1154, tmp1158, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1154); + + uint64_t *tmp1160 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1158, tmp255, tmp1160); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1158); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp255); + + int64_t tmp1163 = (int32_t)3; + + uint64_t *tmp1164 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1160, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)416, tmp1142, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1160, tmp1163, tmp1164); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1160); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1142); + ClearMemPublic(tmp1163); + + uint64_t *tmp1168 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, + tmp1164, tmp256, tmp257, (int32_t)0, (int32_t)11, tmp1168); + ClearMemSecret1((int32_t)448, tmp256); + ClearMemSecret1((int32_t)448, tmp257); + + uint64_t *tmp1171 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1168, tmp1171, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1168); + + uint64_t *tmp1173 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1171, tmp260, tmp1173); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128, tmp260); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1171); + + uint64_t *tmp1176 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1173, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1173, tmp261, tmp262, (int32_t)0, (int32_t)11, tmp1176); + ClearMemSecret1((int32_t)128, tmp261); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1173); + ClearMemSecret1((int32_t)128, tmp262); + + uint64_t *tmp1180 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1176, tmp1180, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1176); + + uint64_t *tmp1182 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1180, tmp265, tmp1182); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1180); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp265); + + int64_t tmp1185 = (int32_t)3; + + uint64_t *tmp1186 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1182, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)448, tmp1164, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1182, tmp1185, tmp1186); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1182); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1164); + ClearMemPublic(tmp1185); + + uint64_t *tmp1190 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, + tmp1186, tmp266, tmp267, (int32_t)0, (int32_t)11, tmp1190); + ClearMemSecret1((int32_t)480, tmp266); + ClearMemSecret1((int32_t)480, tmp267); + + uint64_t *tmp1193 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1190, tmp1193, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1190); + + uint64_t *tmp1195 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1193, tmp270, tmp1195); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1193); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128, tmp270); + + uint64_t *tmp1198 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1195, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1195, tmp271, tmp272, (int32_t)0, (int32_t)11, tmp1198); + ClearMemSecret1((int32_t)128, tmp271); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1195); + ClearMemSecret1((int32_t)128, tmp272); + + uint64_t *tmp1202 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1198, tmp1202, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1198); + + uint64_t *tmp1204 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1202, tmp275, tmp1204); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp275); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1202); + + int64_t tmp1207 = (int32_t)3; + + uint64_t *tmp1208 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1204, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)480, tmp1186, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1204, tmp1207, tmp1208); + ClearMemPublic(tmp1207); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1204); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1186); + + uint64_t *tmp1212 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, + tmp1208, tmp276, tmp277, (int32_t)0, (int32_t)11, tmp1212); + ClearMemSecret1((int32_t)512, tmp277); + ClearMemSecret1((int32_t)512, tmp276); + + uint64_t *tmp1215 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1212, tmp1215, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1212); + + uint64_t *tmp1217 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1215, tmp280, tmp1217); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp280); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1215); + + uint64_t *tmp1220 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1217, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1217, tmp281, tmp282, (int32_t)0, (int32_t)11, tmp1220); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1217); + ClearMemSecret1((int32_t)128, tmp282); + ClearMemSecret1((int32_t)128, tmp281); + + uint64_t *tmp1224 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1220, tmp1224, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1220); + + uint64_t *tmp1226 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1224, tmp285, tmp1226); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp285); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1224); + + int64_t tmp1229 = (int32_t)3; + + uint64_t *tmp1230 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1226, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)512, tmp1208, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1226, tmp1229, tmp1230); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1208); + ClearMemPublic(tmp1229); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1226); + + uint64_t *tmp1234 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, + tmp1230, tmp286, tmp287, (int32_t)0, (int32_t)11, tmp1234); + ClearMemSecret1((int32_t)544, tmp287); + ClearMemSecret1((int32_t)544, tmp286); + + uint64_t *tmp1237 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1234, tmp1237, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1234); + + uint64_t *tmp1239 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1237, tmp290, tmp1239); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128, tmp290); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1237); + + uint64_t *tmp1242 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1239, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1239, tmp291, tmp292, (int32_t)0, (int32_t)11, tmp1242); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1239); + ClearMemSecret1((int32_t)128, tmp291); + ClearMemSecret1((int32_t)128, tmp292); + + uint64_t *tmp1246 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1242, tmp1246, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1242); + + uint64_t *tmp1248 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1246, tmp295, tmp1248); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp295); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1246); + + int64_t tmp1251 = (int32_t)3; + + uint64_t *tmp1252 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1248, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)544, tmp1230, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1248, tmp1251, tmp1252); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1230); + ClearMemPublic(tmp1251); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1248); + + uint64_t *tmp1256 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, + tmp1252, tmp296, tmp297, (int32_t)0, (int32_t)11, tmp1256); + ClearMemSecret1((int32_t)576, tmp296); + ClearMemSecret1((int32_t)576, tmp297); + + uint64_t *tmp1259 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1256, tmp1259, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1256); + + uint64_t *tmp1261 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1259, tmp300, tmp1261); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128, tmp300); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1259); + + uint64_t *tmp1264 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1261, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1261, tmp301, tmp302, (int32_t)0, (int32_t)11, tmp1264); + ClearMemSecret1((int32_t)128, tmp301); + ClearMemSecret1((int32_t)128, tmp302); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1261); + + uint64_t *tmp1268 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1264, tmp1268, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1264); + + uint64_t *tmp1270 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1268, tmp305, tmp1270); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1268); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp305); + + int64_t tmp1273 = (int32_t)3; + + uint64_t *tmp1274 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1270, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)576, tmp1252, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1270, tmp1273, tmp1274); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1270); + ClearMemPublic(tmp1273); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1252); + + uint64_t *tmp1278 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, + tmp1274, tmp306, tmp307, (int32_t)0, (int32_t)11, tmp1278); + ClearMemSecret1((int32_t)608, tmp307); + ClearMemSecret1((int32_t)608, tmp306); + + uint64_t *tmp1281 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1278, tmp1281, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1278); + + uint64_t *tmp1283 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1281, tmp310, tmp1283); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128, tmp310); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1281); + + uint64_t *tmp1286 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1283, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1283, tmp311, tmp312, (int32_t)0, (int32_t)11, tmp1286); + ClearMemSecret1((int32_t)128, tmp312); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1283); + ClearMemSecret1((int32_t)128, tmp311); + + uint64_t *tmp1290 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1286, tmp1290, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1286); + + uint64_t *tmp1292 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1290, tmp315, tmp1292); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1290); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp315); + + int64_t tmp1295 = (int32_t)3; + + uint64_t *tmp1296 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1292, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)608, tmp1274, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1292, tmp1295, tmp1296); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1292); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1274); + ClearMemPublic(tmp1295); + + uint64_t *tmp1300 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, + tmp1296, tmp316, tmp317, (int32_t)0, (int32_t)11, tmp1300); + ClearMemSecret1((int32_t)640, tmp316); + ClearMemSecret1((int32_t)640, tmp317); + + uint64_t *tmp1303 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1300, tmp1303, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1300); + + uint64_t *tmp1305 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1303, tmp320, tmp1305); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1303); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128, tmp320); + + uint64_t *tmp1308 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1305, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1305, tmp321, tmp322, (int32_t)0, (int32_t)11, tmp1308); + ClearMemSecret1((int32_t)128, tmp322); + ClearMemSecret1((int32_t)128, tmp321); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1305); + + uint64_t *tmp1312 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1308, tmp1312, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1308); + + uint64_t *tmp1314 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1312, tmp325, tmp1314); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1312); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp325); + + int64_t tmp1317 = (int32_t)3; + + uint64_t *tmp1318 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1314, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)640, tmp1296, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1314, tmp1317, tmp1318); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1296); + ClearMemPublic(tmp1317); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1314); + + uint64_t *tmp1322 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, + tmp1318, tmp326, tmp327, (int32_t)0, (int32_t)11, tmp1322); + ClearMemSecret1((int32_t)672, tmp327); + ClearMemSecret1((int32_t)672, tmp326); + + uint64_t *tmp1325 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1322, tmp1325, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1322); + + uint64_t *tmp1327 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1325, tmp330, tmp1327); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1325); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128, tmp330); + + uint64_t *tmp1330 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1327, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1327, tmp331, tmp332, (int32_t)0, (int32_t)11, tmp1330); + ClearMemSecret1((int32_t)128, tmp332); + ClearMemSecret1((int32_t)128, tmp331); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1327); + + uint64_t *tmp1334 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1330, tmp1334, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1330); + + uint64_t *tmp1336 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1334, tmp335, tmp1336); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp335); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1334); + + int64_t tmp1339 = (int32_t)3; + + uint64_t *tmp1340 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1336, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)672, tmp1318, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1336, tmp1339, tmp1340); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1318); + ClearMemPublic(tmp1339); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1336); + + uint64_t *tmp1344 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, + tmp1340, tmp336, tmp337, (int32_t)0, (int32_t)11, tmp1344); + ClearMemSecret1((int32_t)704, tmp337); + ClearMemSecret1((int32_t)704, tmp336); + + uint64_t *tmp1347 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1344, tmp1347, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1344); + + uint64_t *tmp1349 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1347, tmp340, tmp1349); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128, tmp340); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1347); + + uint64_t *tmp1352 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1349, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1349, tmp341, tmp342, (int32_t)0, (int32_t)11, tmp1352); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1349); + ClearMemSecret1((int32_t)128, tmp342); + ClearMemSecret1((int32_t)128, tmp341); + + uint64_t *tmp1356 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1352, tmp1356, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1352); + + uint64_t *tmp1358 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1356, tmp345, tmp1358); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1356); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp345); + + int64_t tmp1361 = (int32_t)3; + + uint64_t *tmp1362 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1358, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)704, tmp1340, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1358, tmp1361, tmp1362); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1358); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1340); + ClearMemPublic(tmp1361); + + uint64_t *tmp1366 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, + tmp1362, tmp346, tmp347, (int32_t)0, (int32_t)11, tmp1366); + ClearMemSecret1((int32_t)736, tmp347); + ClearMemSecret1((int32_t)736, tmp346); + + uint64_t *tmp1369 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1366, tmp1369, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1366); + + uint64_t *tmp1371 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1369, tmp350, tmp1371); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128, tmp350); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1369); + + uint64_t *tmp1374 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1371, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1371, tmp351, tmp352, (int32_t)0, (int32_t)11, tmp1374); + ClearMemSecret1((int32_t)128, tmp352); + ClearMemSecret1((int32_t)128, tmp351); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1371); + + uint64_t *tmp1378 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1374, tmp1378, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1374); + + uint64_t *tmp1380 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1378, tmp355, tmp1380); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp355); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1378); + + int64_t tmp1383 = (int32_t)3; + + uint64_t *tmp1384 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1380, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)736, tmp1362, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1380, tmp1383, tmp1384); + ClearMemPublic(tmp1383); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1362); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1380); + + uint64_t *tmp1388 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, + tmp1384, tmp356, tmp357, (int32_t)0, (int32_t)11, tmp1388); + ClearMemSecret1((int32_t)768, tmp356); + ClearMemSecret1((int32_t)768, tmp357); + + uint64_t *tmp1391 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1388, tmp1391, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1388); + + uint64_t *tmp1393 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1391, tmp360, tmp1393); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128, tmp360); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1391); + + uint64_t *tmp1396 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1393, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1393, tmp361, tmp362, (int32_t)0, (int32_t)11, tmp1396); + ClearMemSecret1((int32_t)128, tmp362); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1393); + ClearMemSecret1((int32_t)128, tmp361); + + uint64_t *tmp1400 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1396, tmp1400, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1396); + + uint64_t *tmp1402 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1400, tmp365, tmp1402); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp365); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1400); + + int64_t tmp1405 = (int32_t)3; + + uint64_t *tmp1406 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1402, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)768, tmp1384, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1402, tmp1405, tmp1406); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1384); + ClearMemPublic(tmp1405); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1402); + + uint64_t *tmp1410 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, + tmp1406, tmp366, tmp367, (int32_t)0, (int32_t)11, tmp1410); + ClearMemSecret1((int32_t)800, tmp367); + ClearMemSecret1((int32_t)800, tmp366); + + uint64_t *tmp1413 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1410, tmp1413, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1410); + + uint64_t *tmp1415 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1413, tmp370, tmp1415); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128, tmp370); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1413); + + uint64_t *tmp1418 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1415, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1415, tmp371, tmp372, (int32_t)0, (int32_t)11, tmp1418); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1415); + ClearMemSecret1((int32_t)128, tmp372); + ClearMemSecret1((int32_t)128, tmp371); + + uint64_t *tmp1422 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1418, tmp1422, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1418); + + uint64_t *tmp1424 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1422, tmp375, tmp1424); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1422); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp375); + + int64_t tmp1427 = (int32_t)3; + + uint64_t *tmp1428 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1424, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)800, tmp1406, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1424, tmp1427, tmp1428); + ClearMemPublic(tmp1427); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1424); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1406); + + uint64_t *tmp1432 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, + tmp1428, tmp376, tmp377, (int32_t)0, (int32_t)11, tmp1432); + ClearMemSecret1((int32_t)832, tmp376); + ClearMemSecret1((int32_t)832, tmp377); + + uint64_t *tmp1435 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1432, tmp1435, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1432); + + uint64_t *tmp1437 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1435, tmp380, tmp1437); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1435); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128, tmp380); + + uint64_t *tmp1440 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1437, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1437, tmp381, tmp382, (int32_t)0, (int32_t)11, tmp1440); + ClearMemSecret1((int32_t)128, tmp382); + ClearMemSecret1((int32_t)128, tmp381); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1437); + + uint64_t *tmp1444 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1440, tmp1444, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1440); + + uint64_t *tmp1446 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1444, tmp385, tmp1446); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp385); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1444); + + int64_t tmp1449 = (int32_t)3; + + uint64_t *tmp1450 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1446, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)832, tmp1428, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1446, tmp1449, tmp1450); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1446); + ClearMemPublic(tmp1449); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1428); + + uint64_t *tmp1454 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, + tmp1450, tmp386, tmp387, (int32_t)0, (int32_t)11, tmp1454); + ClearMemSecret1((int32_t)864, tmp387); + ClearMemSecret1((int32_t)864, tmp386); + + uint64_t *tmp1457 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1454, tmp1457, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1454); + + uint64_t *tmp1459 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1457, tmp390, tmp1459); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128, tmp390); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1457); + + uint64_t *tmp1462 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1459, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1459, tmp391, tmp392, (int32_t)0, (int32_t)11, tmp1462); + ClearMemSecret1((int32_t)128, tmp392); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1459); + ClearMemSecret1((int32_t)128, tmp391); + + uint64_t *tmp1466 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1462, tmp1466, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1462); + + uint64_t *tmp1468 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1466, tmp395, tmp1468); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp395); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1466); + + int64_t tmp1471 = (int32_t)3; + + uint64_t *tmp1472 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1468, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)864, tmp1450, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1468, tmp1471, tmp1472); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1468); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1450); + ClearMemPublic(tmp1471); + + uint64_t *tmp1476 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, + tmp1472, tmp396, tmp397, (int32_t)0, (int32_t)11, tmp1476); + ClearMemSecret1((int32_t)896, tmp397); + ClearMemSecret1((int32_t)896, tmp396); + + uint64_t *tmp1479 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1476, tmp1479, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1476); + + uint64_t *tmp1481 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1479, tmp400, tmp1481); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128, tmp400); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1479); + + uint64_t *tmp1484 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1481, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1481, tmp401, tmp402, (int32_t)0, (int32_t)11, tmp1484); + ClearMemSecret1((int32_t)128, tmp401); + ClearMemSecret1((int32_t)128, tmp402); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1481); + + uint64_t *tmp1488 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1484, tmp1488, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1484); + + uint64_t *tmp1490 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1488, tmp405, tmp1490); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp405); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1488); + + int64_t tmp1493 = (int32_t)3; + + uint64_t *tmp1494 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1490, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)896, tmp1472, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1490, tmp1493, tmp1494); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1472); + ClearMemPublic(tmp1493); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1490); + + uint64_t *tmp1498 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, + tmp1494, tmp406, tmp407, (int32_t)0, (int32_t)11, tmp1498); + ClearMemSecret1((int32_t)928, tmp407); + ClearMemSecret1((int32_t)928, tmp406); + + uint64_t *tmp1501 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1498, tmp1501, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1498); + + uint64_t *tmp1503 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1501, tmp410, tmp1503); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1501); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128, tmp410); + + uint64_t *tmp1506 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1503, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1503, tmp411, tmp412, (int32_t)0, (int32_t)11, tmp1506); + ClearMemSecret1((int32_t)128, tmp412); + ClearMemSecret1((int32_t)128, tmp411); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1503); + + uint64_t *tmp1510 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1506, tmp1510, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1506); + + uint64_t *tmp1512 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1510, tmp415, tmp1512); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp415); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1510); + + int64_t tmp1515 = (int32_t)3; + + uint64_t *tmp1516 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1512, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)928, tmp1494, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1512, tmp1515, tmp1516); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1512); + ClearMemPublic(tmp1515); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1494); + + uint64_t *tmp1520 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, + tmp1516, tmp416, tmp417, (int32_t)0, (int32_t)11, tmp1520); + ClearMemSecret1((int32_t)960, tmp416); + ClearMemSecret1((int32_t)960, tmp417); + + uint64_t *tmp1523 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1520, tmp1523, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1520); + + uint64_t *tmp1525 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1523, tmp420, tmp1525); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128, tmp420); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1523); + + uint64_t *tmp1528 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1525, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1525, tmp421, tmp422, (int32_t)0, (int32_t)11, tmp1528); + ClearMemSecret1((int32_t)128, tmp421); + ClearMemSecret1((int32_t)128, tmp422); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1525); + + uint64_t *tmp1532 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1528, tmp1532, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1528); + + uint64_t *tmp1534 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1532, tmp425, tmp1534); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1532); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp425); + + int64_t tmp1537 = (int32_t)3; + + uint64_t *tmp1538 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1534, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)960, tmp1516, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1534, tmp1537, tmp1538); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1534); + ClearMemPublic(tmp1537); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1516); + + uint64_t *tmp1542 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, + tmp1538, tmp426, tmp427, (int32_t)0, (int32_t)11, tmp1542); + ClearMemSecret1((int32_t)992, tmp427); + ClearMemSecret1((int32_t)992, tmp426); + + uint64_t *tmp1545 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1542, tmp1545, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1542); + + uint64_t *tmp1547 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1545, tmp430, tmp1547); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1545); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128, tmp430); + + uint64_t *tmp1550 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1547, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, + tmp1547, tmp431, tmp432, (int32_t)0, (int32_t)11, tmp1550); + ClearMemSecret1((int32_t)128, tmp432); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1547); + ClearMemSecret1((int32_t)128, tmp431); + + uint64_t *tmp1554 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1550, tmp1554, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1550); + + uint64_t *tmp1556 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1554, tmp435, tmp1556); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1554); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp435); + + int64_t tmp1559 = (int32_t)3; + + uint64_t *tmp1560 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1556, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)992, tmp1538, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)32, tmp1556, tmp1559, tmp1560); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1556); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1538); + ClearMemPublic(tmp1559); + + uint64_t *tmp1564 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, + tmp1560, tmp436, tmp437, (int32_t)0, (int32_t)11, tmp1564); + ClearMemSecret1((int32_t)1024, tmp437); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1560); + ClearMemSecret1((int32_t)1024, tmp436); + + uint64_t *tmp1568 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1564, tmp1568, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1564); + + uint64_t *tmp1570 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1568, tmp440, tmp1570); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1568); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512, tmp440); + + uint64_t *tmp1573 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + AvgPool((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)2, + (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)14, (int32_t)14, + (int32_t)512, tmp1570, tmp1573); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1570); + + uint64_t *tmp1575 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573, + tmp441, tmp442, (int32_t)0, (int32_t)11, tmp1575); + ClearMemSecret1((int32_t)512, tmp442); + ClearMemSecret1((int32_t)512, tmp441); + + uint64_t *tmp1578 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1575, tmp1578, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1575); + + uint64_t *tmp1580 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1578, tmp445, tmp1580); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp445); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1578); + + uint64_t *tmp1583 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1580, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1580, + tmp446, tmp447, (int32_t)0, (int32_t)11, tmp1583); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1580); + ClearMemSecret1((int32_t)128, tmp447); + ClearMemSecret1((int32_t)128, tmp446); + + uint64_t *tmp1587 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1583, tmp1587, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1583); + + uint64_t *tmp1589 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1587, tmp450, tmp1589); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1587); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp450); + + int64_t tmp1592 = (int32_t)3; + + uint64_t *tmp1593 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1589, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)512, tmp1573, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1589, tmp1592, tmp1593); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1589); + ClearMemPublic(tmp1592); + + uint64_t *tmp1597 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1593, + tmp451, tmp452, (int32_t)0, (int32_t)11, tmp1597); + ClearMemSecret1((int32_t)544, tmp452); + ClearMemSecret1((int32_t)544, tmp451); + + uint64_t *tmp1600 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1597, tmp1600, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1597); + + uint64_t *tmp1602 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1600, tmp455, tmp1602); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1600); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128, tmp455); + + uint64_t *tmp1605 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1602, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1602, + tmp456, tmp457, (int32_t)0, (int32_t)11, tmp1605); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1602); + ClearMemSecret1((int32_t)128, tmp456); + ClearMemSecret1((int32_t)128, tmp457); + + uint64_t *tmp1609 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1605, tmp1609, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1605); + + uint64_t *tmp1611 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1609, tmp460, tmp1611); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1609); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp460); + + int64_t tmp1614 = (int32_t)3; + + uint64_t *tmp1615 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1611, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)544, tmp1593, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1611, tmp1614, tmp1615); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1611); + ClearMemPublic(tmp1614); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1593); + + uint64_t *tmp1619 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1615, + tmp461, tmp462, (int32_t)0, (int32_t)11, tmp1619); + ClearMemSecret1((int32_t)576, tmp461); + ClearMemSecret1((int32_t)576, tmp462); + + uint64_t *tmp1622 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1619, tmp1622, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1619); + + uint64_t *tmp1624 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1622, tmp465, tmp1624); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1622); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128, tmp465); + + uint64_t *tmp1627 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1624, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1624, + tmp466, tmp467, (int32_t)0, (int32_t)11, tmp1627); + ClearMemSecret1((int32_t)128, tmp466); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1624); + ClearMemSecret1((int32_t)128, tmp467); + + uint64_t *tmp1631 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1627, tmp1631, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1627); + + uint64_t *tmp1633 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1631, tmp470, tmp1633); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1631); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp470); + + int64_t tmp1636 = (int32_t)3; + + uint64_t *tmp1637 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1633, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)576, tmp1615, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1633, tmp1636, tmp1637); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1615); + ClearMemPublic(tmp1636); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1633); + + uint64_t *tmp1641 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1637, + tmp471, tmp472, (int32_t)0, (int32_t)11, tmp1641); + ClearMemSecret1((int32_t)608, tmp471); + ClearMemSecret1((int32_t)608, tmp472); + + uint64_t *tmp1644 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1641, tmp1644, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1641); + + uint64_t *tmp1646 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1644, tmp475, tmp1646); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1644); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128, tmp475); + + uint64_t *tmp1649 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1646, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1646, + tmp476, tmp477, (int32_t)0, (int32_t)11, tmp1649); + ClearMemSecret1((int32_t)128, tmp477); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1646); + ClearMemSecret1((int32_t)128, tmp476); + + uint64_t *tmp1653 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1649, tmp1653, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1649); + + uint64_t *tmp1655 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1653, tmp480, tmp1655); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1653); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp480); + + int64_t tmp1658 = (int32_t)3; + + uint64_t *tmp1659 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1655, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)608, tmp1637, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1655, tmp1658, tmp1659); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1655); + ClearMemPublic(tmp1658); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1637); + + uint64_t *tmp1663 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1659, + tmp481, tmp482, (int32_t)0, (int32_t)11, tmp1663); + ClearMemSecret1((int32_t)640, tmp481); + ClearMemSecret1((int32_t)640, tmp482); + + uint64_t *tmp1666 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1663, tmp1666, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1663); + + uint64_t *tmp1668 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1666, tmp485, tmp1668); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1666); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128, tmp485); + + uint64_t *tmp1671 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1668, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1668, + tmp486, tmp487, (int32_t)0, (int32_t)11, tmp1671); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1668); + ClearMemSecret1((int32_t)128, tmp487); + ClearMemSecret1((int32_t)128, tmp486); + + uint64_t *tmp1675 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1671, tmp1675, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1671); + + uint64_t *tmp1677 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1675, tmp490, tmp1677); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp490); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1675); + + int64_t tmp1680 = (int32_t)3; + + uint64_t *tmp1681 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1677, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)640, tmp1659, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1677, tmp1680, tmp1681); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1677); + ClearMemPublic(tmp1680); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1659); + + uint64_t *tmp1685 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1681, + tmp491, tmp492, (int32_t)0, (int32_t)11, tmp1685); + ClearMemSecret1((int32_t)672, tmp492); + ClearMemSecret1((int32_t)672, tmp491); + + uint64_t *tmp1688 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1685, tmp1688, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1685); + + uint64_t *tmp1690 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1688, tmp495, tmp1690); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128, tmp495); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1688); + + uint64_t *tmp1693 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1690, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1690, + tmp496, tmp497, (int32_t)0, (int32_t)11, tmp1693); + ClearMemSecret1((int32_t)128, tmp497); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1690); + ClearMemSecret1((int32_t)128, tmp496); + + uint64_t *tmp1697 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1693, tmp1697, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1693); + + uint64_t *tmp1699 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1697, tmp500, tmp1699); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp500); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1697); + + int64_t tmp1702 = (int32_t)3; + + uint64_t *tmp1703 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1699, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)672, tmp1681, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1699, tmp1702, tmp1703); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1681); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1699); + ClearMemPublic(tmp1702); + + uint64_t *tmp1707 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1703, + tmp501, tmp502, (int32_t)0, (int32_t)11, tmp1707); + ClearMemSecret1((int32_t)704, tmp502); + ClearMemSecret1((int32_t)704, tmp501); + + uint64_t *tmp1710 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1707, tmp1710, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1707); + + uint64_t *tmp1712 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1710, tmp505, tmp1712); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1710); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128, tmp505); + + uint64_t *tmp1715 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1712, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1712, + tmp506, tmp507, (int32_t)0, (int32_t)11, tmp1715); + ClearMemSecret1((int32_t)128, tmp506); + ClearMemSecret1((int32_t)128, tmp507); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1712); + + uint64_t *tmp1719 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1715, tmp1719, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1715); + + uint64_t *tmp1721 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1719, tmp510, tmp1721); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1719); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp510); + + int64_t tmp1724 = (int32_t)3; + + uint64_t *tmp1725 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1721, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)704, tmp1703, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1721, tmp1724, tmp1725); + ClearMemPublic(tmp1724); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1703); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1721); + + uint64_t *tmp1729 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1725, + tmp511, tmp512, (int32_t)0, (int32_t)11, tmp1729); + ClearMemSecret1((int32_t)736, tmp511); + ClearMemSecret1((int32_t)736, tmp512); + + uint64_t *tmp1732 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1729, tmp1732, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1729); + + uint64_t *tmp1734 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1732, tmp515, tmp1734); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128, tmp515); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1732); + + uint64_t *tmp1737 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1734, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1734, + tmp516, tmp517, (int32_t)0, (int32_t)11, tmp1737); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1734); + ClearMemSecret1((int32_t)128, tmp516); + ClearMemSecret1((int32_t)128, tmp517); + + uint64_t *tmp1741 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1737, tmp1741, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1737); + + uint64_t *tmp1743 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1741, tmp520, tmp1743); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp520); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1741); + + int64_t tmp1746 = (int32_t)3; + + uint64_t *tmp1747 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1743, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)736, tmp1725, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1743, tmp1746, tmp1747); + ClearMemPublic(tmp1746); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1725); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1743); + + uint64_t *tmp1751 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1747, + tmp521, tmp522, (int32_t)0, (int32_t)11, tmp1751); + ClearMemSecret1((int32_t)768, tmp522); + ClearMemSecret1((int32_t)768, tmp521); + + uint64_t *tmp1754 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1751, tmp1754, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1751); + + uint64_t *tmp1756 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1754, tmp525, tmp1756); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1754); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128, tmp525); + + uint64_t *tmp1759 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1756, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1756, + tmp526, tmp527, (int32_t)0, (int32_t)11, tmp1759); + ClearMemSecret1((int32_t)128, tmp526); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1756); + ClearMemSecret1((int32_t)128, tmp527); + + uint64_t *tmp1763 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1759, tmp1763, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1759); + + uint64_t *tmp1765 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1763, tmp530, tmp1765); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp530); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1763); + + int64_t tmp1768 = (int32_t)3; + + uint64_t *tmp1769 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1765, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)768, tmp1747, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1765, tmp1768, tmp1769); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1747); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1765); + ClearMemPublic(tmp1768); + + uint64_t *tmp1773 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1769, + tmp531, tmp532, (int32_t)0, (int32_t)11, tmp1773); + ClearMemSecret1((int32_t)800, tmp531); + ClearMemSecret1((int32_t)800, tmp532); + + uint64_t *tmp1776 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1773, tmp1776, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1773); + + uint64_t *tmp1778 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1776, tmp535, tmp1778); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1776); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128, tmp535); + + uint64_t *tmp1781 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1778, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1778, + tmp536, tmp537, (int32_t)0, (int32_t)11, tmp1781); + ClearMemSecret1((int32_t)128, tmp536); + ClearMemSecret1((int32_t)128, tmp537); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1778); + + uint64_t *tmp1785 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1781, tmp1785, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1781); + + uint64_t *tmp1787 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1785, tmp540, tmp1787); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1785); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp540); + + int64_t tmp1790 = (int32_t)3; + + uint64_t *tmp1791 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1787, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)800, tmp1769, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1787, tmp1790, tmp1791); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1769); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1787); + ClearMemPublic(tmp1790); + + uint64_t *tmp1795 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1791, + tmp541, tmp542, (int32_t)0, (int32_t)11, tmp1795); + ClearMemSecret1((int32_t)832, tmp541); + ClearMemSecret1((int32_t)832, tmp542); + + uint64_t *tmp1798 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1795, tmp1798, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1795); + + uint64_t *tmp1800 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1798, tmp545, tmp1800); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128, tmp545); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1798); + + uint64_t *tmp1803 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1800, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1800, + tmp546, tmp547, (int32_t)0, (int32_t)11, tmp1803); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1800); + ClearMemSecret1((int32_t)128, tmp547); + ClearMemSecret1((int32_t)128, tmp546); + + uint64_t *tmp1807 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1803, tmp1807, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1803); + + uint64_t *tmp1809 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1807, tmp550, tmp1809); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp550); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1807); + + int64_t tmp1812 = (int32_t)3; + + uint64_t *tmp1813 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1809, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)832, tmp1791, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1809, tmp1812, tmp1813); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1791); + ClearMemPublic(tmp1812); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1809); + + uint64_t *tmp1817 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1813, + tmp551, tmp552, (int32_t)0, (int32_t)11, tmp1817); + ClearMemSecret1((int32_t)864, tmp551); + ClearMemSecret1((int32_t)864, tmp552); + + uint64_t *tmp1820 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1817, tmp1820, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1817); + + uint64_t *tmp1822 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1820, tmp555, tmp1822); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128, tmp555); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1820); + + uint64_t *tmp1825 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1822, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1822, + tmp556, tmp557, (int32_t)0, (int32_t)11, tmp1825); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1822); + ClearMemSecret1((int32_t)128, tmp557); + ClearMemSecret1((int32_t)128, tmp556); + + uint64_t *tmp1829 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1825, tmp1829, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1825); + + uint64_t *tmp1831 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1829, tmp560, tmp1831); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1829); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp560); + + int64_t tmp1834 = (int32_t)3; + + uint64_t *tmp1835 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1831, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)864, tmp1813, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1831, tmp1834, tmp1835); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1831); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1813); + ClearMemPublic(tmp1834); + + uint64_t *tmp1839 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1835, + tmp561, tmp562, (int32_t)0, (int32_t)11, tmp1839); + ClearMemSecret1((int32_t)896, tmp561); + ClearMemSecret1((int32_t)896, tmp562); + + uint64_t *tmp1842 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1839, tmp1842, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1839); + + uint64_t *tmp1844 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1842, tmp565, tmp1844); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128, tmp565); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1842); + + uint64_t *tmp1847 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1844, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1844, + tmp566, tmp567, (int32_t)0, (int32_t)11, tmp1847); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1844); + ClearMemSecret1((int32_t)128, tmp566); + ClearMemSecret1((int32_t)128, tmp567); + + uint64_t *tmp1851 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1847, tmp1851, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1847); + + uint64_t *tmp1853 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1851, tmp570, tmp1853); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1851); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp570); + + int64_t tmp1856 = (int32_t)3; + + uint64_t *tmp1857 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1853, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)896, tmp1835, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1853, tmp1856, tmp1857); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1835); + ClearMemPublic(tmp1856); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1853); + + uint64_t *tmp1861 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1857, + tmp571, tmp572, (int32_t)0, (int32_t)11, tmp1861); + ClearMemSecret1((int32_t)928, tmp571); + ClearMemSecret1((int32_t)928, tmp572); + + uint64_t *tmp1864 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1861, tmp1864, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1861); + + uint64_t *tmp1866 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1864, tmp575, tmp1866); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128, tmp575); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1864); + + uint64_t *tmp1869 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1866, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1866, + tmp576, tmp577, (int32_t)0, (int32_t)11, tmp1869); + ClearMemSecret1((int32_t)128, tmp576); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1866); + ClearMemSecret1((int32_t)128, tmp577); + + uint64_t *tmp1873 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1869, tmp1873, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1869); + + uint64_t *tmp1875 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1873, tmp580, tmp1875); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp580); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1873); + + int64_t tmp1878 = (int32_t)3; + + uint64_t *tmp1879 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1875, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)928, tmp1857, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1875, tmp1878, tmp1879); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1857); + ClearMemPublic(tmp1878); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1875); + + uint64_t *tmp1883 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1879, + tmp581, tmp582, (int32_t)0, (int32_t)11, tmp1883); + ClearMemSecret1((int32_t)960, tmp581); + ClearMemSecret1((int32_t)960, tmp582); + + uint64_t *tmp1886 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1883, tmp1886, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1883); + + uint64_t *tmp1888 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1886, tmp585, tmp1888); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1886); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128, tmp585); + + uint64_t *tmp1891 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1888, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1888, + tmp586, tmp587, (int32_t)0, (int32_t)11, tmp1891); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1888); + ClearMemSecret1((int32_t)128, tmp587); + ClearMemSecret1((int32_t)128, tmp586); + + uint64_t *tmp1895 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1891, tmp1895, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1891); + + uint64_t *tmp1897 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1895, tmp590, tmp1897); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1895); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp590); + + int64_t tmp1900 = (int32_t)3; + + uint64_t *tmp1901 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1897, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)960, tmp1879, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1897, tmp1900, tmp1901); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1897); + ClearMemPublic(tmp1900); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1879); + + uint64_t *tmp1905 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1901, + tmp591, tmp592, (int32_t)0, (int32_t)11, tmp1905); + ClearMemSecret1((int32_t)992, tmp592); + ClearMemSecret1((int32_t)992, tmp591); + + uint64_t *tmp1908 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1905, tmp1908, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1905); + + uint64_t *tmp1910 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1908, tmp595, tmp1910); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1908); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128, tmp595); + + uint64_t *tmp1913 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1910, + (int32_t)11); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1910, + tmp596, tmp597, (int32_t)0, (int32_t)11, tmp1913); + ClearMemSecret1((int32_t)128, tmp596); + ClearMemSecret1((int32_t)128, tmp597); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1910); + + uint64_t *tmp1917 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1913, tmp1917, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1913); + + uint64_t *tmp1919 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp1917, tmp600, tmp1919); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp600); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1917); + + int64_t tmp1922 = (int32_t)3; + + uint64_t *tmp1923 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1919, + (int32_t)11); + Concat2T444((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)992, tmp1901, (int32_t)1, + (int32_t)7, (int32_t)7, (int32_t)32, tmp1919, tmp1922, tmp1923); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1919); + ClearMemPublic(tmp1922); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1901); + + uint64_t *tmp1927 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1923, + tmp601, tmp602, (int32_t)0, (int32_t)11, tmp1927); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1923); + ClearMemSecret1((int32_t)1024, tmp602); + ClearMemSecret1((int32_t)1024, tmp601); + + uint64_t *tmp1931 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1927, tmp1931, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1927); + + uint64_t *tmp1933 = + make_array((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024); + AvgPool((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)7, + (int32_t)7, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)7, (int32_t)7, + (int32_t)1024, tmp1931, tmp1933); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1931); + + uint64_t *tmp1935 = + make_array((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000); + Conv2DWrapper((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1, + (int32_t)1, (int32_t)1000, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp1933, tmp605, tmp1935); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024, tmp1933); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1000, tmp605); + + uint64_t *tmp1938 = + make_array((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000); + ScaleUp1((int32_t)1000, tmp606, (int32_t)11); + MatAddBroadCast4((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1935, + tmp606, tmp1938); + ClearMemSecret1((int32_t)1000, tmp606); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1935); + + int64_t tmp1941 = (int32_t)3; + + uint64_t *tmp1942 = make_array((int32_t)1, (int32_t)1, (int32_t)1); + ArgMax3((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1000, tmp1938, tmp1941, tmp1942); + ClearMemPublic(tmp1941); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1938); + EndComputation(); + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1; i2++) { + cout << (funcReconstruct2PCCons(Arr3DIdxRowM(tmp1942, (int32_t)1, + (int32_t)1, (int32_t)1, i0, + i1, i2), + 2)) + << endl; + } + } + } +} diff --git a/SCI/networks/main_densenet121_field64.cpp b/SCI/networks/main_densenet121_field64.cpp deleted file mode 100644 index c63007df..00000000 --- a/SCI/networks/main_densenet121_field64.cpp +++ /dev/null @@ -1,11069 +0,0 @@ -/* -This is an autogenerated file, generated using the EzPC compiler. -*/ - - -#define BITLEN_32 -#define SCI_HE - - -#include "globals.h" -#include "functionalities_wrapper.h" -#include -using namespace std; - -template -T* make_array(size_t s1){ -return new T[s1]; -} - -template -T* make_array(size_t s1, size_t s2){ -return new T[s1*s2]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3){ -return new T[s1*s2*s3]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){ -return new T[s1*s2*s3*s4]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){ -return new T[s1*s2*s3*s4*s5]; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr1DIdxRowM(B,s2,i2)); -} -} -} - -void MatAdd2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr2DIdxRowM(B,s1,s2,i1,i2)); -} -} -} - -void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr1DIdxRowM(B,s4,i4)); -} -} -} -} -} - -void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr4DIdxRowM(B,s1,s2,s3,s4,i1,i2,i3,i4)); -} -} -} -} -} - -void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr1DIdxRowM(B,s5,i5)); -} -} -} -} -} -} - -void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr5DIdxRowM(B,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5)); -} -} -} -} -} -} - -void CreateTensor1(int64_t s1, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(arr,s1,i1) = val; -} -} - -void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(arr,s1,s2,i1,i2) = val; -} -} -} - -void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = val; -} -} -} -} - -void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = val; -} -} -} -} -} - -void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(arr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = val; -} -} -} -} -} -} - -void CopyTensor1(int64_t s1, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(targetArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CopyTensor2(int64_t s1, int64_t s2, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(targetArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(targetArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(targetArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateIdentity11(int64_t s1, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(newArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CreateIdentity22(int64_t s1, int64_t s2, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(newArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(newArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(newArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,inps1,inps2,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j)); -} -} -} - -void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inArr,inps1,inps2,inps3,inps4,inps5,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)2) + k),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)3) + l),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)4) + m)); -} -} -} -} -} -} - -void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,(i1 - inp1s1),i2); -} -} else { -if ((i2 < inp1s2)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,i1,(i2 - inp1s2)); -} -} -} -} -} - -void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,(i1 - inp1s1),i2,i3,i4); -} -} else { -if ((axis == (int32_t)1)) { -if ((i2 < inp1s2)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,(i2 - inp1s2),i3,i4); -} -} else { -if ((axis == (int32_t)2)) { -if ((i3 < inp1s3)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,(i3 - inp1s3),i4); -} -} else { -if ((i4 < inp1s4)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,i3,(i4 - inp1s4)); -} -} -} -} -} -} -} -} -} - -void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, int64_t I2, int64_t I3, int64_t I4, uint64_t* inp, int64_t axis, int64_t curCount, int64_t total, uint64_t* out){ -for (uint64_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint64_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint64_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint64_t o4 = (int32_t)0; o4 < O4; o4++){ - -int64_t i1 = o1; - -int64_t i2 = o2; - -int64_t i3 = o3; - -int64_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (((I1 / total) * curCount) + o1); -} -if ((axis == (int32_t)1)) { -i2 = (((I2 / total) * curCount) + o2); -} -if ((axis == (int32_t)2)) { -i3 = (((I3 / total) * curCount) + o3); -} -if ((axis == (int32_t)3)) { -i4 = (((I4 / total) * curCount) + o4); -} -Arr4DIdxRowM(out,O1,O2,O3,O4,o1,o2,o3,o4) = Arr4DIdxRowM(inp,I1,I2,I3,I4,i1,i2,i3,i4); -} -} -} -} -} - -void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CI,CO,fh,fw,ci,co); -} -} -} -} -} - -void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t outH, int64_t outW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t GIS = (CI / G); - -int64_t GOS = (CO / G); -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint64_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint64_t g = (int32_t)0; g < G; g++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ - -uint64_t val = funcSSCons( (int32_t)0); - -int64_t ci = ((GIS * g) + cig); - -int64_t co = ((GOS * g) + cog); - -int64_t curPosH = ((strideH * h) - zPadHLeft); -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ - -int64_t curPosW = ((strideW * w) - zPadWLeft); -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && (curPosH < H)) && (curPosW < W))) { -val = SecretAdd(val, SecretMult(Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci), Arr4DIdxRowM(filterArr,FH,FW,(CI / G),CO,fh,fw,(ci / G),co))); -} -curPosW = (curPosW + (int32_t)1); -} -curPosH = (curPosH + (int32_t)1); -} -Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co) = SecretAdd(Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co), val); -} -} -} -} -} -} -} - -void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t CIG = (CI / G); - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ - -int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); -Arr2DIdxRowM(outputArr,(CO / G),((FH * FW) * (CI / G)),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,(CI / G),CO,fh,fw,ci,(co + startCO)); -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,(co + startCO)) = Arr2DIdxRowM(inputArr,(CO / G),((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t g, int64_t G, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; - -int64_t CIG = (CI / G); -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); - -int64_t startCI = (g * CIG); -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,(ci + startCI)); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CIG) + (fw * CIG)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t CIG = (CI / G); - -int64_t reshapedFilterRows = (CO / G); - -int64_t reshapedFilterCols = ((FH * FW) * CIG); - -int64_t reshapedIPRows = ((FH * FW) * CIG); - -int64_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * outH) * outW); -for (uint64_t g = (int32_t)0; g < G; g++){ - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -} -} - -void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CI,CO,fd,fh,fw,ci,co); -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t d = (int32_t)0; d < finalD; d++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr5DIdxRowM(outputArr,N,finalD,finalH,finalW,CO,n,d,h,w,co) = Arr2DIdxRowM(inputArr,CO,(((N * finalD) * finalH) * finalW),co,((((((n * finalD) * finalH) * finalW) + ((d * finalH) * finalW)) + (h * finalW)) + w)); -} -} -} -} -} -} - -void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadDLeft); - -int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= D)) || ((curPosH < (int32_t)0) || (curPosH >= H))) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -leftTopCornerD = (leftTopCornerD + strideD); -} - -} -} - -void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = (((N * newD) * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); fd++){ -for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); fh++){ -for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); fw++){ - -int64_t curPosD = (fd - zPadDLeft); - -int64_t curPosH = (fh - zPadHLeft); - -int64_t curPosW = (fw - zPadWLeft); -if (((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W))) { - -int64_t curFilterPosD = (fd - (d * strideD)); - -int64_t curFilterPosH = (fh - (h * strideH)); - -int64_t curFilterPosW = (fw - (w * strideW)); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CI,CO,curFilterPosD,curFilterPosH,curFilterPosW,ci,co))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CO,CI,((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} - -void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int32_t)0); -} else { -if ((((curPosH % strideH) == (int32_t)0) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr4DIdxRowM(inputArr,N,HPrime,WPrime,CI,n,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -} -} - -void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t reshapedIPCols = ((N * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CO,CI,((FD - (int32_t)1) - fd),((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadTrDLeft); - -int64_t DPrimeTilde = (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); - -int64_t extremeRightBottomCornerD = ((DPrimeTilde - (int32_t)1) + zPadTrDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int32_t)0); -} else { -if (((((curPosD % strideD) == (int32_t)0) && ((curPosH % strideH) == (int32_t)0)) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputD = (curPosD / strideD); - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr5DIdxRowM(inputArr,N,DPrime,HPrime,WPrime,CI,n,idxInputD,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -leftTopCornerD = (leftTopCornerD + (int32_t)1); -} - -} -} - -void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t reshapedIPCols = (((N * D) * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t fd = d; fd < (d + FD); fd++){ -for (uint64_t fh = h; fh < (h + FH); fh++){ -for (uint64_t fw = w; fw < (w + FW); fw++){ - -int64_t curPosD = ((fd - zPadDLeft) / strideD); - -int64_t curPosH = ((fh - zPadHLeft) / strideD); - -int64_t curPosW = ((fw - zPadWLeft) / strideD); -if ((((((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W)) && (((fd - zPadDLeft) % strideD) == (int32_t)0)) && (((fh - zPadHLeft) % strideH) == (int32_t)0)) && (((fw - zPadWLeft) % strideW) == (int32_t)0))) { - -int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); - -int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); - -int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CO,CI,curFilterPosD,curFilterPosH,curFilterPosW,co,ci))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,s2,s1,j,i); -} -} -} - -void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = Arr4DIdxRowM(inpArr,inps1,inps2,inps3,inps4,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0))); -} else { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = funcSSCons( (int32_t)0); -} -} -} -} -} -} - -void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); - -int64_t lbounds5 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0); - -int64_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl)) && (m >= lbounds5)) && (m < rbounds5excl))) { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inpArr,inps1,inps2,inps3,inps4,inps5,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0)),(m - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0))); -} else { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = funcSSCons( (int32_t)0); -} -} -} -} -} -} -} - -void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, int64_t i2, int64_t i3, int64_t i4, uint64_t* inpArr, int64_t pads, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr1DIdxRowM(paddings,pads, (int32_t)0); - -int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings,pads, (int32_t)4)); - -int64_t lbounds2 = Arr1DIdxRowM(paddings,pads, (int32_t)1); - -int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings,pads, (int32_t)5)); - -int64_t lbounds3 = Arr1DIdxRowM(paddings,pads, (int32_t)2); - -int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings,pads, (int32_t)6)); - -int64_t lbounds4 = Arr1DIdxRowM(paddings,pads, (int32_t)3); - -int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings,pads, (int32_t)7)); -for (uint64_t i = (int32_t)0; i < o1; i++){ -for (uint64_t j = (int32_t)0; j < o2; j++){ -for (uint64_t k = (int32_t)0; k < o3; k++){ -for (uint64_t l = (int32_t)0; l < o4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = Arr4DIdxRowM(inpArr,i1,i2,i3,i4,(i - Arr1DIdxRowM(paddings,pads, (int32_t)0)),(j - Arr1DIdxRowM(paddings,pads, (int32_t)1)),(k - Arr1DIdxRowM(paddings,pads, (int32_t)2)),(l - Arr1DIdxRowM(paddings,pads, (int32_t)3))); -} else { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = funcSSCons( (int32_t)0); -} -} -} -} -} -} - -void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < ins1; i++){ -for (uint64_t j = (int32_t)0; j < ins2; j++){ -for (uint64_t k = (int32_t)0; k < ins3; k++){ -for (uint64_t l = (int32_t)0; l < ins4; l++){ - -int64_t linIdx = ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + (k * ins4)) + l); - -int64_t outIdx1 = (linIdx / s2); - -int64_t outIdx2 = (linIdx % s2); -Arr2DIdxRowM(outArr,s1,s2,outIdx1,outIdx2) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i,j,k,l); -} -} -} -} -} - -void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s4,i4); -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s4); -for (uint64_t ii = (int32_t)0; ii < s4; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s4,ii) = Arr1DIdxRowM(biasArr,s4,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outputArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s4,i4)); -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s5,i5); -} -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s5); -for (uint64_t ii = (int32_t)0; ii < s5; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s5,ii) = Arr1DIdxRowM(biasArr,s5,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outputArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s5,i5)); -} -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s5, biasArrScaledUp); -} - -void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (s1 * s2); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr1,s1,s2,i1,i2); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr2,s1,s2,i1,i2); -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr1,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr2,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr1,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr2,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t* axes, uint64_t* outputArr){ - -int64_t divisor = (inS2 * inS3); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = funcSSCons( (int32_t)0); -for (uint64_t i = (int32_t)0; i < inS2; i++){ -for (uint64_t j = (int32_t)0; j < inS3; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i,j,i2)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t axis1, int64_t axis2, uint64_t* outputArr){ - -int64_t divisor = (inS3 * inS4); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = funcSSCons( (int32_t)0); -for (uint64_t i = (int32_t)0; i < inS3; i++){ -for (uint64_t j = (int32_t)0; j < inS4; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i2,i,j)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, uint64_t* inArr, int64_t dim, uint64_t* outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, int64_t dim, uint64_t* outArr){ - -int64_t size = ((ins1 * ins2) * ins3); - -uint64_t* reshapedInArr = make_array(size, ins4); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr2DIdxRowM(reshapedInArr,size,ins4,linIdx,i4) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i1,i2,i3,i4); -} -} -} -} -ArgMax(size, ins4, reshapedInArr, reshapedOutArr); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr3DIdxRowM(outArr,outs1,outs2,outs3,i1,i2,i3) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -ClearMemSecret2(size, ins4, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Floor2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Floor(size, reshapedInArr, reshapedOutArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void ScaleUp1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleUp(s1, arr, sf); -} - -void ScaleUp2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleDown(s1, arr, sf); -} - -void ScaleDown2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - - -int main(int argc, char** argv) -{ -ArgMapping amap; -int port = 32000; -string serverAddr = "127.0.0.1"; - -amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); -amap.arg("p", port, "Port Number"); -amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); -amap.parse(argc, argv); - -assert(party==sci::ALICE || party==sci::BOB); - -checkIfUsingEigen(); -for(int i=0;i(ioArr[i]); -prgInstanceArr[i] = new sci::PRG128(); -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); -if (i == 0) { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength); -} -else if (i == 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength); -} -else if (i & 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[1]); -} -else { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[0]); -} -} - -io = ioArr[0]; -iknpOT = new sci::IKNP(io); -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good -kkot = new sci::KKOT(io); -prg128Instance = new sci::PRG128(); -otpack = new sci::OTPack(io, party, baseForRelu, bitlength); - -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - -#ifdef SCI_OT -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack); -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -#endif - -#ifdef SCI_HE -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -heConvImpl = new ConvField(party,io); -heFCImpl = new FCField(party,io); -heProdImpl = new ElemWiseProdField(party, io); -assertFieldRun(); -#endif -#ifdef MULTITHREADED_NONLIN -#ifdef SCI_OT -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -} -#endif -#ifdef SCI_HE -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -} -#endif -#endif - -if (party==sci::ALICE){ -iknpOT->setup_send(); -iknpOTRoleReversed->setup_recv(); -} -else if (party==sci::BOB){ -iknpOT->setup_recv(); -iknpOTRoleReversed->setup_send(); -} -cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3); -/* Variable to read the clear value corresponding to the input variable tmp0 at (1930,1-1930,46) */ -uint64_t __tmp_in_tmp0; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)224; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)224; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)3; i3++){ -if ((party == CLIENT)) { -cin >> __tmp_in_tmp0; -} -Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3,i0,i1,i2,i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; -} -} -} -} - -uint64_t* tmp1 = make_array( (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp1 at (1933,1-1933,43) */ -uint64_t __tmp_in_tmp1; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)7; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)7; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)3; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp1; -} -Arr4DIdxRowM(tmp1, (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; -} -} -} -} - -uint64_t* tmp2 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp2 at (1936,1-1936,34) */ -uint64_t __tmp_in_tmp2; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp2; -} -Arr1DIdxRowM(tmp2, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; -} - -uint64_t* tmp3 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp3 at (1939,1-1939,34) */ -uint64_t __tmp_in_tmp3; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp3; -} -Arr1DIdxRowM(tmp3, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp3 : 0; -} - -uint64_t* tmp4 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp4 at (1942,1-1942,34) */ -uint64_t __tmp_in_tmp4; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp4; -} -Arr1DIdxRowM(tmp4, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; -} - -uint64_t* tmp5 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp5 at (1945,1-1945,34) */ -uint64_t __tmp_in_tmp5; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp5; -} -Arr1DIdxRowM(tmp5, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp5 : 0; -} - -uint64_t* tmp6 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp6 at (1948,1-1948,34) */ -uint64_t __tmp_in_tmp6; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp6; -} -Arr1DIdxRowM(tmp6, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp6 : 0; -} - -uint64_t* tmp7 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp7 at (1951,1-1951,34) */ -uint64_t __tmp_in_tmp7; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp7; -} -Arr1DIdxRowM(tmp7, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp7 : 0; -} - -uint64_t* tmp8 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp8 at (1954,1-1954,34) */ -uint64_t __tmp_in_tmp8; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp8; -} -Arr1DIdxRowM(tmp8, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; -} - -uint64_t* tmp9 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp9 at (1957,1-1957,34) */ -uint64_t __tmp_in_tmp9; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp9; -} -Arr1DIdxRowM(tmp9, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; -} - -uint64_t* tmp10 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp10 at (1960,1-1960,46) */ -uint64_t __tmp_in_tmp10; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp10; -} -Arr4DIdxRowM(tmp10, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp10 : 0; -} -} -} -} - -uint64_t* tmp11 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp11 at (1963,1-1963,36) */ -uint64_t __tmp_in_tmp11; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp11; -} -Arr1DIdxRowM(tmp11, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp11 : 0; -} - -uint64_t* tmp12 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp12 at (1966,1-1966,36) */ -uint64_t __tmp_in_tmp12; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp12; -} -Arr1DIdxRowM(tmp12, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp12 : 0; -} - -uint64_t* tmp13 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp13 at (1969,1-1969,36) */ -uint64_t __tmp_in_tmp13; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp13; -} -Arr1DIdxRowM(tmp13, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp13 : 0; -} - -uint64_t* tmp14 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp14 at (1972,1-1972,36) */ -uint64_t __tmp_in_tmp14; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp14; -} -Arr1DIdxRowM(tmp14, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp14 : 0; -} - -uint64_t* tmp15 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp15 at (1975,1-1975,46) */ -uint64_t __tmp_in_tmp15; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp15; -} -Arr4DIdxRowM(tmp15, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp15 : 0; -} -} -} -} - -uint64_t* tmp16 = make_array( (int32_t)96); -/* Variable to read the clear value corresponding to the input variable tmp16 at (1978,1-1978,35) */ -uint64_t __tmp_in_tmp16; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)96; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp16; -} -Arr1DIdxRowM(tmp16, (int32_t)96,i0) = (party == SERVER) ? __tmp_in_tmp16 : 0; -} - -uint64_t* tmp17 = make_array( (int32_t)96); -/* Variable to read the clear value corresponding to the input variable tmp17 at (1981,1-1981,35) */ -uint64_t __tmp_in_tmp17; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)96; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp17; -} -Arr1DIdxRowM(tmp17, (int32_t)96,i0) = (party == SERVER) ? __tmp_in_tmp17 : 0; -} - -uint64_t* tmp18 = make_array( (int32_t)96); -/* Variable to read the clear value corresponding to the input variable tmp18 at (1984,1-1984,35) */ -uint64_t __tmp_in_tmp18; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)96; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp18; -} -Arr1DIdxRowM(tmp18, (int32_t)96,i0) = (party == SERVER) ? __tmp_in_tmp18 : 0; -} - -uint64_t* tmp19 = make_array( (int32_t)96); -/* Variable to read the clear value corresponding to the input variable tmp19 at (1987,1-1987,35) */ -uint64_t __tmp_in_tmp19; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)96; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp19; -} -Arr1DIdxRowM(tmp19, (int32_t)96,i0) = (party == SERVER) ? __tmp_in_tmp19 : 0; -} - -uint64_t* tmp20 = make_array( (int32_t)1, (int32_t)1, (int32_t)96, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp20 at (1990,1-1990,46) */ -uint64_t __tmp_in_tmp20; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)96; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp20; -} -Arr4DIdxRowM(tmp20, (int32_t)1, (int32_t)1, (int32_t)96, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp20 : 0; -} -} -} -} - -uint64_t* tmp21 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp21 at (1993,1-1993,36) */ -uint64_t __tmp_in_tmp21; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp21; -} -Arr1DIdxRowM(tmp21, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp21 : 0; -} - -uint64_t* tmp22 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp22 at (1996,1-1996,36) */ -uint64_t __tmp_in_tmp22; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp22; -} -Arr1DIdxRowM(tmp22, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp22 : 0; -} - -uint64_t* tmp23 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp23 at (1999,1-1999,36) */ -uint64_t __tmp_in_tmp23; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp23; -} -Arr1DIdxRowM(tmp23, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp23 : 0; -} - -uint64_t* tmp24 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp24 at (2002,1-2002,36) */ -uint64_t __tmp_in_tmp24; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp24; -} -Arr1DIdxRowM(tmp24, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp24 : 0; -} - -uint64_t* tmp25 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp25 at (2005,1-2005,46) */ -uint64_t __tmp_in_tmp25; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp25; -} -Arr4DIdxRowM(tmp25, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp25 : 0; -} -} -} -} - -uint64_t* tmp26 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp26 at (2008,1-2008,36) */ -uint64_t __tmp_in_tmp26; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp26; -} -Arr1DIdxRowM(tmp26, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp26 : 0; -} - -uint64_t* tmp27 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp27 at (2011,1-2011,36) */ -uint64_t __tmp_in_tmp27; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp27; -} -Arr1DIdxRowM(tmp27, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp27 : 0; -} - -uint64_t* tmp28 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp28 at (2014,1-2014,36) */ -uint64_t __tmp_in_tmp28; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp28; -} -Arr1DIdxRowM(tmp28, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp28 : 0; -} - -uint64_t* tmp29 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp29 at (2017,1-2017,36) */ -uint64_t __tmp_in_tmp29; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp29; -} -Arr1DIdxRowM(tmp29, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp29 : 0; -} - -uint64_t* tmp30 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp30 at (2020,1-2020,47) */ -uint64_t __tmp_in_tmp30; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp30; -} -Arr4DIdxRowM(tmp30, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp30 : 0; -} -} -} -} - -uint64_t* tmp31 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp31 at (2023,1-2023,36) */ -uint64_t __tmp_in_tmp31; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp31; -} -Arr1DIdxRowM(tmp31, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp31 : 0; -} - -uint64_t* tmp32 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp32 at (2026,1-2026,36) */ -uint64_t __tmp_in_tmp32; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp32; -} -Arr1DIdxRowM(tmp32, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp32 : 0; -} - -uint64_t* tmp33 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp33 at (2029,1-2029,36) */ -uint64_t __tmp_in_tmp33; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp33; -} -Arr1DIdxRowM(tmp33, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp33 : 0; -} - -uint64_t* tmp34 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp34 at (2032,1-2032,36) */ -uint64_t __tmp_in_tmp34; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp34; -} -Arr1DIdxRowM(tmp34, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp34 : 0; -} - -uint64_t* tmp35 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp35 at (2035,1-2035,46) */ -uint64_t __tmp_in_tmp35; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp35; -} -Arr4DIdxRowM(tmp35, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp35 : 0; -} -} -} -} - -uint64_t* tmp36 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp36 at (2038,1-2038,36) */ -uint64_t __tmp_in_tmp36; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp36; -} -Arr1DIdxRowM(tmp36, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp36 : 0; -} - -uint64_t* tmp37 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp37 at (2041,1-2041,36) */ -uint64_t __tmp_in_tmp37; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp37; -} -Arr1DIdxRowM(tmp37, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp37 : 0; -} - -uint64_t* tmp38 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp38 at (2044,1-2044,36) */ -uint64_t __tmp_in_tmp38; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp38; -} -Arr1DIdxRowM(tmp38, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp38 : 0; -} - -uint64_t* tmp39 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp39 at (2047,1-2047,36) */ -uint64_t __tmp_in_tmp39; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp39; -} -Arr1DIdxRowM(tmp39, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp39 : 0; -} - -uint64_t* tmp40 = make_array( (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp40 at (2050,1-2050,47) */ -uint64_t __tmp_in_tmp40; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)160; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp40; -} -Arr4DIdxRowM(tmp40, (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp40 : 0; -} -} -} -} - -uint64_t* tmp41 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp41 at (2053,1-2053,36) */ -uint64_t __tmp_in_tmp41; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp41; -} -Arr1DIdxRowM(tmp41, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp41 : 0; -} - -uint64_t* tmp42 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp42 at (2056,1-2056,36) */ -uint64_t __tmp_in_tmp42; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp42; -} -Arr1DIdxRowM(tmp42, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp42 : 0; -} - -uint64_t* tmp43 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp43 at (2059,1-2059,36) */ -uint64_t __tmp_in_tmp43; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp43; -} -Arr1DIdxRowM(tmp43, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp43 : 0; -} - -uint64_t* tmp44 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp44 at (2062,1-2062,36) */ -uint64_t __tmp_in_tmp44; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp44; -} -Arr1DIdxRowM(tmp44, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp44 : 0; -} - -uint64_t* tmp45 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp45 at (2065,1-2065,46) */ -uint64_t __tmp_in_tmp45; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp45; -} -Arr4DIdxRowM(tmp45, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp45 : 0; -} -} -} -} - -uint64_t* tmp46 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp46 at (2068,1-2068,36) */ -uint64_t __tmp_in_tmp46; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp46; -} -Arr1DIdxRowM(tmp46, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp46 : 0; -} - -uint64_t* tmp47 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp47 at (2071,1-2071,36) */ -uint64_t __tmp_in_tmp47; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp47; -} -Arr1DIdxRowM(tmp47, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp47 : 0; -} - -uint64_t* tmp48 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp48 at (2074,1-2074,36) */ -uint64_t __tmp_in_tmp48; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp48; -} -Arr1DIdxRowM(tmp48, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp48 : 0; -} - -uint64_t* tmp49 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp49 at (2077,1-2077,36) */ -uint64_t __tmp_in_tmp49; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp49; -} -Arr1DIdxRowM(tmp49, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp49 : 0; -} - -uint64_t* tmp50 = make_array( (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp50 at (2080,1-2080,47) */ -uint64_t __tmp_in_tmp50; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)192; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp50; -} -Arr4DIdxRowM(tmp50, (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp50 : 0; -} -} -} -} - -uint64_t* tmp51 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp51 at (2083,1-2083,36) */ -uint64_t __tmp_in_tmp51; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp51; -} -Arr1DIdxRowM(tmp51, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp51 : 0; -} - -uint64_t* tmp52 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp52 at (2086,1-2086,36) */ -uint64_t __tmp_in_tmp52; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp52; -} -Arr1DIdxRowM(tmp52, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp52 : 0; -} - -uint64_t* tmp53 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp53 at (2089,1-2089,36) */ -uint64_t __tmp_in_tmp53; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp53; -} -Arr1DIdxRowM(tmp53, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp53 : 0; -} - -uint64_t* tmp54 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp54 at (2092,1-2092,36) */ -uint64_t __tmp_in_tmp54; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp54; -} -Arr1DIdxRowM(tmp54, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp54 : 0; -} - -uint64_t* tmp55 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp55 at (2095,1-2095,46) */ -uint64_t __tmp_in_tmp55; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp55; -} -Arr4DIdxRowM(tmp55, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp55 : 0; -} -} -} -} - -uint64_t* tmp56 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp56 at (2098,1-2098,36) */ -uint64_t __tmp_in_tmp56; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp56; -} -Arr1DIdxRowM(tmp56, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp56 : 0; -} - -uint64_t* tmp57 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp57 at (2101,1-2101,36) */ -uint64_t __tmp_in_tmp57; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp57; -} -Arr1DIdxRowM(tmp57, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp57 : 0; -} - -uint64_t* tmp58 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp58 at (2104,1-2104,36) */ -uint64_t __tmp_in_tmp58; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp58; -} -Arr1DIdxRowM(tmp58, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp58 : 0; -} - -uint64_t* tmp59 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp59 at (2107,1-2107,36) */ -uint64_t __tmp_in_tmp59; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp59; -} -Arr1DIdxRowM(tmp59, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp59 : 0; -} - -uint64_t* tmp60 = make_array( (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp60 at (2110,1-2110,47) */ -uint64_t __tmp_in_tmp60; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)224; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp60; -} -Arr4DIdxRowM(tmp60, (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp60 : 0; -} -} -} -} - -uint64_t* tmp61 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp61 at (2113,1-2113,36) */ -uint64_t __tmp_in_tmp61; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp61; -} -Arr1DIdxRowM(tmp61, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp61 : 0; -} - -uint64_t* tmp62 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp62 at (2116,1-2116,36) */ -uint64_t __tmp_in_tmp62; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp62; -} -Arr1DIdxRowM(tmp62, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp62 : 0; -} - -uint64_t* tmp63 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp63 at (2119,1-2119,36) */ -uint64_t __tmp_in_tmp63; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp63; -} -Arr1DIdxRowM(tmp63, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp63 : 0; -} - -uint64_t* tmp64 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp64 at (2122,1-2122,36) */ -uint64_t __tmp_in_tmp64; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp64; -} -Arr1DIdxRowM(tmp64, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp64 : 0; -} - -uint64_t* tmp65 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp65 at (2125,1-2125,46) */ -uint64_t __tmp_in_tmp65; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp65; -} -Arr4DIdxRowM(tmp65, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp65 : 0; -} -} -} -} - -uint64_t* tmp66 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp66 at (2128,1-2128,36) */ -uint64_t __tmp_in_tmp66; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp66; -} -Arr1DIdxRowM(tmp66, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp66 : 0; -} - -uint64_t* tmp67 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp67 at (2131,1-2131,36) */ -uint64_t __tmp_in_tmp67; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp67; -} -Arr1DIdxRowM(tmp67, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp67 : 0; -} - -uint64_t* tmp68 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp68 at (2134,1-2134,36) */ -uint64_t __tmp_in_tmp68; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp68; -} -Arr1DIdxRowM(tmp68, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp68 : 0; -} - -uint64_t* tmp69 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp69 at (2137,1-2137,36) */ -uint64_t __tmp_in_tmp69; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp69; -} -Arr1DIdxRowM(tmp69, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp69 : 0; -} - -uint64_t* tmp70 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp70 at (2140,1-2140,47) */ -uint64_t __tmp_in_tmp70; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp70; -} -Arr4DIdxRowM(tmp70, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp70 : 0; -} -} -} -} - -uint64_t* tmp71 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp71 at (2143,1-2143,36) */ -uint64_t __tmp_in_tmp71; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp71; -} -Arr1DIdxRowM(tmp71, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp71 : 0; -} - -uint64_t* tmp72 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp72 at (2146,1-2146,36) */ -uint64_t __tmp_in_tmp72; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp72; -} -Arr1DIdxRowM(tmp72, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp72 : 0; -} - -uint64_t* tmp73 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp73 at (2149,1-2149,36) */ -uint64_t __tmp_in_tmp73; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp73; -} -Arr1DIdxRowM(tmp73, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp73 : 0; -} - -uint64_t* tmp74 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp74 at (2152,1-2152,36) */ -uint64_t __tmp_in_tmp74; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp74; -} -Arr1DIdxRowM(tmp74, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp74 : 0; -} - -uint64_t* tmp75 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp75 at (2155,1-2155,47) */ -uint64_t __tmp_in_tmp75; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp75; -} -Arr4DIdxRowM(tmp75, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp75 : 0; -} -} -} -} - -uint64_t* tmp76 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp76 at (2158,1-2158,36) */ -uint64_t __tmp_in_tmp76; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp76; -} -Arr1DIdxRowM(tmp76, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp76 : 0; -} - -uint64_t* tmp77 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp77 at (2161,1-2161,36) */ -uint64_t __tmp_in_tmp77; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp77; -} -Arr1DIdxRowM(tmp77, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp77 : 0; -} - -uint64_t* tmp78 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp78 at (2164,1-2164,36) */ -uint64_t __tmp_in_tmp78; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp78; -} -Arr1DIdxRowM(tmp78, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp78 : 0; -} - -uint64_t* tmp79 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp79 at (2167,1-2167,36) */ -uint64_t __tmp_in_tmp79; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp79; -} -Arr1DIdxRowM(tmp79, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp79 : 0; -} - -uint64_t* tmp80 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp80 at (2170,1-2170,46) */ -uint64_t __tmp_in_tmp80; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp80; -} -Arr4DIdxRowM(tmp80, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp80 : 0; -} -} -} -} - -uint64_t* tmp81 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp81 at (2173,1-2173,36) */ -uint64_t __tmp_in_tmp81; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp81; -} -Arr1DIdxRowM(tmp81, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp81 : 0; -} - -uint64_t* tmp82 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp82 at (2176,1-2176,36) */ -uint64_t __tmp_in_tmp82; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp82; -} -Arr1DIdxRowM(tmp82, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp82 : 0; -} - -uint64_t* tmp83 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp83 at (2179,1-2179,36) */ -uint64_t __tmp_in_tmp83; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp83; -} -Arr1DIdxRowM(tmp83, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp83 : 0; -} - -uint64_t* tmp84 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp84 at (2182,1-2182,36) */ -uint64_t __tmp_in_tmp84; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp84; -} -Arr1DIdxRowM(tmp84, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp84 : 0; -} - -uint64_t* tmp85 = make_array( (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp85 at (2185,1-2185,47) */ -uint64_t __tmp_in_tmp85; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)160; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp85; -} -Arr4DIdxRowM(tmp85, (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp85 : 0; -} -} -} -} - -uint64_t* tmp86 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp86 at (2188,1-2188,36) */ -uint64_t __tmp_in_tmp86; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp86; -} -Arr1DIdxRowM(tmp86, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp86 : 0; -} - -uint64_t* tmp87 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp87 at (2191,1-2191,36) */ -uint64_t __tmp_in_tmp87; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp87; -} -Arr1DIdxRowM(tmp87, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp87 : 0; -} - -uint64_t* tmp88 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp88 at (2194,1-2194,36) */ -uint64_t __tmp_in_tmp88; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp88; -} -Arr1DIdxRowM(tmp88, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp88 : 0; -} - -uint64_t* tmp89 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp89 at (2197,1-2197,36) */ -uint64_t __tmp_in_tmp89; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp89; -} -Arr1DIdxRowM(tmp89, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp89 : 0; -} - -uint64_t* tmp90 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp90 at (2200,1-2200,46) */ -uint64_t __tmp_in_tmp90; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp90; -} -Arr4DIdxRowM(tmp90, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp90 : 0; -} -} -} -} - -uint64_t* tmp91 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp91 at (2203,1-2203,36) */ -uint64_t __tmp_in_tmp91; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp91; -} -Arr1DIdxRowM(tmp91, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp91 : 0; -} - -uint64_t* tmp92 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp92 at (2206,1-2206,36) */ -uint64_t __tmp_in_tmp92; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp92; -} -Arr1DIdxRowM(tmp92, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp92 : 0; -} - -uint64_t* tmp93 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp93 at (2209,1-2209,36) */ -uint64_t __tmp_in_tmp93; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp93; -} -Arr1DIdxRowM(tmp93, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp93 : 0; -} - -uint64_t* tmp94 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp94 at (2212,1-2212,36) */ -uint64_t __tmp_in_tmp94; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp94; -} -Arr1DIdxRowM(tmp94, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp94 : 0; -} - -uint64_t* tmp95 = make_array( (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp95 at (2215,1-2215,47) */ -uint64_t __tmp_in_tmp95; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)192; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp95; -} -Arr4DIdxRowM(tmp95, (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp95 : 0; -} -} -} -} - -uint64_t* tmp96 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp96 at (2218,1-2218,36) */ -uint64_t __tmp_in_tmp96; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp96; -} -Arr1DIdxRowM(tmp96, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp96 : 0; -} - -uint64_t* tmp97 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp97 at (2221,1-2221,36) */ -uint64_t __tmp_in_tmp97; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp97; -} -Arr1DIdxRowM(tmp97, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp97 : 0; -} - -uint64_t* tmp98 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp98 at (2224,1-2224,36) */ -uint64_t __tmp_in_tmp98; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp98; -} -Arr1DIdxRowM(tmp98, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp98 : 0; -} - -uint64_t* tmp99 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp99 at (2227,1-2227,36) */ -uint64_t __tmp_in_tmp99; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp99; -} -Arr1DIdxRowM(tmp99, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp99 : 0; -} - -uint64_t* tmp100 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp100 at (2230,1-2230,47) */ -uint64_t __tmp_in_tmp100; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp100; -} -Arr4DIdxRowM(tmp100, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp100 : 0; -} -} -} -} - -uint64_t* tmp101 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp101 at (2233,1-2233,37) */ -uint64_t __tmp_in_tmp101; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp101; -} -Arr1DIdxRowM(tmp101, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp101 : 0; -} - -uint64_t* tmp102 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp102 at (2236,1-2236,37) */ -uint64_t __tmp_in_tmp102; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp102; -} -Arr1DIdxRowM(tmp102, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp102 : 0; -} - -uint64_t* tmp103 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp103 at (2239,1-2239,37) */ -uint64_t __tmp_in_tmp103; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp103; -} -Arr1DIdxRowM(tmp103, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp103 : 0; -} - -uint64_t* tmp104 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp104 at (2242,1-2242,37) */ -uint64_t __tmp_in_tmp104; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp104; -} -Arr1DIdxRowM(tmp104, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp104 : 0; -} - -uint64_t* tmp105 = make_array( (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp105 at (2245,1-2245,48) */ -uint64_t __tmp_in_tmp105; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)224; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp105; -} -Arr4DIdxRowM(tmp105, (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp105 : 0; -} -} -} -} - -uint64_t* tmp106 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp106 at (2248,1-2248,37) */ -uint64_t __tmp_in_tmp106; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp106; -} -Arr1DIdxRowM(tmp106, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp106 : 0; -} - -uint64_t* tmp107 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp107 at (2251,1-2251,37) */ -uint64_t __tmp_in_tmp107; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp107; -} -Arr1DIdxRowM(tmp107, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp107 : 0; -} - -uint64_t* tmp108 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp108 at (2254,1-2254,37) */ -uint64_t __tmp_in_tmp108; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp108; -} -Arr1DIdxRowM(tmp108, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp108 : 0; -} - -uint64_t* tmp109 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp109 at (2257,1-2257,37) */ -uint64_t __tmp_in_tmp109; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp109; -} -Arr1DIdxRowM(tmp109, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp109 : 0; -} - -uint64_t* tmp110 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp110 at (2260,1-2260,47) */ -uint64_t __tmp_in_tmp110; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp110; -} -Arr4DIdxRowM(tmp110, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp110 : 0; -} -} -} -} - -uint64_t* tmp111 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp111 at (2263,1-2263,37) */ -uint64_t __tmp_in_tmp111; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp111; -} -Arr1DIdxRowM(tmp111, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp111 : 0; -} - -uint64_t* tmp112 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp112 at (2266,1-2266,37) */ -uint64_t __tmp_in_tmp112; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp112; -} -Arr1DIdxRowM(tmp112, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp112 : 0; -} - -uint64_t* tmp113 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp113 at (2269,1-2269,37) */ -uint64_t __tmp_in_tmp113; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp113; -} -Arr1DIdxRowM(tmp113, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp113 : 0; -} - -uint64_t* tmp114 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp114 at (2272,1-2272,37) */ -uint64_t __tmp_in_tmp114; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp114; -} -Arr1DIdxRowM(tmp114, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp114 : 0; -} - -uint64_t* tmp115 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp115 at (2275,1-2275,48) */ -uint64_t __tmp_in_tmp115; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp115; -} -Arr4DIdxRowM(tmp115, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp115 : 0; -} -} -} -} - -uint64_t* tmp116 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp116 at (2278,1-2278,37) */ -uint64_t __tmp_in_tmp116; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp116; -} -Arr1DIdxRowM(tmp116, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp116 : 0; -} - -uint64_t* tmp117 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp117 at (2281,1-2281,37) */ -uint64_t __tmp_in_tmp117; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp117; -} -Arr1DIdxRowM(tmp117, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp117 : 0; -} - -uint64_t* tmp118 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp118 at (2284,1-2284,37) */ -uint64_t __tmp_in_tmp118; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp118; -} -Arr1DIdxRowM(tmp118, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp118 : 0; -} - -uint64_t* tmp119 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp119 at (2287,1-2287,37) */ -uint64_t __tmp_in_tmp119; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp119; -} -Arr1DIdxRowM(tmp119, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp119 : 0; -} - -uint64_t* tmp120 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp120 at (2290,1-2290,47) */ -uint64_t __tmp_in_tmp120; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp120; -} -Arr4DIdxRowM(tmp120, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp120 : 0; -} -} -} -} - -uint64_t* tmp121 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp121 at (2293,1-2293,37) */ -uint64_t __tmp_in_tmp121; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp121; -} -Arr1DIdxRowM(tmp121, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp121 : 0; -} - -uint64_t* tmp122 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp122 at (2296,1-2296,37) */ -uint64_t __tmp_in_tmp122; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp122; -} -Arr1DIdxRowM(tmp122, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp122 : 0; -} - -uint64_t* tmp123 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp123 at (2299,1-2299,37) */ -uint64_t __tmp_in_tmp123; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp123; -} -Arr1DIdxRowM(tmp123, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp123 : 0; -} - -uint64_t* tmp124 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp124 at (2302,1-2302,37) */ -uint64_t __tmp_in_tmp124; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp124; -} -Arr1DIdxRowM(tmp124, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp124 : 0; -} - -uint64_t* tmp125 = make_array( (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp125 at (2305,1-2305,48) */ -uint64_t __tmp_in_tmp125; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)288; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp125; -} -Arr4DIdxRowM(tmp125, (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp125 : 0; -} -} -} -} - -uint64_t* tmp126 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp126 at (2308,1-2308,37) */ -uint64_t __tmp_in_tmp126; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp126; -} -Arr1DIdxRowM(tmp126, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp126 : 0; -} - -uint64_t* tmp127 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp127 at (2311,1-2311,37) */ -uint64_t __tmp_in_tmp127; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp127; -} -Arr1DIdxRowM(tmp127, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp127 : 0; -} - -uint64_t* tmp128 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp128 at (2314,1-2314,37) */ -uint64_t __tmp_in_tmp128; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp128; -} -Arr1DIdxRowM(tmp128, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp128 : 0; -} - -uint64_t* tmp129 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp129 at (2317,1-2317,37) */ -uint64_t __tmp_in_tmp129; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp129; -} -Arr1DIdxRowM(tmp129, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp129 : 0; -} - -uint64_t* tmp130 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp130 at (2320,1-2320,47) */ -uint64_t __tmp_in_tmp130; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp130; -} -Arr4DIdxRowM(tmp130, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp130 : 0; -} -} -} -} - -uint64_t* tmp131 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp131 at (2323,1-2323,37) */ -uint64_t __tmp_in_tmp131; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp131; -} -Arr1DIdxRowM(tmp131, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp131 : 0; -} - -uint64_t* tmp132 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp132 at (2326,1-2326,37) */ -uint64_t __tmp_in_tmp132; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp132; -} -Arr1DIdxRowM(tmp132, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp132 : 0; -} - -uint64_t* tmp133 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp133 at (2329,1-2329,37) */ -uint64_t __tmp_in_tmp133; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp133; -} -Arr1DIdxRowM(tmp133, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp133 : 0; -} - -uint64_t* tmp134 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp134 at (2332,1-2332,37) */ -uint64_t __tmp_in_tmp134; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp134; -} -Arr1DIdxRowM(tmp134, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp134 : 0; -} - -uint64_t* tmp135 = make_array( (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp135 at (2335,1-2335,48) */ -uint64_t __tmp_in_tmp135; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)320; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp135; -} -Arr4DIdxRowM(tmp135, (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp135 : 0; -} -} -} -} - -uint64_t* tmp136 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp136 at (2338,1-2338,37) */ -uint64_t __tmp_in_tmp136; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp136; -} -Arr1DIdxRowM(tmp136, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp136 : 0; -} - -uint64_t* tmp137 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp137 at (2341,1-2341,37) */ -uint64_t __tmp_in_tmp137; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp137; -} -Arr1DIdxRowM(tmp137, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp137 : 0; -} - -uint64_t* tmp138 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp138 at (2344,1-2344,37) */ -uint64_t __tmp_in_tmp138; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp138; -} -Arr1DIdxRowM(tmp138, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp138 : 0; -} - -uint64_t* tmp139 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp139 at (2347,1-2347,37) */ -uint64_t __tmp_in_tmp139; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp139; -} -Arr1DIdxRowM(tmp139, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp139 : 0; -} - -uint64_t* tmp140 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp140 at (2350,1-2350,47) */ -uint64_t __tmp_in_tmp140; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp140; -} -Arr4DIdxRowM(tmp140, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp140 : 0; -} -} -} -} - -uint64_t* tmp141 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp141 at (2353,1-2353,37) */ -uint64_t __tmp_in_tmp141; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp141; -} -Arr1DIdxRowM(tmp141, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp141 : 0; -} - -uint64_t* tmp142 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp142 at (2356,1-2356,37) */ -uint64_t __tmp_in_tmp142; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp142; -} -Arr1DIdxRowM(tmp142, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp142 : 0; -} - -uint64_t* tmp143 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp143 at (2359,1-2359,37) */ -uint64_t __tmp_in_tmp143; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp143; -} -Arr1DIdxRowM(tmp143, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp143 : 0; -} - -uint64_t* tmp144 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp144 at (2362,1-2362,37) */ -uint64_t __tmp_in_tmp144; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp144; -} -Arr1DIdxRowM(tmp144, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp144 : 0; -} - -uint64_t* tmp145 = make_array( (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp145 at (2365,1-2365,48) */ -uint64_t __tmp_in_tmp145; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)352; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp145; -} -Arr4DIdxRowM(tmp145, (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp145 : 0; -} -} -} -} - -uint64_t* tmp146 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp146 at (2368,1-2368,37) */ -uint64_t __tmp_in_tmp146; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp146; -} -Arr1DIdxRowM(tmp146, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp146 : 0; -} - -uint64_t* tmp147 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp147 at (2371,1-2371,37) */ -uint64_t __tmp_in_tmp147; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp147; -} -Arr1DIdxRowM(tmp147, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp147 : 0; -} - -uint64_t* tmp148 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp148 at (2374,1-2374,37) */ -uint64_t __tmp_in_tmp148; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp148; -} -Arr1DIdxRowM(tmp148, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp148 : 0; -} - -uint64_t* tmp149 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp149 at (2377,1-2377,37) */ -uint64_t __tmp_in_tmp149; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp149; -} -Arr1DIdxRowM(tmp149, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp149 : 0; -} - -uint64_t* tmp150 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp150 at (2380,1-2380,47) */ -uint64_t __tmp_in_tmp150; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp150; -} -Arr4DIdxRowM(tmp150, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp150 : 0; -} -} -} -} - -uint64_t* tmp151 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp151 at (2383,1-2383,37) */ -uint64_t __tmp_in_tmp151; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp151; -} -Arr1DIdxRowM(tmp151, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp151 : 0; -} - -uint64_t* tmp152 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp152 at (2386,1-2386,37) */ -uint64_t __tmp_in_tmp152; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp152; -} -Arr1DIdxRowM(tmp152, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp152 : 0; -} - -uint64_t* tmp153 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp153 at (2389,1-2389,37) */ -uint64_t __tmp_in_tmp153; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp153; -} -Arr1DIdxRowM(tmp153, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp153 : 0; -} - -uint64_t* tmp154 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp154 at (2392,1-2392,37) */ -uint64_t __tmp_in_tmp154; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp154; -} -Arr1DIdxRowM(tmp154, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp154 : 0; -} - -uint64_t* tmp155 = make_array( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp155 at (2395,1-2395,48) */ -uint64_t __tmp_in_tmp155; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)384; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp155; -} -Arr4DIdxRowM(tmp155, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp155 : 0; -} -} -} -} - -uint64_t* tmp156 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp156 at (2398,1-2398,37) */ -uint64_t __tmp_in_tmp156; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp156; -} -Arr1DIdxRowM(tmp156, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp156 : 0; -} - -uint64_t* tmp157 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp157 at (2401,1-2401,37) */ -uint64_t __tmp_in_tmp157; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp157; -} -Arr1DIdxRowM(tmp157, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp157 : 0; -} - -uint64_t* tmp158 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp158 at (2404,1-2404,37) */ -uint64_t __tmp_in_tmp158; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp158; -} -Arr1DIdxRowM(tmp158, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp158 : 0; -} - -uint64_t* tmp159 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp159 at (2407,1-2407,37) */ -uint64_t __tmp_in_tmp159; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp159; -} -Arr1DIdxRowM(tmp159, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp159 : 0; -} - -uint64_t* tmp160 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp160 at (2410,1-2410,47) */ -uint64_t __tmp_in_tmp160; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp160; -} -Arr4DIdxRowM(tmp160, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp160 : 0; -} -} -} -} - -uint64_t* tmp161 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp161 at (2413,1-2413,37) */ -uint64_t __tmp_in_tmp161; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp161; -} -Arr1DIdxRowM(tmp161, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp161 : 0; -} - -uint64_t* tmp162 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp162 at (2416,1-2416,37) */ -uint64_t __tmp_in_tmp162; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp162; -} -Arr1DIdxRowM(tmp162, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp162 : 0; -} - -uint64_t* tmp163 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp163 at (2419,1-2419,37) */ -uint64_t __tmp_in_tmp163; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp163; -} -Arr1DIdxRowM(tmp163, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp163 : 0; -} - -uint64_t* tmp164 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp164 at (2422,1-2422,37) */ -uint64_t __tmp_in_tmp164; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp164; -} -Arr1DIdxRowM(tmp164, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp164 : 0; -} - -uint64_t* tmp165 = make_array( (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp165 at (2425,1-2425,48) */ -uint64_t __tmp_in_tmp165; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)416; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp165; -} -Arr4DIdxRowM(tmp165, (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp165 : 0; -} -} -} -} - -uint64_t* tmp166 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp166 at (2428,1-2428,37) */ -uint64_t __tmp_in_tmp166; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp166; -} -Arr1DIdxRowM(tmp166, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp166 : 0; -} - -uint64_t* tmp167 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp167 at (2431,1-2431,37) */ -uint64_t __tmp_in_tmp167; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp167; -} -Arr1DIdxRowM(tmp167, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp167 : 0; -} - -uint64_t* tmp168 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp168 at (2434,1-2434,37) */ -uint64_t __tmp_in_tmp168; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp168; -} -Arr1DIdxRowM(tmp168, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp168 : 0; -} - -uint64_t* tmp169 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp169 at (2437,1-2437,37) */ -uint64_t __tmp_in_tmp169; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp169; -} -Arr1DIdxRowM(tmp169, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp169 : 0; -} - -uint64_t* tmp170 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp170 at (2440,1-2440,47) */ -uint64_t __tmp_in_tmp170; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp170; -} -Arr4DIdxRowM(tmp170, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp170 : 0; -} -} -} -} - -uint64_t* tmp171 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp171 at (2443,1-2443,37) */ -uint64_t __tmp_in_tmp171; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp171; -} -Arr1DIdxRowM(tmp171, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp171 : 0; -} - -uint64_t* tmp172 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp172 at (2446,1-2446,37) */ -uint64_t __tmp_in_tmp172; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp172; -} -Arr1DIdxRowM(tmp172, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp172 : 0; -} - -uint64_t* tmp173 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp173 at (2449,1-2449,37) */ -uint64_t __tmp_in_tmp173; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp173; -} -Arr1DIdxRowM(tmp173, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp173 : 0; -} - -uint64_t* tmp174 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp174 at (2452,1-2452,37) */ -uint64_t __tmp_in_tmp174; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp174; -} -Arr1DIdxRowM(tmp174, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp174 : 0; -} - -uint64_t* tmp175 = make_array( (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp175 at (2455,1-2455,48) */ -uint64_t __tmp_in_tmp175; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)448; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp175; -} -Arr4DIdxRowM(tmp175, (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp175 : 0; -} -} -} -} - -uint64_t* tmp176 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp176 at (2458,1-2458,37) */ -uint64_t __tmp_in_tmp176; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp176; -} -Arr1DIdxRowM(tmp176, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp176 : 0; -} - -uint64_t* tmp177 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp177 at (2461,1-2461,37) */ -uint64_t __tmp_in_tmp177; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp177; -} -Arr1DIdxRowM(tmp177, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp177 : 0; -} - -uint64_t* tmp178 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp178 at (2464,1-2464,37) */ -uint64_t __tmp_in_tmp178; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp178; -} -Arr1DIdxRowM(tmp178, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp178 : 0; -} - -uint64_t* tmp179 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp179 at (2467,1-2467,37) */ -uint64_t __tmp_in_tmp179; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp179; -} -Arr1DIdxRowM(tmp179, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp179 : 0; -} - -uint64_t* tmp180 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp180 at (2470,1-2470,47) */ -uint64_t __tmp_in_tmp180; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp180; -} -Arr4DIdxRowM(tmp180, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp180 : 0; -} -} -} -} - -uint64_t* tmp181 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp181 at (2473,1-2473,37) */ -uint64_t __tmp_in_tmp181; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp181; -} -Arr1DIdxRowM(tmp181, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp181 : 0; -} - -uint64_t* tmp182 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp182 at (2476,1-2476,37) */ -uint64_t __tmp_in_tmp182; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp182; -} -Arr1DIdxRowM(tmp182, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp182 : 0; -} - -uint64_t* tmp183 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp183 at (2479,1-2479,37) */ -uint64_t __tmp_in_tmp183; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp183; -} -Arr1DIdxRowM(tmp183, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp183 : 0; -} - -uint64_t* tmp184 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp184 at (2482,1-2482,37) */ -uint64_t __tmp_in_tmp184; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp184; -} -Arr1DIdxRowM(tmp184, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp184 : 0; -} - -uint64_t* tmp185 = make_array( (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp185 at (2485,1-2485,48) */ -uint64_t __tmp_in_tmp185; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)480; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp185; -} -Arr4DIdxRowM(tmp185, (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp185 : 0; -} -} -} -} - -uint64_t* tmp186 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp186 at (2488,1-2488,37) */ -uint64_t __tmp_in_tmp186; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp186; -} -Arr1DIdxRowM(tmp186, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp186 : 0; -} - -uint64_t* tmp187 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp187 at (2491,1-2491,37) */ -uint64_t __tmp_in_tmp187; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp187; -} -Arr1DIdxRowM(tmp187, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp187 : 0; -} - -uint64_t* tmp188 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp188 at (2494,1-2494,37) */ -uint64_t __tmp_in_tmp188; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp188; -} -Arr1DIdxRowM(tmp188, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp188 : 0; -} - -uint64_t* tmp189 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp189 at (2497,1-2497,37) */ -uint64_t __tmp_in_tmp189; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp189; -} -Arr1DIdxRowM(tmp189, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp189 : 0; -} - -uint64_t* tmp190 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp190 at (2500,1-2500,47) */ -uint64_t __tmp_in_tmp190; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp190; -} -Arr4DIdxRowM(tmp190, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp190 : 0; -} -} -} -} - -uint64_t* tmp191 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp191 at (2503,1-2503,37) */ -uint64_t __tmp_in_tmp191; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp191; -} -Arr1DIdxRowM(tmp191, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp191 : 0; -} - -uint64_t* tmp192 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp192 at (2506,1-2506,37) */ -uint64_t __tmp_in_tmp192; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp192; -} -Arr1DIdxRowM(tmp192, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp192 : 0; -} - -uint64_t* tmp193 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp193 at (2509,1-2509,37) */ -uint64_t __tmp_in_tmp193; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp193; -} -Arr1DIdxRowM(tmp193, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp193 : 0; -} - -uint64_t* tmp194 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp194 at (2512,1-2512,37) */ -uint64_t __tmp_in_tmp194; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp194; -} -Arr1DIdxRowM(tmp194, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp194 : 0; -} - -uint64_t* tmp195 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp195 at (2515,1-2515,48) */ -uint64_t __tmp_in_tmp195; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp195; -} -Arr4DIdxRowM(tmp195, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp195 : 0; -} -} -} -} - -uint64_t* tmp196 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp196 at (2518,1-2518,37) */ -uint64_t __tmp_in_tmp196; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp196; -} -Arr1DIdxRowM(tmp196, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp196 : 0; -} - -uint64_t* tmp197 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp197 at (2521,1-2521,37) */ -uint64_t __tmp_in_tmp197; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp197; -} -Arr1DIdxRowM(tmp197, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp197 : 0; -} - -uint64_t* tmp198 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp198 at (2524,1-2524,37) */ -uint64_t __tmp_in_tmp198; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp198; -} -Arr1DIdxRowM(tmp198, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp198 : 0; -} - -uint64_t* tmp199 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp199 at (2527,1-2527,37) */ -uint64_t __tmp_in_tmp199; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp199; -} -Arr1DIdxRowM(tmp199, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp199 : 0; -} - -uint64_t* tmp200 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp200 at (2530,1-2530,48) */ -uint64_t __tmp_in_tmp200; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp200; -} -Arr4DIdxRowM(tmp200, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp200 : 0; -} -} -} -} - -uint64_t* tmp201 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp201 at (2533,1-2533,37) */ -uint64_t __tmp_in_tmp201; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp201; -} -Arr1DIdxRowM(tmp201, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp201 : 0; -} - -uint64_t* tmp202 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp202 at (2536,1-2536,37) */ -uint64_t __tmp_in_tmp202; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp202; -} -Arr1DIdxRowM(tmp202, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp202 : 0; -} - -uint64_t* tmp203 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp203 at (2539,1-2539,37) */ -uint64_t __tmp_in_tmp203; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp203; -} -Arr1DIdxRowM(tmp203, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp203 : 0; -} - -uint64_t* tmp204 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp204 at (2542,1-2542,37) */ -uint64_t __tmp_in_tmp204; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp204; -} -Arr1DIdxRowM(tmp204, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp204 : 0; -} - -uint64_t* tmp205 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp205 at (2545,1-2545,47) */ -uint64_t __tmp_in_tmp205; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp205; -} -Arr4DIdxRowM(tmp205, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp205 : 0; -} -} -} -} - -uint64_t* tmp206 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp206 at (2548,1-2548,37) */ -uint64_t __tmp_in_tmp206; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp206; -} -Arr1DIdxRowM(tmp206, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp206 : 0; -} - -uint64_t* tmp207 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp207 at (2551,1-2551,37) */ -uint64_t __tmp_in_tmp207; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp207; -} -Arr1DIdxRowM(tmp207, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp207 : 0; -} - -uint64_t* tmp208 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp208 at (2554,1-2554,37) */ -uint64_t __tmp_in_tmp208; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp208; -} -Arr1DIdxRowM(tmp208, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp208 : 0; -} - -uint64_t* tmp209 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp209 at (2557,1-2557,37) */ -uint64_t __tmp_in_tmp209; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp209; -} -Arr1DIdxRowM(tmp209, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp209 : 0; -} - -uint64_t* tmp210 = make_array( (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp210 at (2560,1-2560,48) */ -uint64_t __tmp_in_tmp210; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)288; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp210; -} -Arr4DIdxRowM(tmp210, (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp210 : 0; -} -} -} -} - -uint64_t* tmp211 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp211 at (2563,1-2563,37) */ -uint64_t __tmp_in_tmp211; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp211; -} -Arr1DIdxRowM(tmp211, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp211 : 0; -} - -uint64_t* tmp212 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp212 at (2566,1-2566,37) */ -uint64_t __tmp_in_tmp212; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp212; -} -Arr1DIdxRowM(tmp212, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp212 : 0; -} - -uint64_t* tmp213 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp213 at (2569,1-2569,37) */ -uint64_t __tmp_in_tmp213; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp213; -} -Arr1DIdxRowM(tmp213, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp213 : 0; -} - -uint64_t* tmp214 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp214 at (2572,1-2572,37) */ -uint64_t __tmp_in_tmp214; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp214; -} -Arr1DIdxRowM(tmp214, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp214 : 0; -} - -uint64_t* tmp215 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp215 at (2575,1-2575,47) */ -uint64_t __tmp_in_tmp215; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp215; -} -Arr4DIdxRowM(tmp215, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp215 : 0; -} -} -} -} - -uint64_t* tmp216 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp216 at (2578,1-2578,37) */ -uint64_t __tmp_in_tmp216; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp216; -} -Arr1DIdxRowM(tmp216, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp216 : 0; -} - -uint64_t* tmp217 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp217 at (2581,1-2581,37) */ -uint64_t __tmp_in_tmp217; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp217; -} -Arr1DIdxRowM(tmp217, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp217 : 0; -} - -uint64_t* tmp218 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp218 at (2584,1-2584,37) */ -uint64_t __tmp_in_tmp218; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp218; -} -Arr1DIdxRowM(tmp218, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp218 : 0; -} - -uint64_t* tmp219 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp219 at (2587,1-2587,37) */ -uint64_t __tmp_in_tmp219; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp219; -} -Arr1DIdxRowM(tmp219, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp219 : 0; -} - -uint64_t* tmp220 = make_array( (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp220 at (2590,1-2590,48) */ -uint64_t __tmp_in_tmp220; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)320; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp220; -} -Arr4DIdxRowM(tmp220, (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp220 : 0; -} -} -} -} - -uint64_t* tmp221 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp221 at (2593,1-2593,37) */ -uint64_t __tmp_in_tmp221; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp221; -} -Arr1DIdxRowM(tmp221, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp221 : 0; -} - -uint64_t* tmp222 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp222 at (2596,1-2596,37) */ -uint64_t __tmp_in_tmp222; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp222; -} -Arr1DIdxRowM(tmp222, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp222 : 0; -} - -uint64_t* tmp223 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp223 at (2599,1-2599,37) */ -uint64_t __tmp_in_tmp223; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp223; -} -Arr1DIdxRowM(tmp223, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp223 : 0; -} - -uint64_t* tmp224 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp224 at (2602,1-2602,37) */ -uint64_t __tmp_in_tmp224; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp224; -} -Arr1DIdxRowM(tmp224, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp224 : 0; -} - -uint64_t* tmp225 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp225 at (2605,1-2605,47) */ -uint64_t __tmp_in_tmp225; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp225; -} -Arr4DIdxRowM(tmp225, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp225 : 0; -} -} -} -} - -uint64_t* tmp226 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp226 at (2608,1-2608,37) */ -uint64_t __tmp_in_tmp226; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp226; -} -Arr1DIdxRowM(tmp226, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp226 : 0; -} - -uint64_t* tmp227 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp227 at (2611,1-2611,37) */ -uint64_t __tmp_in_tmp227; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp227; -} -Arr1DIdxRowM(tmp227, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp227 : 0; -} - -uint64_t* tmp228 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp228 at (2614,1-2614,37) */ -uint64_t __tmp_in_tmp228; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp228; -} -Arr1DIdxRowM(tmp228, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp228 : 0; -} - -uint64_t* tmp229 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp229 at (2617,1-2617,37) */ -uint64_t __tmp_in_tmp229; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp229; -} -Arr1DIdxRowM(tmp229, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp229 : 0; -} - -uint64_t* tmp230 = make_array( (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp230 at (2620,1-2620,48) */ -uint64_t __tmp_in_tmp230; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)352; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp230; -} -Arr4DIdxRowM(tmp230, (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp230 : 0; -} -} -} -} - -uint64_t* tmp231 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp231 at (2623,1-2623,37) */ -uint64_t __tmp_in_tmp231; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp231; -} -Arr1DIdxRowM(tmp231, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp231 : 0; -} - -uint64_t* tmp232 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp232 at (2626,1-2626,37) */ -uint64_t __tmp_in_tmp232; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp232; -} -Arr1DIdxRowM(tmp232, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp232 : 0; -} - -uint64_t* tmp233 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp233 at (2629,1-2629,37) */ -uint64_t __tmp_in_tmp233; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp233; -} -Arr1DIdxRowM(tmp233, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp233 : 0; -} - -uint64_t* tmp234 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp234 at (2632,1-2632,37) */ -uint64_t __tmp_in_tmp234; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp234; -} -Arr1DIdxRowM(tmp234, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp234 : 0; -} - -uint64_t* tmp235 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp235 at (2635,1-2635,47) */ -uint64_t __tmp_in_tmp235; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp235; -} -Arr4DIdxRowM(tmp235, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp235 : 0; -} -} -} -} - -uint64_t* tmp236 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp236 at (2638,1-2638,37) */ -uint64_t __tmp_in_tmp236; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp236; -} -Arr1DIdxRowM(tmp236, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp236 : 0; -} - -uint64_t* tmp237 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp237 at (2641,1-2641,37) */ -uint64_t __tmp_in_tmp237; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp237; -} -Arr1DIdxRowM(tmp237, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp237 : 0; -} - -uint64_t* tmp238 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp238 at (2644,1-2644,37) */ -uint64_t __tmp_in_tmp238; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp238; -} -Arr1DIdxRowM(tmp238, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp238 : 0; -} - -uint64_t* tmp239 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp239 at (2647,1-2647,37) */ -uint64_t __tmp_in_tmp239; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp239; -} -Arr1DIdxRowM(tmp239, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp239 : 0; -} - -uint64_t* tmp240 = make_array( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp240 at (2650,1-2650,48) */ -uint64_t __tmp_in_tmp240; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)384; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp240; -} -Arr4DIdxRowM(tmp240, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp240 : 0; -} -} -} -} - -uint64_t* tmp241 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp241 at (2653,1-2653,37) */ -uint64_t __tmp_in_tmp241; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp241; -} -Arr1DIdxRowM(tmp241, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp241 : 0; -} - -uint64_t* tmp242 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp242 at (2656,1-2656,37) */ -uint64_t __tmp_in_tmp242; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp242; -} -Arr1DIdxRowM(tmp242, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp242 : 0; -} - -uint64_t* tmp243 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp243 at (2659,1-2659,37) */ -uint64_t __tmp_in_tmp243; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp243; -} -Arr1DIdxRowM(tmp243, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp243 : 0; -} - -uint64_t* tmp244 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp244 at (2662,1-2662,37) */ -uint64_t __tmp_in_tmp244; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp244; -} -Arr1DIdxRowM(tmp244, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp244 : 0; -} - -uint64_t* tmp245 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp245 at (2665,1-2665,47) */ -uint64_t __tmp_in_tmp245; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp245; -} -Arr4DIdxRowM(tmp245, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp245 : 0; -} -} -} -} - -uint64_t* tmp246 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp246 at (2668,1-2668,37) */ -uint64_t __tmp_in_tmp246; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp246; -} -Arr1DIdxRowM(tmp246, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp246 : 0; -} - -uint64_t* tmp247 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp247 at (2671,1-2671,37) */ -uint64_t __tmp_in_tmp247; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp247; -} -Arr1DIdxRowM(tmp247, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp247 : 0; -} - -uint64_t* tmp248 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp248 at (2674,1-2674,37) */ -uint64_t __tmp_in_tmp248; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp248; -} -Arr1DIdxRowM(tmp248, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp248 : 0; -} - -uint64_t* tmp249 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp249 at (2677,1-2677,37) */ -uint64_t __tmp_in_tmp249; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp249; -} -Arr1DIdxRowM(tmp249, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp249 : 0; -} - -uint64_t* tmp250 = make_array( (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp250 at (2680,1-2680,48) */ -uint64_t __tmp_in_tmp250; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)416; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp250; -} -Arr4DIdxRowM(tmp250, (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp250 : 0; -} -} -} -} - -uint64_t* tmp251 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp251 at (2683,1-2683,37) */ -uint64_t __tmp_in_tmp251; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp251; -} -Arr1DIdxRowM(tmp251, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp251 : 0; -} - -uint64_t* tmp252 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp252 at (2686,1-2686,37) */ -uint64_t __tmp_in_tmp252; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp252; -} -Arr1DIdxRowM(tmp252, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp252 : 0; -} - -uint64_t* tmp253 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp253 at (2689,1-2689,37) */ -uint64_t __tmp_in_tmp253; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp253; -} -Arr1DIdxRowM(tmp253, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp253 : 0; -} - -uint64_t* tmp254 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp254 at (2692,1-2692,37) */ -uint64_t __tmp_in_tmp254; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp254; -} -Arr1DIdxRowM(tmp254, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp254 : 0; -} - -uint64_t* tmp255 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp255 at (2695,1-2695,47) */ -uint64_t __tmp_in_tmp255; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp255; -} -Arr4DIdxRowM(tmp255, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp255 : 0; -} -} -} -} - -uint64_t* tmp256 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp256 at (2698,1-2698,37) */ -uint64_t __tmp_in_tmp256; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp256; -} -Arr1DIdxRowM(tmp256, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp256 : 0; -} - -uint64_t* tmp257 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp257 at (2701,1-2701,37) */ -uint64_t __tmp_in_tmp257; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp257; -} -Arr1DIdxRowM(tmp257, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp257 : 0; -} - -uint64_t* tmp258 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp258 at (2704,1-2704,37) */ -uint64_t __tmp_in_tmp258; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp258; -} -Arr1DIdxRowM(tmp258, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp258 : 0; -} - -uint64_t* tmp259 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp259 at (2707,1-2707,37) */ -uint64_t __tmp_in_tmp259; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp259; -} -Arr1DIdxRowM(tmp259, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp259 : 0; -} - -uint64_t* tmp260 = make_array( (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp260 at (2710,1-2710,48) */ -uint64_t __tmp_in_tmp260; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)448; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp260; -} -Arr4DIdxRowM(tmp260, (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp260 : 0; -} -} -} -} - -uint64_t* tmp261 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp261 at (2713,1-2713,37) */ -uint64_t __tmp_in_tmp261; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp261; -} -Arr1DIdxRowM(tmp261, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp261 : 0; -} - -uint64_t* tmp262 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp262 at (2716,1-2716,37) */ -uint64_t __tmp_in_tmp262; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp262; -} -Arr1DIdxRowM(tmp262, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp262 : 0; -} - -uint64_t* tmp263 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp263 at (2719,1-2719,37) */ -uint64_t __tmp_in_tmp263; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp263; -} -Arr1DIdxRowM(tmp263, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp263 : 0; -} - -uint64_t* tmp264 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp264 at (2722,1-2722,37) */ -uint64_t __tmp_in_tmp264; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp264; -} -Arr1DIdxRowM(tmp264, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp264 : 0; -} - -uint64_t* tmp265 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp265 at (2725,1-2725,47) */ -uint64_t __tmp_in_tmp265; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp265; -} -Arr4DIdxRowM(tmp265, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp265 : 0; -} -} -} -} - -uint64_t* tmp266 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp266 at (2728,1-2728,37) */ -uint64_t __tmp_in_tmp266; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp266; -} -Arr1DIdxRowM(tmp266, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp266 : 0; -} - -uint64_t* tmp267 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp267 at (2731,1-2731,37) */ -uint64_t __tmp_in_tmp267; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp267; -} -Arr1DIdxRowM(tmp267, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp267 : 0; -} - -uint64_t* tmp268 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp268 at (2734,1-2734,37) */ -uint64_t __tmp_in_tmp268; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp268; -} -Arr1DIdxRowM(tmp268, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp268 : 0; -} - -uint64_t* tmp269 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp269 at (2737,1-2737,37) */ -uint64_t __tmp_in_tmp269; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp269; -} -Arr1DIdxRowM(tmp269, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp269 : 0; -} - -uint64_t* tmp270 = make_array( (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp270 at (2740,1-2740,48) */ -uint64_t __tmp_in_tmp270; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)480; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp270; -} -Arr4DIdxRowM(tmp270, (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp270 : 0; -} -} -} -} - -uint64_t* tmp271 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp271 at (2743,1-2743,37) */ -uint64_t __tmp_in_tmp271; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp271; -} -Arr1DIdxRowM(tmp271, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp271 : 0; -} - -uint64_t* tmp272 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp272 at (2746,1-2746,37) */ -uint64_t __tmp_in_tmp272; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp272; -} -Arr1DIdxRowM(tmp272, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp272 : 0; -} - -uint64_t* tmp273 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp273 at (2749,1-2749,37) */ -uint64_t __tmp_in_tmp273; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp273; -} -Arr1DIdxRowM(tmp273, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp273 : 0; -} - -uint64_t* tmp274 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp274 at (2752,1-2752,37) */ -uint64_t __tmp_in_tmp274; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp274; -} -Arr1DIdxRowM(tmp274, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp274 : 0; -} - -uint64_t* tmp275 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp275 at (2755,1-2755,47) */ -uint64_t __tmp_in_tmp275; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp275; -} -Arr4DIdxRowM(tmp275, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp275 : 0; -} -} -} -} - -uint64_t* tmp276 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp276 at (2758,1-2758,37) */ -uint64_t __tmp_in_tmp276; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp276; -} -Arr1DIdxRowM(tmp276, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp276 : 0; -} - -uint64_t* tmp277 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp277 at (2761,1-2761,37) */ -uint64_t __tmp_in_tmp277; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp277; -} -Arr1DIdxRowM(tmp277, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp277 : 0; -} - -uint64_t* tmp278 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp278 at (2764,1-2764,37) */ -uint64_t __tmp_in_tmp278; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp278; -} -Arr1DIdxRowM(tmp278, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp278 : 0; -} - -uint64_t* tmp279 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp279 at (2767,1-2767,37) */ -uint64_t __tmp_in_tmp279; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp279; -} -Arr1DIdxRowM(tmp279, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp279 : 0; -} - -uint64_t* tmp280 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp280 at (2770,1-2770,48) */ -uint64_t __tmp_in_tmp280; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp280; -} -Arr4DIdxRowM(tmp280, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp280 : 0; -} -} -} -} - -uint64_t* tmp281 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp281 at (2773,1-2773,37) */ -uint64_t __tmp_in_tmp281; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp281; -} -Arr1DIdxRowM(tmp281, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp281 : 0; -} - -uint64_t* tmp282 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp282 at (2776,1-2776,37) */ -uint64_t __tmp_in_tmp282; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp282; -} -Arr1DIdxRowM(tmp282, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp282 : 0; -} - -uint64_t* tmp283 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp283 at (2779,1-2779,37) */ -uint64_t __tmp_in_tmp283; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp283; -} -Arr1DIdxRowM(tmp283, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp283 : 0; -} - -uint64_t* tmp284 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp284 at (2782,1-2782,37) */ -uint64_t __tmp_in_tmp284; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp284; -} -Arr1DIdxRowM(tmp284, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp284 : 0; -} - -uint64_t* tmp285 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp285 at (2785,1-2785,47) */ -uint64_t __tmp_in_tmp285; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp285; -} -Arr4DIdxRowM(tmp285, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp285 : 0; -} -} -} -} - -uint64_t* tmp286 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp286 at (2788,1-2788,37) */ -uint64_t __tmp_in_tmp286; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp286; -} -Arr1DIdxRowM(tmp286, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp286 : 0; -} - -uint64_t* tmp287 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp287 at (2791,1-2791,37) */ -uint64_t __tmp_in_tmp287; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp287; -} -Arr1DIdxRowM(tmp287, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp287 : 0; -} - -uint64_t* tmp288 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp288 at (2794,1-2794,37) */ -uint64_t __tmp_in_tmp288; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp288; -} -Arr1DIdxRowM(tmp288, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp288 : 0; -} - -uint64_t* tmp289 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp289 at (2797,1-2797,37) */ -uint64_t __tmp_in_tmp289; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp289; -} -Arr1DIdxRowM(tmp289, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp289 : 0; -} - -uint64_t* tmp290 = make_array( (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp290 at (2800,1-2800,48) */ -uint64_t __tmp_in_tmp290; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)544; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp290; -} -Arr4DIdxRowM(tmp290, (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp290 : 0; -} -} -} -} - -uint64_t* tmp291 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp291 at (2803,1-2803,37) */ -uint64_t __tmp_in_tmp291; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp291; -} -Arr1DIdxRowM(tmp291, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp291 : 0; -} - -uint64_t* tmp292 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp292 at (2806,1-2806,37) */ -uint64_t __tmp_in_tmp292; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp292; -} -Arr1DIdxRowM(tmp292, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp292 : 0; -} - -uint64_t* tmp293 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp293 at (2809,1-2809,37) */ -uint64_t __tmp_in_tmp293; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp293; -} -Arr1DIdxRowM(tmp293, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp293 : 0; -} - -uint64_t* tmp294 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp294 at (2812,1-2812,37) */ -uint64_t __tmp_in_tmp294; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp294; -} -Arr1DIdxRowM(tmp294, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp294 : 0; -} - -uint64_t* tmp295 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp295 at (2815,1-2815,47) */ -uint64_t __tmp_in_tmp295; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp295; -} -Arr4DIdxRowM(tmp295, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp295 : 0; -} -} -} -} - -uint64_t* tmp296 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp296 at (2818,1-2818,37) */ -uint64_t __tmp_in_tmp296; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp296; -} -Arr1DIdxRowM(tmp296, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp296 : 0; -} - -uint64_t* tmp297 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp297 at (2821,1-2821,37) */ -uint64_t __tmp_in_tmp297; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp297; -} -Arr1DIdxRowM(tmp297, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp297 : 0; -} - -uint64_t* tmp298 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp298 at (2824,1-2824,37) */ -uint64_t __tmp_in_tmp298; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp298; -} -Arr1DIdxRowM(tmp298, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp298 : 0; -} - -uint64_t* tmp299 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp299 at (2827,1-2827,37) */ -uint64_t __tmp_in_tmp299; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp299; -} -Arr1DIdxRowM(tmp299, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp299 : 0; -} - -uint64_t* tmp300 = make_array( (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp300 at (2830,1-2830,48) */ -uint64_t __tmp_in_tmp300; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)576; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp300; -} -Arr4DIdxRowM(tmp300, (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp300 : 0; -} -} -} -} - -uint64_t* tmp301 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp301 at (2833,1-2833,37) */ -uint64_t __tmp_in_tmp301; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp301; -} -Arr1DIdxRowM(tmp301, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp301 : 0; -} - -uint64_t* tmp302 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp302 at (2836,1-2836,37) */ -uint64_t __tmp_in_tmp302; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp302; -} -Arr1DIdxRowM(tmp302, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp302 : 0; -} - -uint64_t* tmp303 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp303 at (2839,1-2839,37) */ -uint64_t __tmp_in_tmp303; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp303; -} -Arr1DIdxRowM(tmp303, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp303 : 0; -} - -uint64_t* tmp304 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp304 at (2842,1-2842,37) */ -uint64_t __tmp_in_tmp304; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp304; -} -Arr1DIdxRowM(tmp304, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp304 : 0; -} - -uint64_t* tmp305 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp305 at (2845,1-2845,47) */ -uint64_t __tmp_in_tmp305; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp305; -} -Arr4DIdxRowM(tmp305, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp305 : 0; -} -} -} -} - -uint64_t* tmp306 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp306 at (2848,1-2848,37) */ -uint64_t __tmp_in_tmp306; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp306; -} -Arr1DIdxRowM(tmp306, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp306 : 0; -} - -uint64_t* tmp307 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp307 at (2851,1-2851,37) */ -uint64_t __tmp_in_tmp307; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp307; -} -Arr1DIdxRowM(tmp307, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp307 : 0; -} - -uint64_t* tmp308 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp308 at (2854,1-2854,37) */ -uint64_t __tmp_in_tmp308; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp308; -} -Arr1DIdxRowM(tmp308, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp308 : 0; -} - -uint64_t* tmp309 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp309 at (2857,1-2857,37) */ -uint64_t __tmp_in_tmp309; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp309; -} -Arr1DIdxRowM(tmp309, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp309 : 0; -} - -uint64_t* tmp310 = make_array( (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp310 at (2860,1-2860,48) */ -uint64_t __tmp_in_tmp310; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)608; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp310; -} -Arr4DIdxRowM(tmp310, (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp310 : 0; -} -} -} -} - -uint64_t* tmp311 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp311 at (2863,1-2863,37) */ -uint64_t __tmp_in_tmp311; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp311; -} -Arr1DIdxRowM(tmp311, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp311 : 0; -} - -uint64_t* tmp312 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp312 at (2866,1-2866,37) */ -uint64_t __tmp_in_tmp312; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp312; -} -Arr1DIdxRowM(tmp312, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp312 : 0; -} - -uint64_t* tmp313 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp313 at (2869,1-2869,37) */ -uint64_t __tmp_in_tmp313; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp313; -} -Arr1DIdxRowM(tmp313, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp313 : 0; -} - -uint64_t* tmp314 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp314 at (2872,1-2872,37) */ -uint64_t __tmp_in_tmp314; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp314; -} -Arr1DIdxRowM(tmp314, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp314 : 0; -} - -uint64_t* tmp315 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp315 at (2875,1-2875,47) */ -uint64_t __tmp_in_tmp315; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp315; -} -Arr4DIdxRowM(tmp315, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp315 : 0; -} -} -} -} - -uint64_t* tmp316 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp316 at (2878,1-2878,37) */ -uint64_t __tmp_in_tmp316; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp316; -} -Arr1DIdxRowM(tmp316, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp316 : 0; -} - -uint64_t* tmp317 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp317 at (2881,1-2881,37) */ -uint64_t __tmp_in_tmp317; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp317; -} -Arr1DIdxRowM(tmp317, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp317 : 0; -} - -uint64_t* tmp318 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp318 at (2884,1-2884,37) */ -uint64_t __tmp_in_tmp318; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp318; -} -Arr1DIdxRowM(tmp318, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp318 : 0; -} - -uint64_t* tmp319 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp319 at (2887,1-2887,37) */ -uint64_t __tmp_in_tmp319; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp319; -} -Arr1DIdxRowM(tmp319, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp319 : 0; -} - -uint64_t* tmp320 = make_array( (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp320 at (2890,1-2890,48) */ -uint64_t __tmp_in_tmp320; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)640; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp320; -} -Arr4DIdxRowM(tmp320, (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp320 : 0; -} -} -} -} - -uint64_t* tmp321 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp321 at (2893,1-2893,37) */ -uint64_t __tmp_in_tmp321; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp321; -} -Arr1DIdxRowM(tmp321, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp321 : 0; -} - -uint64_t* tmp322 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp322 at (2896,1-2896,37) */ -uint64_t __tmp_in_tmp322; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp322; -} -Arr1DIdxRowM(tmp322, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp322 : 0; -} - -uint64_t* tmp323 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp323 at (2899,1-2899,37) */ -uint64_t __tmp_in_tmp323; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp323; -} -Arr1DIdxRowM(tmp323, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp323 : 0; -} - -uint64_t* tmp324 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp324 at (2902,1-2902,37) */ -uint64_t __tmp_in_tmp324; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp324; -} -Arr1DIdxRowM(tmp324, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp324 : 0; -} - -uint64_t* tmp325 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp325 at (2905,1-2905,47) */ -uint64_t __tmp_in_tmp325; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp325; -} -Arr4DIdxRowM(tmp325, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp325 : 0; -} -} -} -} - -uint64_t* tmp326 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp326 at (2908,1-2908,37) */ -uint64_t __tmp_in_tmp326; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp326; -} -Arr1DIdxRowM(tmp326, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp326 : 0; -} - -uint64_t* tmp327 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp327 at (2911,1-2911,37) */ -uint64_t __tmp_in_tmp327; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp327; -} -Arr1DIdxRowM(tmp327, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp327 : 0; -} - -uint64_t* tmp328 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp328 at (2914,1-2914,37) */ -uint64_t __tmp_in_tmp328; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp328; -} -Arr1DIdxRowM(tmp328, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp328 : 0; -} - -uint64_t* tmp329 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp329 at (2917,1-2917,37) */ -uint64_t __tmp_in_tmp329; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp329; -} -Arr1DIdxRowM(tmp329, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp329 : 0; -} - -uint64_t* tmp330 = make_array( (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp330 at (2920,1-2920,48) */ -uint64_t __tmp_in_tmp330; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)672; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp330; -} -Arr4DIdxRowM(tmp330, (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp330 : 0; -} -} -} -} - -uint64_t* tmp331 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp331 at (2923,1-2923,37) */ -uint64_t __tmp_in_tmp331; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp331; -} -Arr1DIdxRowM(tmp331, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp331 : 0; -} - -uint64_t* tmp332 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp332 at (2926,1-2926,37) */ -uint64_t __tmp_in_tmp332; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp332; -} -Arr1DIdxRowM(tmp332, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp332 : 0; -} - -uint64_t* tmp333 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp333 at (2929,1-2929,37) */ -uint64_t __tmp_in_tmp333; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp333; -} -Arr1DIdxRowM(tmp333, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp333 : 0; -} - -uint64_t* tmp334 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp334 at (2932,1-2932,37) */ -uint64_t __tmp_in_tmp334; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp334; -} -Arr1DIdxRowM(tmp334, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp334 : 0; -} - -uint64_t* tmp335 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp335 at (2935,1-2935,47) */ -uint64_t __tmp_in_tmp335; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp335; -} -Arr4DIdxRowM(tmp335, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp335 : 0; -} -} -} -} - -uint64_t* tmp336 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp336 at (2938,1-2938,37) */ -uint64_t __tmp_in_tmp336; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp336; -} -Arr1DIdxRowM(tmp336, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp336 : 0; -} - -uint64_t* tmp337 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp337 at (2941,1-2941,37) */ -uint64_t __tmp_in_tmp337; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp337; -} -Arr1DIdxRowM(tmp337, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp337 : 0; -} - -uint64_t* tmp338 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp338 at (2944,1-2944,37) */ -uint64_t __tmp_in_tmp338; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp338; -} -Arr1DIdxRowM(tmp338, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp338 : 0; -} - -uint64_t* tmp339 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp339 at (2947,1-2947,37) */ -uint64_t __tmp_in_tmp339; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp339; -} -Arr1DIdxRowM(tmp339, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp339 : 0; -} - -uint64_t* tmp340 = make_array( (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp340 at (2950,1-2950,48) */ -uint64_t __tmp_in_tmp340; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)704; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp340; -} -Arr4DIdxRowM(tmp340, (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp340 : 0; -} -} -} -} - -uint64_t* tmp341 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp341 at (2953,1-2953,37) */ -uint64_t __tmp_in_tmp341; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp341; -} -Arr1DIdxRowM(tmp341, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp341 : 0; -} - -uint64_t* tmp342 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp342 at (2956,1-2956,37) */ -uint64_t __tmp_in_tmp342; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp342; -} -Arr1DIdxRowM(tmp342, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp342 : 0; -} - -uint64_t* tmp343 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp343 at (2959,1-2959,37) */ -uint64_t __tmp_in_tmp343; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp343; -} -Arr1DIdxRowM(tmp343, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp343 : 0; -} - -uint64_t* tmp344 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp344 at (2962,1-2962,37) */ -uint64_t __tmp_in_tmp344; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp344; -} -Arr1DIdxRowM(tmp344, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp344 : 0; -} - -uint64_t* tmp345 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp345 at (2965,1-2965,47) */ -uint64_t __tmp_in_tmp345; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp345; -} -Arr4DIdxRowM(tmp345, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp345 : 0; -} -} -} -} - -uint64_t* tmp346 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp346 at (2968,1-2968,37) */ -uint64_t __tmp_in_tmp346; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp346; -} -Arr1DIdxRowM(tmp346, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp346 : 0; -} - -uint64_t* tmp347 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp347 at (2971,1-2971,37) */ -uint64_t __tmp_in_tmp347; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp347; -} -Arr1DIdxRowM(tmp347, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp347 : 0; -} - -uint64_t* tmp348 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp348 at (2974,1-2974,37) */ -uint64_t __tmp_in_tmp348; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp348; -} -Arr1DIdxRowM(tmp348, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp348 : 0; -} - -uint64_t* tmp349 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp349 at (2977,1-2977,37) */ -uint64_t __tmp_in_tmp349; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp349; -} -Arr1DIdxRowM(tmp349, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp349 : 0; -} - -uint64_t* tmp350 = make_array( (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp350 at (2980,1-2980,48) */ -uint64_t __tmp_in_tmp350; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)736; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp350; -} -Arr4DIdxRowM(tmp350, (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp350 : 0; -} -} -} -} - -uint64_t* tmp351 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp351 at (2983,1-2983,37) */ -uint64_t __tmp_in_tmp351; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp351; -} -Arr1DIdxRowM(tmp351, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp351 : 0; -} - -uint64_t* tmp352 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp352 at (2986,1-2986,37) */ -uint64_t __tmp_in_tmp352; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp352; -} -Arr1DIdxRowM(tmp352, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp352 : 0; -} - -uint64_t* tmp353 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp353 at (2989,1-2989,37) */ -uint64_t __tmp_in_tmp353; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp353; -} -Arr1DIdxRowM(tmp353, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp353 : 0; -} - -uint64_t* tmp354 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp354 at (2992,1-2992,37) */ -uint64_t __tmp_in_tmp354; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp354; -} -Arr1DIdxRowM(tmp354, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp354 : 0; -} - -uint64_t* tmp355 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp355 at (2995,1-2995,47) */ -uint64_t __tmp_in_tmp355; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp355; -} -Arr4DIdxRowM(tmp355, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp355 : 0; -} -} -} -} - -uint64_t* tmp356 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp356 at (2998,1-2998,37) */ -uint64_t __tmp_in_tmp356; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp356; -} -Arr1DIdxRowM(tmp356, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp356 : 0; -} - -uint64_t* tmp357 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp357 at (3001,1-3001,37) */ -uint64_t __tmp_in_tmp357; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp357; -} -Arr1DIdxRowM(tmp357, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp357 : 0; -} - -uint64_t* tmp358 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp358 at (3004,1-3004,37) */ -uint64_t __tmp_in_tmp358; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp358; -} -Arr1DIdxRowM(tmp358, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp358 : 0; -} - -uint64_t* tmp359 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp359 at (3007,1-3007,37) */ -uint64_t __tmp_in_tmp359; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp359; -} -Arr1DIdxRowM(tmp359, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp359 : 0; -} - -uint64_t* tmp360 = make_array( (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp360 at (3010,1-3010,48) */ -uint64_t __tmp_in_tmp360; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)768; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp360; -} -Arr4DIdxRowM(tmp360, (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp360 : 0; -} -} -} -} - -uint64_t* tmp361 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp361 at (3013,1-3013,37) */ -uint64_t __tmp_in_tmp361; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp361; -} -Arr1DIdxRowM(tmp361, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp361 : 0; -} - -uint64_t* tmp362 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp362 at (3016,1-3016,37) */ -uint64_t __tmp_in_tmp362; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp362; -} -Arr1DIdxRowM(tmp362, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp362 : 0; -} - -uint64_t* tmp363 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp363 at (3019,1-3019,37) */ -uint64_t __tmp_in_tmp363; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp363; -} -Arr1DIdxRowM(tmp363, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp363 : 0; -} - -uint64_t* tmp364 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp364 at (3022,1-3022,37) */ -uint64_t __tmp_in_tmp364; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp364; -} -Arr1DIdxRowM(tmp364, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp364 : 0; -} - -uint64_t* tmp365 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp365 at (3025,1-3025,47) */ -uint64_t __tmp_in_tmp365; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp365; -} -Arr4DIdxRowM(tmp365, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp365 : 0; -} -} -} -} - -uint64_t* tmp366 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp366 at (3028,1-3028,37) */ -uint64_t __tmp_in_tmp366; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp366; -} -Arr1DIdxRowM(tmp366, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp366 : 0; -} - -uint64_t* tmp367 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp367 at (3031,1-3031,37) */ -uint64_t __tmp_in_tmp367; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp367; -} -Arr1DIdxRowM(tmp367, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp367 : 0; -} - -uint64_t* tmp368 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp368 at (3034,1-3034,37) */ -uint64_t __tmp_in_tmp368; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp368; -} -Arr1DIdxRowM(tmp368, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp368 : 0; -} - -uint64_t* tmp369 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp369 at (3037,1-3037,37) */ -uint64_t __tmp_in_tmp369; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp369; -} -Arr1DIdxRowM(tmp369, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp369 : 0; -} - -uint64_t* tmp370 = make_array( (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp370 at (3040,1-3040,48) */ -uint64_t __tmp_in_tmp370; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)800; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp370; -} -Arr4DIdxRowM(tmp370, (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp370 : 0; -} -} -} -} - -uint64_t* tmp371 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp371 at (3043,1-3043,37) */ -uint64_t __tmp_in_tmp371; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp371; -} -Arr1DIdxRowM(tmp371, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp371 : 0; -} - -uint64_t* tmp372 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp372 at (3046,1-3046,37) */ -uint64_t __tmp_in_tmp372; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp372; -} -Arr1DIdxRowM(tmp372, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp372 : 0; -} - -uint64_t* tmp373 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp373 at (3049,1-3049,37) */ -uint64_t __tmp_in_tmp373; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp373; -} -Arr1DIdxRowM(tmp373, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp373 : 0; -} - -uint64_t* tmp374 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp374 at (3052,1-3052,37) */ -uint64_t __tmp_in_tmp374; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp374; -} -Arr1DIdxRowM(tmp374, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp374 : 0; -} - -uint64_t* tmp375 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp375 at (3055,1-3055,47) */ -uint64_t __tmp_in_tmp375; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp375; -} -Arr4DIdxRowM(tmp375, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp375 : 0; -} -} -} -} - -uint64_t* tmp376 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp376 at (3058,1-3058,37) */ -uint64_t __tmp_in_tmp376; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp376; -} -Arr1DIdxRowM(tmp376, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp376 : 0; -} - -uint64_t* tmp377 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp377 at (3061,1-3061,37) */ -uint64_t __tmp_in_tmp377; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp377; -} -Arr1DIdxRowM(tmp377, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp377 : 0; -} - -uint64_t* tmp378 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp378 at (3064,1-3064,37) */ -uint64_t __tmp_in_tmp378; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp378; -} -Arr1DIdxRowM(tmp378, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp378 : 0; -} - -uint64_t* tmp379 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp379 at (3067,1-3067,37) */ -uint64_t __tmp_in_tmp379; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp379; -} -Arr1DIdxRowM(tmp379, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp379 : 0; -} - -uint64_t* tmp380 = make_array( (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp380 at (3070,1-3070,48) */ -uint64_t __tmp_in_tmp380; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)832; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp380; -} -Arr4DIdxRowM(tmp380, (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp380 : 0; -} -} -} -} - -uint64_t* tmp381 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp381 at (3073,1-3073,37) */ -uint64_t __tmp_in_tmp381; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp381; -} -Arr1DIdxRowM(tmp381, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp381 : 0; -} - -uint64_t* tmp382 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp382 at (3076,1-3076,37) */ -uint64_t __tmp_in_tmp382; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp382; -} -Arr1DIdxRowM(tmp382, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp382 : 0; -} - -uint64_t* tmp383 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp383 at (3079,1-3079,37) */ -uint64_t __tmp_in_tmp383; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp383; -} -Arr1DIdxRowM(tmp383, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp383 : 0; -} - -uint64_t* tmp384 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp384 at (3082,1-3082,37) */ -uint64_t __tmp_in_tmp384; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp384; -} -Arr1DIdxRowM(tmp384, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp384 : 0; -} - -uint64_t* tmp385 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp385 at (3085,1-3085,47) */ -uint64_t __tmp_in_tmp385; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp385; -} -Arr4DIdxRowM(tmp385, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp385 : 0; -} -} -} -} - -uint64_t* tmp386 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp386 at (3088,1-3088,37) */ -uint64_t __tmp_in_tmp386; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp386; -} -Arr1DIdxRowM(tmp386, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp386 : 0; -} - -uint64_t* tmp387 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp387 at (3091,1-3091,37) */ -uint64_t __tmp_in_tmp387; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp387; -} -Arr1DIdxRowM(tmp387, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp387 : 0; -} - -uint64_t* tmp388 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp388 at (3094,1-3094,37) */ -uint64_t __tmp_in_tmp388; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp388; -} -Arr1DIdxRowM(tmp388, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp388 : 0; -} - -uint64_t* tmp389 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp389 at (3097,1-3097,37) */ -uint64_t __tmp_in_tmp389; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp389; -} -Arr1DIdxRowM(tmp389, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp389 : 0; -} - -uint64_t* tmp390 = make_array( (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp390 at (3100,1-3100,48) */ -uint64_t __tmp_in_tmp390; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)864; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp390; -} -Arr4DIdxRowM(tmp390, (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp390 : 0; -} -} -} -} - -uint64_t* tmp391 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp391 at (3103,1-3103,37) */ -uint64_t __tmp_in_tmp391; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp391; -} -Arr1DIdxRowM(tmp391, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp391 : 0; -} - -uint64_t* tmp392 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp392 at (3106,1-3106,37) */ -uint64_t __tmp_in_tmp392; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp392; -} -Arr1DIdxRowM(tmp392, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp392 : 0; -} - -uint64_t* tmp393 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp393 at (3109,1-3109,37) */ -uint64_t __tmp_in_tmp393; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp393; -} -Arr1DIdxRowM(tmp393, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp393 : 0; -} - -uint64_t* tmp394 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp394 at (3112,1-3112,37) */ -uint64_t __tmp_in_tmp394; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp394; -} -Arr1DIdxRowM(tmp394, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp394 : 0; -} - -uint64_t* tmp395 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp395 at (3115,1-3115,47) */ -uint64_t __tmp_in_tmp395; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp395; -} -Arr4DIdxRowM(tmp395, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp395 : 0; -} -} -} -} - -uint64_t* tmp396 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp396 at (3118,1-3118,37) */ -uint64_t __tmp_in_tmp396; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp396; -} -Arr1DIdxRowM(tmp396, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp396 : 0; -} - -uint64_t* tmp397 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp397 at (3121,1-3121,37) */ -uint64_t __tmp_in_tmp397; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp397; -} -Arr1DIdxRowM(tmp397, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp397 : 0; -} - -uint64_t* tmp398 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp398 at (3124,1-3124,37) */ -uint64_t __tmp_in_tmp398; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp398; -} -Arr1DIdxRowM(tmp398, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp398 : 0; -} - -uint64_t* tmp399 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp399 at (3127,1-3127,37) */ -uint64_t __tmp_in_tmp399; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp399; -} -Arr1DIdxRowM(tmp399, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp399 : 0; -} - -uint64_t* tmp400 = make_array( (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp400 at (3130,1-3130,48) */ -uint64_t __tmp_in_tmp400; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)896; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp400; -} -Arr4DIdxRowM(tmp400, (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp400 : 0; -} -} -} -} - -uint64_t* tmp401 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp401 at (3133,1-3133,37) */ -uint64_t __tmp_in_tmp401; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp401; -} -Arr1DIdxRowM(tmp401, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp401 : 0; -} - -uint64_t* tmp402 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp402 at (3136,1-3136,37) */ -uint64_t __tmp_in_tmp402; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp402; -} -Arr1DIdxRowM(tmp402, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp402 : 0; -} - -uint64_t* tmp403 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp403 at (3139,1-3139,37) */ -uint64_t __tmp_in_tmp403; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp403; -} -Arr1DIdxRowM(tmp403, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp403 : 0; -} - -uint64_t* tmp404 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp404 at (3142,1-3142,37) */ -uint64_t __tmp_in_tmp404; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp404; -} -Arr1DIdxRowM(tmp404, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp404 : 0; -} - -uint64_t* tmp405 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp405 at (3145,1-3145,47) */ -uint64_t __tmp_in_tmp405; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp405; -} -Arr4DIdxRowM(tmp405, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp405 : 0; -} -} -} -} - -uint64_t* tmp406 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp406 at (3148,1-3148,37) */ -uint64_t __tmp_in_tmp406; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp406; -} -Arr1DIdxRowM(tmp406, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp406 : 0; -} - -uint64_t* tmp407 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp407 at (3151,1-3151,37) */ -uint64_t __tmp_in_tmp407; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp407; -} -Arr1DIdxRowM(tmp407, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp407 : 0; -} - -uint64_t* tmp408 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp408 at (3154,1-3154,37) */ -uint64_t __tmp_in_tmp408; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp408; -} -Arr1DIdxRowM(tmp408, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp408 : 0; -} - -uint64_t* tmp409 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp409 at (3157,1-3157,37) */ -uint64_t __tmp_in_tmp409; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp409; -} -Arr1DIdxRowM(tmp409, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp409 : 0; -} - -uint64_t* tmp410 = make_array( (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp410 at (3160,1-3160,48) */ -uint64_t __tmp_in_tmp410; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)928; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp410; -} -Arr4DIdxRowM(tmp410, (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp410 : 0; -} -} -} -} - -uint64_t* tmp411 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp411 at (3163,1-3163,37) */ -uint64_t __tmp_in_tmp411; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp411; -} -Arr1DIdxRowM(tmp411, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp411 : 0; -} - -uint64_t* tmp412 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp412 at (3166,1-3166,37) */ -uint64_t __tmp_in_tmp412; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp412; -} -Arr1DIdxRowM(tmp412, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp412 : 0; -} - -uint64_t* tmp413 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp413 at (3169,1-3169,37) */ -uint64_t __tmp_in_tmp413; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp413; -} -Arr1DIdxRowM(tmp413, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp413 : 0; -} - -uint64_t* tmp414 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp414 at (3172,1-3172,37) */ -uint64_t __tmp_in_tmp414; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp414; -} -Arr1DIdxRowM(tmp414, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp414 : 0; -} - -uint64_t* tmp415 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp415 at (3175,1-3175,47) */ -uint64_t __tmp_in_tmp415; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp415; -} -Arr4DIdxRowM(tmp415, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp415 : 0; -} -} -} -} - -uint64_t* tmp416 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp416 at (3178,1-3178,37) */ -uint64_t __tmp_in_tmp416; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp416; -} -Arr1DIdxRowM(tmp416, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp416 : 0; -} - -uint64_t* tmp417 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp417 at (3181,1-3181,37) */ -uint64_t __tmp_in_tmp417; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp417; -} -Arr1DIdxRowM(tmp417, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp417 : 0; -} - -uint64_t* tmp418 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp418 at (3184,1-3184,37) */ -uint64_t __tmp_in_tmp418; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp418; -} -Arr1DIdxRowM(tmp418, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp418 : 0; -} - -uint64_t* tmp419 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp419 at (3187,1-3187,37) */ -uint64_t __tmp_in_tmp419; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp419; -} -Arr1DIdxRowM(tmp419, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp419 : 0; -} - -uint64_t* tmp420 = make_array( (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp420 at (3190,1-3190,48) */ -uint64_t __tmp_in_tmp420; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)960; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp420; -} -Arr4DIdxRowM(tmp420, (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp420 : 0; -} -} -} -} - -uint64_t* tmp421 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp421 at (3193,1-3193,37) */ -uint64_t __tmp_in_tmp421; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp421; -} -Arr1DIdxRowM(tmp421, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp421 : 0; -} - -uint64_t* tmp422 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp422 at (3196,1-3196,37) */ -uint64_t __tmp_in_tmp422; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp422; -} -Arr1DIdxRowM(tmp422, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp422 : 0; -} - -uint64_t* tmp423 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp423 at (3199,1-3199,37) */ -uint64_t __tmp_in_tmp423; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp423; -} -Arr1DIdxRowM(tmp423, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp423 : 0; -} - -uint64_t* tmp424 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp424 at (3202,1-3202,37) */ -uint64_t __tmp_in_tmp424; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp424; -} -Arr1DIdxRowM(tmp424, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp424 : 0; -} - -uint64_t* tmp425 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp425 at (3205,1-3205,47) */ -uint64_t __tmp_in_tmp425; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp425; -} -Arr4DIdxRowM(tmp425, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp425 : 0; -} -} -} -} - -uint64_t* tmp426 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp426 at (3208,1-3208,37) */ -uint64_t __tmp_in_tmp426; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp426; -} -Arr1DIdxRowM(tmp426, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp426 : 0; -} - -uint64_t* tmp427 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp427 at (3211,1-3211,37) */ -uint64_t __tmp_in_tmp427; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp427; -} -Arr1DIdxRowM(tmp427, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp427 : 0; -} - -uint64_t* tmp428 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp428 at (3214,1-3214,37) */ -uint64_t __tmp_in_tmp428; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp428; -} -Arr1DIdxRowM(tmp428, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp428 : 0; -} - -uint64_t* tmp429 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp429 at (3217,1-3217,37) */ -uint64_t __tmp_in_tmp429; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp429; -} -Arr1DIdxRowM(tmp429, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp429 : 0; -} - -uint64_t* tmp430 = make_array( (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp430 at (3220,1-3220,48) */ -uint64_t __tmp_in_tmp430; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)992; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp430; -} -Arr4DIdxRowM(tmp430, (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp430 : 0; -} -} -} -} - -uint64_t* tmp431 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp431 at (3223,1-3223,37) */ -uint64_t __tmp_in_tmp431; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp431; -} -Arr1DIdxRowM(tmp431, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp431 : 0; -} - -uint64_t* tmp432 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp432 at (3226,1-3226,37) */ -uint64_t __tmp_in_tmp432; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp432; -} -Arr1DIdxRowM(tmp432, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp432 : 0; -} - -uint64_t* tmp433 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp433 at (3229,1-3229,37) */ -uint64_t __tmp_in_tmp433; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp433; -} -Arr1DIdxRowM(tmp433, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp433 : 0; -} - -uint64_t* tmp434 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp434 at (3232,1-3232,37) */ -uint64_t __tmp_in_tmp434; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp434; -} -Arr1DIdxRowM(tmp434, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp434 : 0; -} - -uint64_t* tmp435 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp435 at (3235,1-3235,47) */ -uint64_t __tmp_in_tmp435; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp435; -} -Arr4DIdxRowM(tmp435, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp435 : 0; -} -} -} -} - -uint64_t* tmp436 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp436 at (3238,1-3238,38) */ -uint64_t __tmp_in_tmp436; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp436; -} -Arr1DIdxRowM(tmp436, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp436 : 0; -} - -uint64_t* tmp437 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp437 at (3241,1-3241,38) */ -uint64_t __tmp_in_tmp437; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp437; -} -Arr1DIdxRowM(tmp437, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp437 : 0; -} - -uint64_t* tmp438 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp438 at (3244,1-3244,38) */ -uint64_t __tmp_in_tmp438; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp438; -} -Arr1DIdxRowM(tmp438, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp438 : 0; -} - -uint64_t* tmp439 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp439 at (3247,1-3247,38) */ -uint64_t __tmp_in_tmp439; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp439; -} -Arr1DIdxRowM(tmp439, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp439 : 0; -} - -uint64_t* tmp440 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp440 at (3250,1-3250,49) */ -uint64_t __tmp_in_tmp440; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp440; -} -Arr4DIdxRowM(tmp440, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp440 : 0; -} -} -} -} - -uint64_t* tmp441 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp441 at (3253,1-3253,37) */ -uint64_t __tmp_in_tmp441; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp441; -} -Arr1DIdxRowM(tmp441, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp441 : 0; -} - -uint64_t* tmp442 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp442 at (3256,1-3256,37) */ -uint64_t __tmp_in_tmp442; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp442; -} -Arr1DIdxRowM(tmp442, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp442 : 0; -} - -uint64_t* tmp443 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp443 at (3259,1-3259,37) */ -uint64_t __tmp_in_tmp443; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp443; -} -Arr1DIdxRowM(tmp443, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp443 : 0; -} - -uint64_t* tmp444 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp444 at (3262,1-3262,37) */ -uint64_t __tmp_in_tmp444; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp444; -} -Arr1DIdxRowM(tmp444, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp444 : 0; -} - -uint64_t* tmp445 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp445 at (3265,1-3265,48) */ -uint64_t __tmp_in_tmp445; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp445; -} -Arr4DIdxRowM(tmp445, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp445 : 0; -} -} -} -} - -uint64_t* tmp446 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp446 at (3268,1-3268,37) */ -uint64_t __tmp_in_tmp446; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp446; -} -Arr1DIdxRowM(tmp446, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp446 : 0; -} - -uint64_t* tmp447 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp447 at (3271,1-3271,37) */ -uint64_t __tmp_in_tmp447; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp447; -} -Arr1DIdxRowM(tmp447, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp447 : 0; -} - -uint64_t* tmp448 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp448 at (3274,1-3274,37) */ -uint64_t __tmp_in_tmp448; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp448; -} -Arr1DIdxRowM(tmp448, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp448 : 0; -} - -uint64_t* tmp449 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp449 at (3277,1-3277,37) */ -uint64_t __tmp_in_tmp449; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp449; -} -Arr1DIdxRowM(tmp449, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp449 : 0; -} - -uint64_t* tmp450 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp450 at (3280,1-3280,47) */ -uint64_t __tmp_in_tmp450; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp450; -} -Arr4DIdxRowM(tmp450, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp450 : 0; -} -} -} -} - -uint64_t* tmp451 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp451 at (3283,1-3283,37) */ -uint64_t __tmp_in_tmp451; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp451; -} -Arr1DIdxRowM(tmp451, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp451 : 0; -} - -uint64_t* tmp452 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp452 at (3286,1-3286,37) */ -uint64_t __tmp_in_tmp452; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp452; -} -Arr1DIdxRowM(tmp452, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp452 : 0; -} - -uint64_t* tmp453 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp453 at (3289,1-3289,37) */ -uint64_t __tmp_in_tmp453; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp453; -} -Arr1DIdxRowM(tmp453, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp453 : 0; -} - -uint64_t* tmp454 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp454 at (3292,1-3292,37) */ -uint64_t __tmp_in_tmp454; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp454; -} -Arr1DIdxRowM(tmp454, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp454 : 0; -} - -uint64_t* tmp455 = make_array( (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp455 at (3295,1-3295,48) */ -uint64_t __tmp_in_tmp455; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)544; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp455; -} -Arr4DIdxRowM(tmp455, (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp455 : 0; -} -} -} -} - -uint64_t* tmp456 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp456 at (3298,1-3298,37) */ -uint64_t __tmp_in_tmp456; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp456; -} -Arr1DIdxRowM(tmp456, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp456 : 0; -} - -uint64_t* tmp457 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp457 at (3301,1-3301,37) */ -uint64_t __tmp_in_tmp457; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp457; -} -Arr1DIdxRowM(tmp457, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp457 : 0; -} - -uint64_t* tmp458 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp458 at (3304,1-3304,37) */ -uint64_t __tmp_in_tmp458; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp458; -} -Arr1DIdxRowM(tmp458, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp458 : 0; -} - -uint64_t* tmp459 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp459 at (3307,1-3307,37) */ -uint64_t __tmp_in_tmp459; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp459; -} -Arr1DIdxRowM(tmp459, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp459 : 0; -} - -uint64_t* tmp460 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp460 at (3310,1-3310,47) */ -uint64_t __tmp_in_tmp460; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp460; -} -Arr4DIdxRowM(tmp460, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp460 : 0; -} -} -} -} - -uint64_t* tmp461 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp461 at (3313,1-3313,37) */ -uint64_t __tmp_in_tmp461; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp461; -} -Arr1DIdxRowM(tmp461, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp461 : 0; -} - -uint64_t* tmp462 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp462 at (3316,1-3316,37) */ -uint64_t __tmp_in_tmp462; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp462; -} -Arr1DIdxRowM(tmp462, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp462 : 0; -} - -uint64_t* tmp463 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp463 at (3319,1-3319,37) */ -uint64_t __tmp_in_tmp463; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp463; -} -Arr1DIdxRowM(tmp463, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp463 : 0; -} - -uint64_t* tmp464 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp464 at (3322,1-3322,37) */ -uint64_t __tmp_in_tmp464; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp464; -} -Arr1DIdxRowM(tmp464, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp464 : 0; -} - -uint64_t* tmp465 = make_array( (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp465 at (3325,1-3325,48) */ -uint64_t __tmp_in_tmp465; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)576; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp465; -} -Arr4DIdxRowM(tmp465, (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp465 : 0; -} -} -} -} - -uint64_t* tmp466 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp466 at (3328,1-3328,37) */ -uint64_t __tmp_in_tmp466; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp466; -} -Arr1DIdxRowM(tmp466, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp466 : 0; -} - -uint64_t* tmp467 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp467 at (3331,1-3331,37) */ -uint64_t __tmp_in_tmp467; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp467; -} -Arr1DIdxRowM(tmp467, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp467 : 0; -} - -uint64_t* tmp468 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp468 at (3334,1-3334,37) */ -uint64_t __tmp_in_tmp468; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp468; -} -Arr1DIdxRowM(tmp468, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp468 : 0; -} - -uint64_t* tmp469 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp469 at (3337,1-3337,37) */ -uint64_t __tmp_in_tmp469; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp469; -} -Arr1DIdxRowM(tmp469, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp469 : 0; -} - -uint64_t* tmp470 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp470 at (3340,1-3340,47) */ -uint64_t __tmp_in_tmp470; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp470; -} -Arr4DIdxRowM(tmp470, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp470 : 0; -} -} -} -} - -uint64_t* tmp471 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp471 at (3343,1-3343,37) */ -uint64_t __tmp_in_tmp471; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp471; -} -Arr1DIdxRowM(tmp471, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp471 : 0; -} - -uint64_t* tmp472 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp472 at (3346,1-3346,37) */ -uint64_t __tmp_in_tmp472; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp472; -} -Arr1DIdxRowM(tmp472, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp472 : 0; -} - -uint64_t* tmp473 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp473 at (3349,1-3349,37) */ -uint64_t __tmp_in_tmp473; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp473; -} -Arr1DIdxRowM(tmp473, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp473 : 0; -} - -uint64_t* tmp474 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp474 at (3352,1-3352,37) */ -uint64_t __tmp_in_tmp474; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp474; -} -Arr1DIdxRowM(tmp474, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp474 : 0; -} - -uint64_t* tmp475 = make_array( (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp475 at (3355,1-3355,48) */ -uint64_t __tmp_in_tmp475; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)608; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp475; -} -Arr4DIdxRowM(tmp475, (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp475 : 0; -} -} -} -} - -uint64_t* tmp476 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp476 at (3358,1-3358,37) */ -uint64_t __tmp_in_tmp476; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp476; -} -Arr1DIdxRowM(tmp476, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp476 : 0; -} - -uint64_t* tmp477 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp477 at (3361,1-3361,37) */ -uint64_t __tmp_in_tmp477; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp477; -} -Arr1DIdxRowM(tmp477, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp477 : 0; -} - -uint64_t* tmp478 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp478 at (3364,1-3364,37) */ -uint64_t __tmp_in_tmp478; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp478; -} -Arr1DIdxRowM(tmp478, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp478 : 0; -} - -uint64_t* tmp479 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp479 at (3367,1-3367,37) */ -uint64_t __tmp_in_tmp479; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp479; -} -Arr1DIdxRowM(tmp479, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp479 : 0; -} - -uint64_t* tmp480 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp480 at (3370,1-3370,47) */ -uint64_t __tmp_in_tmp480; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp480; -} -Arr4DIdxRowM(tmp480, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp480 : 0; -} -} -} -} - -uint64_t* tmp481 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp481 at (3373,1-3373,37) */ -uint64_t __tmp_in_tmp481; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp481; -} -Arr1DIdxRowM(tmp481, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp481 : 0; -} - -uint64_t* tmp482 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp482 at (3376,1-3376,37) */ -uint64_t __tmp_in_tmp482; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp482; -} -Arr1DIdxRowM(tmp482, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp482 : 0; -} - -uint64_t* tmp483 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp483 at (3379,1-3379,37) */ -uint64_t __tmp_in_tmp483; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp483; -} -Arr1DIdxRowM(tmp483, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp483 : 0; -} - -uint64_t* tmp484 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp484 at (3382,1-3382,37) */ -uint64_t __tmp_in_tmp484; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp484; -} -Arr1DIdxRowM(tmp484, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp484 : 0; -} - -uint64_t* tmp485 = make_array( (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp485 at (3385,1-3385,48) */ -uint64_t __tmp_in_tmp485; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)640; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp485; -} -Arr4DIdxRowM(tmp485, (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp485 : 0; -} -} -} -} - -uint64_t* tmp486 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp486 at (3388,1-3388,37) */ -uint64_t __tmp_in_tmp486; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp486; -} -Arr1DIdxRowM(tmp486, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp486 : 0; -} - -uint64_t* tmp487 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp487 at (3391,1-3391,37) */ -uint64_t __tmp_in_tmp487; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp487; -} -Arr1DIdxRowM(tmp487, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp487 : 0; -} - -uint64_t* tmp488 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp488 at (3394,1-3394,37) */ -uint64_t __tmp_in_tmp488; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp488; -} -Arr1DIdxRowM(tmp488, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp488 : 0; -} - -uint64_t* tmp489 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp489 at (3397,1-3397,37) */ -uint64_t __tmp_in_tmp489; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp489; -} -Arr1DIdxRowM(tmp489, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp489 : 0; -} - -uint64_t* tmp490 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp490 at (3400,1-3400,47) */ -uint64_t __tmp_in_tmp490; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp490; -} -Arr4DIdxRowM(tmp490, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp490 : 0; -} -} -} -} - -uint64_t* tmp491 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp491 at (3403,1-3403,37) */ -uint64_t __tmp_in_tmp491; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp491; -} -Arr1DIdxRowM(tmp491, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp491 : 0; -} - -uint64_t* tmp492 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp492 at (3406,1-3406,37) */ -uint64_t __tmp_in_tmp492; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp492; -} -Arr1DIdxRowM(tmp492, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp492 : 0; -} - -uint64_t* tmp493 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp493 at (3409,1-3409,37) */ -uint64_t __tmp_in_tmp493; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp493; -} -Arr1DIdxRowM(tmp493, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp493 : 0; -} - -uint64_t* tmp494 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp494 at (3412,1-3412,37) */ -uint64_t __tmp_in_tmp494; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp494; -} -Arr1DIdxRowM(tmp494, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp494 : 0; -} - -uint64_t* tmp495 = make_array( (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp495 at (3415,1-3415,48) */ -uint64_t __tmp_in_tmp495; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)672; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp495; -} -Arr4DIdxRowM(tmp495, (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp495 : 0; -} -} -} -} - -uint64_t* tmp496 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp496 at (3418,1-3418,37) */ -uint64_t __tmp_in_tmp496; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp496; -} -Arr1DIdxRowM(tmp496, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp496 : 0; -} - -uint64_t* tmp497 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp497 at (3421,1-3421,37) */ -uint64_t __tmp_in_tmp497; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp497; -} -Arr1DIdxRowM(tmp497, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp497 : 0; -} - -uint64_t* tmp498 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp498 at (3424,1-3424,37) */ -uint64_t __tmp_in_tmp498; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp498; -} -Arr1DIdxRowM(tmp498, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp498 : 0; -} - -uint64_t* tmp499 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp499 at (3427,1-3427,37) */ -uint64_t __tmp_in_tmp499; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp499; -} -Arr1DIdxRowM(tmp499, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp499 : 0; -} - -uint64_t* tmp500 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp500 at (3430,1-3430,47) */ -uint64_t __tmp_in_tmp500; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp500; -} -Arr4DIdxRowM(tmp500, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp500 : 0; -} -} -} -} - -uint64_t* tmp501 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp501 at (3433,1-3433,37) */ -uint64_t __tmp_in_tmp501; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp501; -} -Arr1DIdxRowM(tmp501, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp501 : 0; -} - -uint64_t* tmp502 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp502 at (3436,1-3436,37) */ -uint64_t __tmp_in_tmp502; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp502; -} -Arr1DIdxRowM(tmp502, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp502 : 0; -} - -uint64_t* tmp503 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp503 at (3439,1-3439,37) */ -uint64_t __tmp_in_tmp503; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp503; -} -Arr1DIdxRowM(tmp503, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp503 : 0; -} - -uint64_t* tmp504 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp504 at (3442,1-3442,37) */ -uint64_t __tmp_in_tmp504; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp504; -} -Arr1DIdxRowM(tmp504, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp504 : 0; -} - -uint64_t* tmp505 = make_array( (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp505 at (3445,1-3445,48) */ -uint64_t __tmp_in_tmp505; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)704; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp505; -} -Arr4DIdxRowM(tmp505, (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp505 : 0; -} -} -} -} - -uint64_t* tmp506 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp506 at (3448,1-3448,37) */ -uint64_t __tmp_in_tmp506; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp506; -} -Arr1DIdxRowM(tmp506, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp506 : 0; -} - -uint64_t* tmp507 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp507 at (3451,1-3451,37) */ -uint64_t __tmp_in_tmp507; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp507; -} -Arr1DIdxRowM(tmp507, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp507 : 0; -} - -uint64_t* tmp508 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp508 at (3454,1-3454,37) */ -uint64_t __tmp_in_tmp508; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp508; -} -Arr1DIdxRowM(tmp508, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp508 : 0; -} - -uint64_t* tmp509 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp509 at (3457,1-3457,37) */ -uint64_t __tmp_in_tmp509; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp509; -} -Arr1DIdxRowM(tmp509, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp509 : 0; -} - -uint64_t* tmp510 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp510 at (3460,1-3460,47) */ -uint64_t __tmp_in_tmp510; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp510; -} -Arr4DIdxRowM(tmp510, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp510 : 0; -} -} -} -} - -uint64_t* tmp511 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp511 at (3463,1-3463,37) */ -uint64_t __tmp_in_tmp511; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp511; -} -Arr1DIdxRowM(tmp511, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp511 : 0; -} - -uint64_t* tmp512 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp512 at (3466,1-3466,37) */ -uint64_t __tmp_in_tmp512; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp512; -} -Arr1DIdxRowM(tmp512, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp512 : 0; -} - -uint64_t* tmp513 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp513 at (3469,1-3469,37) */ -uint64_t __tmp_in_tmp513; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp513; -} -Arr1DIdxRowM(tmp513, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp513 : 0; -} - -uint64_t* tmp514 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp514 at (3472,1-3472,37) */ -uint64_t __tmp_in_tmp514; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp514; -} -Arr1DIdxRowM(tmp514, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp514 : 0; -} - -uint64_t* tmp515 = make_array( (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp515 at (3475,1-3475,48) */ -uint64_t __tmp_in_tmp515; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)736; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp515; -} -Arr4DIdxRowM(tmp515, (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp515 : 0; -} -} -} -} - -uint64_t* tmp516 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp516 at (3478,1-3478,37) */ -uint64_t __tmp_in_tmp516; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp516; -} -Arr1DIdxRowM(tmp516, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp516 : 0; -} - -uint64_t* tmp517 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp517 at (3481,1-3481,37) */ -uint64_t __tmp_in_tmp517; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp517; -} -Arr1DIdxRowM(tmp517, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp517 : 0; -} - -uint64_t* tmp518 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp518 at (3484,1-3484,37) */ -uint64_t __tmp_in_tmp518; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp518; -} -Arr1DIdxRowM(tmp518, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp518 : 0; -} - -uint64_t* tmp519 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp519 at (3487,1-3487,37) */ -uint64_t __tmp_in_tmp519; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp519; -} -Arr1DIdxRowM(tmp519, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp519 : 0; -} - -uint64_t* tmp520 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp520 at (3490,1-3490,47) */ -uint64_t __tmp_in_tmp520; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp520; -} -Arr4DIdxRowM(tmp520, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp520 : 0; -} -} -} -} - -uint64_t* tmp521 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp521 at (3493,1-3493,37) */ -uint64_t __tmp_in_tmp521; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp521; -} -Arr1DIdxRowM(tmp521, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp521 : 0; -} - -uint64_t* tmp522 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp522 at (3496,1-3496,37) */ -uint64_t __tmp_in_tmp522; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp522; -} -Arr1DIdxRowM(tmp522, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp522 : 0; -} - -uint64_t* tmp523 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp523 at (3499,1-3499,37) */ -uint64_t __tmp_in_tmp523; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp523; -} -Arr1DIdxRowM(tmp523, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp523 : 0; -} - -uint64_t* tmp524 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp524 at (3502,1-3502,37) */ -uint64_t __tmp_in_tmp524; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp524; -} -Arr1DIdxRowM(tmp524, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp524 : 0; -} - -uint64_t* tmp525 = make_array( (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp525 at (3505,1-3505,48) */ -uint64_t __tmp_in_tmp525; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)768; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp525; -} -Arr4DIdxRowM(tmp525, (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp525 : 0; -} -} -} -} - -uint64_t* tmp526 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp526 at (3508,1-3508,37) */ -uint64_t __tmp_in_tmp526; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp526; -} -Arr1DIdxRowM(tmp526, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp526 : 0; -} - -uint64_t* tmp527 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp527 at (3511,1-3511,37) */ -uint64_t __tmp_in_tmp527; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp527; -} -Arr1DIdxRowM(tmp527, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp527 : 0; -} - -uint64_t* tmp528 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp528 at (3514,1-3514,37) */ -uint64_t __tmp_in_tmp528; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp528; -} -Arr1DIdxRowM(tmp528, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp528 : 0; -} - -uint64_t* tmp529 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp529 at (3517,1-3517,37) */ -uint64_t __tmp_in_tmp529; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp529; -} -Arr1DIdxRowM(tmp529, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp529 : 0; -} - -uint64_t* tmp530 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp530 at (3520,1-3520,47) */ -uint64_t __tmp_in_tmp530; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp530; -} -Arr4DIdxRowM(tmp530, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp530 : 0; -} -} -} -} - -uint64_t* tmp531 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp531 at (3523,1-3523,37) */ -uint64_t __tmp_in_tmp531; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp531; -} -Arr1DIdxRowM(tmp531, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp531 : 0; -} - -uint64_t* tmp532 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp532 at (3526,1-3526,37) */ -uint64_t __tmp_in_tmp532; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp532; -} -Arr1DIdxRowM(tmp532, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp532 : 0; -} - -uint64_t* tmp533 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp533 at (3529,1-3529,37) */ -uint64_t __tmp_in_tmp533; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp533; -} -Arr1DIdxRowM(tmp533, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp533 : 0; -} - -uint64_t* tmp534 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp534 at (3532,1-3532,37) */ -uint64_t __tmp_in_tmp534; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp534; -} -Arr1DIdxRowM(tmp534, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp534 : 0; -} - -uint64_t* tmp535 = make_array( (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp535 at (3535,1-3535,48) */ -uint64_t __tmp_in_tmp535; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)800; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp535; -} -Arr4DIdxRowM(tmp535, (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp535 : 0; -} -} -} -} - -uint64_t* tmp536 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp536 at (3538,1-3538,37) */ -uint64_t __tmp_in_tmp536; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp536; -} -Arr1DIdxRowM(tmp536, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp536 : 0; -} - -uint64_t* tmp537 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp537 at (3541,1-3541,37) */ -uint64_t __tmp_in_tmp537; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp537; -} -Arr1DIdxRowM(tmp537, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp537 : 0; -} - -uint64_t* tmp538 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp538 at (3544,1-3544,37) */ -uint64_t __tmp_in_tmp538; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp538; -} -Arr1DIdxRowM(tmp538, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp538 : 0; -} - -uint64_t* tmp539 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp539 at (3547,1-3547,37) */ -uint64_t __tmp_in_tmp539; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp539; -} -Arr1DIdxRowM(tmp539, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp539 : 0; -} - -uint64_t* tmp540 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp540 at (3550,1-3550,47) */ -uint64_t __tmp_in_tmp540; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp540; -} -Arr4DIdxRowM(tmp540, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp540 : 0; -} -} -} -} - -uint64_t* tmp541 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp541 at (3553,1-3553,37) */ -uint64_t __tmp_in_tmp541; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp541; -} -Arr1DIdxRowM(tmp541, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp541 : 0; -} - -uint64_t* tmp542 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp542 at (3556,1-3556,37) */ -uint64_t __tmp_in_tmp542; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp542; -} -Arr1DIdxRowM(tmp542, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp542 : 0; -} - -uint64_t* tmp543 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp543 at (3559,1-3559,37) */ -uint64_t __tmp_in_tmp543; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp543; -} -Arr1DIdxRowM(tmp543, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp543 : 0; -} - -uint64_t* tmp544 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp544 at (3562,1-3562,37) */ -uint64_t __tmp_in_tmp544; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp544; -} -Arr1DIdxRowM(tmp544, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp544 : 0; -} - -uint64_t* tmp545 = make_array( (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp545 at (3565,1-3565,48) */ -uint64_t __tmp_in_tmp545; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)832; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp545; -} -Arr4DIdxRowM(tmp545, (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp545 : 0; -} -} -} -} - -uint64_t* tmp546 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp546 at (3568,1-3568,37) */ -uint64_t __tmp_in_tmp546; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp546; -} -Arr1DIdxRowM(tmp546, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp546 : 0; -} - -uint64_t* tmp547 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp547 at (3571,1-3571,37) */ -uint64_t __tmp_in_tmp547; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp547; -} -Arr1DIdxRowM(tmp547, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp547 : 0; -} - -uint64_t* tmp548 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp548 at (3574,1-3574,37) */ -uint64_t __tmp_in_tmp548; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp548; -} -Arr1DIdxRowM(tmp548, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp548 : 0; -} - -uint64_t* tmp549 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp549 at (3577,1-3577,37) */ -uint64_t __tmp_in_tmp549; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp549; -} -Arr1DIdxRowM(tmp549, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp549 : 0; -} - -uint64_t* tmp550 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp550 at (3580,1-3580,47) */ -uint64_t __tmp_in_tmp550; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp550; -} -Arr4DIdxRowM(tmp550, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp550 : 0; -} -} -} -} - -uint64_t* tmp551 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp551 at (3583,1-3583,37) */ -uint64_t __tmp_in_tmp551; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp551; -} -Arr1DIdxRowM(tmp551, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp551 : 0; -} - -uint64_t* tmp552 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp552 at (3586,1-3586,37) */ -uint64_t __tmp_in_tmp552; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp552; -} -Arr1DIdxRowM(tmp552, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp552 : 0; -} - -uint64_t* tmp553 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp553 at (3589,1-3589,37) */ -uint64_t __tmp_in_tmp553; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp553; -} -Arr1DIdxRowM(tmp553, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp553 : 0; -} - -uint64_t* tmp554 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp554 at (3592,1-3592,37) */ -uint64_t __tmp_in_tmp554; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp554; -} -Arr1DIdxRowM(tmp554, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp554 : 0; -} - -uint64_t* tmp555 = make_array( (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp555 at (3595,1-3595,48) */ -uint64_t __tmp_in_tmp555; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)864; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp555; -} -Arr4DIdxRowM(tmp555, (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp555 : 0; -} -} -} -} - -uint64_t* tmp556 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp556 at (3598,1-3598,37) */ -uint64_t __tmp_in_tmp556; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp556; -} -Arr1DIdxRowM(tmp556, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp556 : 0; -} - -uint64_t* tmp557 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp557 at (3601,1-3601,37) */ -uint64_t __tmp_in_tmp557; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp557; -} -Arr1DIdxRowM(tmp557, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp557 : 0; -} - -uint64_t* tmp558 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp558 at (3604,1-3604,37) */ -uint64_t __tmp_in_tmp558; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp558; -} -Arr1DIdxRowM(tmp558, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp558 : 0; -} - -uint64_t* tmp559 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp559 at (3607,1-3607,37) */ -uint64_t __tmp_in_tmp559; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp559; -} -Arr1DIdxRowM(tmp559, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp559 : 0; -} - -uint64_t* tmp560 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp560 at (3610,1-3610,47) */ -uint64_t __tmp_in_tmp560; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp560; -} -Arr4DIdxRowM(tmp560, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp560 : 0; -} -} -} -} - -uint64_t* tmp561 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp561 at (3613,1-3613,37) */ -uint64_t __tmp_in_tmp561; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp561; -} -Arr1DIdxRowM(tmp561, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp561 : 0; -} - -uint64_t* tmp562 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp562 at (3616,1-3616,37) */ -uint64_t __tmp_in_tmp562; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp562; -} -Arr1DIdxRowM(tmp562, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp562 : 0; -} - -uint64_t* tmp563 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp563 at (3619,1-3619,37) */ -uint64_t __tmp_in_tmp563; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp563; -} -Arr1DIdxRowM(tmp563, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp563 : 0; -} - -uint64_t* tmp564 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp564 at (3622,1-3622,37) */ -uint64_t __tmp_in_tmp564; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp564; -} -Arr1DIdxRowM(tmp564, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp564 : 0; -} - -uint64_t* tmp565 = make_array( (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp565 at (3625,1-3625,48) */ -uint64_t __tmp_in_tmp565; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)896; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp565; -} -Arr4DIdxRowM(tmp565, (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp565 : 0; -} -} -} -} - -uint64_t* tmp566 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp566 at (3628,1-3628,37) */ -uint64_t __tmp_in_tmp566; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp566; -} -Arr1DIdxRowM(tmp566, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp566 : 0; -} - -uint64_t* tmp567 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp567 at (3631,1-3631,37) */ -uint64_t __tmp_in_tmp567; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp567; -} -Arr1DIdxRowM(tmp567, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp567 : 0; -} - -uint64_t* tmp568 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp568 at (3634,1-3634,37) */ -uint64_t __tmp_in_tmp568; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp568; -} -Arr1DIdxRowM(tmp568, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp568 : 0; -} - -uint64_t* tmp569 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp569 at (3637,1-3637,37) */ -uint64_t __tmp_in_tmp569; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp569; -} -Arr1DIdxRowM(tmp569, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp569 : 0; -} - -uint64_t* tmp570 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp570 at (3640,1-3640,47) */ -uint64_t __tmp_in_tmp570; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp570; -} -Arr4DIdxRowM(tmp570, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp570 : 0; -} -} -} -} - -uint64_t* tmp571 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp571 at (3643,1-3643,37) */ -uint64_t __tmp_in_tmp571; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp571; -} -Arr1DIdxRowM(tmp571, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp571 : 0; -} - -uint64_t* tmp572 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp572 at (3646,1-3646,37) */ -uint64_t __tmp_in_tmp572; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp572; -} -Arr1DIdxRowM(tmp572, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp572 : 0; -} - -uint64_t* tmp573 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp573 at (3649,1-3649,37) */ -uint64_t __tmp_in_tmp573; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp573; -} -Arr1DIdxRowM(tmp573, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp573 : 0; -} - -uint64_t* tmp574 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp574 at (3652,1-3652,37) */ -uint64_t __tmp_in_tmp574; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp574; -} -Arr1DIdxRowM(tmp574, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp574 : 0; -} - -uint64_t* tmp575 = make_array( (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp575 at (3655,1-3655,48) */ -uint64_t __tmp_in_tmp575; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)928; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp575; -} -Arr4DIdxRowM(tmp575, (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp575 : 0; -} -} -} -} - -uint64_t* tmp576 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp576 at (3658,1-3658,37) */ -uint64_t __tmp_in_tmp576; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp576; -} -Arr1DIdxRowM(tmp576, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp576 : 0; -} - -uint64_t* tmp577 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp577 at (3661,1-3661,37) */ -uint64_t __tmp_in_tmp577; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp577; -} -Arr1DIdxRowM(tmp577, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp577 : 0; -} - -uint64_t* tmp578 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp578 at (3664,1-3664,37) */ -uint64_t __tmp_in_tmp578; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp578; -} -Arr1DIdxRowM(tmp578, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp578 : 0; -} - -uint64_t* tmp579 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp579 at (3667,1-3667,37) */ -uint64_t __tmp_in_tmp579; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp579; -} -Arr1DIdxRowM(tmp579, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp579 : 0; -} - -uint64_t* tmp580 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp580 at (3670,1-3670,47) */ -uint64_t __tmp_in_tmp580; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp580; -} -Arr4DIdxRowM(tmp580, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp580 : 0; -} -} -} -} - -uint64_t* tmp581 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp581 at (3673,1-3673,37) */ -uint64_t __tmp_in_tmp581; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp581; -} -Arr1DIdxRowM(tmp581, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp581 : 0; -} - -uint64_t* tmp582 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp582 at (3676,1-3676,37) */ -uint64_t __tmp_in_tmp582; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp582; -} -Arr1DIdxRowM(tmp582, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp582 : 0; -} - -uint64_t* tmp583 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp583 at (3679,1-3679,37) */ -uint64_t __tmp_in_tmp583; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp583; -} -Arr1DIdxRowM(tmp583, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp583 : 0; -} - -uint64_t* tmp584 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp584 at (3682,1-3682,37) */ -uint64_t __tmp_in_tmp584; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp584; -} -Arr1DIdxRowM(tmp584, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp584 : 0; -} - -uint64_t* tmp585 = make_array( (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp585 at (3685,1-3685,48) */ -uint64_t __tmp_in_tmp585; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)960; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp585; -} -Arr4DIdxRowM(tmp585, (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp585 : 0; -} -} -} -} - -uint64_t* tmp586 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp586 at (3688,1-3688,37) */ -uint64_t __tmp_in_tmp586; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp586; -} -Arr1DIdxRowM(tmp586, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp586 : 0; -} - -uint64_t* tmp587 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp587 at (3691,1-3691,37) */ -uint64_t __tmp_in_tmp587; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp587; -} -Arr1DIdxRowM(tmp587, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp587 : 0; -} - -uint64_t* tmp588 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp588 at (3694,1-3694,37) */ -uint64_t __tmp_in_tmp588; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp588; -} -Arr1DIdxRowM(tmp588, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp588 : 0; -} - -uint64_t* tmp589 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp589 at (3697,1-3697,37) */ -uint64_t __tmp_in_tmp589; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp589; -} -Arr1DIdxRowM(tmp589, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp589 : 0; -} - -uint64_t* tmp590 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp590 at (3700,1-3700,47) */ -uint64_t __tmp_in_tmp590; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp590; -} -Arr4DIdxRowM(tmp590, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp590 : 0; -} -} -} -} - -uint64_t* tmp591 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp591 at (3703,1-3703,37) */ -uint64_t __tmp_in_tmp591; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp591; -} -Arr1DIdxRowM(tmp591, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp591 : 0; -} - -uint64_t* tmp592 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp592 at (3706,1-3706,37) */ -uint64_t __tmp_in_tmp592; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp592; -} -Arr1DIdxRowM(tmp592, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp592 : 0; -} - -uint64_t* tmp593 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp593 at (3709,1-3709,37) */ -uint64_t __tmp_in_tmp593; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp593; -} -Arr1DIdxRowM(tmp593, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp593 : 0; -} - -uint64_t* tmp594 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp594 at (3712,1-3712,37) */ -uint64_t __tmp_in_tmp594; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp594; -} -Arr1DIdxRowM(tmp594, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp594 : 0; -} - -uint64_t* tmp595 = make_array( (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp595 at (3715,1-3715,48) */ -uint64_t __tmp_in_tmp595; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)992; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp595; -} -Arr4DIdxRowM(tmp595, (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp595 : 0; -} -} -} -} - -uint64_t* tmp596 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp596 at (3718,1-3718,37) */ -uint64_t __tmp_in_tmp596; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp596; -} -Arr1DIdxRowM(tmp596, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp596 : 0; -} - -uint64_t* tmp597 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp597 at (3721,1-3721,37) */ -uint64_t __tmp_in_tmp597; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp597; -} -Arr1DIdxRowM(tmp597, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp597 : 0; -} - -uint64_t* tmp598 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp598 at (3724,1-3724,37) */ -uint64_t __tmp_in_tmp598; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp598; -} -Arr1DIdxRowM(tmp598, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp598 : 0; -} - -uint64_t* tmp599 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp599 at (3727,1-3727,37) */ -uint64_t __tmp_in_tmp599; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp599; -} -Arr1DIdxRowM(tmp599, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp599 : 0; -} - -uint64_t* tmp600 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp600 at (3730,1-3730,47) */ -uint64_t __tmp_in_tmp600; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp600; -} -Arr4DIdxRowM(tmp600, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp600 : 0; -} -} -} -} - -uint64_t* tmp601 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp601 at (3733,1-3733,38) */ -uint64_t __tmp_in_tmp601; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp601; -} -Arr1DIdxRowM(tmp601, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp601 : 0; -} - -uint64_t* tmp602 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp602 at (3736,1-3736,38) */ -uint64_t __tmp_in_tmp602; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp602; -} -Arr1DIdxRowM(tmp602, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp602 : 0; -} - -uint64_t* tmp603 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp603 at (3739,1-3739,38) */ -uint64_t __tmp_in_tmp603; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp603; -} -Arr1DIdxRowM(tmp603, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp603 : 0; -} - -uint64_t* tmp604 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp604 at (3742,1-3742,38) */ -uint64_t __tmp_in_tmp604; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp604; -} -Arr1DIdxRowM(tmp604, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp604 : 0; -} - -uint64_t* tmp605 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1000); -/* Variable to read the clear value corresponding to the input variable tmp605 at (3745,1-3745,50) */ -uint64_t __tmp_in_tmp605; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1000; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp605; -} -Arr4DIdxRowM(tmp605, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1000,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp605 : 0; -} -} -} -} - -uint64_t* tmp606 = make_array( (int32_t)1000); -/* Variable to read the clear value corresponding to the input variable tmp606 at (3748,1-3748,38) */ -uint64_t __tmp_in_tmp606; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1000; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp606; -} -Arr1DIdxRowM(tmp606, (int32_t)1000,i0) = (party == SERVER) ? __tmp_in_tmp606 : 0; -} -StartComputation(); - -uint64_t* tmp607 = make_array( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, (int32_t)7, (int32_t)7, (int32_t)64, (int32_t)2, (int32_t)3, (int32_t)2, (int32_t)3, (int32_t)2, (int32_t)2, tmp0, tmp1, tmp607); -ClearMemSecret4( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, tmp0); -ClearMemSecret4( (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64, tmp1); - -uint64_t* tmp610 = make_array( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp607, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp607, tmp2, tmp3, (int32_t)0, (int32_t)11, tmp610); -ClearMemSecret4( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp607); -ClearMemSecret1( (int32_t)64, tmp3); -ClearMemSecret1( (int32_t)64, tmp2); - -uint64_t* tmp614 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -MaxPool( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp610, tmp614); -ClearMemSecret4( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp610); - -uint64_t* tmp616 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp614, tmp616, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp614); - -uint64_t* tmp618 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp616, tmp6, tmp7, (int32_t)0, (int32_t)11, tmp618); -ClearMemSecret1( (int32_t)64, tmp6); -ClearMemSecret1( (int32_t)64, tmp7); - -uint64_t* tmp621 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp618, tmp621, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp618); - -uint64_t* tmp623 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp621, tmp10, tmp623); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)128, tmp10); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp621); - -uint64_t* tmp626 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp623, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp623, tmp11, tmp12, (int32_t)0, (int32_t)11, tmp626); -ClearMemSecret1( (int32_t)128, tmp11); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp623); -ClearMemSecret1( (int32_t)128, tmp12); - -uint64_t* tmp630 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp626, tmp630, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp626); - -uint64_t* tmp632 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp630, tmp15, tmp632); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp630); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp15); - -int64_t tmp635 = (int32_t)3; - -uint64_t* tmp636 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp632, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp616, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp632, tmp635, tmp636); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp616); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp632); -ClearMemPublic(tmp635); - -uint64_t* tmp640 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp636, tmp16, tmp17, (int32_t)0, (int32_t)11, tmp640); -ClearMemSecret1( (int32_t)96, tmp16); -ClearMemSecret1( (int32_t)96, tmp17); - -uint64_t* tmp643 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp640, tmp643, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp640); - -uint64_t* tmp645 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp643, tmp20, tmp645); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp643); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)96, (int32_t)128, tmp20); - -uint64_t* tmp648 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp645, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp645, tmp21, tmp22, (int32_t)0, (int32_t)11, tmp648); -ClearMemSecret1( (int32_t)128, tmp21); -ClearMemSecret1( (int32_t)128, tmp22); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp645); - -uint64_t* tmp652 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp648, tmp652, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp648); - -uint64_t* tmp654 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp652, tmp25, tmp654); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp652); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp25); - -int64_t tmp657 = (int32_t)3; - -uint64_t* tmp658 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp654, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp636, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp654, tmp657, tmp658); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp636); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp654); -ClearMemPublic(tmp657); - -uint64_t* tmp662 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp658, tmp26, tmp27, (int32_t)0, (int32_t)11, tmp662); -ClearMemSecret1( (int32_t)128, tmp27); -ClearMemSecret1( (int32_t)128, tmp26); - -uint64_t* tmp665 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp662, tmp665, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp662); - -uint64_t* tmp667 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp665, tmp30, tmp667); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp665); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128, tmp30); - -uint64_t* tmp670 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp667, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp667, tmp31, tmp32, (int32_t)0, (int32_t)11, tmp670); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp667); -ClearMemSecret1( (int32_t)128, tmp32); -ClearMemSecret1( (int32_t)128, tmp31); - -uint64_t* tmp674 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp670, tmp674, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp670); - -uint64_t* tmp676 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp674, tmp35, tmp676); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp35); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp674); - -int64_t tmp679 = (int32_t)3; - -uint64_t* tmp680 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp676, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp658, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp676, tmp679, tmp680); -ClearMemPublic(tmp679); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp676); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp658); - -uint64_t* tmp684 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp680, tmp36, tmp37, (int32_t)0, (int32_t)11, tmp684); -ClearMemSecret1( (int32_t)160, tmp37); -ClearMemSecret1( (int32_t)160, tmp36); - -uint64_t* tmp687 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp684, tmp687, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp684); - -uint64_t* tmp689 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp687, tmp40, tmp689); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128, tmp40); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp687); - -uint64_t* tmp692 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp689, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp689, tmp41, tmp42, (int32_t)0, (int32_t)11, tmp692); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp689); -ClearMemSecret1( (int32_t)128, tmp42); -ClearMemSecret1( (int32_t)128, tmp41); - -uint64_t* tmp696 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp692, tmp696, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp692); - -uint64_t* tmp698 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp696, tmp45, tmp698); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp45); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp696); - -int64_t tmp701 = (int32_t)3; - -uint64_t* tmp702 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp698, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp680, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp698, tmp701, tmp702); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp698); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp680); -ClearMemPublic(tmp701); - -uint64_t* tmp706 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp702, tmp46, tmp47, (int32_t)0, (int32_t)11, tmp706); -ClearMemSecret1( (int32_t)192, tmp47); -ClearMemSecret1( (int32_t)192, tmp46); - -uint64_t* tmp709 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp706, tmp709, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp706); - -uint64_t* tmp711 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp709, tmp50, tmp711); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp709); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128, tmp50); - -uint64_t* tmp714 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp711, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp711, tmp51, tmp52, (int32_t)0, (int32_t)11, tmp714); -ClearMemSecret1( (int32_t)128, tmp52); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp711); -ClearMemSecret1( (int32_t)128, tmp51); - -uint64_t* tmp718 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp714, tmp718, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp714); - -uint64_t* tmp720 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp718, tmp55, tmp720); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp55); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp718); - -int64_t tmp723 = (int32_t)3; - -uint64_t* tmp724 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp720, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp702, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp720, tmp723, tmp724); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp720); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp702); -ClearMemPublic(tmp723); - -uint64_t* tmp728 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp724, tmp56, tmp57, (int32_t)0, (int32_t)11, tmp728); -ClearMemSecret1( (int32_t)224, tmp56); -ClearMemSecret1( (int32_t)224, tmp57); - -uint64_t* tmp731 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp728, tmp731, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp728); - -uint64_t* tmp733 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp731, tmp60, tmp733); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp731); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128, tmp60); - -uint64_t* tmp736 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp733, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp733, tmp61, tmp62, (int32_t)0, (int32_t)11, tmp736); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp733); -ClearMemSecret1( (int32_t)128, tmp61); -ClearMemSecret1( (int32_t)128, tmp62); - -uint64_t* tmp740 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp736, tmp740, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp736); - -uint64_t* tmp742 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp740, tmp65, tmp742); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp65); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp740); - -int64_t tmp745 = (int32_t)3; - -uint64_t* tmp746 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp742, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp724, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp742, tmp745, tmp746); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp724); -ClearMemPublic(tmp745); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp742); - -uint64_t* tmp750 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp746, tmp66, tmp67, (int32_t)0, (int32_t)11, tmp750); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp746); -ClearMemSecret1( (int32_t)256, tmp66); -ClearMemSecret1( (int32_t)256, tmp67); - -uint64_t* tmp754 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp750, tmp754, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp750); - -uint64_t* tmp756 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp754, tmp70, tmp756); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp754); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp70); - -uint64_t* tmp759 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -AvgPool( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp756, tmp759); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp756); - -uint64_t* tmp761 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759, tmp71, tmp72, (int32_t)0, (int32_t)11, tmp761); -ClearMemSecret1( (int32_t)128, tmp72); -ClearMemSecret1( (int32_t)128, tmp71); - -uint64_t* tmp764 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp761, tmp764, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp761); - -uint64_t* tmp766 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp764, tmp75, tmp766); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp764); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128, tmp75); - -uint64_t* tmp769 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp766, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp766, tmp76, tmp77, (int32_t)0, (int32_t)11, tmp769); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp766); -ClearMemSecret1( (int32_t)128, tmp76); -ClearMemSecret1( (int32_t)128, tmp77); - -uint64_t* tmp773 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp769, tmp773, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp769); - -uint64_t* tmp775 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp773, tmp80, tmp775); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp773); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp80); - -int64_t tmp778 = (int32_t)3; - -uint64_t* tmp779 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp775, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp775, tmp778, tmp779); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759); -ClearMemPublic(tmp778); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp775); - -uint64_t* tmp783 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp779, tmp81, tmp82, (int32_t)0, (int32_t)11, tmp783); -ClearMemSecret1( (int32_t)160, tmp82); -ClearMemSecret1( (int32_t)160, tmp81); - -uint64_t* tmp786 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp783, tmp786, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp783); - -uint64_t* tmp788 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp786, tmp85, tmp788); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128, tmp85); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp786); - -uint64_t* tmp791 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp788, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp788, tmp86, tmp87, (int32_t)0, (int32_t)11, tmp791); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp788); -ClearMemSecret1( (int32_t)128, tmp87); -ClearMemSecret1( (int32_t)128, tmp86); - -uint64_t* tmp795 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp791, tmp795, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp791); - -uint64_t* tmp797 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp795, tmp90, tmp797); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp795); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp90); - -int64_t tmp800 = (int32_t)3; - -uint64_t* tmp801 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp797, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp779, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp797, tmp800, tmp801); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp779); -ClearMemPublic(tmp800); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp797); - -uint64_t* tmp805 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp801, tmp91, tmp92, (int32_t)0, (int32_t)11, tmp805); -ClearMemSecret1( (int32_t)192, tmp92); -ClearMemSecret1( (int32_t)192, tmp91); - -uint64_t* tmp808 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp805, tmp808, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp805); - -uint64_t* tmp810 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp808, tmp95, tmp810); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128, tmp95); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp808); - -uint64_t* tmp813 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp810, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp810, tmp96, tmp97, (int32_t)0, (int32_t)11, tmp813); -ClearMemSecret1( (int32_t)128, tmp96); -ClearMemSecret1( (int32_t)128, tmp97); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp810); - -uint64_t* tmp817 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp813, tmp817, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp813); - -uint64_t* tmp819 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp817, tmp100, tmp819); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp100); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp817); - -int64_t tmp822 = (int32_t)3; - -uint64_t* tmp823 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp819, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp801, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp819, tmp822, tmp823); -ClearMemPublic(tmp822); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp801); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp819); - -uint64_t* tmp827 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp823, tmp101, tmp102, (int32_t)0, (int32_t)11, tmp827); -ClearMemSecret1( (int32_t)224, tmp102); -ClearMemSecret1( (int32_t)224, tmp101); - -uint64_t* tmp830 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp827, tmp830, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp827); - -uint64_t* tmp832 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp830, tmp105, tmp832); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128, tmp105); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp830); - -uint64_t* tmp835 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp832, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp832, tmp106, tmp107, (int32_t)0, (int32_t)11, tmp835); -ClearMemSecret1( (int32_t)128, tmp107); -ClearMemSecret1( (int32_t)128, tmp106); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp832); - -uint64_t* tmp839 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp835, tmp839, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp835); - -uint64_t* tmp841 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp839, tmp110, tmp841); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp839); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp110); - -int64_t tmp844 = (int32_t)3; - -uint64_t* tmp845 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp841, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp823, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp841, tmp844, tmp845); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp823); -ClearMemPublic(tmp844); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp841); - -uint64_t* tmp849 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp845, tmp111, tmp112, (int32_t)0, (int32_t)11, tmp849); -ClearMemSecret1( (int32_t)256, tmp111); -ClearMemSecret1( (int32_t)256, tmp112); - -uint64_t* tmp852 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp849, tmp852, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp849); - -uint64_t* tmp854 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp852, tmp115, tmp854); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp115); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp852); - -uint64_t* tmp857 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp854, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp854, tmp116, tmp117, (int32_t)0, (int32_t)11, tmp857); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp854); -ClearMemSecret1( (int32_t)128, tmp116); -ClearMemSecret1( (int32_t)128, tmp117); - -uint64_t* tmp861 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp857, tmp861, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp857); - -uint64_t* tmp863 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp861, tmp120, tmp863); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp861); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp120); - -int64_t tmp866 = (int32_t)3; - -uint64_t* tmp867 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp863, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp845, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp863, tmp866, tmp867); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp863); -ClearMemPublic(tmp866); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp845); - -uint64_t* tmp871 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp867, tmp121, tmp122, (int32_t)0, (int32_t)11, tmp871); -ClearMemSecret1( (int32_t)288, tmp121); -ClearMemSecret1( (int32_t)288, tmp122); - -uint64_t* tmp874 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp871, tmp874, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp871); - -uint64_t* tmp876 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp874, tmp125, tmp876); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp874); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128, tmp125); - -uint64_t* tmp879 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp876, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp876, tmp126, tmp127, (int32_t)0, (int32_t)11, tmp879); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp876); -ClearMemSecret1( (int32_t)128, tmp126); -ClearMemSecret1( (int32_t)128, tmp127); - -uint64_t* tmp883 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp879, tmp883, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp879); - -uint64_t* tmp885 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp883, tmp130, tmp885); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp883); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp130); - -int64_t tmp888 = (int32_t)3; - -uint64_t* tmp889 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp885, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp867, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp885, tmp888, tmp889); -ClearMemPublic(tmp888); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp867); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp885); - -uint64_t* tmp893 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp889, tmp131, tmp132, (int32_t)0, (int32_t)11, tmp893); -ClearMemSecret1( (int32_t)320, tmp131); -ClearMemSecret1( (int32_t)320, tmp132); - -uint64_t* tmp896 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp893, tmp896, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp893); - -uint64_t* tmp898 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp896, tmp135, tmp898); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp896); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128, tmp135); - -uint64_t* tmp901 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp898, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp898, tmp136, tmp137, (int32_t)0, (int32_t)11, tmp901); -ClearMemSecret1( (int32_t)128, tmp137); -ClearMemSecret1( (int32_t)128, tmp136); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp898); - -uint64_t* tmp905 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp901, tmp905, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp901); - -uint64_t* tmp907 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp905, tmp140, tmp907); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp140); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp905); - -int64_t tmp910 = (int32_t)3; - -uint64_t* tmp911 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp907, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp889, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp907, tmp910, tmp911); -ClearMemPublic(tmp910); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp907); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp889); - -uint64_t* tmp915 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp911, tmp141, tmp142, (int32_t)0, (int32_t)11, tmp915); -ClearMemSecret1( (int32_t)352, tmp142); -ClearMemSecret1( (int32_t)352, tmp141); - -uint64_t* tmp918 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp915, tmp918, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp915); - -uint64_t* tmp920 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp918, tmp145, tmp920); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp918); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128, tmp145); - -uint64_t* tmp923 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp920, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp920, tmp146, tmp147, (int32_t)0, (int32_t)11, tmp923); -ClearMemSecret1( (int32_t)128, tmp146); -ClearMemSecret1( (int32_t)128, tmp147); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp920); - -uint64_t* tmp927 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp923, tmp927, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp923); - -uint64_t* tmp929 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp927, tmp150, tmp929); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp150); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp927); - -int64_t tmp932 = (int32_t)3; - -uint64_t* tmp933 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp929, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp911, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp929, tmp932, tmp933); -ClearMemPublic(tmp932); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp929); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp911); - -uint64_t* tmp937 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp933, tmp151, tmp152, (int32_t)0, (int32_t)11, tmp937); -ClearMemSecret1( (int32_t)384, tmp152); -ClearMemSecret1( (int32_t)384, tmp151); - -uint64_t* tmp940 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp937, tmp940, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp937); - -uint64_t* tmp942 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp940, tmp155, tmp942); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128, tmp155); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp940); - -uint64_t* tmp945 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp942, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp942, tmp156, tmp157, (int32_t)0, (int32_t)11, tmp945); -ClearMemSecret1( (int32_t)128, tmp156); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp942); -ClearMemSecret1( (int32_t)128, tmp157); - -uint64_t* tmp949 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp945, tmp949, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp945); - -uint64_t* tmp951 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp949, tmp160, tmp951); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp949); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp160); - -int64_t tmp954 = (int32_t)3; - -uint64_t* tmp955 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp951, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp933, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp951, tmp954, tmp955); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp951); -ClearMemPublic(tmp954); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp933); - -uint64_t* tmp959 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp955, tmp161, tmp162, (int32_t)0, (int32_t)11, tmp959); -ClearMemSecret1( (int32_t)416, tmp161); -ClearMemSecret1( (int32_t)416, tmp162); - -uint64_t* tmp962 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp959, tmp962, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp959); - -uint64_t* tmp964 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp962, tmp165, tmp964); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp962); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128, tmp165); - -uint64_t* tmp967 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp964, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp964, tmp166, tmp167, (int32_t)0, (int32_t)11, tmp967); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp964); -ClearMemSecret1( (int32_t)128, tmp166); -ClearMemSecret1( (int32_t)128, tmp167); - -uint64_t* tmp971 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp967, tmp971, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp967); - -uint64_t* tmp973 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp971, tmp170, tmp973); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp971); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp170); - -int64_t tmp976 = (int32_t)3; - -uint64_t* tmp977 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp973, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp955, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp973, tmp976, tmp977); -ClearMemPublic(tmp976); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp955); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp973); - -uint64_t* tmp981 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp977, tmp171, tmp172, (int32_t)0, (int32_t)11, tmp981); -ClearMemSecret1( (int32_t)448, tmp172); -ClearMemSecret1( (int32_t)448, tmp171); - -uint64_t* tmp984 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp981, tmp984, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp981); - -uint64_t* tmp986 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp984, tmp175, tmp986); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128, tmp175); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp984); - -uint64_t* tmp989 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp986, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp986, tmp176, tmp177, (int32_t)0, (int32_t)11, tmp989); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp986); -ClearMemSecret1( (int32_t)128, tmp176); -ClearMemSecret1( (int32_t)128, tmp177); - -uint64_t* tmp993 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp989, tmp993, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp989); - -uint64_t* tmp995 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp993, tmp180, tmp995); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp180); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp993); - -int64_t tmp998 = (int32_t)3; - -uint64_t* tmp999 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp995, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp977, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp995, tmp998, tmp999); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp977); -ClearMemPublic(tmp998); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp995); - -uint64_t* tmp1003 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp999, tmp181, tmp182, (int32_t)0, (int32_t)11, tmp1003); -ClearMemSecret1( (int32_t)480, tmp182); -ClearMemSecret1( (int32_t)480, tmp181); - -uint64_t* tmp1006 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp1003, tmp1006, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp1003); - -uint64_t* tmp1008 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1006, tmp185, tmp1008); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128, tmp185); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp1006); - -uint64_t* tmp1011 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1008, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1008, tmp186, tmp187, (int32_t)0, (int32_t)11, tmp1011); -ClearMemSecret1( (int32_t)128, tmp186); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1008); -ClearMemSecret1( (int32_t)128, tmp187); - -uint64_t* tmp1015 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1011, tmp1015, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1011); - -uint64_t* tmp1017 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1015, tmp190, tmp1017); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp190); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1015); - -int64_t tmp1020 = (int32_t)3; - -uint64_t* tmp1021 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp1017, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp999, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp1017, tmp1020, tmp1021); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp999); -ClearMemPublic(tmp1020); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp1017); - -uint64_t* tmp1025 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1021, tmp191, tmp192, (int32_t)0, (int32_t)11, tmp1025); -ClearMemSecret1( (int32_t)512, tmp192); -ClearMemSecret1( (int32_t)512, tmp191); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1021); - -uint64_t* tmp1029 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1025, tmp1029, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1025); - -uint64_t* tmp1031 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1029, tmp195, tmp1031); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256, tmp195); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1029); - -uint64_t* tmp1034 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -AvgPool( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp1031, tmp1034); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp1031); - -uint64_t* tmp1036 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034, tmp196, tmp197, (int32_t)0, (int32_t)11, tmp1036); -ClearMemSecret1( (int32_t)256, tmp197); -ClearMemSecret1( (int32_t)256, tmp196); - -uint64_t* tmp1039 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1036, tmp1039, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1036); - -uint64_t* tmp1041 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1039, tmp200, tmp1041); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp200); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1039); - -uint64_t* tmp1044 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1041, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1041, tmp201, tmp202, (int32_t)0, (int32_t)11, tmp1044); -ClearMemSecret1( (int32_t)128, tmp202); -ClearMemSecret1( (int32_t)128, tmp201); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1041); - -uint64_t* tmp1048 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1044, tmp1048, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1044); - -uint64_t* tmp1050 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1048, tmp205, tmp1050); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1048); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp205); - -int64_t tmp1053 = (int32_t)3; - -uint64_t* tmp1054 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1050, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1050, tmp1053, tmp1054); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1050); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034); -ClearMemPublic(tmp1053); - -uint64_t* tmp1058 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1054, tmp206, tmp207, (int32_t)0, (int32_t)11, tmp1058); -ClearMemSecret1( (int32_t)288, tmp206); -ClearMemSecret1( (int32_t)288, tmp207); - -uint64_t* tmp1061 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1058, tmp1061, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1058); - -uint64_t* tmp1063 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1061, tmp210, tmp1063); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128, tmp210); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1061); - -uint64_t* tmp1066 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1063, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1063, tmp211, tmp212, (int32_t)0, (int32_t)11, tmp1066); -ClearMemSecret1( (int32_t)128, tmp211); -ClearMemSecret1( (int32_t)128, tmp212); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1063); - -uint64_t* tmp1070 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1066, tmp1070, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1066); - -uint64_t* tmp1072 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1070, tmp215, tmp1072); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp215); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1070); - -int64_t tmp1075 = (int32_t)3; - -uint64_t* tmp1076 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1072, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1054, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1072, tmp1075, tmp1076); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1054); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1072); -ClearMemPublic(tmp1075); - -uint64_t* tmp1080 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1076, tmp216, tmp217, (int32_t)0, (int32_t)11, tmp1080); -ClearMemSecret1( (int32_t)320, tmp216); -ClearMemSecret1( (int32_t)320, tmp217); - -uint64_t* tmp1083 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1080, tmp1083, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1080); - -uint64_t* tmp1085 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1083, tmp220, tmp1085); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128, tmp220); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1083); - -uint64_t* tmp1088 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1085, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1085, tmp221, tmp222, (int32_t)0, (int32_t)11, tmp1088); -ClearMemSecret1( (int32_t)128, tmp221); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1085); -ClearMemSecret1( (int32_t)128, tmp222); - -uint64_t* tmp1092 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1088, tmp1092, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1088); - -uint64_t* tmp1094 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1092, tmp225, tmp1094); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1092); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp225); - -int64_t tmp1097 = (int32_t)3; - -uint64_t* tmp1098 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1094, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1076, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1094, tmp1097, tmp1098); -ClearMemPublic(tmp1097); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1094); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1076); - -uint64_t* tmp1102 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1098, tmp226, tmp227, (int32_t)0, (int32_t)11, tmp1102); -ClearMemSecret1( (int32_t)352, tmp227); -ClearMemSecret1( (int32_t)352, tmp226); - -uint64_t* tmp1105 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1102, tmp1105, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1102); - -uint64_t* tmp1107 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1105, tmp230, tmp1107); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128, tmp230); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1105); - -uint64_t* tmp1110 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1107, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1107, tmp231, tmp232, (int32_t)0, (int32_t)11, tmp1110); -ClearMemSecret1( (int32_t)128, tmp231); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1107); -ClearMemSecret1( (int32_t)128, tmp232); - -uint64_t* tmp1114 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1110, tmp1114, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1110); - -uint64_t* tmp1116 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1114, tmp235, tmp1116); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp235); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1114); - -int64_t tmp1119 = (int32_t)3; - -uint64_t* tmp1120 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1116, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1098, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1116, tmp1119, tmp1120); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1116); -ClearMemPublic(tmp1119); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1098); - -uint64_t* tmp1124 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1120, tmp236, tmp237, (int32_t)0, (int32_t)11, tmp1124); -ClearMemSecret1( (int32_t)384, tmp236); -ClearMemSecret1( (int32_t)384, tmp237); - -uint64_t* tmp1127 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1124, tmp1127, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1124); - -uint64_t* tmp1129 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1127, tmp240, tmp1129); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128, tmp240); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1127); - -uint64_t* tmp1132 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1129, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1129, tmp241, tmp242, (int32_t)0, (int32_t)11, tmp1132); -ClearMemSecret1( (int32_t)128, tmp242); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1129); -ClearMemSecret1( (int32_t)128, tmp241); - -uint64_t* tmp1136 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1132, tmp1136, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1132); - -uint64_t* tmp1138 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1136, tmp245, tmp1138); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1136); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp245); - -int64_t tmp1141 = (int32_t)3; - -uint64_t* tmp1142 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1138, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1120, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1138, tmp1141, tmp1142); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1138); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1120); -ClearMemPublic(tmp1141); - -uint64_t* tmp1146 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1142, tmp246, tmp247, (int32_t)0, (int32_t)11, tmp1146); -ClearMemSecret1( (int32_t)416, tmp246); -ClearMemSecret1( (int32_t)416, tmp247); - -uint64_t* tmp1149 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1146, tmp1149, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1146); - -uint64_t* tmp1151 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1149, tmp250, tmp1151); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128, tmp250); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1149); - -uint64_t* tmp1154 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1151, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1151, tmp251, tmp252, (int32_t)0, (int32_t)11, tmp1154); -ClearMemSecret1( (int32_t)128, tmp251); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1151); -ClearMemSecret1( (int32_t)128, tmp252); - -uint64_t* tmp1158 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1154, tmp1158, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1154); - -uint64_t* tmp1160 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1158, tmp255, tmp1160); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1158); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp255); - -int64_t tmp1163 = (int32_t)3; - -uint64_t* tmp1164 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1160, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1142, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1160, tmp1163, tmp1164); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1160); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1142); -ClearMemPublic(tmp1163); - -uint64_t* tmp1168 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1164, tmp256, tmp257, (int32_t)0, (int32_t)11, tmp1168); -ClearMemSecret1( (int32_t)448, tmp256); -ClearMemSecret1( (int32_t)448, tmp257); - -uint64_t* tmp1171 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1168, tmp1171, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1168); - -uint64_t* tmp1173 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1171, tmp260, tmp1173); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128, tmp260); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1171); - -uint64_t* tmp1176 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1173, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1173, tmp261, tmp262, (int32_t)0, (int32_t)11, tmp1176); -ClearMemSecret1( (int32_t)128, tmp261); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1173); -ClearMemSecret1( (int32_t)128, tmp262); - -uint64_t* tmp1180 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1176, tmp1180, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1176); - -uint64_t* tmp1182 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1180, tmp265, tmp1182); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1180); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp265); - -int64_t tmp1185 = (int32_t)3; - -uint64_t* tmp1186 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1182, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1164, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1182, tmp1185, tmp1186); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1182); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1164); -ClearMemPublic(tmp1185); - -uint64_t* tmp1190 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1186, tmp266, tmp267, (int32_t)0, (int32_t)11, tmp1190); -ClearMemSecret1( (int32_t)480, tmp266); -ClearMemSecret1( (int32_t)480, tmp267); - -uint64_t* tmp1193 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1190, tmp1193, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1190); - -uint64_t* tmp1195 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1193, tmp270, tmp1195); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1193); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128, tmp270); - -uint64_t* tmp1198 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1195, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1195, tmp271, tmp272, (int32_t)0, (int32_t)11, tmp1198); -ClearMemSecret1( (int32_t)128, tmp271); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1195); -ClearMemSecret1( (int32_t)128, tmp272); - -uint64_t* tmp1202 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1198, tmp1202, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1198); - -uint64_t* tmp1204 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1202, tmp275, tmp1204); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp275); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1202); - -int64_t tmp1207 = (int32_t)3; - -uint64_t* tmp1208 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1204, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1186, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1204, tmp1207, tmp1208); -ClearMemPublic(tmp1207); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1204); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1186); - -uint64_t* tmp1212 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1208, tmp276, tmp277, (int32_t)0, (int32_t)11, tmp1212); -ClearMemSecret1( (int32_t)512, tmp277); -ClearMemSecret1( (int32_t)512, tmp276); - -uint64_t* tmp1215 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1212, tmp1215, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1212); - -uint64_t* tmp1217 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1215, tmp280, tmp1217); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp280); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1215); - -uint64_t* tmp1220 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1217, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1217, tmp281, tmp282, (int32_t)0, (int32_t)11, tmp1220); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1217); -ClearMemSecret1( (int32_t)128, tmp282); -ClearMemSecret1( (int32_t)128, tmp281); - -uint64_t* tmp1224 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1220, tmp1224, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1220); - -uint64_t* tmp1226 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1224, tmp285, tmp1226); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp285); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1224); - -int64_t tmp1229 = (int32_t)3; - -uint64_t* tmp1230 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1226, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1208, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1226, tmp1229, tmp1230); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1208); -ClearMemPublic(tmp1229); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1226); - -uint64_t* tmp1234 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1230, tmp286, tmp287, (int32_t)0, (int32_t)11, tmp1234); -ClearMemSecret1( (int32_t)544, tmp287); -ClearMemSecret1( (int32_t)544, tmp286); - -uint64_t* tmp1237 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1234, tmp1237, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1234); - -uint64_t* tmp1239 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1237, tmp290, tmp1239); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128, tmp290); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1237); - -uint64_t* tmp1242 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1239, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1239, tmp291, tmp292, (int32_t)0, (int32_t)11, tmp1242); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1239); -ClearMemSecret1( (int32_t)128, tmp291); -ClearMemSecret1( (int32_t)128, tmp292); - -uint64_t* tmp1246 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1242, tmp1246, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1242); - -uint64_t* tmp1248 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1246, tmp295, tmp1248); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp295); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1246); - -int64_t tmp1251 = (int32_t)3; - -uint64_t* tmp1252 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1248, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1230, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1248, tmp1251, tmp1252); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1230); -ClearMemPublic(tmp1251); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1248); - -uint64_t* tmp1256 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1252, tmp296, tmp297, (int32_t)0, (int32_t)11, tmp1256); -ClearMemSecret1( (int32_t)576, tmp296); -ClearMemSecret1( (int32_t)576, tmp297); - -uint64_t* tmp1259 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1256, tmp1259, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1256); - -uint64_t* tmp1261 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1259, tmp300, tmp1261); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128, tmp300); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1259); - -uint64_t* tmp1264 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1261, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1261, tmp301, tmp302, (int32_t)0, (int32_t)11, tmp1264); -ClearMemSecret1( (int32_t)128, tmp301); -ClearMemSecret1( (int32_t)128, tmp302); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1261); - -uint64_t* tmp1268 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1264, tmp1268, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1264); - -uint64_t* tmp1270 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1268, tmp305, tmp1270); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1268); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp305); - -int64_t tmp1273 = (int32_t)3; - -uint64_t* tmp1274 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1270, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1252, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1270, tmp1273, tmp1274); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1270); -ClearMemPublic(tmp1273); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1252); - -uint64_t* tmp1278 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1274, tmp306, tmp307, (int32_t)0, (int32_t)11, tmp1278); -ClearMemSecret1( (int32_t)608, tmp307); -ClearMemSecret1( (int32_t)608, tmp306); - -uint64_t* tmp1281 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1278, tmp1281, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1278); - -uint64_t* tmp1283 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1281, tmp310, tmp1283); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128, tmp310); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1281); - -uint64_t* tmp1286 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1283, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1283, tmp311, tmp312, (int32_t)0, (int32_t)11, tmp1286); -ClearMemSecret1( (int32_t)128, tmp312); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1283); -ClearMemSecret1( (int32_t)128, tmp311); - -uint64_t* tmp1290 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1286, tmp1290, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1286); - -uint64_t* tmp1292 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1290, tmp315, tmp1292); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1290); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp315); - -int64_t tmp1295 = (int32_t)3; - -uint64_t* tmp1296 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1292, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1274, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1292, tmp1295, tmp1296); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1292); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1274); -ClearMemPublic(tmp1295); - -uint64_t* tmp1300 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1296, tmp316, tmp317, (int32_t)0, (int32_t)11, tmp1300); -ClearMemSecret1( (int32_t)640, tmp316); -ClearMemSecret1( (int32_t)640, tmp317); - -uint64_t* tmp1303 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1300, tmp1303, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1300); - -uint64_t* tmp1305 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1303, tmp320, tmp1305); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1303); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128, tmp320); - -uint64_t* tmp1308 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1305, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1305, tmp321, tmp322, (int32_t)0, (int32_t)11, tmp1308); -ClearMemSecret1( (int32_t)128, tmp322); -ClearMemSecret1( (int32_t)128, tmp321); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1305); - -uint64_t* tmp1312 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1308, tmp1312, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1308); - -uint64_t* tmp1314 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1312, tmp325, tmp1314); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1312); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp325); - -int64_t tmp1317 = (int32_t)3; - -uint64_t* tmp1318 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1314, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1296, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1314, tmp1317, tmp1318); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1296); -ClearMemPublic(tmp1317); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1314); - -uint64_t* tmp1322 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1318, tmp326, tmp327, (int32_t)0, (int32_t)11, tmp1322); -ClearMemSecret1( (int32_t)672, tmp327); -ClearMemSecret1( (int32_t)672, tmp326); - -uint64_t* tmp1325 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1322, tmp1325, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1322); - -uint64_t* tmp1327 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1325, tmp330, tmp1327); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1325); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128, tmp330); - -uint64_t* tmp1330 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1327, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1327, tmp331, tmp332, (int32_t)0, (int32_t)11, tmp1330); -ClearMemSecret1( (int32_t)128, tmp332); -ClearMemSecret1( (int32_t)128, tmp331); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1327); - -uint64_t* tmp1334 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1330, tmp1334, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1330); - -uint64_t* tmp1336 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1334, tmp335, tmp1336); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp335); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1334); - -int64_t tmp1339 = (int32_t)3; - -uint64_t* tmp1340 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1336, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1318, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1336, tmp1339, tmp1340); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1318); -ClearMemPublic(tmp1339); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1336); - -uint64_t* tmp1344 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1340, tmp336, tmp337, (int32_t)0, (int32_t)11, tmp1344); -ClearMemSecret1( (int32_t)704, tmp337); -ClearMemSecret1( (int32_t)704, tmp336); - -uint64_t* tmp1347 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1344, tmp1347, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1344); - -uint64_t* tmp1349 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1347, tmp340, tmp1349); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128, tmp340); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1347); - -uint64_t* tmp1352 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1349, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1349, tmp341, tmp342, (int32_t)0, (int32_t)11, tmp1352); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1349); -ClearMemSecret1( (int32_t)128, tmp342); -ClearMemSecret1( (int32_t)128, tmp341); - -uint64_t* tmp1356 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1352, tmp1356, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1352); - -uint64_t* tmp1358 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1356, tmp345, tmp1358); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1356); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp345); - -int64_t tmp1361 = (int32_t)3; - -uint64_t* tmp1362 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1358, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1340, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1358, tmp1361, tmp1362); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1358); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1340); -ClearMemPublic(tmp1361); - -uint64_t* tmp1366 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1362, tmp346, tmp347, (int32_t)0, (int32_t)11, tmp1366); -ClearMemSecret1( (int32_t)736, tmp347); -ClearMemSecret1( (int32_t)736, tmp346); - -uint64_t* tmp1369 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1366, tmp1369, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1366); - -uint64_t* tmp1371 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1369, tmp350, tmp1371); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128, tmp350); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1369); - -uint64_t* tmp1374 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1371, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1371, tmp351, tmp352, (int32_t)0, (int32_t)11, tmp1374); -ClearMemSecret1( (int32_t)128, tmp352); -ClearMemSecret1( (int32_t)128, tmp351); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1371); - -uint64_t* tmp1378 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1374, tmp1378, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1374); - -uint64_t* tmp1380 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1378, tmp355, tmp1380); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp355); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1378); - -int64_t tmp1383 = (int32_t)3; - -uint64_t* tmp1384 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1380, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1362, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1380, tmp1383, tmp1384); -ClearMemPublic(tmp1383); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1362); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1380); - -uint64_t* tmp1388 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1384, tmp356, tmp357, (int32_t)0, (int32_t)11, tmp1388); -ClearMemSecret1( (int32_t)768, tmp356); -ClearMemSecret1( (int32_t)768, tmp357); - -uint64_t* tmp1391 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1388, tmp1391, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1388); - -uint64_t* tmp1393 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1391, tmp360, tmp1393); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128, tmp360); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1391); - -uint64_t* tmp1396 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1393, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1393, tmp361, tmp362, (int32_t)0, (int32_t)11, tmp1396); -ClearMemSecret1( (int32_t)128, tmp362); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1393); -ClearMemSecret1( (int32_t)128, tmp361); - -uint64_t* tmp1400 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1396, tmp1400, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1396); - -uint64_t* tmp1402 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1400, tmp365, tmp1402); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp365); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1400); - -int64_t tmp1405 = (int32_t)3; - -uint64_t* tmp1406 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1402, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1384, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1402, tmp1405, tmp1406); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1384); -ClearMemPublic(tmp1405); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1402); - -uint64_t* tmp1410 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1406, tmp366, tmp367, (int32_t)0, (int32_t)11, tmp1410); -ClearMemSecret1( (int32_t)800, tmp367); -ClearMemSecret1( (int32_t)800, tmp366); - -uint64_t* tmp1413 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1410, tmp1413, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1410); - -uint64_t* tmp1415 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1413, tmp370, tmp1415); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128, tmp370); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1413); - -uint64_t* tmp1418 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1415, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1415, tmp371, tmp372, (int32_t)0, (int32_t)11, tmp1418); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1415); -ClearMemSecret1( (int32_t)128, tmp372); -ClearMemSecret1( (int32_t)128, tmp371); - -uint64_t* tmp1422 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1418, tmp1422, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1418); - -uint64_t* tmp1424 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1422, tmp375, tmp1424); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1422); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp375); - -int64_t tmp1427 = (int32_t)3; - -uint64_t* tmp1428 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1424, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1406, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1424, tmp1427, tmp1428); -ClearMemPublic(tmp1427); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1424); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1406); - -uint64_t* tmp1432 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1428, tmp376, tmp377, (int32_t)0, (int32_t)11, tmp1432); -ClearMemSecret1( (int32_t)832, tmp376); -ClearMemSecret1( (int32_t)832, tmp377); - -uint64_t* tmp1435 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1432, tmp1435, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1432); - -uint64_t* tmp1437 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1435, tmp380, tmp1437); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1435); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128, tmp380); - -uint64_t* tmp1440 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1437, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1437, tmp381, tmp382, (int32_t)0, (int32_t)11, tmp1440); -ClearMemSecret1( (int32_t)128, tmp382); -ClearMemSecret1( (int32_t)128, tmp381); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1437); - -uint64_t* tmp1444 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1440, tmp1444, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1440); - -uint64_t* tmp1446 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1444, tmp385, tmp1446); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp385); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1444); - -int64_t tmp1449 = (int32_t)3; - -uint64_t* tmp1450 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1446, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1428, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1446, tmp1449, tmp1450); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1446); -ClearMemPublic(tmp1449); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1428); - -uint64_t* tmp1454 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1450, tmp386, tmp387, (int32_t)0, (int32_t)11, tmp1454); -ClearMemSecret1( (int32_t)864, tmp387); -ClearMemSecret1( (int32_t)864, tmp386); - -uint64_t* tmp1457 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1454, tmp1457, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1454); - -uint64_t* tmp1459 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1457, tmp390, tmp1459); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128, tmp390); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1457); - -uint64_t* tmp1462 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1459, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1459, tmp391, tmp392, (int32_t)0, (int32_t)11, tmp1462); -ClearMemSecret1( (int32_t)128, tmp392); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1459); -ClearMemSecret1( (int32_t)128, tmp391); - -uint64_t* tmp1466 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1462, tmp1466, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1462); - -uint64_t* tmp1468 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1466, tmp395, tmp1468); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp395); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1466); - -int64_t tmp1471 = (int32_t)3; - -uint64_t* tmp1472 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1468, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1450, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1468, tmp1471, tmp1472); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1468); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1450); -ClearMemPublic(tmp1471); - -uint64_t* tmp1476 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1472, tmp396, tmp397, (int32_t)0, (int32_t)11, tmp1476); -ClearMemSecret1( (int32_t)896, tmp397); -ClearMemSecret1( (int32_t)896, tmp396); - -uint64_t* tmp1479 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1476, tmp1479, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1476); - -uint64_t* tmp1481 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1479, tmp400, tmp1481); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128, tmp400); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1479); - -uint64_t* tmp1484 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1481, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1481, tmp401, tmp402, (int32_t)0, (int32_t)11, tmp1484); -ClearMemSecret1( (int32_t)128, tmp401); -ClearMemSecret1( (int32_t)128, tmp402); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1481); - -uint64_t* tmp1488 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1484, tmp1488, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1484); - -uint64_t* tmp1490 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1488, tmp405, tmp1490); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp405); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1488); - -int64_t tmp1493 = (int32_t)3; - -uint64_t* tmp1494 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1490, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1472, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1490, tmp1493, tmp1494); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1472); -ClearMemPublic(tmp1493); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1490); - -uint64_t* tmp1498 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1494, tmp406, tmp407, (int32_t)0, (int32_t)11, tmp1498); -ClearMemSecret1( (int32_t)928, tmp407); -ClearMemSecret1( (int32_t)928, tmp406); - -uint64_t* tmp1501 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1498, tmp1501, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1498); - -uint64_t* tmp1503 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1501, tmp410, tmp1503); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1501); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128, tmp410); - -uint64_t* tmp1506 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1503, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1503, tmp411, tmp412, (int32_t)0, (int32_t)11, tmp1506); -ClearMemSecret1( (int32_t)128, tmp412); -ClearMemSecret1( (int32_t)128, tmp411); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1503); - -uint64_t* tmp1510 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1506, tmp1510, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1506); - -uint64_t* tmp1512 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1510, tmp415, tmp1512); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp415); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1510); - -int64_t tmp1515 = (int32_t)3; - -uint64_t* tmp1516 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1512, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1494, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1512, tmp1515, tmp1516); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1512); -ClearMemPublic(tmp1515); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1494); - -uint64_t* tmp1520 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1516, tmp416, tmp417, (int32_t)0, (int32_t)11, tmp1520); -ClearMemSecret1( (int32_t)960, tmp416); -ClearMemSecret1( (int32_t)960, tmp417); - -uint64_t* tmp1523 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1520, tmp1523, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1520); - -uint64_t* tmp1525 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1523, tmp420, tmp1525); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128, tmp420); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1523); - -uint64_t* tmp1528 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1525, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1525, tmp421, tmp422, (int32_t)0, (int32_t)11, tmp1528); -ClearMemSecret1( (int32_t)128, tmp421); -ClearMemSecret1( (int32_t)128, tmp422); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1525); - -uint64_t* tmp1532 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1528, tmp1532, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1528); - -uint64_t* tmp1534 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1532, tmp425, tmp1534); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1532); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp425); - -int64_t tmp1537 = (int32_t)3; - -uint64_t* tmp1538 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1534, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1516, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1534, tmp1537, tmp1538); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1534); -ClearMemPublic(tmp1537); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1516); - -uint64_t* tmp1542 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1538, tmp426, tmp427, (int32_t)0, (int32_t)11, tmp1542); -ClearMemSecret1( (int32_t)992, tmp427); -ClearMemSecret1( (int32_t)992, tmp426); - -uint64_t* tmp1545 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1542, tmp1545, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1542); - -uint64_t* tmp1547 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1545, tmp430, tmp1547); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1545); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128, tmp430); - -uint64_t* tmp1550 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1547, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1547, tmp431, tmp432, (int32_t)0, (int32_t)11, tmp1550); -ClearMemSecret1( (int32_t)128, tmp432); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1547); -ClearMemSecret1( (int32_t)128, tmp431); - -uint64_t* tmp1554 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1550, tmp1554, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1550); - -uint64_t* tmp1556 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1554, tmp435, tmp1556); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1554); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp435); - -int64_t tmp1559 = (int32_t)3; - -uint64_t* tmp1560 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1556, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1538, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1556, tmp1559, tmp1560); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1556); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1538); -ClearMemPublic(tmp1559); - -uint64_t* tmp1564 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1560, tmp436, tmp437, (int32_t)0, (int32_t)11, tmp1564); -ClearMemSecret1( (int32_t)1024, tmp437); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1560); -ClearMemSecret1( (int32_t)1024, tmp436); - -uint64_t* tmp1568 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1564, tmp1568, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1564); - -uint64_t* tmp1570 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1568, tmp440, tmp1570); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1568); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512, tmp440); - -uint64_t* tmp1573 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -AvgPool( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1570, tmp1573); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1570); - -uint64_t* tmp1575 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573, tmp441, tmp442, (int32_t)0, (int32_t)11, tmp1575); -ClearMemSecret1( (int32_t)512, tmp442); -ClearMemSecret1( (int32_t)512, tmp441); - -uint64_t* tmp1578 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1575, tmp1578, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1575); - -uint64_t* tmp1580 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1578, tmp445, tmp1580); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp445); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1578); - -uint64_t* tmp1583 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1580, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1580, tmp446, tmp447, (int32_t)0, (int32_t)11, tmp1583); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1580); -ClearMemSecret1( (int32_t)128, tmp447); -ClearMemSecret1( (int32_t)128, tmp446); - -uint64_t* tmp1587 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1583, tmp1587, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1583); - -uint64_t* tmp1589 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1587, tmp450, tmp1589); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1587); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp450); - -int64_t tmp1592 = (int32_t)3; - -uint64_t* tmp1593 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1589, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1589, tmp1592, tmp1593); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1589); -ClearMemPublic(tmp1592); - -uint64_t* tmp1597 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1593, tmp451, tmp452, (int32_t)0, (int32_t)11, tmp1597); -ClearMemSecret1( (int32_t)544, tmp452); -ClearMemSecret1( (int32_t)544, tmp451); - -uint64_t* tmp1600 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1597, tmp1600, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1597); - -uint64_t* tmp1602 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1600, tmp455, tmp1602); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1600); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128, tmp455); - -uint64_t* tmp1605 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1602, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1602, tmp456, tmp457, (int32_t)0, (int32_t)11, tmp1605); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1602); -ClearMemSecret1( (int32_t)128, tmp456); -ClearMemSecret1( (int32_t)128, tmp457); - -uint64_t* tmp1609 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1605, tmp1609, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1605); - -uint64_t* tmp1611 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1609, tmp460, tmp1611); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1609); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp460); - -int64_t tmp1614 = (int32_t)3; - -uint64_t* tmp1615 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1611, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1593, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1611, tmp1614, tmp1615); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1611); -ClearMemPublic(tmp1614); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1593); - -uint64_t* tmp1619 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1615, tmp461, tmp462, (int32_t)0, (int32_t)11, tmp1619); -ClearMemSecret1( (int32_t)576, tmp461); -ClearMemSecret1( (int32_t)576, tmp462); - -uint64_t* tmp1622 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1619, tmp1622, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1619); - -uint64_t* tmp1624 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1622, tmp465, tmp1624); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1622); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128, tmp465); - -uint64_t* tmp1627 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1624, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1624, tmp466, tmp467, (int32_t)0, (int32_t)11, tmp1627); -ClearMemSecret1( (int32_t)128, tmp466); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1624); -ClearMemSecret1( (int32_t)128, tmp467); - -uint64_t* tmp1631 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1627, tmp1631, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1627); - -uint64_t* tmp1633 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1631, tmp470, tmp1633); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1631); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp470); - -int64_t tmp1636 = (int32_t)3; - -uint64_t* tmp1637 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1633, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1615, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1633, tmp1636, tmp1637); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1615); -ClearMemPublic(tmp1636); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1633); - -uint64_t* tmp1641 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1637, tmp471, tmp472, (int32_t)0, (int32_t)11, tmp1641); -ClearMemSecret1( (int32_t)608, tmp471); -ClearMemSecret1( (int32_t)608, tmp472); - -uint64_t* tmp1644 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1641, tmp1644, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1641); - -uint64_t* tmp1646 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1644, tmp475, tmp1646); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1644); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128, tmp475); - -uint64_t* tmp1649 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1646, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1646, tmp476, tmp477, (int32_t)0, (int32_t)11, tmp1649); -ClearMemSecret1( (int32_t)128, tmp477); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1646); -ClearMemSecret1( (int32_t)128, tmp476); - -uint64_t* tmp1653 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1649, tmp1653, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1649); - -uint64_t* tmp1655 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1653, tmp480, tmp1655); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1653); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp480); - -int64_t tmp1658 = (int32_t)3; - -uint64_t* tmp1659 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1655, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1637, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1655, tmp1658, tmp1659); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1655); -ClearMemPublic(tmp1658); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1637); - -uint64_t* tmp1663 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1659, tmp481, tmp482, (int32_t)0, (int32_t)11, tmp1663); -ClearMemSecret1( (int32_t)640, tmp481); -ClearMemSecret1( (int32_t)640, tmp482); - -uint64_t* tmp1666 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1663, tmp1666, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1663); - -uint64_t* tmp1668 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1666, tmp485, tmp1668); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1666); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128, tmp485); - -uint64_t* tmp1671 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1668, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1668, tmp486, tmp487, (int32_t)0, (int32_t)11, tmp1671); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1668); -ClearMemSecret1( (int32_t)128, tmp487); -ClearMemSecret1( (int32_t)128, tmp486); - -uint64_t* tmp1675 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1671, tmp1675, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1671); - -uint64_t* tmp1677 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1675, tmp490, tmp1677); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp490); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1675); - -int64_t tmp1680 = (int32_t)3; - -uint64_t* tmp1681 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1677, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1659, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1677, tmp1680, tmp1681); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1677); -ClearMemPublic(tmp1680); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1659); - -uint64_t* tmp1685 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1681, tmp491, tmp492, (int32_t)0, (int32_t)11, tmp1685); -ClearMemSecret1( (int32_t)672, tmp492); -ClearMemSecret1( (int32_t)672, tmp491); - -uint64_t* tmp1688 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1685, tmp1688, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1685); - -uint64_t* tmp1690 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1688, tmp495, tmp1690); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128, tmp495); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1688); - -uint64_t* tmp1693 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1690, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1690, tmp496, tmp497, (int32_t)0, (int32_t)11, tmp1693); -ClearMemSecret1( (int32_t)128, tmp497); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1690); -ClearMemSecret1( (int32_t)128, tmp496); - -uint64_t* tmp1697 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1693, tmp1697, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1693); - -uint64_t* tmp1699 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1697, tmp500, tmp1699); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp500); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1697); - -int64_t tmp1702 = (int32_t)3; - -uint64_t* tmp1703 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1699, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1681, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1699, tmp1702, tmp1703); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1681); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1699); -ClearMemPublic(tmp1702); - -uint64_t* tmp1707 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1703, tmp501, tmp502, (int32_t)0, (int32_t)11, tmp1707); -ClearMemSecret1( (int32_t)704, tmp502); -ClearMemSecret1( (int32_t)704, tmp501); - -uint64_t* tmp1710 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1707, tmp1710, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1707); - -uint64_t* tmp1712 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1710, tmp505, tmp1712); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1710); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128, tmp505); - -uint64_t* tmp1715 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1712, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1712, tmp506, tmp507, (int32_t)0, (int32_t)11, tmp1715); -ClearMemSecret1( (int32_t)128, tmp506); -ClearMemSecret1( (int32_t)128, tmp507); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1712); - -uint64_t* tmp1719 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1715, tmp1719, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1715); - -uint64_t* tmp1721 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1719, tmp510, tmp1721); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1719); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp510); - -int64_t tmp1724 = (int32_t)3; - -uint64_t* tmp1725 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1721, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1703, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1721, tmp1724, tmp1725); -ClearMemPublic(tmp1724); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1703); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1721); - -uint64_t* tmp1729 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1725, tmp511, tmp512, (int32_t)0, (int32_t)11, tmp1729); -ClearMemSecret1( (int32_t)736, tmp511); -ClearMemSecret1( (int32_t)736, tmp512); - -uint64_t* tmp1732 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1729, tmp1732, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1729); - -uint64_t* tmp1734 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1732, tmp515, tmp1734); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128, tmp515); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1732); - -uint64_t* tmp1737 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1734, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1734, tmp516, tmp517, (int32_t)0, (int32_t)11, tmp1737); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1734); -ClearMemSecret1( (int32_t)128, tmp516); -ClearMemSecret1( (int32_t)128, tmp517); - -uint64_t* tmp1741 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1737, tmp1741, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1737); - -uint64_t* tmp1743 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1741, tmp520, tmp1743); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp520); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1741); - -int64_t tmp1746 = (int32_t)3; - -uint64_t* tmp1747 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1743, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1725, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1743, tmp1746, tmp1747); -ClearMemPublic(tmp1746); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1725); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1743); - -uint64_t* tmp1751 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1747, tmp521, tmp522, (int32_t)0, (int32_t)11, tmp1751); -ClearMemSecret1( (int32_t)768, tmp522); -ClearMemSecret1( (int32_t)768, tmp521); - -uint64_t* tmp1754 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1751, tmp1754, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1751); - -uint64_t* tmp1756 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1754, tmp525, tmp1756); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1754); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128, tmp525); - -uint64_t* tmp1759 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1756, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1756, tmp526, tmp527, (int32_t)0, (int32_t)11, tmp1759); -ClearMemSecret1( (int32_t)128, tmp526); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1756); -ClearMemSecret1( (int32_t)128, tmp527); - -uint64_t* tmp1763 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1759, tmp1763, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1759); - -uint64_t* tmp1765 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1763, tmp530, tmp1765); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp530); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1763); - -int64_t tmp1768 = (int32_t)3; - -uint64_t* tmp1769 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1765, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1747, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1765, tmp1768, tmp1769); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1747); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1765); -ClearMemPublic(tmp1768); - -uint64_t* tmp1773 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1769, tmp531, tmp532, (int32_t)0, (int32_t)11, tmp1773); -ClearMemSecret1( (int32_t)800, tmp531); -ClearMemSecret1( (int32_t)800, tmp532); - -uint64_t* tmp1776 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1773, tmp1776, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1773); - -uint64_t* tmp1778 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1776, tmp535, tmp1778); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1776); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128, tmp535); - -uint64_t* tmp1781 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1778, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1778, tmp536, tmp537, (int32_t)0, (int32_t)11, tmp1781); -ClearMemSecret1( (int32_t)128, tmp536); -ClearMemSecret1( (int32_t)128, tmp537); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1778); - -uint64_t* tmp1785 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1781, tmp1785, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1781); - -uint64_t* tmp1787 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1785, tmp540, tmp1787); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1785); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp540); - -int64_t tmp1790 = (int32_t)3; - -uint64_t* tmp1791 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1787, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1769, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1787, tmp1790, tmp1791); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1769); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1787); -ClearMemPublic(tmp1790); - -uint64_t* tmp1795 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1791, tmp541, tmp542, (int32_t)0, (int32_t)11, tmp1795); -ClearMemSecret1( (int32_t)832, tmp541); -ClearMemSecret1( (int32_t)832, tmp542); - -uint64_t* tmp1798 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1795, tmp1798, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1795); - -uint64_t* tmp1800 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1798, tmp545, tmp1800); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128, tmp545); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1798); - -uint64_t* tmp1803 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1800, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1800, tmp546, tmp547, (int32_t)0, (int32_t)11, tmp1803); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1800); -ClearMemSecret1( (int32_t)128, tmp547); -ClearMemSecret1( (int32_t)128, tmp546); - -uint64_t* tmp1807 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1803, tmp1807, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1803); - -uint64_t* tmp1809 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1807, tmp550, tmp1809); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp550); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1807); - -int64_t tmp1812 = (int32_t)3; - -uint64_t* tmp1813 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1809, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1791, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1809, tmp1812, tmp1813); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1791); -ClearMemPublic(tmp1812); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1809); - -uint64_t* tmp1817 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1813, tmp551, tmp552, (int32_t)0, (int32_t)11, tmp1817); -ClearMemSecret1( (int32_t)864, tmp551); -ClearMemSecret1( (int32_t)864, tmp552); - -uint64_t* tmp1820 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1817, tmp1820, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1817); - -uint64_t* tmp1822 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1820, tmp555, tmp1822); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128, tmp555); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1820); - -uint64_t* tmp1825 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1822, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1822, tmp556, tmp557, (int32_t)0, (int32_t)11, tmp1825); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1822); -ClearMemSecret1( (int32_t)128, tmp557); -ClearMemSecret1( (int32_t)128, tmp556); - -uint64_t* tmp1829 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1825, tmp1829, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1825); - -uint64_t* tmp1831 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1829, tmp560, tmp1831); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1829); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp560); - -int64_t tmp1834 = (int32_t)3; - -uint64_t* tmp1835 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1831, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1813, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1831, tmp1834, tmp1835); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1831); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1813); -ClearMemPublic(tmp1834); - -uint64_t* tmp1839 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1835, tmp561, tmp562, (int32_t)0, (int32_t)11, tmp1839); -ClearMemSecret1( (int32_t)896, tmp561); -ClearMemSecret1( (int32_t)896, tmp562); - -uint64_t* tmp1842 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1839, tmp1842, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1839); - -uint64_t* tmp1844 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1842, tmp565, tmp1844); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128, tmp565); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1842); - -uint64_t* tmp1847 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1844, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1844, tmp566, tmp567, (int32_t)0, (int32_t)11, tmp1847); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1844); -ClearMemSecret1( (int32_t)128, tmp566); -ClearMemSecret1( (int32_t)128, tmp567); - -uint64_t* tmp1851 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1847, tmp1851, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1847); - -uint64_t* tmp1853 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1851, tmp570, tmp1853); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1851); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp570); - -int64_t tmp1856 = (int32_t)3; - -uint64_t* tmp1857 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1853, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1835, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1853, tmp1856, tmp1857); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1835); -ClearMemPublic(tmp1856); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1853); - -uint64_t* tmp1861 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1857, tmp571, tmp572, (int32_t)0, (int32_t)11, tmp1861); -ClearMemSecret1( (int32_t)928, tmp571); -ClearMemSecret1( (int32_t)928, tmp572); - -uint64_t* tmp1864 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1861, tmp1864, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1861); - -uint64_t* tmp1866 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1864, tmp575, tmp1866); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128, tmp575); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1864); - -uint64_t* tmp1869 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1866, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1866, tmp576, tmp577, (int32_t)0, (int32_t)11, tmp1869); -ClearMemSecret1( (int32_t)128, tmp576); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1866); -ClearMemSecret1( (int32_t)128, tmp577); - -uint64_t* tmp1873 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1869, tmp1873, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1869); - -uint64_t* tmp1875 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1873, tmp580, tmp1875); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp580); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1873); - -int64_t tmp1878 = (int32_t)3; - -uint64_t* tmp1879 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1875, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1857, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1875, tmp1878, tmp1879); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1857); -ClearMemPublic(tmp1878); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1875); - -uint64_t* tmp1883 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1879, tmp581, tmp582, (int32_t)0, (int32_t)11, tmp1883); -ClearMemSecret1( (int32_t)960, tmp581); -ClearMemSecret1( (int32_t)960, tmp582); - -uint64_t* tmp1886 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1883, tmp1886, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1883); - -uint64_t* tmp1888 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1886, tmp585, tmp1888); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1886); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128, tmp585); - -uint64_t* tmp1891 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1888, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1888, tmp586, tmp587, (int32_t)0, (int32_t)11, tmp1891); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1888); -ClearMemSecret1( (int32_t)128, tmp587); -ClearMemSecret1( (int32_t)128, tmp586); - -uint64_t* tmp1895 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1891, tmp1895, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1891); - -uint64_t* tmp1897 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1895, tmp590, tmp1897); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1895); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp590); - -int64_t tmp1900 = (int32_t)3; - -uint64_t* tmp1901 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1897, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1879, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1897, tmp1900, tmp1901); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1897); -ClearMemPublic(tmp1900); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1879); - -uint64_t* tmp1905 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1901, tmp591, tmp592, (int32_t)0, (int32_t)11, tmp1905); -ClearMemSecret1( (int32_t)992, tmp592); -ClearMemSecret1( (int32_t)992, tmp591); - -uint64_t* tmp1908 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1905, tmp1908, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1905); - -uint64_t* tmp1910 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1908, tmp595, tmp1910); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1908); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128, tmp595); - -uint64_t* tmp1913 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1910, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1910, tmp596, tmp597, (int32_t)0, (int32_t)11, tmp1913); -ClearMemSecret1( (int32_t)128, tmp596); -ClearMemSecret1( (int32_t)128, tmp597); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1910); - -uint64_t* tmp1917 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1913, tmp1917, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1913); - -uint64_t* tmp1919 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1917, tmp600, tmp1919); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp600); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1917); - -int64_t tmp1922 = (int32_t)3; - -uint64_t* tmp1923 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1919, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1901, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1919, tmp1922, tmp1923); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1919); -ClearMemPublic(tmp1922); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1901); - -uint64_t* tmp1927 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1923, tmp601, tmp602, (int32_t)0, (int32_t)11, tmp1927); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1923); -ClearMemSecret1( (int32_t)1024, tmp602); -ClearMemSecret1( (int32_t)1024, tmp601); - -uint64_t* tmp1931 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1927, tmp1931, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1927); - -uint64_t* tmp1933 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024); -AvgPool( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)7, (int32_t)7, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1931, tmp1933); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1931); - -uint64_t* tmp1935 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000); -Conv2DWrapper( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)1000, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1933, tmp605, tmp1935); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024, tmp1933); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1000, tmp605); - -uint64_t* tmp1938 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000); -ScaleUp1( (int32_t)1000, tmp606, (int32_t)11); -MatAddBroadCast4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1935, tmp606, tmp1938); -ClearMemSecret1( (int32_t)1000, tmp606); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1935); - -int64_t tmp1941 = (int32_t)3; - -uint64_t* tmp1942 = make_array( (int32_t)1, (int32_t)1, (int32_t)1); -ArgMax3( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1938, tmp1941, tmp1942); -ClearMemPublic(tmp1941); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1938); -EndComputation(); -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1; i2++){ -cout << (funcReconstruct2PCCons(Arr3DIdxRowM(tmp1942, (int32_t)1, (int32_t)1, (int32_t)1,i0,i1,i2), 2)) << endl; -} -} -} -} - diff --git a/SCI/networks/main_densenet121_ring32.cpp b/SCI/networks/main_densenet121_ring32.cpp deleted file mode 100644 index 303998ae..00000000 --- a/SCI/networks/main_densenet121_ring32.cpp +++ /dev/null @@ -1,11069 +0,0 @@ -/* -This is an autogenerated file, generated using the EzPC compiler. -*/ - - -#define BITLEN_32 -#define SCI_OT - - -#include "globals.h" -#include "functionalities_wrapper.h" -#include -using namespace std; - -template -T* make_array(size_t s1){ -return new T[s1]; -} - -template -T* make_array(size_t s1, size_t s2){ -return new T[s1*s2]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3){ -return new T[s1*s2*s3]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){ -return new T[s1*s2*s3*s4]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){ -return new T[s1*s2*s3*s4*s5]; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void MatAddBroadCast2(int32_t s1, int32_t s2, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr1DIdxRowM(B,s2,i2)); -} -} -} - -void MatAdd2(int32_t s1, int32_t s2, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr2DIdxRowM(B,s1,s2,i1,i2)); -} -} -} - -void MatAddBroadCast4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr1DIdxRowM(B,s4,i4)); -} -} -} -} -} - -void MatAdd4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr4DIdxRowM(B,s1,s2,s3,s4,i1,i2,i3,i4)); -} -} -} -} -} - -void MatAddBroadCast5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr1DIdxRowM(B,s5,i5)); -} -} -} -} -} -} - -void MatAdd5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr5DIdxRowM(B,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5)); -} -} -} -} -} -} - -void CreateTensor1(int32_t s1, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(arr,s1,i1) = val; -} -} - -void CreateTensor2(int32_t s1, int32_t s2, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(arr,s1,s2,i1,i2) = val; -} -} -} - -void CreateTensor3(int32_t s1, int32_t s2, int32_t s3, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = val; -} -} -} -} - -void CreateTensor4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = val; -} -} -} -} -} - -void CreateTensor5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(arr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = val; -} -} -} -} -} -} - -void CopyTensor1(int32_t s1, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(targetArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CopyTensor2(int32_t s1, int32_t s2, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(targetArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CopyTensor3(int32_t s1, int32_t s2, int32_t s3, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(targetArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CopyTensor4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(targetArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateIdentity11(int32_t s1, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(newArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CreateIdentity22(int32_t s1, int32_t s2, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(newArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CreateIdentity33(int32_t s1, int32_t s2, int32_t s3, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(newArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CreateIdentity44(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(newArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateCopy2211(int32_t s1, int32_t s2, int32_t inps1, int32_t inps2, uint32_t* inArr, int32_t perDimSize, int32_t* beginIdx, int32_t* sizeIdx, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,inps1,inps2,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j)); -} -} -} - -void CreateCopy5511(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, int32_t inps5, uint32_t* inArr, int32_t perDimSize, int32_t* beginIdx, int32_t* sizeIdx, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -for (uint32_t m = (int32_t)0; m < s5; m++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inArr,inps1,inps2,inps3,inps4,inps5,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)2) + k),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)3) + l),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)4) + m)); -} -} -} -} -} -} - -void Concat2T222(int32_t s1, int32_t s2, int32_t inp1s1, int32_t inp1s2, uint32_t* inp1, int32_t inp2s1, int32_t inp2s2, uint32_t* inp2, int32_t axis, uint32_t* outp){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,(i1 - inp1s1),i2); -} -} else { -if ((i2 < inp1s2)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,i1,(i2 - inp1s2)); -} -} -} -} -} - -void Concat2T444(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t inp1s1, int32_t inp1s2, int32_t inp1s3, int32_t inp1s4, uint32_t* inp1, int32_t inp2s1, int32_t inp2s2, int32_t inp2s3, int32_t inp2s4, uint32_t* inp2, int32_t axis, uint32_t* outp){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,(i1 - inp1s1),i2,i3,i4); -} -} else { -if ((axis == (int32_t)1)) { -if ((i2 < inp1s2)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,(i2 - inp1s2),i3,i4); -} -} else { -if ((axis == (int32_t)2)) { -if ((i3 < inp1s3)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,(i3 - inp1s3),i4); -} -} else { -if ((i4 < inp1s4)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,i3,(i4 - inp1s4)); -} -} -} -} -} -} -} -} -} - -void Split44(int32_t O1, int32_t O2, int32_t O3, int32_t O4, int32_t I1, int32_t I2, int32_t I3, int32_t I4, uint32_t* inp, int32_t axis, int32_t curCount, int32_t total, uint32_t* out){ -for (uint32_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint32_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint32_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint32_t o4 = (int32_t)0; o4 < O4; o4++){ - -int32_t i1 = o1; - -int32_t i2 = o2; - -int32_t i3 = o3; - -int32_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (((I1 / total) * curCount) + o1); -} -if ((axis == (int32_t)1)) { -i2 = (((I2 / total) * curCount) + o2); -} -if ((axis == (int32_t)2)) { -i3 = (((I3 / total) * curCount) + o3); -} -if ((axis == (int32_t)3)) { -i4 = (((I4 / total) * curCount) + o4); -} -Arr4DIdxRowM(out,O1,O2,O3,O4,o1,o2,o3,o4) = Arr4DIdxRowM(inp,I1,I2,I3,I4,i1,i2,i3,i4); -} -} -} -} -} - -void Conv2DReshapeFilter(int32_t FH, int32_t FW, int32_t CI, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CI,CO,fh,fw,ci,co); -} -} -} -} -} - -void Conv2DReshapeMatMulOP(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInput(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2D(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = ((FH * FW) * CI); - -int32_t reshapedIPRows = ((FH * FW) * CI); - -int32_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = ((N * newH) * newW); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t outH, int32_t outW, int32_t G, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t GIS = (CI / G); - -int32_t GOS = (CO / G); -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint32_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint32_t g = (int32_t)0; g < G; g++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ - -uint32_t val = funcSSCons( (int32_t)0); - -int32_t ci = ((GIS * g) + cig); - -int32_t co = ((GOS * g) + cog); - -int32_t curPosH = ((strideH * h) - zPadHLeft); -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ - -int32_t curPosW = ((strideW * w) - zPadWLeft); -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && (curPosH < H)) && (curPosW < W))) { -val = SecretAdd(val, SecretMult(Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci), Arr4DIdxRowM(filterArr,FH,FW,(CI / G),CO,fh,fw,(ci / G),co))); -} -curPosW = (curPosW + (int32_t)1); -} -curPosH = (curPosH + (int32_t)1); -} -Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co) = SecretAdd(Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co), val); -} -} -} -} -} -} -} - -void Conv2DLoop(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t G, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int32_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup(int32_t FH, int32_t FW, int32_t CI, int32_t CO, int32_t g, int32_t G, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t CIG = (CI / G); - -int32_t COG = (CO / G); - -int32_t startCO = (g * COG); -for (uint32_t co = (int32_t)0; co < COG; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CIG; ci++){ - -int32_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); -Arr2DIdxRowM(outputArr,(CO / G),((FH * FW) * (CI / G)),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,(CI / G),CO,fh,fw,ci,(co + startCO)); -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, int32_t g, int32_t G, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t COG = (CO / G); - -int32_t startCO = (g * COG); -for (uint32_t co = (int32_t)0; co < COG; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,(co + startCO)) = Arr2DIdxRowM(inputArr,(CO / G),((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInputGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t g, int32_t G, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; - -int32_t CIG = (CI / G); -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); - -int32_t startCI = (g * CIG); -for (uint32_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,(ci + startCI)); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CIG) + (fw * CIG)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2DGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t G, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t CIG = (CI / G); - -int32_t reshapedFilterRows = (CO / G); - -int32_t reshapedFilterCols = ((FH * FW) * CIG); - -int32_t reshapedIPRows = ((FH * FW) * CIG); - -int32_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = ((N * outH) * outW); -for (uint32_t g = (int32_t)0; g < G; g++){ - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -} -} - -void Conv3DReshapeFilter(int32_t FD, int32_t FH, int32_t FW, int32_t CI, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CI,CO,fd,fh,fw,ci,co); -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP(int32_t N, int32_t finalD, int32_t finalH, int32_t finalW, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t d = (int32_t)0; d < finalD; d++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr5DIdxRowM(outputArr,N,finalD,finalH,finalW,CO,n,d,h,w,co) = Arr2DIdxRowM(inputArr,CO,(((N * finalD) * finalH) * finalW),co,((((((n * finalD) * finalH) * finalW) + ((d * finalH) * finalW)) + (h * finalW)) + w)); -} -} -} -} -} -} - -void Conv3DReshapeInput(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerD = ( (int32_t)0 - zPadDLeft); - -int32_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosD = (leftTopCornerD + fd); - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= D)) || ((curPosH < (int32_t)0) || (curPosH >= H))) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -leftTopCornerD = (leftTopCornerD + strideD); -} - -} -} - -void Conv3D(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int32_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int32_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); - -int32_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = (((N * newD) * newH) * newW); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t outD, int32_t outH, int32_t outW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t d = (int32_t)0; d < outD; d++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t fd = (d * strideD); fd < ((d * strideD) + FD); fd++){ -for (uint32_t fh = (h * strideH); fh < ((h * strideH) + FH); fh++){ -for (uint32_t fw = (w * strideW); fw < ((w * strideW) + FW); fw++){ - -int32_t curPosD = (fd - zPadDLeft); - -int32_t curPosH = (fh - zPadHLeft); - -int32_t curPosW = (fw - zPadWLeft); -if (((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W))) { - -int32_t curFilterPosD = (fd - (d * strideD)); - -int32_t curFilterPosH = (fh - (h * strideH)); - -int32_t curFilterPosW = (fw - (w * strideW)); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CI,CO,curFilterPosD,curFilterPosH,curFilterPosW,ci,co))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void Conv3DLoop(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); - -int32_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int32_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void ConvTranspose2DReshapeFilter(int32_t FH, int32_t FW, int32_t CO, int32_t CI, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CO,CI,((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} - -void ConvTranspose2DReshapeInput(int32_t N, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FH, int32_t FW, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int32_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int32_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int32_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int32_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int32_t)0); -} else { -if ((((curPosH % strideH) == (int32_t)0) && ((curPosW % strideW) == (int32_t)0))) { - -int32_t idxInputH = (curPosH / strideH); - -int32_t idxInputW = (curPosW / strideW); -val = Arr4DIdxRowM(inputArr,N,HPrime,WPrime,CI,n,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -} -} - -void ConvTranspose2D(int32_t N, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t H, int32_t W, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = ((FH * FW) * CI); - -int32_t reshapedIPRows = ((FH * FW) * CI); - -int32_t reshapedIPCols = ((N * H) * W); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter(int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t CI, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CO,CI,((FD - (int32_t)1) - fd),((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerD = ( (int32_t)0 - zPadTrDLeft); - -int32_t DPrimeTilde = (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); - -int32_t extremeRightBottomCornerD = ((DPrimeTilde - (int32_t)1) + zPadTrDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int32_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int32_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int32_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int32_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int32_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosD = (leftTopCornerD + fd); - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int32_t)0); -} else { -if (((((curPosD % strideD) == (int32_t)0) && ((curPosH % strideH) == (int32_t)0)) && ((curPosW % strideW) == (int32_t)0))) { - -int32_t idxInputD = (curPosD / strideD); - -int32_t idxInputH = (curPosH / strideH); - -int32_t idxInputW = (curPosW / strideW); -val = Arr5DIdxRowM(inputArr,N,DPrime,HPrime,WPrime,CI,n,idxInputD,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -leftTopCornerD = (leftTopCornerD + (int32_t)1); -} - -} -} - -void ConvTranspose3D(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t D, int32_t H, int32_t W, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int32_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int32_t reshapedIPCols = (((N * D) * H) * W); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t outD, int32_t outH, int32_t outW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t d = (int32_t)0; d < outD; d++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t fd = d; fd < (d + FD); fd++){ -for (uint32_t fh = h; fh < (h + FH); fh++){ -for (uint32_t fw = w; fw < (w + FW); fw++){ - -int32_t curPosD = ((fd - zPadDLeft) / strideD); - -int32_t curPosH = ((fh - zPadHLeft) / strideD); - -int32_t curPosW = ((fw - zPadWLeft) / strideD); -if ((((((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W)) && (((fd - zPadDLeft) % strideD) == (int32_t)0)) && (((fh - zPadHLeft) % strideH) == (int32_t)0)) && (((fw - zPadWLeft) % strideW) == (int32_t)0))) { - -int32_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); - -int32_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); - -int32_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CO,CI,curFilterPosD,curFilterPosH,curFilterPosW,co,ci))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t D, int32_t H, int32_t W, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ -ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2(int32_t s1, int32_t s2, uint32_t* inArr, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,s2,s1,j,i); -} -} -} - -void Pad442(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, uint32_t* inpArr, int32_t pads1, int32_t pads2, int32_t* paddings, uint32_t* outArr){ - -int32_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int32_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int32_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int32_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int32_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int32_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int32_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int32_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = Arr4DIdxRowM(inpArr,inps1,inps2,inps3,inps4,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0))); -} else { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = funcSSCons( (int32_t)0); -} -} -} -} -} -} - -void Pad552(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, int32_t inps5, uint32_t* inpArr, int32_t pads1, int32_t pads2, int32_t* paddings, uint32_t* outArr){ - -int32_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int32_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int32_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int32_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int32_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int32_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int32_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int32_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); - -int32_t lbounds5 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0); - -int32_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)1)); -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -for (uint32_t m = (int32_t)0; m < s5; m++){ -if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl)) && (m >= lbounds5)) && (m < rbounds5excl))) { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inpArr,inps1,inps2,inps3,inps4,inps5,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0)),(m - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0))); -} else { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = funcSSCons( (int32_t)0); -} -} -} -} -} -} -} - -void PadONNX441(int32_t o1, int32_t o2, int32_t o3, int32_t o4, int32_t i1, int32_t i2, int32_t i3, int32_t i4, uint32_t* inpArr, int32_t pads, int32_t* paddings, uint32_t* outArr){ - -int32_t lbounds1 = Arr1DIdxRowM(paddings,pads, (int32_t)0); - -int32_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings,pads, (int32_t)4)); - -int32_t lbounds2 = Arr1DIdxRowM(paddings,pads, (int32_t)1); - -int32_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings,pads, (int32_t)5)); - -int32_t lbounds3 = Arr1DIdxRowM(paddings,pads, (int32_t)2); - -int32_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings,pads, (int32_t)6)); - -int32_t lbounds4 = Arr1DIdxRowM(paddings,pads, (int32_t)3); - -int32_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings,pads, (int32_t)7)); -for (uint32_t i = (int32_t)0; i < o1; i++){ -for (uint32_t j = (int32_t)0; j < o2; j++){ -for (uint32_t k = (int32_t)0; k < o3; k++){ -for (uint32_t l = (int32_t)0; l < o4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = Arr4DIdxRowM(inpArr,i1,i2,i3,i4,(i - Arr1DIdxRowM(paddings,pads, (int32_t)0)),(j - Arr1DIdxRowM(paddings,pads, (int32_t)1)),(k - Arr1DIdxRowM(paddings,pads, (int32_t)2)),(l - Arr1DIdxRowM(paddings,pads, (int32_t)3))); -} else { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = funcSSCons( (int32_t)0); -} -} -} -} -} -} - -void Squeeze24(int32_t s1, int32_t s2, int32_t dim1, int32_t dim2, int32_t ins1, int32_t ins2, int32_t ins3, int32_t ins4, uint32_t* inArr, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < ins1; i++){ -for (uint32_t j = (int32_t)0; j < ins2; j++){ -for (uint32_t k = (int32_t)0; k < ins3; k++){ -for (uint32_t l = (int32_t)0; l < ins4; l++){ - -int32_t linIdx = ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + (k * ins4)) + l); - -int32_t outIdx1 = (linIdx / s2); - -int32_t outIdx2 = (linIdx % s2); -Arr2DIdxRowM(outArr,s1,s2,outIdx1,outIdx2) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i,j,k,l); -} -} -} -} -} - -void FusedBatchNorm4411(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* inArr, uint32_t* multArr, uint32_t* biasArr, int32_t multExprScaleDownSf, int32_t biasExprScaleUpSf, uint32_t* outputArr){ - -int32_t inpSize = (((s1 * s2) * s3) * s4); - -uint32_t* inArrReshaped = make_array(inpSize); - -uint32_t* multArrReshaped = make_array(inpSize); - -uint32_t* multExprAns = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s4,i4); -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint32_t* biasArrScaledUp = make_array(s4); -for (uint32_t ii = (int32_t)0; ii < s4; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s4,ii) = Arr1DIdxRowM(biasArr,s4,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outputArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s4,i4)); -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* inArr, uint32_t* multArr, uint32_t* biasArr, int32_t multExprScaleDownSf, int32_t biasExprScaleUpSf, uint32_t* outputArr){ - -int32_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint32_t* inArrReshaped = make_array(inpSize); - -uint32_t* multArrReshaped = make_array(inpSize); - -uint32_t* multExprAns = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s5,i5); -} -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint32_t* biasArrScaledUp = make_array(s5); -for (uint32_t ii = (int32_t)0; ii < s5; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s5,ii) = Arr1DIdxRowM(biasArr,s5,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outputArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s5,i5)); -} -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s5, biasArrScaledUp); -} - -void ElemWiseMul2(int32_t s1, int32_t s2, uint32_t* arr1, uint32_t* arr2, uint32_t* outArr){ - -int32_t inpSize = (s1 * s2); - -uint32_t* arr1Reshaped = make_array(inpSize); - -uint32_t* arr2Reshaped = make_array(inpSize); - -uint32_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr1,s1,s2,i1,i2); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr2,s1,s2,i1,i2); -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* arr1, uint32_t* arr2, uint32_t* outArr){ - -int32_t inpSize = (((s1 * s2) * s3) * s4); - -uint32_t* arr1Reshaped = make_array(inpSize); - -uint32_t* arr2Reshaped = make_array(inpSize); - -uint32_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr1,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr2,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* arr1, uint32_t* arr2, uint32_t* outArr){ - -int32_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint32_t* arr1Reshaped = make_array(inpSize); - -uint32_t* arr2Reshaped = make_array(inpSize); - -uint32_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr1,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr2,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ReduceMean24(int32_t outS1, int32_t outS2, int32_t inS1, int32_t inS2, int32_t inS3, int32_t inS4, uint32_t* inputArr, int32_t* axes, uint32_t* outputArr){ - -int32_t divisor = (inS2 * inS3); - -int32_t outputSize = (outS1 * outS2); - -uint32_t* sumArr = make_array(outputSize); - -uint32_t* outputArrReshaped = make_array(outputSize); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint32_t summ = funcSSCons( (int32_t)0); -for (uint32_t i = (int32_t)0; i < inS2; i++){ -for (uint32_t j = (int32_t)0; j < inS3; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i,j,i2)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24(int32_t outS1, int32_t outS2, int32_t inS1, int32_t inS2, int32_t inS3, int32_t inS4, uint32_t* inputArr, int32_t axis1, int32_t axis2, uint32_t* outputArr){ - -int32_t divisor = (inS3 * inS4); - -int32_t outputSize = (outS1 * outS2); - -uint32_t* sumArr = make_array(outputSize); - -uint32_t* outputArrReshaped = make_array(outputSize); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint32_t summ = funcSSCons( (int32_t)0); -for (uint32_t i = (int32_t)0; i < inS3; i++){ -for (uint32_t j = (int32_t)0; j < inS4; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i2,i,j)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ArgMax1(int32_t outArrS1, int32_t inArrS1, int32_t inArrS2, uint32_t* inArr, int32_t dim, uint32_t* outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3(int32_t outs1, int32_t outs2, int32_t outs3, int32_t ins1, int32_t ins2, int32_t ins3, int32_t ins4, uint32_t* inArr, int32_t dim, uint32_t* outArr){ - -int32_t size = ((ins1 * ins2) * ins3); - -uint32_t* reshapedInArr = make_array(size, ins4); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < ins4; i4++){ - -int32_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr2DIdxRowM(reshapedInArr,size,ins4,linIdx,i4) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i1,i2,i3,i4); -} -} -} -} -ArgMax(size, ins4, reshapedInArr, reshapedOutArr); -for (uint32_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < ins3; i3++){ - -int32_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr3DIdxRowM(outArr,outs1,outs2,outs3,i1,i2,i3) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -ClearMemSecret2(size, ins4, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu2(int32_t s1, int32_t s2, uint32_t* inArr, uint32_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* inArr, uint32_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* inArr, uint32_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = ((((s1 * s2) * s3) * s4) * s5); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Floor2(int32_t s1, int32_t s2, uint32_t* inArr, uint32_t* outArr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Floor(size, reshapedInArr, reshapedOutArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void ScaleUp1(int32_t s1, uint32_t* arr, int32_t sf){ -ScaleUp(s1, arr, sf); -} - -void ScaleUp2(int32_t s1, int32_t s2, uint32_t* arr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp3(int32_t s1, int32_t s2, int32_t s3, uint32_t* arr, int32_t sf){ - -int32_t size = ((s1 * s2) * s3); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* arr, int32_t sf){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown1(int32_t s1, uint32_t* arr, int32_t sf){ -ScaleDown(s1, arr, sf); -} - -void ScaleDown2(int32_t s1, int32_t s2, uint32_t* arr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown3(int32_t s1, int32_t s2, int32_t s3, uint32_t* arr, int32_t sf){ - -int32_t size = ((s1 * s2) * s3); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* arr, int32_t sf){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - - -int main(int argc, char** argv) -{ -ArgMapping amap; -int port = 32000; -string serverAddr = "127.0.0.1"; - -amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); -amap.arg("p", port, "Port Number"); -amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); -amap.parse(argc, argv); - -assert(party==sci::ALICE || party==sci::BOB); - -checkIfUsingEigen(); -for(int i=0;i(ioArr[i]); -prgInstanceArr[i] = new sci::PRG128(); -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); -if (i == 0) { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength); -} -else if (i == 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength); -} -else if (i & 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[1]); -} -else { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[0]); -} -} - -io = ioArr[0]; -iknpOT = new sci::IKNP(io); -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good -kkot = new sci::KKOT(io); -prg128Instance = new sci::PRG128(); -otpack = new sci::OTPack(io, party, baseForRelu, bitlength); - -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - -#ifdef SCI_OT -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack); -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -#endif - -#ifdef SCI_HE -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -heConvImpl = new ConvField(party,io); -heFCImpl = new FCField(party,io); -heProdImpl = new ElemWiseProdField(party, io); -assertFieldRun(); -#endif -#ifdef MULTITHREADED_NONLIN -#ifdef SCI_OT -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -} -#endif -#ifdef SCI_HE -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -} -#endif -#endif - -if (party==sci::ALICE){ -iknpOT->setup_send(); -iknpOTRoleReversed->setup_recv(); -} -else if (party==sci::BOB){ -iknpOT->setup_recv(); -iknpOTRoleReversed->setup_send(); -} -cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3); -/* Variable to read the clear value corresponding to the input variable tmp0 at (1930,1-1930,46) */ -uint32_t __tmp_in_tmp0; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)224; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)224; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)3; i3++){ -if ((party == CLIENT)) { -cin >> __tmp_in_tmp0; -} -Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3,i0,i1,i2,i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; -} -} -} -} - -uint32_t* tmp1 = make_array( (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp1 at (1933,1-1933,43) */ -uint32_t __tmp_in_tmp1; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)7; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)7; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)3; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp1; -} -Arr4DIdxRowM(tmp1, (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; -} -} -} -} - -uint32_t* tmp2 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp2 at (1936,1-1936,34) */ -uint32_t __tmp_in_tmp2; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp2; -} -Arr1DIdxRowM(tmp2, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; -} - -uint32_t* tmp3 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp3 at (1939,1-1939,34) */ -uint32_t __tmp_in_tmp3; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp3; -} -Arr1DIdxRowM(tmp3, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp3 : 0; -} - -uint32_t* tmp4 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp4 at (1942,1-1942,34) */ -uint32_t __tmp_in_tmp4; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp4; -} -Arr1DIdxRowM(tmp4, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; -} - -uint32_t* tmp5 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp5 at (1945,1-1945,34) */ -uint32_t __tmp_in_tmp5; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp5; -} -Arr1DIdxRowM(tmp5, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp5 : 0; -} - -uint32_t* tmp6 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp6 at (1948,1-1948,34) */ -uint32_t __tmp_in_tmp6; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp6; -} -Arr1DIdxRowM(tmp6, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp6 : 0; -} - -uint32_t* tmp7 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp7 at (1951,1-1951,34) */ -uint32_t __tmp_in_tmp7; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp7; -} -Arr1DIdxRowM(tmp7, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp7 : 0; -} - -uint32_t* tmp8 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp8 at (1954,1-1954,34) */ -uint32_t __tmp_in_tmp8; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp8; -} -Arr1DIdxRowM(tmp8, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; -} - -uint32_t* tmp9 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp9 at (1957,1-1957,34) */ -uint32_t __tmp_in_tmp9; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp9; -} -Arr1DIdxRowM(tmp9, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; -} - -uint32_t* tmp10 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp10 at (1960,1-1960,46) */ -uint32_t __tmp_in_tmp10; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp10; -} -Arr4DIdxRowM(tmp10, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp10 : 0; -} -} -} -} - -uint32_t* tmp11 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp11 at (1963,1-1963,36) */ -uint32_t __tmp_in_tmp11; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp11; -} -Arr1DIdxRowM(tmp11, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp11 : 0; -} - -uint32_t* tmp12 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp12 at (1966,1-1966,36) */ -uint32_t __tmp_in_tmp12; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp12; -} -Arr1DIdxRowM(tmp12, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp12 : 0; -} - -uint32_t* tmp13 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp13 at (1969,1-1969,36) */ -uint32_t __tmp_in_tmp13; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp13; -} -Arr1DIdxRowM(tmp13, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp13 : 0; -} - -uint32_t* tmp14 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp14 at (1972,1-1972,36) */ -uint32_t __tmp_in_tmp14; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp14; -} -Arr1DIdxRowM(tmp14, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp14 : 0; -} - -uint32_t* tmp15 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp15 at (1975,1-1975,46) */ -uint32_t __tmp_in_tmp15; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp15; -} -Arr4DIdxRowM(tmp15, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp15 : 0; -} -} -} -} - -uint32_t* tmp16 = make_array( (int32_t)96); -/* Variable to read the clear value corresponding to the input variable tmp16 at (1978,1-1978,35) */ -uint32_t __tmp_in_tmp16; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)96; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp16; -} -Arr1DIdxRowM(tmp16, (int32_t)96,i0) = (party == SERVER) ? __tmp_in_tmp16 : 0; -} - -uint32_t* tmp17 = make_array( (int32_t)96); -/* Variable to read the clear value corresponding to the input variable tmp17 at (1981,1-1981,35) */ -uint32_t __tmp_in_tmp17; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)96; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp17; -} -Arr1DIdxRowM(tmp17, (int32_t)96,i0) = (party == SERVER) ? __tmp_in_tmp17 : 0; -} - -uint32_t* tmp18 = make_array( (int32_t)96); -/* Variable to read the clear value corresponding to the input variable tmp18 at (1984,1-1984,35) */ -uint32_t __tmp_in_tmp18; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)96; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp18; -} -Arr1DIdxRowM(tmp18, (int32_t)96,i0) = (party == SERVER) ? __tmp_in_tmp18 : 0; -} - -uint32_t* tmp19 = make_array( (int32_t)96); -/* Variable to read the clear value corresponding to the input variable tmp19 at (1987,1-1987,35) */ -uint32_t __tmp_in_tmp19; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)96; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp19; -} -Arr1DIdxRowM(tmp19, (int32_t)96,i0) = (party == SERVER) ? __tmp_in_tmp19 : 0; -} - -uint32_t* tmp20 = make_array( (int32_t)1, (int32_t)1, (int32_t)96, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp20 at (1990,1-1990,46) */ -uint32_t __tmp_in_tmp20; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)96; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp20; -} -Arr4DIdxRowM(tmp20, (int32_t)1, (int32_t)1, (int32_t)96, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp20 : 0; -} -} -} -} - -uint32_t* tmp21 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp21 at (1993,1-1993,36) */ -uint32_t __tmp_in_tmp21; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp21; -} -Arr1DIdxRowM(tmp21, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp21 : 0; -} - -uint32_t* tmp22 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp22 at (1996,1-1996,36) */ -uint32_t __tmp_in_tmp22; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp22; -} -Arr1DIdxRowM(tmp22, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp22 : 0; -} - -uint32_t* tmp23 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp23 at (1999,1-1999,36) */ -uint32_t __tmp_in_tmp23; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp23; -} -Arr1DIdxRowM(tmp23, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp23 : 0; -} - -uint32_t* tmp24 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp24 at (2002,1-2002,36) */ -uint32_t __tmp_in_tmp24; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp24; -} -Arr1DIdxRowM(tmp24, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp24 : 0; -} - -uint32_t* tmp25 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp25 at (2005,1-2005,46) */ -uint32_t __tmp_in_tmp25; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp25; -} -Arr4DIdxRowM(tmp25, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp25 : 0; -} -} -} -} - -uint32_t* tmp26 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp26 at (2008,1-2008,36) */ -uint32_t __tmp_in_tmp26; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp26; -} -Arr1DIdxRowM(tmp26, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp26 : 0; -} - -uint32_t* tmp27 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp27 at (2011,1-2011,36) */ -uint32_t __tmp_in_tmp27; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp27; -} -Arr1DIdxRowM(tmp27, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp27 : 0; -} - -uint32_t* tmp28 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp28 at (2014,1-2014,36) */ -uint32_t __tmp_in_tmp28; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp28; -} -Arr1DIdxRowM(tmp28, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp28 : 0; -} - -uint32_t* tmp29 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp29 at (2017,1-2017,36) */ -uint32_t __tmp_in_tmp29; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp29; -} -Arr1DIdxRowM(tmp29, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp29 : 0; -} - -uint32_t* tmp30 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp30 at (2020,1-2020,47) */ -uint32_t __tmp_in_tmp30; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp30; -} -Arr4DIdxRowM(tmp30, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp30 : 0; -} -} -} -} - -uint32_t* tmp31 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp31 at (2023,1-2023,36) */ -uint32_t __tmp_in_tmp31; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp31; -} -Arr1DIdxRowM(tmp31, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp31 : 0; -} - -uint32_t* tmp32 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp32 at (2026,1-2026,36) */ -uint32_t __tmp_in_tmp32; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp32; -} -Arr1DIdxRowM(tmp32, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp32 : 0; -} - -uint32_t* tmp33 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp33 at (2029,1-2029,36) */ -uint32_t __tmp_in_tmp33; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp33; -} -Arr1DIdxRowM(tmp33, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp33 : 0; -} - -uint32_t* tmp34 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp34 at (2032,1-2032,36) */ -uint32_t __tmp_in_tmp34; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp34; -} -Arr1DIdxRowM(tmp34, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp34 : 0; -} - -uint32_t* tmp35 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp35 at (2035,1-2035,46) */ -uint32_t __tmp_in_tmp35; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp35; -} -Arr4DIdxRowM(tmp35, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp35 : 0; -} -} -} -} - -uint32_t* tmp36 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp36 at (2038,1-2038,36) */ -uint32_t __tmp_in_tmp36; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp36; -} -Arr1DIdxRowM(tmp36, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp36 : 0; -} - -uint32_t* tmp37 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp37 at (2041,1-2041,36) */ -uint32_t __tmp_in_tmp37; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp37; -} -Arr1DIdxRowM(tmp37, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp37 : 0; -} - -uint32_t* tmp38 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp38 at (2044,1-2044,36) */ -uint32_t __tmp_in_tmp38; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp38; -} -Arr1DIdxRowM(tmp38, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp38 : 0; -} - -uint32_t* tmp39 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp39 at (2047,1-2047,36) */ -uint32_t __tmp_in_tmp39; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp39; -} -Arr1DIdxRowM(tmp39, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp39 : 0; -} - -uint32_t* tmp40 = make_array( (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp40 at (2050,1-2050,47) */ -uint32_t __tmp_in_tmp40; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)160; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp40; -} -Arr4DIdxRowM(tmp40, (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp40 : 0; -} -} -} -} - -uint32_t* tmp41 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp41 at (2053,1-2053,36) */ -uint32_t __tmp_in_tmp41; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp41; -} -Arr1DIdxRowM(tmp41, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp41 : 0; -} - -uint32_t* tmp42 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp42 at (2056,1-2056,36) */ -uint32_t __tmp_in_tmp42; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp42; -} -Arr1DIdxRowM(tmp42, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp42 : 0; -} - -uint32_t* tmp43 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp43 at (2059,1-2059,36) */ -uint32_t __tmp_in_tmp43; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp43; -} -Arr1DIdxRowM(tmp43, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp43 : 0; -} - -uint32_t* tmp44 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp44 at (2062,1-2062,36) */ -uint32_t __tmp_in_tmp44; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp44; -} -Arr1DIdxRowM(tmp44, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp44 : 0; -} - -uint32_t* tmp45 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp45 at (2065,1-2065,46) */ -uint32_t __tmp_in_tmp45; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp45; -} -Arr4DIdxRowM(tmp45, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp45 : 0; -} -} -} -} - -uint32_t* tmp46 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp46 at (2068,1-2068,36) */ -uint32_t __tmp_in_tmp46; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp46; -} -Arr1DIdxRowM(tmp46, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp46 : 0; -} - -uint32_t* tmp47 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp47 at (2071,1-2071,36) */ -uint32_t __tmp_in_tmp47; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp47; -} -Arr1DIdxRowM(tmp47, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp47 : 0; -} - -uint32_t* tmp48 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp48 at (2074,1-2074,36) */ -uint32_t __tmp_in_tmp48; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp48; -} -Arr1DIdxRowM(tmp48, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp48 : 0; -} - -uint32_t* tmp49 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp49 at (2077,1-2077,36) */ -uint32_t __tmp_in_tmp49; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp49; -} -Arr1DIdxRowM(tmp49, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp49 : 0; -} - -uint32_t* tmp50 = make_array( (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp50 at (2080,1-2080,47) */ -uint32_t __tmp_in_tmp50; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)192; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp50; -} -Arr4DIdxRowM(tmp50, (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp50 : 0; -} -} -} -} - -uint32_t* tmp51 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp51 at (2083,1-2083,36) */ -uint32_t __tmp_in_tmp51; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp51; -} -Arr1DIdxRowM(tmp51, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp51 : 0; -} - -uint32_t* tmp52 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp52 at (2086,1-2086,36) */ -uint32_t __tmp_in_tmp52; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp52; -} -Arr1DIdxRowM(tmp52, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp52 : 0; -} - -uint32_t* tmp53 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp53 at (2089,1-2089,36) */ -uint32_t __tmp_in_tmp53; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp53; -} -Arr1DIdxRowM(tmp53, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp53 : 0; -} - -uint32_t* tmp54 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp54 at (2092,1-2092,36) */ -uint32_t __tmp_in_tmp54; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp54; -} -Arr1DIdxRowM(tmp54, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp54 : 0; -} - -uint32_t* tmp55 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp55 at (2095,1-2095,46) */ -uint32_t __tmp_in_tmp55; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp55; -} -Arr4DIdxRowM(tmp55, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp55 : 0; -} -} -} -} - -uint32_t* tmp56 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp56 at (2098,1-2098,36) */ -uint32_t __tmp_in_tmp56; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp56; -} -Arr1DIdxRowM(tmp56, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp56 : 0; -} - -uint32_t* tmp57 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp57 at (2101,1-2101,36) */ -uint32_t __tmp_in_tmp57; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp57; -} -Arr1DIdxRowM(tmp57, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp57 : 0; -} - -uint32_t* tmp58 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp58 at (2104,1-2104,36) */ -uint32_t __tmp_in_tmp58; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp58; -} -Arr1DIdxRowM(tmp58, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp58 : 0; -} - -uint32_t* tmp59 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp59 at (2107,1-2107,36) */ -uint32_t __tmp_in_tmp59; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp59; -} -Arr1DIdxRowM(tmp59, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp59 : 0; -} - -uint32_t* tmp60 = make_array( (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp60 at (2110,1-2110,47) */ -uint32_t __tmp_in_tmp60; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)224; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp60; -} -Arr4DIdxRowM(tmp60, (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp60 : 0; -} -} -} -} - -uint32_t* tmp61 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp61 at (2113,1-2113,36) */ -uint32_t __tmp_in_tmp61; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp61; -} -Arr1DIdxRowM(tmp61, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp61 : 0; -} - -uint32_t* tmp62 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp62 at (2116,1-2116,36) */ -uint32_t __tmp_in_tmp62; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp62; -} -Arr1DIdxRowM(tmp62, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp62 : 0; -} - -uint32_t* tmp63 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp63 at (2119,1-2119,36) */ -uint32_t __tmp_in_tmp63; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp63; -} -Arr1DIdxRowM(tmp63, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp63 : 0; -} - -uint32_t* tmp64 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp64 at (2122,1-2122,36) */ -uint32_t __tmp_in_tmp64; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp64; -} -Arr1DIdxRowM(tmp64, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp64 : 0; -} - -uint32_t* tmp65 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp65 at (2125,1-2125,46) */ -uint32_t __tmp_in_tmp65; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp65; -} -Arr4DIdxRowM(tmp65, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp65 : 0; -} -} -} -} - -uint32_t* tmp66 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp66 at (2128,1-2128,36) */ -uint32_t __tmp_in_tmp66; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp66; -} -Arr1DIdxRowM(tmp66, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp66 : 0; -} - -uint32_t* tmp67 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp67 at (2131,1-2131,36) */ -uint32_t __tmp_in_tmp67; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp67; -} -Arr1DIdxRowM(tmp67, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp67 : 0; -} - -uint32_t* tmp68 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp68 at (2134,1-2134,36) */ -uint32_t __tmp_in_tmp68; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp68; -} -Arr1DIdxRowM(tmp68, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp68 : 0; -} - -uint32_t* tmp69 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp69 at (2137,1-2137,36) */ -uint32_t __tmp_in_tmp69; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp69; -} -Arr1DIdxRowM(tmp69, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp69 : 0; -} - -uint32_t* tmp70 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp70 at (2140,1-2140,47) */ -uint32_t __tmp_in_tmp70; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp70; -} -Arr4DIdxRowM(tmp70, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp70 : 0; -} -} -} -} - -uint32_t* tmp71 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp71 at (2143,1-2143,36) */ -uint32_t __tmp_in_tmp71; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp71; -} -Arr1DIdxRowM(tmp71, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp71 : 0; -} - -uint32_t* tmp72 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp72 at (2146,1-2146,36) */ -uint32_t __tmp_in_tmp72; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp72; -} -Arr1DIdxRowM(tmp72, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp72 : 0; -} - -uint32_t* tmp73 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp73 at (2149,1-2149,36) */ -uint32_t __tmp_in_tmp73; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp73; -} -Arr1DIdxRowM(tmp73, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp73 : 0; -} - -uint32_t* tmp74 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp74 at (2152,1-2152,36) */ -uint32_t __tmp_in_tmp74; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp74; -} -Arr1DIdxRowM(tmp74, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp74 : 0; -} - -uint32_t* tmp75 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp75 at (2155,1-2155,47) */ -uint32_t __tmp_in_tmp75; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp75; -} -Arr4DIdxRowM(tmp75, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp75 : 0; -} -} -} -} - -uint32_t* tmp76 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp76 at (2158,1-2158,36) */ -uint32_t __tmp_in_tmp76; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp76; -} -Arr1DIdxRowM(tmp76, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp76 : 0; -} - -uint32_t* tmp77 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp77 at (2161,1-2161,36) */ -uint32_t __tmp_in_tmp77; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp77; -} -Arr1DIdxRowM(tmp77, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp77 : 0; -} - -uint32_t* tmp78 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp78 at (2164,1-2164,36) */ -uint32_t __tmp_in_tmp78; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp78; -} -Arr1DIdxRowM(tmp78, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp78 : 0; -} - -uint32_t* tmp79 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp79 at (2167,1-2167,36) */ -uint32_t __tmp_in_tmp79; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp79; -} -Arr1DIdxRowM(tmp79, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp79 : 0; -} - -uint32_t* tmp80 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp80 at (2170,1-2170,46) */ -uint32_t __tmp_in_tmp80; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp80; -} -Arr4DIdxRowM(tmp80, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp80 : 0; -} -} -} -} - -uint32_t* tmp81 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp81 at (2173,1-2173,36) */ -uint32_t __tmp_in_tmp81; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp81; -} -Arr1DIdxRowM(tmp81, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp81 : 0; -} - -uint32_t* tmp82 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp82 at (2176,1-2176,36) */ -uint32_t __tmp_in_tmp82; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp82; -} -Arr1DIdxRowM(tmp82, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp82 : 0; -} - -uint32_t* tmp83 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp83 at (2179,1-2179,36) */ -uint32_t __tmp_in_tmp83; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp83; -} -Arr1DIdxRowM(tmp83, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp83 : 0; -} - -uint32_t* tmp84 = make_array( (int32_t)160); -/* Variable to read the clear value corresponding to the input variable tmp84 at (2182,1-2182,36) */ -uint32_t __tmp_in_tmp84; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)160; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp84; -} -Arr1DIdxRowM(tmp84, (int32_t)160,i0) = (party == SERVER) ? __tmp_in_tmp84 : 0; -} - -uint32_t* tmp85 = make_array( (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp85 at (2185,1-2185,47) */ -uint32_t __tmp_in_tmp85; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)160; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp85; -} -Arr4DIdxRowM(tmp85, (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp85 : 0; -} -} -} -} - -uint32_t* tmp86 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp86 at (2188,1-2188,36) */ -uint32_t __tmp_in_tmp86; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp86; -} -Arr1DIdxRowM(tmp86, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp86 : 0; -} - -uint32_t* tmp87 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp87 at (2191,1-2191,36) */ -uint32_t __tmp_in_tmp87; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp87; -} -Arr1DIdxRowM(tmp87, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp87 : 0; -} - -uint32_t* tmp88 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp88 at (2194,1-2194,36) */ -uint32_t __tmp_in_tmp88; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp88; -} -Arr1DIdxRowM(tmp88, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp88 : 0; -} - -uint32_t* tmp89 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp89 at (2197,1-2197,36) */ -uint32_t __tmp_in_tmp89; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp89; -} -Arr1DIdxRowM(tmp89, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp89 : 0; -} - -uint32_t* tmp90 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp90 at (2200,1-2200,46) */ -uint32_t __tmp_in_tmp90; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp90; -} -Arr4DIdxRowM(tmp90, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp90 : 0; -} -} -} -} - -uint32_t* tmp91 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp91 at (2203,1-2203,36) */ -uint32_t __tmp_in_tmp91; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp91; -} -Arr1DIdxRowM(tmp91, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp91 : 0; -} - -uint32_t* tmp92 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp92 at (2206,1-2206,36) */ -uint32_t __tmp_in_tmp92; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp92; -} -Arr1DIdxRowM(tmp92, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp92 : 0; -} - -uint32_t* tmp93 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp93 at (2209,1-2209,36) */ -uint32_t __tmp_in_tmp93; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp93; -} -Arr1DIdxRowM(tmp93, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp93 : 0; -} - -uint32_t* tmp94 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp94 at (2212,1-2212,36) */ -uint32_t __tmp_in_tmp94; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp94; -} -Arr1DIdxRowM(tmp94, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp94 : 0; -} - -uint32_t* tmp95 = make_array( (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp95 at (2215,1-2215,47) */ -uint32_t __tmp_in_tmp95; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)192; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp95; -} -Arr4DIdxRowM(tmp95, (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp95 : 0; -} -} -} -} - -uint32_t* tmp96 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp96 at (2218,1-2218,36) */ -uint32_t __tmp_in_tmp96; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp96; -} -Arr1DIdxRowM(tmp96, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp96 : 0; -} - -uint32_t* tmp97 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp97 at (2221,1-2221,36) */ -uint32_t __tmp_in_tmp97; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp97; -} -Arr1DIdxRowM(tmp97, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp97 : 0; -} - -uint32_t* tmp98 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp98 at (2224,1-2224,36) */ -uint32_t __tmp_in_tmp98; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp98; -} -Arr1DIdxRowM(tmp98, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp98 : 0; -} - -uint32_t* tmp99 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp99 at (2227,1-2227,36) */ -uint32_t __tmp_in_tmp99; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp99; -} -Arr1DIdxRowM(tmp99, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp99 : 0; -} - -uint32_t* tmp100 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp100 at (2230,1-2230,47) */ -uint32_t __tmp_in_tmp100; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp100; -} -Arr4DIdxRowM(tmp100, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp100 : 0; -} -} -} -} - -uint32_t* tmp101 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp101 at (2233,1-2233,37) */ -uint32_t __tmp_in_tmp101; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp101; -} -Arr1DIdxRowM(tmp101, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp101 : 0; -} - -uint32_t* tmp102 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp102 at (2236,1-2236,37) */ -uint32_t __tmp_in_tmp102; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp102; -} -Arr1DIdxRowM(tmp102, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp102 : 0; -} - -uint32_t* tmp103 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp103 at (2239,1-2239,37) */ -uint32_t __tmp_in_tmp103; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp103; -} -Arr1DIdxRowM(tmp103, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp103 : 0; -} - -uint32_t* tmp104 = make_array( (int32_t)224); -/* Variable to read the clear value corresponding to the input variable tmp104 at (2242,1-2242,37) */ -uint32_t __tmp_in_tmp104; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)224; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp104; -} -Arr1DIdxRowM(tmp104, (int32_t)224,i0) = (party == SERVER) ? __tmp_in_tmp104 : 0; -} - -uint32_t* tmp105 = make_array( (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp105 at (2245,1-2245,48) */ -uint32_t __tmp_in_tmp105; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)224; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp105; -} -Arr4DIdxRowM(tmp105, (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp105 : 0; -} -} -} -} - -uint32_t* tmp106 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp106 at (2248,1-2248,37) */ -uint32_t __tmp_in_tmp106; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp106; -} -Arr1DIdxRowM(tmp106, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp106 : 0; -} - -uint32_t* tmp107 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp107 at (2251,1-2251,37) */ -uint32_t __tmp_in_tmp107; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp107; -} -Arr1DIdxRowM(tmp107, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp107 : 0; -} - -uint32_t* tmp108 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp108 at (2254,1-2254,37) */ -uint32_t __tmp_in_tmp108; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp108; -} -Arr1DIdxRowM(tmp108, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp108 : 0; -} - -uint32_t* tmp109 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp109 at (2257,1-2257,37) */ -uint32_t __tmp_in_tmp109; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp109; -} -Arr1DIdxRowM(tmp109, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp109 : 0; -} - -uint32_t* tmp110 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp110 at (2260,1-2260,47) */ -uint32_t __tmp_in_tmp110; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp110; -} -Arr4DIdxRowM(tmp110, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp110 : 0; -} -} -} -} - -uint32_t* tmp111 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp111 at (2263,1-2263,37) */ -uint32_t __tmp_in_tmp111; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp111; -} -Arr1DIdxRowM(tmp111, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp111 : 0; -} - -uint32_t* tmp112 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp112 at (2266,1-2266,37) */ -uint32_t __tmp_in_tmp112; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp112; -} -Arr1DIdxRowM(tmp112, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp112 : 0; -} - -uint32_t* tmp113 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp113 at (2269,1-2269,37) */ -uint32_t __tmp_in_tmp113; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp113; -} -Arr1DIdxRowM(tmp113, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp113 : 0; -} - -uint32_t* tmp114 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp114 at (2272,1-2272,37) */ -uint32_t __tmp_in_tmp114; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp114; -} -Arr1DIdxRowM(tmp114, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp114 : 0; -} - -uint32_t* tmp115 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp115 at (2275,1-2275,48) */ -uint32_t __tmp_in_tmp115; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp115; -} -Arr4DIdxRowM(tmp115, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp115 : 0; -} -} -} -} - -uint32_t* tmp116 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp116 at (2278,1-2278,37) */ -uint32_t __tmp_in_tmp116; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp116; -} -Arr1DIdxRowM(tmp116, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp116 : 0; -} - -uint32_t* tmp117 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp117 at (2281,1-2281,37) */ -uint32_t __tmp_in_tmp117; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp117; -} -Arr1DIdxRowM(tmp117, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp117 : 0; -} - -uint32_t* tmp118 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp118 at (2284,1-2284,37) */ -uint32_t __tmp_in_tmp118; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp118; -} -Arr1DIdxRowM(tmp118, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp118 : 0; -} - -uint32_t* tmp119 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp119 at (2287,1-2287,37) */ -uint32_t __tmp_in_tmp119; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp119; -} -Arr1DIdxRowM(tmp119, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp119 : 0; -} - -uint32_t* tmp120 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp120 at (2290,1-2290,47) */ -uint32_t __tmp_in_tmp120; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp120; -} -Arr4DIdxRowM(tmp120, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp120 : 0; -} -} -} -} - -uint32_t* tmp121 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp121 at (2293,1-2293,37) */ -uint32_t __tmp_in_tmp121; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp121; -} -Arr1DIdxRowM(tmp121, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp121 : 0; -} - -uint32_t* tmp122 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp122 at (2296,1-2296,37) */ -uint32_t __tmp_in_tmp122; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp122; -} -Arr1DIdxRowM(tmp122, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp122 : 0; -} - -uint32_t* tmp123 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp123 at (2299,1-2299,37) */ -uint32_t __tmp_in_tmp123; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp123; -} -Arr1DIdxRowM(tmp123, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp123 : 0; -} - -uint32_t* tmp124 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp124 at (2302,1-2302,37) */ -uint32_t __tmp_in_tmp124; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp124; -} -Arr1DIdxRowM(tmp124, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp124 : 0; -} - -uint32_t* tmp125 = make_array( (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp125 at (2305,1-2305,48) */ -uint32_t __tmp_in_tmp125; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)288; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp125; -} -Arr4DIdxRowM(tmp125, (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp125 : 0; -} -} -} -} - -uint32_t* tmp126 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp126 at (2308,1-2308,37) */ -uint32_t __tmp_in_tmp126; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp126; -} -Arr1DIdxRowM(tmp126, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp126 : 0; -} - -uint32_t* tmp127 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp127 at (2311,1-2311,37) */ -uint32_t __tmp_in_tmp127; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp127; -} -Arr1DIdxRowM(tmp127, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp127 : 0; -} - -uint32_t* tmp128 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp128 at (2314,1-2314,37) */ -uint32_t __tmp_in_tmp128; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp128; -} -Arr1DIdxRowM(tmp128, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp128 : 0; -} - -uint32_t* tmp129 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp129 at (2317,1-2317,37) */ -uint32_t __tmp_in_tmp129; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp129; -} -Arr1DIdxRowM(tmp129, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp129 : 0; -} - -uint32_t* tmp130 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp130 at (2320,1-2320,47) */ -uint32_t __tmp_in_tmp130; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp130; -} -Arr4DIdxRowM(tmp130, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp130 : 0; -} -} -} -} - -uint32_t* tmp131 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp131 at (2323,1-2323,37) */ -uint32_t __tmp_in_tmp131; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp131; -} -Arr1DIdxRowM(tmp131, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp131 : 0; -} - -uint32_t* tmp132 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp132 at (2326,1-2326,37) */ -uint32_t __tmp_in_tmp132; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp132; -} -Arr1DIdxRowM(tmp132, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp132 : 0; -} - -uint32_t* tmp133 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp133 at (2329,1-2329,37) */ -uint32_t __tmp_in_tmp133; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp133; -} -Arr1DIdxRowM(tmp133, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp133 : 0; -} - -uint32_t* tmp134 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp134 at (2332,1-2332,37) */ -uint32_t __tmp_in_tmp134; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp134; -} -Arr1DIdxRowM(tmp134, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp134 : 0; -} - -uint32_t* tmp135 = make_array( (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp135 at (2335,1-2335,48) */ -uint32_t __tmp_in_tmp135; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)320; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp135; -} -Arr4DIdxRowM(tmp135, (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp135 : 0; -} -} -} -} - -uint32_t* tmp136 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp136 at (2338,1-2338,37) */ -uint32_t __tmp_in_tmp136; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp136; -} -Arr1DIdxRowM(tmp136, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp136 : 0; -} - -uint32_t* tmp137 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp137 at (2341,1-2341,37) */ -uint32_t __tmp_in_tmp137; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp137; -} -Arr1DIdxRowM(tmp137, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp137 : 0; -} - -uint32_t* tmp138 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp138 at (2344,1-2344,37) */ -uint32_t __tmp_in_tmp138; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp138; -} -Arr1DIdxRowM(tmp138, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp138 : 0; -} - -uint32_t* tmp139 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp139 at (2347,1-2347,37) */ -uint32_t __tmp_in_tmp139; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp139; -} -Arr1DIdxRowM(tmp139, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp139 : 0; -} - -uint32_t* tmp140 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp140 at (2350,1-2350,47) */ -uint32_t __tmp_in_tmp140; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp140; -} -Arr4DIdxRowM(tmp140, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp140 : 0; -} -} -} -} - -uint32_t* tmp141 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp141 at (2353,1-2353,37) */ -uint32_t __tmp_in_tmp141; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp141; -} -Arr1DIdxRowM(tmp141, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp141 : 0; -} - -uint32_t* tmp142 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp142 at (2356,1-2356,37) */ -uint32_t __tmp_in_tmp142; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp142; -} -Arr1DIdxRowM(tmp142, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp142 : 0; -} - -uint32_t* tmp143 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp143 at (2359,1-2359,37) */ -uint32_t __tmp_in_tmp143; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp143; -} -Arr1DIdxRowM(tmp143, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp143 : 0; -} - -uint32_t* tmp144 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp144 at (2362,1-2362,37) */ -uint32_t __tmp_in_tmp144; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp144; -} -Arr1DIdxRowM(tmp144, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp144 : 0; -} - -uint32_t* tmp145 = make_array( (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp145 at (2365,1-2365,48) */ -uint32_t __tmp_in_tmp145; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)352; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp145; -} -Arr4DIdxRowM(tmp145, (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp145 : 0; -} -} -} -} - -uint32_t* tmp146 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp146 at (2368,1-2368,37) */ -uint32_t __tmp_in_tmp146; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp146; -} -Arr1DIdxRowM(tmp146, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp146 : 0; -} - -uint32_t* tmp147 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp147 at (2371,1-2371,37) */ -uint32_t __tmp_in_tmp147; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp147; -} -Arr1DIdxRowM(tmp147, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp147 : 0; -} - -uint32_t* tmp148 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp148 at (2374,1-2374,37) */ -uint32_t __tmp_in_tmp148; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp148; -} -Arr1DIdxRowM(tmp148, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp148 : 0; -} - -uint32_t* tmp149 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp149 at (2377,1-2377,37) */ -uint32_t __tmp_in_tmp149; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp149; -} -Arr1DIdxRowM(tmp149, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp149 : 0; -} - -uint32_t* tmp150 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp150 at (2380,1-2380,47) */ -uint32_t __tmp_in_tmp150; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp150; -} -Arr4DIdxRowM(tmp150, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp150 : 0; -} -} -} -} - -uint32_t* tmp151 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp151 at (2383,1-2383,37) */ -uint32_t __tmp_in_tmp151; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp151; -} -Arr1DIdxRowM(tmp151, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp151 : 0; -} - -uint32_t* tmp152 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp152 at (2386,1-2386,37) */ -uint32_t __tmp_in_tmp152; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp152; -} -Arr1DIdxRowM(tmp152, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp152 : 0; -} - -uint32_t* tmp153 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp153 at (2389,1-2389,37) */ -uint32_t __tmp_in_tmp153; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp153; -} -Arr1DIdxRowM(tmp153, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp153 : 0; -} - -uint32_t* tmp154 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp154 at (2392,1-2392,37) */ -uint32_t __tmp_in_tmp154; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp154; -} -Arr1DIdxRowM(tmp154, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp154 : 0; -} - -uint32_t* tmp155 = make_array( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp155 at (2395,1-2395,48) */ -uint32_t __tmp_in_tmp155; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)384; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp155; -} -Arr4DIdxRowM(tmp155, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp155 : 0; -} -} -} -} - -uint32_t* tmp156 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp156 at (2398,1-2398,37) */ -uint32_t __tmp_in_tmp156; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp156; -} -Arr1DIdxRowM(tmp156, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp156 : 0; -} - -uint32_t* tmp157 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp157 at (2401,1-2401,37) */ -uint32_t __tmp_in_tmp157; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp157; -} -Arr1DIdxRowM(tmp157, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp157 : 0; -} - -uint32_t* tmp158 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp158 at (2404,1-2404,37) */ -uint32_t __tmp_in_tmp158; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp158; -} -Arr1DIdxRowM(tmp158, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp158 : 0; -} - -uint32_t* tmp159 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp159 at (2407,1-2407,37) */ -uint32_t __tmp_in_tmp159; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp159; -} -Arr1DIdxRowM(tmp159, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp159 : 0; -} - -uint32_t* tmp160 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp160 at (2410,1-2410,47) */ -uint32_t __tmp_in_tmp160; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp160; -} -Arr4DIdxRowM(tmp160, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp160 : 0; -} -} -} -} - -uint32_t* tmp161 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp161 at (2413,1-2413,37) */ -uint32_t __tmp_in_tmp161; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp161; -} -Arr1DIdxRowM(tmp161, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp161 : 0; -} - -uint32_t* tmp162 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp162 at (2416,1-2416,37) */ -uint32_t __tmp_in_tmp162; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp162; -} -Arr1DIdxRowM(tmp162, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp162 : 0; -} - -uint32_t* tmp163 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp163 at (2419,1-2419,37) */ -uint32_t __tmp_in_tmp163; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp163; -} -Arr1DIdxRowM(tmp163, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp163 : 0; -} - -uint32_t* tmp164 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp164 at (2422,1-2422,37) */ -uint32_t __tmp_in_tmp164; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp164; -} -Arr1DIdxRowM(tmp164, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp164 : 0; -} - -uint32_t* tmp165 = make_array( (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp165 at (2425,1-2425,48) */ -uint32_t __tmp_in_tmp165; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)416; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp165; -} -Arr4DIdxRowM(tmp165, (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp165 : 0; -} -} -} -} - -uint32_t* tmp166 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp166 at (2428,1-2428,37) */ -uint32_t __tmp_in_tmp166; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp166; -} -Arr1DIdxRowM(tmp166, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp166 : 0; -} - -uint32_t* tmp167 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp167 at (2431,1-2431,37) */ -uint32_t __tmp_in_tmp167; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp167; -} -Arr1DIdxRowM(tmp167, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp167 : 0; -} - -uint32_t* tmp168 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp168 at (2434,1-2434,37) */ -uint32_t __tmp_in_tmp168; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp168; -} -Arr1DIdxRowM(tmp168, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp168 : 0; -} - -uint32_t* tmp169 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp169 at (2437,1-2437,37) */ -uint32_t __tmp_in_tmp169; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp169; -} -Arr1DIdxRowM(tmp169, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp169 : 0; -} - -uint32_t* tmp170 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp170 at (2440,1-2440,47) */ -uint32_t __tmp_in_tmp170; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp170; -} -Arr4DIdxRowM(tmp170, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp170 : 0; -} -} -} -} - -uint32_t* tmp171 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp171 at (2443,1-2443,37) */ -uint32_t __tmp_in_tmp171; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp171; -} -Arr1DIdxRowM(tmp171, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp171 : 0; -} - -uint32_t* tmp172 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp172 at (2446,1-2446,37) */ -uint32_t __tmp_in_tmp172; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp172; -} -Arr1DIdxRowM(tmp172, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp172 : 0; -} - -uint32_t* tmp173 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp173 at (2449,1-2449,37) */ -uint32_t __tmp_in_tmp173; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp173; -} -Arr1DIdxRowM(tmp173, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp173 : 0; -} - -uint32_t* tmp174 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp174 at (2452,1-2452,37) */ -uint32_t __tmp_in_tmp174; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp174; -} -Arr1DIdxRowM(tmp174, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp174 : 0; -} - -uint32_t* tmp175 = make_array( (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp175 at (2455,1-2455,48) */ -uint32_t __tmp_in_tmp175; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)448; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp175; -} -Arr4DIdxRowM(tmp175, (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp175 : 0; -} -} -} -} - -uint32_t* tmp176 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp176 at (2458,1-2458,37) */ -uint32_t __tmp_in_tmp176; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp176; -} -Arr1DIdxRowM(tmp176, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp176 : 0; -} - -uint32_t* tmp177 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp177 at (2461,1-2461,37) */ -uint32_t __tmp_in_tmp177; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp177; -} -Arr1DIdxRowM(tmp177, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp177 : 0; -} - -uint32_t* tmp178 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp178 at (2464,1-2464,37) */ -uint32_t __tmp_in_tmp178; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp178; -} -Arr1DIdxRowM(tmp178, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp178 : 0; -} - -uint32_t* tmp179 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp179 at (2467,1-2467,37) */ -uint32_t __tmp_in_tmp179; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp179; -} -Arr1DIdxRowM(tmp179, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp179 : 0; -} - -uint32_t* tmp180 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp180 at (2470,1-2470,47) */ -uint32_t __tmp_in_tmp180; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp180; -} -Arr4DIdxRowM(tmp180, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp180 : 0; -} -} -} -} - -uint32_t* tmp181 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp181 at (2473,1-2473,37) */ -uint32_t __tmp_in_tmp181; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp181; -} -Arr1DIdxRowM(tmp181, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp181 : 0; -} - -uint32_t* tmp182 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp182 at (2476,1-2476,37) */ -uint32_t __tmp_in_tmp182; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp182; -} -Arr1DIdxRowM(tmp182, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp182 : 0; -} - -uint32_t* tmp183 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp183 at (2479,1-2479,37) */ -uint32_t __tmp_in_tmp183; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp183; -} -Arr1DIdxRowM(tmp183, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp183 : 0; -} - -uint32_t* tmp184 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp184 at (2482,1-2482,37) */ -uint32_t __tmp_in_tmp184; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp184; -} -Arr1DIdxRowM(tmp184, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp184 : 0; -} - -uint32_t* tmp185 = make_array( (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp185 at (2485,1-2485,48) */ -uint32_t __tmp_in_tmp185; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)480; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp185; -} -Arr4DIdxRowM(tmp185, (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp185 : 0; -} -} -} -} - -uint32_t* tmp186 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp186 at (2488,1-2488,37) */ -uint32_t __tmp_in_tmp186; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp186; -} -Arr1DIdxRowM(tmp186, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp186 : 0; -} - -uint32_t* tmp187 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp187 at (2491,1-2491,37) */ -uint32_t __tmp_in_tmp187; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp187; -} -Arr1DIdxRowM(tmp187, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp187 : 0; -} - -uint32_t* tmp188 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp188 at (2494,1-2494,37) */ -uint32_t __tmp_in_tmp188; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp188; -} -Arr1DIdxRowM(tmp188, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp188 : 0; -} - -uint32_t* tmp189 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp189 at (2497,1-2497,37) */ -uint32_t __tmp_in_tmp189; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp189; -} -Arr1DIdxRowM(tmp189, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp189 : 0; -} - -uint32_t* tmp190 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp190 at (2500,1-2500,47) */ -uint32_t __tmp_in_tmp190; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp190; -} -Arr4DIdxRowM(tmp190, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp190 : 0; -} -} -} -} - -uint32_t* tmp191 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp191 at (2503,1-2503,37) */ -uint32_t __tmp_in_tmp191; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp191; -} -Arr1DIdxRowM(tmp191, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp191 : 0; -} - -uint32_t* tmp192 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp192 at (2506,1-2506,37) */ -uint32_t __tmp_in_tmp192; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp192; -} -Arr1DIdxRowM(tmp192, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp192 : 0; -} - -uint32_t* tmp193 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp193 at (2509,1-2509,37) */ -uint32_t __tmp_in_tmp193; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp193; -} -Arr1DIdxRowM(tmp193, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp193 : 0; -} - -uint32_t* tmp194 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp194 at (2512,1-2512,37) */ -uint32_t __tmp_in_tmp194; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp194; -} -Arr1DIdxRowM(tmp194, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp194 : 0; -} - -uint32_t* tmp195 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp195 at (2515,1-2515,48) */ -uint32_t __tmp_in_tmp195; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp195; -} -Arr4DIdxRowM(tmp195, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp195 : 0; -} -} -} -} - -uint32_t* tmp196 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp196 at (2518,1-2518,37) */ -uint32_t __tmp_in_tmp196; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp196; -} -Arr1DIdxRowM(tmp196, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp196 : 0; -} - -uint32_t* tmp197 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp197 at (2521,1-2521,37) */ -uint32_t __tmp_in_tmp197; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp197; -} -Arr1DIdxRowM(tmp197, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp197 : 0; -} - -uint32_t* tmp198 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp198 at (2524,1-2524,37) */ -uint32_t __tmp_in_tmp198; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp198; -} -Arr1DIdxRowM(tmp198, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp198 : 0; -} - -uint32_t* tmp199 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp199 at (2527,1-2527,37) */ -uint32_t __tmp_in_tmp199; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp199; -} -Arr1DIdxRowM(tmp199, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp199 : 0; -} - -uint32_t* tmp200 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp200 at (2530,1-2530,48) */ -uint32_t __tmp_in_tmp200; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp200; -} -Arr4DIdxRowM(tmp200, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp200 : 0; -} -} -} -} - -uint32_t* tmp201 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp201 at (2533,1-2533,37) */ -uint32_t __tmp_in_tmp201; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp201; -} -Arr1DIdxRowM(tmp201, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp201 : 0; -} - -uint32_t* tmp202 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp202 at (2536,1-2536,37) */ -uint32_t __tmp_in_tmp202; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp202; -} -Arr1DIdxRowM(tmp202, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp202 : 0; -} - -uint32_t* tmp203 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp203 at (2539,1-2539,37) */ -uint32_t __tmp_in_tmp203; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp203; -} -Arr1DIdxRowM(tmp203, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp203 : 0; -} - -uint32_t* tmp204 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp204 at (2542,1-2542,37) */ -uint32_t __tmp_in_tmp204; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp204; -} -Arr1DIdxRowM(tmp204, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp204 : 0; -} - -uint32_t* tmp205 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp205 at (2545,1-2545,47) */ -uint32_t __tmp_in_tmp205; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp205; -} -Arr4DIdxRowM(tmp205, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp205 : 0; -} -} -} -} - -uint32_t* tmp206 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp206 at (2548,1-2548,37) */ -uint32_t __tmp_in_tmp206; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp206; -} -Arr1DIdxRowM(tmp206, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp206 : 0; -} - -uint32_t* tmp207 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp207 at (2551,1-2551,37) */ -uint32_t __tmp_in_tmp207; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp207; -} -Arr1DIdxRowM(tmp207, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp207 : 0; -} - -uint32_t* tmp208 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp208 at (2554,1-2554,37) */ -uint32_t __tmp_in_tmp208; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp208; -} -Arr1DIdxRowM(tmp208, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp208 : 0; -} - -uint32_t* tmp209 = make_array( (int32_t)288); -/* Variable to read the clear value corresponding to the input variable tmp209 at (2557,1-2557,37) */ -uint32_t __tmp_in_tmp209; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)288; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp209; -} -Arr1DIdxRowM(tmp209, (int32_t)288,i0) = (party == SERVER) ? __tmp_in_tmp209 : 0; -} - -uint32_t* tmp210 = make_array( (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp210 at (2560,1-2560,48) */ -uint32_t __tmp_in_tmp210; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)288; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp210; -} -Arr4DIdxRowM(tmp210, (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp210 : 0; -} -} -} -} - -uint32_t* tmp211 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp211 at (2563,1-2563,37) */ -uint32_t __tmp_in_tmp211; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp211; -} -Arr1DIdxRowM(tmp211, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp211 : 0; -} - -uint32_t* tmp212 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp212 at (2566,1-2566,37) */ -uint32_t __tmp_in_tmp212; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp212; -} -Arr1DIdxRowM(tmp212, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp212 : 0; -} - -uint32_t* tmp213 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp213 at (2569,1-2569,37) */ -uint32_t __tmp_in_tmp213; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp213; -} -Arr1DIdxRowM(tmp213, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp213 : 0; -} - -uint32_t* tmp214 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp214 at (2572,1-2572,37) */ -uint32_t __tmp_in_tmp214; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp214; -} -Arr1DIdxRowM(tmp214, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp214 : 0; -} - -uint32_t* tmp215 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp215 at (2575,1-2575,47) */ -uint32_t __tmp_in_tmp215; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp215; -} -Arr4DIdxRowM(tmp215, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp215 : 0; -} -} -} -} - -uint32_t* tmp216 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp216 at (2578,1-2578,37) */ -uint32_t __tmp_in_tmp216; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp216; -} -Arr1DIdxRowM(tmp216, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp216 : 0; -} - -uint32_t* tmp217 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp217 at (2581,1-2581,37) */ -uint32_t __tmp_in_tmp217; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp217; -} -Arr1DIdxRowM(tmp217, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp217 : 0; -} - -uint32_t* tmp218 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp218 at (2584,1-2584,37) */ -uint32_t __tmp_in_tmp218; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp218; -} -Arr1DIdxRowM(tmp218, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp218 : 0; -} - -uint32_t* tmp219 = make_array( (int32_t)320); -/* Variable to read the clear value corresponding to the input variable tmp219 at (2587,1-2587,37) */ -uint32_t __tmp_in_tmp219; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)320; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp219; -} -Arr1DIdxRowM(tmp219, (int32_t)320,i0) = (party == SERVER) ? __tmp_in_tmp219 : 0; -} - -uint32_t* tmp220 = make_array( (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp220 at (2590,1-2590,48) */ -uint32_t __tmp_in_tmp220; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)320; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp220; -} -Arr4DIdxRowM(tmp220, (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp220 : 0; -} -} -} -} - -uint32_t* tmp221 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp221 at (2593,1-2593,37) */ -uint32_t __tmp_in_tmp221; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp221; -} -Arr1DIdxRowM(tmp221, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp221 : 0; -} - -uint32_t* tmp222 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp222 at (2596,1-2596,37) */ -uint32_t __tmp_in_tmp222; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp222; -} -Arr1DIdxRowM(tmp222, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp222 : 0; -} - -uint32_t* tmp223 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp223 at (2599,1-2599,37) */ -uint32_t __tmp_in_tmp223; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp223; -} -Arr1DIdxRowM(tmp223, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp223 : 0; -} - -uint32_t* tmp224 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp224 at (2602,1-2602,37) */ -uint32_t __tmp_in_tmp224; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp224; -} -Arr1DIdxRowM(tmp224, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp224 : 0; -} - -uint32_t* tmp225 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp225 at (2605,1-2605,47) */ -uint32_t __tmp_in_tmp225; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp225; -} -Arr4DIdxRowM(tmp225, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp225 : 0; -} -} -} -} - -uint32_t* tmp226 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp226 at (2608,1-2608,37) */ -uint32_t __tmp_in_tmp226; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp226; -} -Arr1DIdxRowM(tmp226, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp226 : 0; -} - -uint32_t* tmp227 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp227 at (2611,1-2611,37) */ -uint32_t __tmp_in_tmp227; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp227; -} -Arr1DIdxRowM(tmp227, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp227 : 0; -} - -uint32_t* tmp228 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp228 at (2614,1-2614,37) */ -uint32_t __tmp_in_tmp228; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp228; -} -Arr1DIdxRowM(tmp228, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp228 : 0; -} - -uint32_t* tmp229 = make_array( (int32_t)352); -/* Variable to read the clear value corresponding to the input variable tmp229 at (2617,1-2617,37) */ -uint32_t __tmp_in_tmp229; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)352; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp229; -} -Arr1DIdxRowM(tmp229, (int32_t)352,i0) = (party == SERVER) ? __tmp_in_tmp229 : 0; -} - -uint32_t* tmp230 = make_array( (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp230 at (2620,1-2620,48) */ -uint32_t __tmp_in_tmp230; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)352; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp230; -} -Arr4DIdxRowM(tmp230, (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp230 : 0; -} -} -} -} - -uint32_t* tmp231 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp231 at (2623,1-2623,37) */ -uint32_t __tmp_in_tmp231; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp231; -} -Arr1DIdxRowM(tmp231, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp231 : 0; -} - -uint32_t* tmp232 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp232 at (2626,1-2626,37) */ -uint32_t __tmp_in_tmp232; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp232; -} -Arr1DIdxRowM(tmp232, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp232 : 0; -} - -uint32_t* tmp233 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp233 at (2629,1-2629,37) */ -uint32_t __tmp_in_tmp233; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp233; -} -Arr1DIdxRowM(tmp233, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp233 : 0; -} - -uint32_t* tmp234 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp234 at (2632,1-2632,37) */ -uint32_t __tmp_in_tmp234; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp234; -} -Arr1DIdxRowM(tmp234, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp234 : 0; -} - -uint32_t* tmp235 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp235 at (2635,1-2635,47) */ -uint32_t __tmp_in_tmp235; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp235; -} -Arr4DIdxRowM(tmp235, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp235 : 0; -} -} -} -} - -uint32_t* tmp236 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp236 at (2638,1-2638,37) */ -uint32_t __tmp_in_tmp236; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp236; -} -Arr1DIdxRowM(tmp236, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp236 : 0; -} - -uint32_t* tmp237 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp237 at (2641,1-2641,37) */ -uint32_t __tmp_in_tmp237; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp237; -} -Arr1DIdxRowM(tmp237, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp237 : 0; -} - -uint32_t* tmp238 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp238 at (2644,1-2644,37) */ -uint32_t __tmp_in_tmp238; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp238; -} -Arr1DIdxRowM(tmp238, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp238 : 0; -} - -uint32_t* tmp239 = make_array( (int32_t)384); -/* Variable to read the clear value corresponding to the input variable tmp239 at (2647,1-2647,37) */ -uint32_t __tmp_in_tmp239; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)384; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp239; -} -Arr1DIdxRowM(tmp239, (int32_t)384,i0) = (party == SERVER) ? __tmp_in_tmp239 : 0; -} - -uint32_t* tmp240 = make_array( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp240 at (2650,1-2650,48) */ -uint32_t __tmp_in_tmp240; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)384; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp240; -} -Arr4DIdxRowM(tmp240, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp240 : 0; -} -} -} -} - -uint32_t* tmp241 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp241 at (2653,1-2653,37) */ -uint32_t __tmp_in_tmp241; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp241; -} -Arr1DIdxRowM(tmp241, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp241 : 0; -} - -uint32_t* tmp242 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp242 at (2656,1-2656,37) */ -uint32_t __tmp_in_tmp242; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp242; -} -Arr1DIdxRowM(tmp242, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp242 : 0; -} - -uint32_t* tmp243 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp243 at (2659,1-2659,37) */ -uint32_t __tmp_in_tmp243; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp243; -} -Arr1DIdxRowM(tmp243, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp243 : 0; -} - -uint32_t* tmp244 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp244 at (2662,1-2662,37) */ -uint32_t __tmp_in_tmp244; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp244; -} -Arr1DIdxRowM(tmp244, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp244 : 0; -} - -uint32_t* tmp245 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp245 at (2665,1-2665,47) */ -uint32_t __tmp_in_tmp245; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp245; -} -Arr4DIdxRowM(tmp245, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp245 : 0; -} -} -} -} - -uint32_t* tmp246 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp246 at (2668,1-2668,37) */ -uint32_t __tmp_in_tmp246; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp246; -} -Arr1DIdxRowM(tmp246, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp246 : 0; -} - -uint32_t* tmp247 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp247 at (2671,1-2671,37) */ -uint32_t __tmp_in_tmp247; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp247; -} -Arr1DIdxRowM(tmp247, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp247 : 0; -} - -uint32_t* tmp248 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp248 at (2674,1-2674,37) */ -uint32_t __tmp_in_tmp248; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp248; -} -Arr1DIdxRowM(tmp248, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp248 : 0; -} - -uint32_t* tmp249 = make_array( (int32_t)416); -/* Variable to read the clear value corresponding to the input variable tmp249 at (2677,1-2677,37) */ -uint32_t __tmp_in_tmp249; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)416; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp249; -} -Arr1DIdxRowM(tmp249, (int32_t)416,i0) = (party == SERVER) ? __tmp_in_tmp249 : 0; -} - -uint32_t* tmp250 = make_array( (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp250 at (2680,1-2680,48) */ -uint32_t __tmp_in_tmp250; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)416; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp250; -} -Arr4DIdxRowM(tmp250, (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp250 : 0; -} -} -} -} - -uint32_t* tmp251 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp251 at (2683,1-2683,37) */ -uint32_t __tmp_in_tmp251; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp251; -} -Arr1DIdxRowM(tmp251, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp251 : 0; -} - -uint32_t* tmp252 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp252 at (2686,1-2686,37) */ -uint32_t __tmp_in_tmp252; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp252; -} -Arr1DIdxRowM(tmp252, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp252 : 0; -} - -uint32_t* tmp253 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp253 at (2689,1-2689,37) */ -uint32_t __tmp_in_tmp253; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp253; -} -Arr1DIdxRowM(tmp253, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp253 : 0; -} - -uint32_t* tmp254 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp254 at (2692,1-2692,37) */ -uint32_t __tmp_in_tmp254; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp254; -} -Arr1DIdxRowM(tmp254, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp254 : 0; -} - -uint32_t* tmp255 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp255 at (2695,1-2695,47) */ -uint32_t __tmp_in_tmp255; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp255; -} -Arr4DIdxRowM(tmp255, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp255 : 0; -} -} -} -} - -uint32_t* tmp256 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp256 at (2698,1-2698,37) */ -uint32_t __tmp_in_tmp256; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp256; -} -Arr1DIdxRowM(tmp256, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp256 : 0; -} - -uint32_t* tmp257 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp257 at (2701,1-2701,37) */ -uint32_t __tmp_in_tmp257; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp257; -} -Arr1DIdxRowM(tmp257, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp257 : 0; -} - -uint32_t* tmp258 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp258 at (2704,1-2704,37) */ -uint32_t __tmp_in_tmp258; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp258; -} -Arr1DIdxRowM(tmp258, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp258 : 0; -} - -uint32_t* tmp259 = make_array( (int32_t)448); -/* Variable to read the clear value corresponding to the input variable tmp259 at (2707,1-2707,37) */ -uint32_t __tmp_in_tmp259; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)448; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp259; -} -Arr1DIdxRowM(tmp259, (int32_t)448,i0) = (party == SERVER) ? __tmp_in_tmp259 : 0; -} - -uint32_t* tmp260 = make_array( (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp260 at (2710,1-2710,48) */ -uint32_t __tmp_in_tmp260; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)448; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp260; -} -Arr4DIdxRowM(tmp260, (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp260 : 0; -} -} -} -} - -uint32_t* tmp261 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp261 at (2713,1-2713,37) */ -uint32_t __tmp_in_tmp261; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp261; -} -Arr1DIdxRowM(tmp261, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp261 : 0; -} - -uint32_t* tmp262 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp262 at (2716,1-2716,37) */ -uint32_t __tmp_in_tmp262; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp262; -} -Arr1DIdxRowM(tmp262, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp262 : 0; -} - -uint32_t* tmp263 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp263 at (2719,1-2719,37) */ -uint32_t __tmp_in_tmp263; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp263; -} -Arr1DIdxRowM(tmp263, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp263 : 0; -} - -uint32_t* tmp264 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp264 at (2722,1-2722,37) */ -uint32_t __tmp_in_tmp264; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp264; -} -Arr1DIdxRowM(tmp264, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp264 : 0; -} - -uint32_t* tmp265 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp265 at (2725,1-2725,47) */ -uint32_t __tmp_in_tmp265; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp265; -} -Arr4DIdxRowM(tmp265, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp265 : 0; -} -} -} -} - -uint32_t* tmp266 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp266 at (2728,1-2728,37) */ -uint32_t __tmp_in_tmp266; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp266; -} -Arr1DIdxRowM(tmp266, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp266 : 0; -} - -uint32_t* tmp267 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp267 at (2731,1-2731,37) */ -uint32_t __tmp_in_tmp267; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp267; -} -Arr1DIdxRowM(tmp267, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp267 : 0; -} - -uint32_t* tmp268 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp268 at (2734,1-2734,37) */ -uint32_t __tmp_in_tmp268; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp268; -} -Arr1DIdxRowM(tmp268, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp268 : 0; -} - -uint32_t* tmp269 = make_array( (int32_t)480); -/* Variable to read the clear value corresponding to the input variable tmp269 at (2737,1-2737,37) */ -uint32_t __tmp_in_tmp269; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)480; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp269; -} -Arr1DIdxRowM(tmp269, (int32_t)480,i0) = (party == SERVER) ? __tmp_in_tmp269 : 0; -} - -uint32_t* tmp270 = make_array( (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp270 at (2740,1-2740,48) */ -uint32_t __tmp_in_tmp270; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)480; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp270; -} -Arr4DIdxRowM(tmp270, (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp270 : 0; -} -} -} -} - -uint32_t* tmp271 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp271 at (2743,1-2743,37) */ -uint32_t __tmp_in_tmp271; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp271; -} -Arr1DIdxRowM(tmp271, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp271 : 0; -} - -uint32_t* tmp272 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp272 at (2746,1-2746,37) */ -uint32_t __tmp_in_tmp272; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp272; -} -Arr1DIdxRowM(tmp272, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp272 : 0; -} - -uint32_t* tmp273 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp273 at (2749,1-2749,37) */ -uint32_t __tmp_in_tmp273; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp273; -} -Arr1DIdxRowM(tmp273, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp273 : 0; -} - -uint32_t* tmp274 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp274 at (2752,1-2752,37) */ -uint32_t __tmp_in_tmp274; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp274; -} -Arr1DIdxRowM(tmp274, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp274 : 0; -} - -uint32_t* tmp275 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp275 at (2755,1-2755,47) */ -uint32_t __tmp_in_tmp275; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp275; -} -Arr4DIdxRowM(tmp275, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp275 : 0; -} -} -} -} - -uint32_t* tmp276 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp276 at (2758,1-2758,37) */ -uint32_t __tmp_in_tmp276; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp276; -} -Arr1DIdxRowM(tmp276, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp276 : 0; -} - -uint32_t* tmp277 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp277 at (2761,1-2761,37) */ -uint32_t __tmp_in_tmp277; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp277; -} -Arr1DIdxRowM(tmp277, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp277 : 0; -} - -uint32_t* tmp278 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp278 at (2764,1-2764,37) */ -uint32_t __tmp_in_tmp278; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp278; -} -Arr1DIdxRowM(tmp278, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp278 : 0; -} - -uint32_t* tmp279 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp279 at (2767,1-2767,37) */ -uint32_t __tmp_in_tmp279; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp279; -} -Arr1DIdxRowM(tmp279, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp279 : 0; -} - -uint32_t* tmp280 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp280 at (2770,1-2770,48) */ -uint32_t __tmp_in_tmp280; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp280; -} -Arr4DIdxRowM(tmp280, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp280 : 0; -} -} -} -} - -uint32_t* tmp281 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp281 at (2773,1-2773,37) */ -uint32_t __tmp_in_tmp281; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp281; -} -Arr1DIdxRowM(tmp281, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp281 : 0; -} - -uint32_t* tmp282 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp282 at (2776,1-2776,37) */ -uint32_t __tmp_in_tmp282; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp282; -} -Arr1DIdxRowM(tmp282, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp282 : 0; -} - -uint32_t* tmp283 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp283 at (2779,1-2779,37) */ -uint32_t __tmp_in_tmp283; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp283; -} -Arr1DIdxRowM(tmp283, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp283 : 0; -} - -uint32_t* tmp284 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp284 at (2782,1-2782,37) */ -uint32_t __tmp_in_tmp284; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp284; -} -Arr1DIdxRowM(tmp284, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp284 : 0; -} - -uint32_t* tmp285 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp285 at (2785,1-2785,47) */ -uint32_t __tmp_in_tmp285; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp285; -} -Arr4DIdxRowM(tmp285, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp285 : 0; -} -} -} -} - -uint32_t* tmp286 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp286 at (2788,1-2788,37) */ -uint32_t __tmp_in_tmp286; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp286; -} -Arr1DIdxRowM(tmp286, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp286 : 0; -} - -uint32_t* tmp287 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp287 at (2791,1-2791,37) */ -uint32_t __tmp_in_tmp287; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp287; -} -Arr1DIdxRowM(tmp287, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp287 : 0; -} - -uint32_t* tmp288 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp288 at (2794,1-2794,37) */ -uint32_t __tmp_in_tmp288; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp288; -} -Arr1DIdxRowM(tmp288, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp288 : 0; -} - -uint32_t* tmp289 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp289 at (2797,1-2797,37) */ -uint32_t __tmp_in_tmp289; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp289; -} -Arr1DIdxRowM(tmp289, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp289 : 0; -} - -uint32_t* tmp290 = make_array( (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp290 at (2800,1-2800,48) */ -uint32_t __tmp_in_tmp290; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)544; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp290; -} -Arr4DIdxRowM(tmp290, (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp290 : 0; -} -} -} -} - -uint32_t* tmp291 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp291 at (2803,1-2803,37) */ -uint32_t __tmp_in_tmp291; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp291; -} -Arr1DIdxRowM(tmp291, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp291 : 0; -} - -uint32_t* tmp292 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp292 at (2806,1-2806,37) */ -uint32_t __tmp_in_tmp292; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp292; -} -Arr1DIdxRowM(tmp292, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp292 : 0; -} - -uint32_t* tmp293 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp293 at (2809,1-2809,37) */ -uint32_t __tmp_in_tmp293; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp293; -} -Arr1DIdxRowM(tmp293, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp293 : 0; -} - -uint32_t* tmp294 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp294 at (2812,1-2812,37) */ -uint32_t __tmp_in_tmp294; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp294; -} -Arr1DIdxRowM(tmp294, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp294 : 0; -} - -uint32_t* tmp295 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp295 at (2815,1-2815,47) */ -uint32_t __tmp_in_tmp295; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp295; -} -Arr4DIdxRowM(tmp295, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp295 : 0; -} -} -} -} - -uint32_t* tmp296 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp296 at (2818,1-2818,37) */ -uint32_t __tmp_in_tmp296; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp296; -} -Arr1DIdxRowM(tmp296, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp296 : 0; -} - -uint32_t* tmp297 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp297 at (2821,1-2821,37) */ -uint32_t __tmp_in_tmp297; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp297; -} -Arr1DIdxRowM(tmp297, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp297 : 0; -} - -uint32_t* tmp298 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp298 at (2824,1-2824,37) */ -uint32_t __tmp_in_tmp298; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp298; -} -Arr1DIdxRowM(tmp298, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp298 : 0; -} - -uint32_t* tmp299 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp299 at (2827,1-2827,37) */ -uint32_t __tmp_in_tmp299; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp299; -} -Arr1DIdxRowM(tmp299, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp299 : 0; -} - -uint32_t* tmp300 = make_array( (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp300 at (2830,1-2830,48) */ -uint32_t __tmp_in_tmp300; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)576; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp300; -} -Arr4DIdxRowM(tmp300, (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp300 : 0; -} -} -} -} - -uint32_t* tmp301 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp301 at (2833,1-2833,37) */ -uint32_t __tmp_in_tmp301; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp301; -} -Arr1DIdxRowM(tmp301, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp301 : 0; -} - -uint32_t* tmp302 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp302 at (2836,1-2836,37) */ -uint32_t __tmp_in_tmp302; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp302; -} -Arr1DIdxRowM(tmp302, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp302 : 0; -} - -uint32_t* tmp303 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp303 at (2839,1-2839,37) */ -uint32_t __tmp_in_tmp303; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp303; -} -Arr1DIdxRowM(tmp303, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp303 : 0; -} - -uint32_t* tmp304 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp304 at (2842,1-2842,37) */ -uint32_t __tmp_in_tmp304; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp304; -} -Arr1DIdxRowM(tmp304, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp304 : 0; -} - -uint32_t* tmp305 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp305 at (2845,1-2845,47) */ -uint32_t __tmp_in_tmp305; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp305; -} -Arr4DIdxRowM(tmp305, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp305 : 0; -} -} -} -} - -uint32_t* tmp306 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp306 at (2848,1-2848,37) */ -uint32_t __tmp_in_tmp306; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp306; -} -Arr1DIdxRowM(tmp306, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp306 : 0; -} - -uint32_t* tmp307 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp307 at (2851,1-2851,37) */ -uint32_t __tmp_in_tmp307; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp307; -} -Arr1DIdxRowM(tmp307, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp307 : 0; -} - -uint32_t* tmp308 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp308 at (2854,1-2854,37) */ -uint32_t __tmp_in_tmp308; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp308; -} -Arr1DIdxRowM(tmp308, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp308 : 0; -} - -uint32_t* tmp309 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp309 at (2857,1-2857,37) */ -uint32_t __tmp_in_tmp309; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp309; -} -Arr1DIdxRowM(tmp309, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp309 : 0; -} - -uint32_t* tmp310 = make_array( (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp310 at (2860,1-2860,48) */ -uint32_t __tmp_in_tmp310; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)608; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp310; -} -Arr4DIdxRowM(tmp310, (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp310 : 0; -} -} -} -} - -uint32_t* tmp311 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp311 at (2863,1-2863,37) */ -uint32_t __tmp_in_tmp311; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp311; -} -Arr1DIdxRowM(tmp311, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp311 : 0; -} - -uint32_t* tmp312 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp312 at (2866,1-2866,37) */ -uint32_t __tmp_in_tmp312; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp312; -} -Arr1DIdxRowM(tmp312, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp312 : 0; -} - -uint32_t* tmp313 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp313 at (2869,1-2869,37) */ -uint32_t __tmp_in_tmp313; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp313; -} -Arr1DIdxRowM(tmp313, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp313 : 0; -} - -uint32_t* tmp314 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp314 at (2872,1-2872,37) */ -uint32_t __tmp_in_tmp314; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp314; -} -Arr1DIdxRowM(tmp314, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp314 : 0; -} - -uint32_t* tmp315 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp315 at (2875,1-2875,47) */ -uint32_t __tmp_in_tmp315; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp315; -} -Arr4DIdxRowM(tmp315, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp315 : 0; -} -} -} -} - -uint32_t* tmp316 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp316 at (2878,1-2878,37) */ -uint32_t __tmp_in_tmp316; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp316; -} -Arr1DIdxRowM(tmp316, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp316 : 0; -} - -uint32_t* tmp317 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp317 at (2881,1-2881,37) */ -uint32_t __tmp_in_tmp317; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp317; -} -Arr1DIdxRowM(tmp317, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp317 : 0; -} - -uint32_t* tmp318 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp318 at (2884,1-2884,37) */ -uint32_t __tmp_in_tmp318; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp318; -} -Arr1DIdxRowM(tmp318, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp318 : 0; -} - -uint32_t* tmp319 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp319 at (2887,1-2887,37) */ -uint32_t __tmp_in_tmp319; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp319; -} -Arr1DIdxRowM(tmp319, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp319 : 0; -} - -uint32_t* tmp320 = make_array( (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp320 at (2890,1-2890,48) */ -uint32_t __tmp_in_tmp320; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)640; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp320; -} -Arr4DIdxRowM(tmp320, (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp320 : 0; -} -} -} -} - -uint32_t* tmp321 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp321 at (2893,1-2893,37) */ -uint32_t __tmp_in_tmp321; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp321; -} -Arr1DIdxRowM(tmp321, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp321 : 0; -} - -uint32_t* tmp322 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp322 at (2896,1-2896,37) */ -uint32_t __tmp_in_tmp322; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp322; -} -Arr1DIdxRowM(tmp322, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp322 : 0; -} - -uint32_t* tmp323 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp323 at (2899,1-2899,37) */ -uint32_t __tmp_in_tmp323; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp323; -} -Arr1DIdxRowM(tmp323, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp323 : 0; -} - -uint32_t* tmp324 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp324 at (2902,1-2902,37) */ -uint32_t __tmp_in_tmp324; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp324; -} -Arr1DIdxRowM(tmp324, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp324 : 0; -} - -uint32_t* tmp325 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp325 at (2905,1-2905,47) */ -uint32_t __tmp_in_tmp325; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp325; -} -Arr4DIdxRowM(tmp325, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp325 : 0; -} -} -} -} - -uint32_t* tmp326 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp326 at (2908,1-2908,37) */ -uint32_t __tmp_in_tmp326; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp326; -} -Arr1DIdxRowM(tmp326, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp326 : 0; -} - -uint32_t* tmp327 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp327 at (2911,1-2911,37) */ -uint32_t __tmp_in_tmp327; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp327; -} -Arr1DIdxRowM(tmp327, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp327 : 0; -} - -uint32_t* tmp328 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp328 at (2914,1-2914,37) */ -uint32_t __tmp_in_tmp328; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp328; -} -Arr1DIdxRowM(tmp328, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp328 : 0; -} - -uint32_t* tmp329 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp329 at (2917,1-2917,37) */ -uint32_t __tmp_in_tmp329; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp329; -} -Arr1DIdxRowM(tmp329, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp329 : 0; -} - -uint32_t* tmp330 = make_array( (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp330 at (2920,1-2920,48) */ -uint32_t __tmp_in_tmp330; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)672; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp330; -} -Arr4DIdxRowM(tmp330, (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp330 : 0; -} -} -} -} - -uint32_t* tmp331 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp331 at (2923,1-2923,37) */ -uint32_t __tmp_in_tmp331; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp331; -} -Arr1DIdxRowM(tmp331, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp331 : 0; -} - -uint32_t* tmp332 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp332 at (2926,1-2926,37) */ -uint32_t __tmp_in_tmp332; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp332; -} -Arr1DIdxRowM(tmp332, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp332 : 0; -} - -uint32_t* tmp333 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp333 at (2929,1-2929,37) */ -uint32_t __tmp_in_tmp333; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp333; -} -Arr1DIdxRowM(tmp333, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp333 : 0; -} - -uint32_t* tmp334 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp334 at (2932,1-2932,37) */ -uint32_t __tmp_in_tmp334; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp334; -} -Arr1DIdxRowM(tmp334, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp334 : 0; -} - -uint32_t* tmp335 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp335 at (2935,1-2935,47) */ -uint32_t __tmp_in_tmp335; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp335; -} -Arr4DIdxRowM(tmp335, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp335 : 0; -} -} -} -} - -uint32_t* tmp336 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp336 at (2938,1-2938,37) */ -uint32_t __tmp_in_tmp336; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp336; -} -Arr1DIdxRowM(tmp336, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp336 : 0; -} - -uint32_t* tmp337 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp337 at (2941,1-2941,37) */ -uint32_t __tmp_in_tmp337; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp337; -} -Arr1DIdxRowM(tmp337, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp337 : 0; -} - -uint32_t* tmp338 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp338 at (2944,1-2944,37) */ -uint32_t __tmp_in_tmp338; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp338; -} -Arr1DIdxRowM(tmp338, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp338 : 0; -} - -uint32_t* tmp339 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp339 at (2947,1-2947,37) */ -uint32_t __tmp_in_tmp339; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp339; -} -Arr1DIdxRowM(tmp339, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp339 : 0; -} - -uint32_t* tmp340 = make_array( (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp340 at (2950,1-2950,48) */ -uint32_t __tmp_in_tmp340; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)704; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp340; -} -Arr4DIdxRowM(tmp340, (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp340 : 0; -} -} -} -} - -uint32_t* tmp341 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp341 at (2953,1-2953,37) */ -uint32_t __tmp_in_tmp341; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp341; -} -Arr1DIdxRowM(tmp341, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp341 : 0; -} - -uint32_t* tmp342 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp342 at (2956,1-2956,37) */ -uint32_t __tmp_in_tmp342; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp342; -} -Arr1DIdxRowM(tmp342, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp342 : 0; -} - -uint32_t* tmp343 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp343 at (2959,1-2959,37) */ -uint32_t __tmp_in_tmp343; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp343; -} -Arr1DIdxRowM(tmp343, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp343 : 0; -} - -uint32_t* tmp344 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp344 at (2962,1-2962,37) */ -uint32_t __tmp_in_tmp344; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp344; -} -Arr1DIdxRowM(tmp344, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp344 : 0; -} - -uint32_t* tmp345 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp345 at (2965,1-2965,47) */ -uint32_t __tmp_in_tmp345; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp345; -} -Arr4DIdxRowM(tmp345, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp345 : 0; -} -} -} -} - -uint32_t* tmp346 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp346 at (2968,1-2968,37) */ -uint32_t __tmp_in_tmp346; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp346; -} -Arr1DIdxRowM(tmp346, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp346 : 0; -} - -uint32_t* tmp347 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp347 at (2971,1-2971,37) */ -uint32_t __tmp_in_tmp347; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp347; -} -Arr1DIdxRowM(tmp347, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp347 : 0; -} - -uint32_t* tmp348 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp348 at (2974,1-2974,37) */ -uint32_t __tmp_in_tmp348; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp348; -} -Arr1DIdxRowM(tmp348, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp348 : 0; -} - -uint32_t* tmp349 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp349 at (2977,1-2977,37) */ -uint32_t __tmp_in_tmp349; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp349; -} -Arr1DIdxRowM(tmp349, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp349 : 0; -} - -uint32_t* tmp350 = make_array( (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp350 at (2980,1-2980,48) */ -uint32_t __tmp_in_tmp350; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)736; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp350; -} -Arr4DIdxRowM(tmp350, (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp350 : 0; -} -} -} -} - -uint32_t* tmp351 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp351 at (2983,1-2983,37) */ -uint32_t __tmp_in_tmp351; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp351; -} -Arr1DIdxRowM(tmp351, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp351 : 0; -} - -uint32_t* tmp352 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp352 at (2986,1-2986,37) */ -uint32_t __tmp_in_tmp352; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp352; -} -Arr1DIdxRowM(tmp352, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp352 : 0; -} - -uint32_t* tmp353 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp353 at (2989,1-2989,37) */ -uint32_t __tmp_in_tmp353; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp353; -} -Arr1DIdxRowM(tmp353, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp353 : 0; -} - -uint32_t* tmp354 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp354 at (2992,1-2992,37) */ -uint32_t __tmp_in_tmp354; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp354; -} -Arr1DIdxRowM(tmp354, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp354 : 0; -} - -uint32_t* tmp355 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp355 at (2995,1-2995,47) */ -uint32_t __tmp_in_tmp355; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp355; -} -Arr4DIdxRowM(tmp355, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp355 : 0; -} -} -} -} - -uint32_t* tmp356 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp356 at (2998,1-2998,37) */ -uint32_t __tmp_in_tmp356; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp356; -} -Arr1DIdxRowM(tmp356, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp356 : 0; -} - -uint32_t* tmp357 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp357 at (3001,1-3001,37) */ -uint32_t __tmp_in_tmp357; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp357; -} -Arr1DIdxRowM(tmp357, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp357 : 0; -} - -uint32_t* tmp358 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp358 at (3004,1-3004,37) */ -uint32_t __tmp_in_tmp358; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp358; -} -Arr1DIdxRowM(tmp358, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp358 : 0; -} - -uint32_t* tmp359 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp359 at (3007,1-3007,37) */ -uint32_t __tmp_in_tmp359; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp359; -} -Arr1DIdxRowM(tmp359, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp359 : 0; -} - -uint32_t* tmp360 = make_array( (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp360 at (3010,1-3010,48) */ -uint32_t __tmp_in_tmp360; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)768; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp360; -} -Arr4DIdxRowM(tmp360, (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp360 : 0; -} -} -} -} - -uint32_t* tmp361 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp361 at (3013,1-3013,37) */ -uint32_t __tmp_in_tmp361; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp361; -} -Arr1DIdxRowM(tmp361, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp361 : 0; -} - -uint32_t* tmp362 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp362 at (3016,1-3016,37) */ -uint32_t __tmp_in_tmp362; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp362; -} -Arr1DIdxRowM(tmp362, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp362 : 0; -} - -uint32_t* tmp363 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp363 at (3019,1-3019,37) */ -uint32_t __tmp_in_tmp363; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp363; -} -Arr1DIdxRowM(tmp363, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp363 : 0; -} - -uint32_t* tmp364 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp364 at (3022,1-3022,37) */ -uint32_t __tmp_in_tmp364; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp364; -} -Arr1DIdxRowM(tmp364, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp364 : 0; -} - -uint32_t* tmp365 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp365 at (3025,1-3025,47) */ -uint32_t __tmp_in_tmp365; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp365; -} -Arr4DIdxRowM(tmp365, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp365 : 0; -} -} -} -} - -uint32_t* tmp366 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp366 at (3028,1-3028,37) */ -uint32_t __tmp_in_tmp366; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp366; -} -Arr1DIdxRowM(tmp366, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp366 : 0; -} - -uint32_t* tmp367 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp367 at (3031,1-3031,37) */ -uint32_t __tmp_in_tmp367; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp367; -} -Arr1DIdxRowM(tmp367, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp367 : 0; -} - -uint32_t* tmp368 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp368 at (3034,1-3034,37) */ -uint32_t __tmp_in_tmp368; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp368; -} -Arr1DIdxRowM(tmp368, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp368 : 0; -} - -uint32_t* tmp369 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp369 at (3037,1-3037,37) */ -uint32_t __tmp_in_tmp369; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp369; -} -Arr1DIdxRowM(tmp369, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp369 : 0; -} - -uint32_t* tmp370 = make_array( (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp370 at (3040,1-3040,48) */ -uint32_t __tmp_in_tmp370; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)800; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp370; -} -Arr4DIdxRowM(tmp370, (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp370 : 0; -} -} -} -} - -uint32_t* tmp371 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp371 at (3043,1-3043,37) */ -uint32_t __tmp_in_tmp371; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp371; -} -Arr1DIdxRowM(tmp371, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp371 : 0; -} - -uint32_t* tmp372 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp372 at (3046,1-3046,37) */ -uint32_t __tmp_in_tmp372; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp372; -} -Arr1DIdxRowM(tmp372, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp372 : 0; -} - -uint32_t* tmp373 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp373 at (3049,1-3049,37) */ -uint32_t __tmp_in_tmp373; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp373; -} -Arr1DIdxRowM(tmp373, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp373 : 0; -} - -uint32_t* tmp374 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp374 at (3052,1-3052,37) */ -uint32_t __tmp_in_tmp374; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp374; -} -Arr1DIdxRowM(tmp374, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp374 : 0; -} - -uint32_t* tmp375 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp375 at (3055,1-3055,47) */ -uint32_t __tmp_in_tmp375; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp375; -} -Arr4DIdxRowM(tmp375, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp375 : 0; -} -} -} -} - -uint32_t* tmp376 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp376 at (3058,1-3058,37) */ -uint32_t __tmp_in_tmp376; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp376; -} -Arr1DIdxRowM(tmp376, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp376 : 0; -} - -uint32_t* tmp377 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp377 at (3061,1-3061,37) */ -uint32_t __tmp_in_tmp377; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp377; -} -Arr1DIdxRowM(tmp377, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp377 : 0; -} - -uint32_t* tmp378 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp378 at (3064,1-3064,37) */ -uint32_t __tmp_in_tmp378; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp378; -} -Arr1DIdxRowM(tmp378, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp378 : 0; -} - -uint32_t* tmp379 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp379 at (3067,1-3067,37) */ -uint32_t __tmp_in_tmp379; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp379; -} -Arr1DIdxRowM(tmp379, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp379 : 0; -} - -uint32_t* tmp380 = make_array( (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp380 at (3070,1-3070,48) */ -uint32_t __tmp_in_tmp380; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)832; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp380; -} -Arr4DIdxRowM(tmp380, (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp380 : 0; -} -} -} -} - -uint32_t* tmp381 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp381 at (3073,1-3073,37) */ -uint32_t __tmp_in_tmp381; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp381; -} -Arr1DIdxRowM(tmp381, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp381 : 0; -} - -uint32_t* tmp382 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp382 at (3076,1-3076,37) */ -uint32_t __tmp_in_tmp382; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp382; -} -Arr1DIdxRowM(tmp382, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp382 : 0; -} - -uint32_t* tmp383 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp383 at (3079,1-3079,37) */ -uint32_t __tmp_in_tmp383; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp383; -} -Arr1DIdxRowM(tmp383, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp383 : 0; -} - -uint32_t* tmp384 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp384 at (3082,1-3082,37) */ -uint32_t __tmp_in_tmp384; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp384; -} -Arr1DIdxRowM(tmp384, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp384 : 0; -} - -uint32_t* tmp385 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp385 at (3085,1-3085,47) */ -uint32_t __tmp_in_tmp385; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp385; -} -Arr4DIdxRowM(tmp385, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp385 : 0; -} -} -} -} - -uint32_t* tmp386 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp386 at (3088,1-3088,37) */ -uint32_t __tmp_in_tmp386; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp386; -} -Arr1DIdxRowM(tmp386, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp386 : 0; -} - -uint32_t* tmp387 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp387 at (3091,1-3091,37) */ -uint32_t __tmp_in_tmp387; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp387; -} -Arr1DIdxRowM(tmp387, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp387 : 0; -} - -uint32_t* tmp388 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp388 at (3094,1-3094,37) */ -uint32_t __tmp_in_tmp388; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp388; -} -Arr1DIdxRowM(tmp388, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp388 : 0; -} - -uint32_t* tmp389 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp389 at (3097,1-3097,37) */ -uint32_t __tmp_in_tmp389; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp389; -} -Arr1DIdxRowM(tmp389, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp389 : 0; -} - -uint32_t* tmp390 = make_array( (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp390 at (3100,1-3100,48) */ -uint32_t __tmp_in_tmp390; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)864; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp390; -} -Arr4DIdxRowM(tmp390, (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp390 : 0; -} -} -} -} - -uint32_t* tmp391 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp391 at (3103,1-3103,37) */ -uint32_t __tmp_in_tmp391; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp391; -} -Arr1DIdxRowM(tmp391, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp391 : 0; -} - -uint32_t* tmp392 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp392 at (3106,1-3106,37) */ -uint32_t __tmp_in_tmp392; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp392; -} -Arr1DIdxRowM(tmp392, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp392 : 0; -} - -uint32_t* tmp393 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp393 at (3109,1-3109,37) */ -uint32_t __tmp_in_tmp393; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp393; -} -Arr1DIdxRowM(tmp393, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp393 : 0; -} - -uint32_t* tmp394 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp394 at (3112,1-3112,37) */ -uint32_t __tmp_in_tmp394; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp394; -} -Arr1DIdxRowM(tmp394, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp394 : 0; -} - -uint32_t* tmp395 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp395 at (3115,1-3115,47) */ -uint32_t __tmp_in_tmp395; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp395; -} -Arr4DIdxRowM(tmp395, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp395 : 0; -} -} -} -} - -uint32_t* tmp396 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp396 at (3118,1-3118,37) */ -uint32_t __tmp_in_tmp396; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp396; -} -Arr1DIdxRowM(tmp396, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp396 : 0; -} - -uint32_t* tmp397 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp397 at (3121,1-3121,37) */ -uint32_t __tmp_in_tmp397; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp397; -} -Arr1DIdxRowM(tmp397, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp397 : 0; -} - -uint32_t* tmp398 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp398 at (3124,1-3124,37) */ -uint32_t __tmp_in_tmp398; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp398; -} -Arr1DIdxRowM(tmp398, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp398 : 0; -} - -uint32_t* tmp399 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp399 at (3127,1-3127,37) */ -uint32_t __tmp_in_tmp399; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp399; -} -Arr1DIdxRowM(tmp399, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp399 : 0; -} - -uint32_t* tmp400 = make_array( (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp400 at (3130,1-3130,48) */ -uint32_t __tmp_in_tmp400; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)896; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp400; -} -Arr4DIdxRowM(tmp400, (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp400 : 0; -} -} -} -} - -uint32_t* tmp401 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp401 at (3133,1-3133,37) */ -uint32_t __tmp_in_tmp401; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp401; -} -Arr1DIdxRowM(tmp401, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp401 : 0; -} - -uint32_t* tmp402 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp402 at (3136,1-3136,37) */ -uint32_t __tmp_in_tmp402; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp402; -} -Arr1DIdxRowM(tmp402, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp402 : 0; -} - -uint32_t* tmp403 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp403 at (3139,1-3139,37) */ -uint32_t __tmp_in_tmp403; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp403; -} -Arr1DIdxRowM(tmp403, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp403 : 0; -} - -uint32_t* tmp404 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp404 at (3142,1-3142,37) */ -uint32_t __tmp_in_tmp404; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp404; -} -Arr1DIdxRowM(tmp404, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp404 : 0; -} - -uint32_t* tmp405 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp405 at (3145,1-3145,47) */ -uint32_t __tmp_in_tmp405; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp405; -} -Arr4DIdxRowM(tmp405, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp405 : 0; -} -} -} -} - -uint32_t* tmp406 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp406 at (3148,1-3148,37) */ -uint32_t __tmp_in_tmp406; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp406; -} -Arr1DIdxRowM(tmp406, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp406 : 0; -} - -uint32_t* tmp407 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp407 at (3151,1-3151,37) */ -uint32_t __tmp_in_tmp407; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp407; -} -Arr1DIdxRowM(tmp407, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp407 : 0; -} - -uint32_t* tmp408 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp408 at (3154,1-3154,37) */ -uint32_t __tmp_in_tmp408; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp408; -} -Arr1DIdxRowM(tmp408, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp408 : 0; -} - -uint32_t* tmp409 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp409 at (3157,1-3157,37) */ -uint32_t __tmp_in_tmp409; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp409; -} -Arr1DIdxRowM(tmp409, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp409 : 0; -} - -uint32_t* tmp410 = make_array( (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp410 at (3160,1-3160,48) */ -uint32_t __tmp_in_tmp410; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)928; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp410; -} -Arr4DIdxRowM(tmp410, (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp410 : 0; -} -} -} -} - -uint32_t* tmp411 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp411 at (3163,1-3163,37) */ -uint32_t __tmp_in_tmp411; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp411; -} -Arr1DIdxRowM(tmp411, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp411 : 0; -} - -uint32_t* tmp412 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp412 at (3166,1-3166,37) */ -uint32_t __tmp_in_tmp412; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp412; -} -Arr1DIdxRowM(tmp412, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp412 : 0; -} - -uint32_t* tmp413 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp413 at (3169,1-3169,37) */ -uint32_t __tmp_in_tmp413; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp413; -} -Arr1DIdxRowM(tmp413, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp413 : 0; -} - -uint32_t* tmp414 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp414 at (3172,1-3172,37) */ -uint32_t __tmp_in_tmp414; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp414; -} -Arr1DIdxRowM(tmp414, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp414 : 0; -} - -uint32_t* tmp415 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp415 at (3175,1-3175,47) */ -uint32_t __tmp_in_tmp415; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp415; -} -Arr4DIdxRowM(tmp415, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp415 : 0; -} -} -} -} - -uint32_t* tmp416 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp416 at (3178,1-3178,37) */ -uint32_t __tmp_in_tmp416; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp416; -} -Arr1DIdxRowM(tmp416, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp416 : 0; -} - -uint32_t* tmp417 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp417 at (3181,1-3181,37) */ -uint32_t __tmp_in_tmp417; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp417; -} -Arr1DIdxRowM(tmp417, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp417 : 0; -} - -uint32_t* tmp418 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp418 at (3184,1-3184,37) */ -uint32_t __tmp_in_tmp418; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp418; -} -Arr1DIdxRowM(tmp418, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp418 : 0; -} - -uint32_t* tmp419 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp419 at (3187,1-3187,37) */ -uint32_t __tmp_in_tmp419; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp419; -} -Arr1DIdxRowM(tmp419, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp419 : 0; -} - -uint32_t* tmp420 = make_array( (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp420 at (3190,1-3190,48) */ -uint32_t __tmp_in_tmp420; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)960; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp420; -} -Arr4DIdxRowM(tmp420, (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp420 : 0; -} -} -} -} - -uint32_t* tmp421 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp421 at (3193,1-3193,37) */ -uint32_t __tmp_in_tmp421; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp421; -} -Arr1DIdxRowM(tmp421, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp421 : 0; -} - -uint32_t* tmp422 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp422 at (3196,1-3196,37) */ -uint32_t __tmp_in_tmp422; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp422; -} -Arr1DIdxRowM(tmp422, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp422 : 0; -} - -uint32_t* tmp423 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp423 at (3199,1-3199,37) */ -uint32_t __tmp_in_tmp423; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp423; -} -Arr1DIdxRowM(tmp423, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp423 : 0; -} - -uint32_t* tmp424 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp424 at (3202,1-3202,37) */ -uint32_t __tmp_in_tmp424; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp424; -} -Arr1DIdxRowM(tmp424, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp424 : 0; -} - -uint32_t* tmp425 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp425 at (3205,1-3205,47) */ -uint32_t __tmp_in_tmp425; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp425; -} -Arr4DIdxRowM(tmp425, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp425 : 0; -} -} -} -} - -uint32_t* tmp426 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp426 at (3208,1-3208,37) */ -uint32_t __tmp_in_tmp426; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp426; -} -Arr1DIdxRowM(tmp426, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp426 : 0; -} - -uint32_t* tmp427 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp427 at (3211,1-3211,37) */ -uint32_t __tmp_in_tmp427; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp427; -} -Arr1DIdxRowM(tmp427, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp427 : 0; -} - -uint32_t* tmp428 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp428 at (3214,1-3214,37) */ -uint32_t __tmp_in_tmp428; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp428; -} -Arr1DIdxRowM(tmp428, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp428 : 0; -} - -uint32_t* tmp429 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp429 at (3217,1-3217,37) */ -uint32_t __tmp_in_tmp429; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp429; -} -Arr1DIdxRowM(tmp429, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp429 : 0; -} - -uint32_t* tmp430 = make_array( (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp430 at (3220,1-3220,48) */ -uint32_t __tmp_in_tmp430; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)992; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp430; -} -Arr4DIdxRowM(tmp430, (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp430 : 0; -} -} -} -} - -uint32_t* tmp431 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp431 at (3223,1-3223,37) */ -uint32_t __tmp_in_tmp431; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp431; -} -Arr1DIdxRowM(tmp431, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp431 : 0; -} - -uint32_t* tmp432 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp432 at (3226,1-3226,37) */ -uint32_t __tmp_in_tmp432; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp432; -} -Arr1DIdxRowM(tmp432, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp432 : 0; -} - -uint32_t* tmp433 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp433 at (3229,1-3229,37) */ -uint32_t __tmp_in_tmp433; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp433; -} -Arr1DIdxRowM(tmp433, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp433 : 0; -} - -uint32_t* tmp434 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp434 at (3232,1-3232,37) */ -uint32_t __tmp_in_tmp434; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp434; -} -Arr1DIdxRowM(tmp434, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp434 : 0; -} - -uint32_t* tmp435 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp435 at (3235,1-3235,47) */ -uint32_t __tmp_in_tmp435; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp435; -} -Arr4DIdxRowM(tmp435, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp435 : 0; -} -} -} -} - -uint32_t* tmp436 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp436 at (3238,1-3238,38) */ -uint32_t __tmp_in_tmp436; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp436; -} -Arr1DIdxRowM(tmp436, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp436 : 0; -} - -uint32_t* tmp437 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp437 at (3241,1-3241,38) */ -uint32_t __tmp_in_tmp437; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp437; -} -Arr1DIdxRowM(tmp437, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp437 : 0; -} - -uint32_t* tmp438 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp438 at (3244,1-3244,38) */ -uint32_t __tmp_in_tmp438; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp438; -} -Arr1DIdxRowM(tmp438, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp438 : 0; -} - -uint32_t* tmp439 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp439 at (3247,1-3247,38) */ -uint32_t __tmp_in_tmp439; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp439; -} -Arr1DIdxRowM(tmp439, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp439 : 0; -} - -uint32_t* tmp440 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp440 at (3250,1-3250,49) */ -uint32_t __tmp_in_tmp440; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1024; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp440; -} -Arr4DIdxRowM(tmp440, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp440 : 0; -} -} -} -} - -uint32_t* tmp441 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp441 at (3253,1-3253,37) */ -uint32_t __tmp_in_tmp441; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp441; -} -Arr1DIdxRowM(tmp441, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp441 : 0; -} - -uint32_t* tmp442 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp442 at (3256,1-3256,37) */ -uint32_t __tmp_in_tmp442; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp442; -} -Arr1DIdxRowM(tmp442, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp442 : 0; -} - -uint32_t* tmp443 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp443 at (3259,1-3259,37) */ -uint32_t __tmp_in_tmp443; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp443; -} -Arr1DIdxRowM(tmp443, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp443 : 0; -} - -uint32_t* tmp444 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp444 at (3262,1-3262,37) */ -uint32_t __tmp_in_tmp444; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp444; -} -Arr1DIdxRowM(tmp444, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp444 : 0; -} - -uint32_t* tmp445 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp445 at (3265,1-3265,48) */ -uint32_t __tmp_in_tmp445; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp445; -} -Arr4DIdxRowM(tmp445, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp445 : 0; -} -} -} -} - -uint32_t* tmp446 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp446 at (3268,1-3268,37) */ -uint32_t __tmp_in_tmp446; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp446; -} -Arr1DIdxRowM(tmp446, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp446 : 0; -} - -uint32_t* tmp447 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp447 at (3271,1-3271,37) */ -uint32_t __tmp_in_tmp447; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp447; -} -Arr1DIdxRowM(tmp447, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp447 : 0; -} - -uint32_t* tmp448 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp448 at (3274,1-3274,37) */ -uint32_t __tmp_in_tmp448; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp448; -} -Arr1DIdxRowM(tmp448, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp448 : 0; -} - -uint32_t* tmp449 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp449 at (3277,1-3277,37) */ -uint32_t __tmp_in_tmp449; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp449; -} -Arr1DIdxRowM(tmp449, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp449 : 0; -} - -uint32_t* tmp450 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp450 at (3280,1-3280,47) */ -uint32_t __tmp_in_tmp450; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp450; -} -Arr4DIdxRowM(tmp450, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp450 : 0; -} -} -} -} - -uint32_t* tmp451 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp451 at (3283,1-3283,37) */ -uint32_t __tmp_in_tmp451; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp451; -} -Arr1DIdxRowM(tmp451, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp451 : 0; -} - -uint32_t* tmp452 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp452 at (3286,1-3286,37) */ -uint32_t __tmp_in_tmp452; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp452; -} -Arr1DIdxRowM(tmp452, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp452 : 0; -} - -uint32_t* tmp453 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp453 at (3289,1-3289,37) */ -uint32_t __tmp_in_tmp453; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp453; -} -Arr1DIdxRowM(tmp453, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp453 : 0; -} - -uint32_t* tmp454 = make_array( (int32_t)544); -/* Variable to read the clear value corresponding to the input variable tmp454 at (3292,1-3292,37) */ -uint32_t __tmp_in_tmp454; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)544; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp454; -} -Arr1DIdxRowM(tmp454, (int32_t)544,i0) = (party == SERVER) ? __tmp_in_tmp454 : 0; -} - -uint32_t* tmp455 = make_array( (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp455 at (3295,1-3295,48) */ -uint32_t __tmp_in_tmp455; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)544; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp455; -} -Arr4DIdxRowM(tmp455, (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp455 : 0; -} -} -} -} - -uint32_t* tmp456 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp456 at (3298,1-3298,37) */ -uint32_t __tmp_in_tmp456; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp456; -} -Arr1DIdxRowM(tmp456, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp456 : 0; -} - -uint32_t* tmp457 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp457 at (3301,1-3301,37) */ -uint32_t __tmp_in_tmp457; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp457; -} -Arr1DIdxRowM(tmp457, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp457 : 0; -} - -uint32_t* tmp458 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp458 at (3304,1-3304,37) */ -uint32_t __tmp_in_tmp458; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp458; -} -Arr1DIdxRowM(tmp458, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp458 : 0; -} - -uint32_t* tmp459 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp459 at (3307,1-3307,37) */ -uint32_t __tmp_in_tmp459; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp459; -} -Arr1DIdxRowM(tmp459, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp459 : 0; -} - -uint32_t* tmp460 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp460 at (3310,1-3310,47) */ -uint32_t __tmp_in_tmp460; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp460; -} -Arr4DIdxRowM(tmp460, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp460 : 0; -} -} -} -} - -uint32_t* tmp461 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp461 at (3313,1-3313,37) */ -uint32_t __tmp_in_tmp461; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp461; -} -Arr1DIdxRowM(tmp461, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp461 : 0; -} - -uint32_t* tmp462 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp462 at (3316,1-3316,37) */ -uint32_t __tmp_in_tmp462; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp462; -} -Arr1DIdxRowM(tmp462, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp462 : 0; -} - -uint32_t* tmp463 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp463 at (3319,1-3319,37) */ -uint32_t __tmp_in_tmp463; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp463; -} -Arr1DIdxRowM(tmp463, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp463 : 0; -} - -uint32_t* tmp464 = make_array( (int32_t)576); -/* Variable to read the clear value corresponding to the input variable tmp464 at (3322,1-3322,37) */ -uint32_t __tmp_in_tmp464; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)576; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp464; -} -Arr1DIdxRowM(tmp464, (int32_t)576,i0) = (party == SERVER) ? __tmp_in_tmp464 : 0; -} - -uint32_t* tmp465 = make_array( (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp465 at (3325,1-3325,48) */ -uint32_t __tmp_in_tmp465; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)576; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp465; -} -Arr4DIdxRowM(tmp465, (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp465 : 0; -} -} -} -} - -uint32_t* tmp466 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp466 at (3328,1-3328,37) */ -uint32_t __tmp_in_tmp466; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp466; -} -Arr1DIdxRowM(tmp466, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp466 : 0; -} - -uint32_t* tmp467 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp467 at (3331,1-3331,37) */ -uint32_t __tmp_in_tmp467; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp467; -} -Arr1DIdxRowM(tmp467, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp467 : 0; -} - -uint32_t* tmp468 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp468 at (3334,1-3334,37) */ -uint32_t __tmp_in_tmp468; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp468; -} -Arr1DIdxRowM(tmp468, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp468 : 0; -} - -uint32_t* tmp469 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp469 at (3337,1-3337,37) */ -uint32_t __tmp_in_tmp469; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp469; -} -Arr1DIdxRowM(tmp469, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp469 : 0; -} - -uint32_t* tmp470 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp470 at (3340,1-3340,47) */ -uint32_t __tmp_in_tmp470; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp470; -} -Arr4DIdxRowM(tmp470, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp470 : 0; -} -} -} -} - -uint32_t* tmp471 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp471 at (3343,1-3343,37) */ -uint32_t __tmp_in_tmp471; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp471; -} -Arr1DIdxRowM(tmp471, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp471 : 0; -} - -uint32_t* tmp472 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp472 at (3346,1-3346,37) */ -uint32_t __tmp_in_tmp472; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp472; -} -Arr1DIdxRowM(tmp472, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp472 : 0; -} - -uint32_t* tmp473 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp473 at (3349,1-3349,37) */ -uint32_t __tmp_in_tmp473; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp473; -} -Arr1DIdxRowM(tmp473, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp473 : 0; -} - -uint32_t* tmp474 = make_array( (int32_t)608); -/* Variable to read the clear value corresponding to the input variable tmp474 at (3352,1-3352,37) */ -uint32_t __tmp_in_tmp474; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)608; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp474; -} -Arr1DIdxRowM(tmp474, (int32_t)608,i0) = (party == SERVER) ? __tmp_in_tmp474 : 0; -} - -uint32_t* tmp475 = make_array( (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp475 at (3355,1-3355,48) */ -uint32_t __tmp_in_tmp475; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)608; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp475; -} -Arr4DIdxRowM(tmp475, (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp475 : 0; -} -} -} -} - -uint32_t* tmp476 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp476 at (3358,1-3358,37) */ -uint32_t __tmp_in_tmp476; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp476; -} -Arr1DIdxRowM(tmp476, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp476 : 0; -} - -uint32_t* tmp477 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp477 at (3361,1-3361,37) */ -uint32_t __tmp_in_tmp477; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp477; -} -Arr1DIdxRowM(tmp477, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp477 : 0; -} - -uint32_t* tmp478 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp478 at (3364,1-3364,37) */ -uint32_t __tmp_in_tmp478; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp478; -} -Arr1DIdxRowM(tmp478, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp478 : 0; -} - -uint32_t* tmp479 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp479 at (3367,1-3367,37) */ -uint32_t __tmp_in_tmp479; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp479; -} -Arr1DIdxRowM(tmp479, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp479 : 0; -} - -uint32_t* tmp480 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp480 at (3370,1-3370,47) */ -uint32_t __tmp_in_tmp480; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp480; -} -Arr4DIdxRowM(tmp480, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp480 : 0; -} -} -} -} - -uint32_t* tmp481 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp481 at (3373,1-3373,37) */ -uint32_t __tmp_in_tmp481; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp481; -} -Arr1DIdxRowM(tmp481, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp481 : 0; -} - -uint32_t* tmp482 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp482 at (3376,1-3376,37) */ -uint32_t __tmp_in_tmp482; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp482; -} -Arr1DIdxRowM(tmp482, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp482 : 0; -} - -uint32_t* tmp483 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp483 at (3379,1-3379,37) */ -uint32_t __tmp_in_tmp483; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp483; -} -Arr1DIdxRowM(tmp483, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp483 : 0; -} - -uint32_t* tmp484 = make_array( (int32_t)640); -/* Variable to read the clear value corresponding to the input variable tmp484 at (3382,1-3382,37) */ -uint32_t __tmp_in_tmp484; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)640; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp484; -} -Arr1DIdxRowM(tmp484, (int32_t)640,i0) = (party == SERVER) ? __tmp_in_tmp484 : 0; -} - -uint32_t* tmp485 = make_array( (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp485 at (3385,1-3385,48) */ -uint32_t __tmp_in_tmp485; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)640; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp485; -} -Arr4DIdxRowM(tmp485, (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp485 : 0; -} -} -} -} - -uint32_t* tmp486 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp486 at (3388,1-3388,37) */ -uint32_t __tmp_in_tmp486; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp486; -} -Arr1DIdxRowM(tmp486, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp486 : 0; -} - -uint32_t* tmp487 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp487 at (3391,1-3391,37) */ -uint32_t __tmp_in_tmp487; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp487; -} -Arr1DIdxRowM(tmp487, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp487 : 0; -} - -uint32_t* tmp488 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp488 at (3394,1-3394,37) */ -uint32_t __tmp_in_tmp488; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp488; -} -Arr1DIdxRowM(tmp488, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp488 : 0; -} - -uint32_t* tmp489 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp489 at (3397,1-3397,37) */ -uint32_t __tmp_in_tmp489; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp489; -} -Arr1DIdxRowM(tmp489, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp489 : 0; -} - -uint32_t* tmp490 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp490 at (3400,1-3400,47) */ -uint32_t __tmp_in_tmp490; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp490; -} -Arr4DIdxRowM(tmp490, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp490 : 0; -} -} -} -} - -uint32_t* tmp491 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp491 at (3403,1-3403,37) */ -uint32_t __tmp_in_tmp491; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp491; -} -Arr1DIdxRowM(tmp491, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp491 : 0; -} - -uint32_t* tmp492 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp492 at (3406,1-3406,37) */ -uint32_t __tmp_in_tmp492; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp492; -} -Arr1DIdxRowM(tmp492, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp492 : 0; -} - -uint32_t* tmp493 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp493 at (3409,1-3409,37) */ -uint32_t __tmp_in_tmp493; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp493; -} -Arr1DIdxRowM(tmp493, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp493 : 0; -} - -uint32_t* tmp494 = make_array( (int32_t)672); -/* Variable to read the clear value corresponding to the input variable tmp494 at (3412,1-3412,37) */ -uint32_t __tmp_in_tmp494; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)672; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp494; -} -Arr1DIdxRowM(tmp494, (int32_t)672,i0) = (party == SERVER) ? __tmp_in_tmp494 : 0; -} - -uint32_t* tmp495 = make_array( (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp495 at (3415,1-3415,48) */ -uint32_t __tmp_in_tmp495; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)672; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp495; -} -Arr4DIdxRowM(tmp495, (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp495 : 0; -} -} -} -} - -uint32_t* tmp496 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp496 at (3418,1-3418,37) */ -uint32_t __tmp_in_tmp496; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp496; -} -Arr1DIdxRowM(tmp496, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp496 : 0; -} - -uint32_t* tmp497 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp497 at (3421,1-3421,37) */ -uint32_t __tmp_in_tmp497; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp497; -} -Arr1DIdxRowM(tmp497, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp497 : 0; -} - -uint32_t* tmp498 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp498 at (3424,1-3424,37) */ -uint32_t __tmp_in_tmp498; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp498; -} -Arr1DIdxRowM(tmp498, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp498 : 0; -} - -uint32_t* tmp499 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp499 at (3427,1-3427,37) */ -uint32_t __tmp_in_tmp499; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp499; -} -Arr1DIdxRowM(tmp499, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp499 : 0; -} - -uint32_t* tmp500 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp500 at (3430,1-3430,47) */ -uint32_t __tmp_in_tmp500; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp500; -} -Arr4DIdxRowM(tmp500, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp500 : 0; -} -} -} -} - -uint32_t* tmp501 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp501 at (3433,1-3433,37) */ -uint32_t __tmp_in_tmp501; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp501; -} -Arr1DIdxRowM(tmp501, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp501 : 0; -} - -uint32_t* tmp502 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp502 at (3436,1-3436,37) */ -uint32_t __tmp_in_tmp502; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp502; -} -Arr1DIdxRowM(tmp502, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp502 : 0; -} - -uint32_t* tmp503 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp503 at (3439,1-3439,37) */ -uint32_t __tmp_in_tmp503; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp503; -} -Arr1DIdxRowM(tmp503, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp503 : 0; -} - -uint32_t* tmp504 = make_array( (int32_t)704); -/* Variable to read the clear value corresponding to the input variable tmp504 at (3442,1-3442,37) */ -uint32_t __tmp_in_tmp504; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)704; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp504; -} -Arr1DIdxRowM(tmp504, (int32_t)704,i0) = (party == SERVER) ? __tmp_in_tmp504 : 0; -} - -uint32_t* tmp505 = make_array( (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp505 at (3445,1-3445,48) */ -uint32_t __tmp_in_tmp505; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)704; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp505; -} -Arr4DIdxRowM(tmp505, (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp505 : 0; -} -} -} -} - -uint32_t* tmp506 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp506 at (3448,1-3448,37) */ -uint32_t __tmp_in_tmp506; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp506; -} -Arr1DIdxRowM(tmp506, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp506 : 0; -} - -uint32_t* tmp507 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp507 at (3451,1-3451,37) */ -uint32_t __tmp_in_tmp507; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp507; -} -Arr1DIdxRowM(tmp507, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp507 : 0; -} - -uint32_t* tmp508 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp508 at (3454,1-3454,37) */ -uint32_t __tmp_in_tmp508; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp508; -} -Arr1DIdxRowM(tmp508, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp508 : 0; -} - -uint32_t* tmp509 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp509 at (3457,1-3457,37) */ -uint32_t __tmp_in_tmp509; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp509; -} -Arr1DIdxRowM(tmp509, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp509 : 0; -} - -uint32_t* tmp510 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp510 at (3460,1-3460,47) */ -uint32_t __tmp_in_tmp510; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp510; -} -Arr4DIdxRowM(tmp510, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp510 : 0; -} -} -} -} - -uint32_t* tmp511 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp511 at (3463,1-3463,37) */ -uint32_t __tmp_in_tmp511; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp511; -} -Arr1DIdxRowM(tmp511, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp511 : 0; -} - -uint32_t* tmp512 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp512 at (3466,1-3466,37) */ -uint32_t __tmp_in_tmp512; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp512; -} -Arr1DIdxRowM(tmp512, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp512 : 0; -} - -uint32_t* tmp513 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp513 at (3469,1-3469,37) */ -uint32_t __tmp_in_tmp513; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp513; -} -Arr1DIdxRowM(tmp513, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp513 : 0; -} - -uint32_t* tmp514 = make_array( (int32_t)736); -/* Variable to read the clear value corresponding to the input variable tmp514 at (3472,1-3472,37) */ -uint32_t __tmp_in_tmp514; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)736; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp514; -} -Arr1DIdxRowM(tmp514, (int32_t)736,i0) = (party == SERVER) ? __tmp_in_tmp514 : 0; -} - -uint32_t* tmp515 = make_array( (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp515 at (3475,1-3475,48) */ -uint32_t __tmp_in_tmp515; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)736; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp515; -} -Arr4DIdxRowM(tmp515, (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp515 : 0; -} -} -} -} - -uint32_t* tmp516 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp516 at (3478,1-3478,37) */ -uint32_t __tmp_in_tmp516; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp516; -} -Arr1DIdxRowM(tmp516, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp516 : 0; -} - -uint32_t* tmp517 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp517 at (3481,1-3481,37) */ -uint32_t __tmp_in_tmp517; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp517; -} -Arr1DIdxRowM(tmp517, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp517 : 0; -} - -uint32_t* tmp518 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp518 at (3484,1-3484,37) */ -uint32_t __tmp_in_tmp518; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp518; -} -Arr1DIdxRowM(tmp518, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp518 : 0; -} - -uint32_t* tmp519 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp519 at (3487,1-3487,37) */ -uint32_t __tmp_in_tmp519; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp519; -} -Arr1DIdxRowM(tmp519, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp519 : 0; -} - -uint32_t* tmp520 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp520 at (3490,1-3490,47) */ -uint32_t __tmp_in_tmp520; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp520; -} -Arr4DIdxRowM(tmp520, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp520 : 0; -} -} -} -} - -uint32_t* tmp521 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp521 at (3493,1-3493,37) */ -uint32_t __tmp_in_tmp521; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp521; -} -Arr1DIdxRowM(tmp521, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp521 : 0; -} - -uint32_t* tmp522 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp522 at (3496,1-3496,37) */ -uint32_t __tmp_in_tmp522; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp522; -} -Arr1DIdxRowM(tmp522, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp522 : 0; -} - -uint32_t* tmp523 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp523 at (3499,1-3499,37) */ -uint32_t __tmp_in_tmp523; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp523; -} -Arr1DIdxRowM(tmp523, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp523 : 0; -} - -uint32_t* tmp524 = make_array( (int32_t)768); -/* Variable to read the clear value corresponding to the input variable tmp524 at (3502,1-3502,37) */ -uint32_t __tmp_in_tmp524; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)768; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp524; -} -Arr1DIdxRowM(tmp524, (int32_t)768,i0) = (party == SERVER) ? __tmp_in_tmp524 : 0; -} - -uint32_t* tmp525 = make_array( (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp525 at (3505,1-3505,48) */ -uint32_t __tmp_in_tmp525; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)768; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp525; -} -Arr4DIdxRowM(tmp525, (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp525 : 0; -} -} -} -} - -uint32_t* tmp526 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp526 at (3508,1-3508,37) */ -uint32_t __tmp_in_tmp526; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp526; -} -Arr1DIdxRowM(tmp526, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp526 : 0; -} - -uint32_t* tmp527 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp527 at (3511,1-3511,37) */ -uint32_t __tmp_in_tmp527; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp527; -} -Arr1DIdxRowM(tmp527, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp527 : 0; -} - -uint32_t* tmp528 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp528 at (3514,1-3514,37) */ -uint32_t __tmp_in_tmp528; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp528; -} -Arr1DIdxRowM(tmp528, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp528 : 0; -} - -uint32_t* tmp529 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp529 at (3517,1-3517,37) */ -uint32_t __tmp_in_tmp529; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp529; -} -Arr1DIdxRowM(tmp529, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp529 : 0; -} - -uint32_t* tmp530 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp530 at (3520,1-3520,47) */ -uint32_t __tmp_in_tmp530; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp530; -} -Arr4DIdxRowM(tmp530, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp530 : 0; -} -} -} -} - -uint32_t* tmp531 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp531 at (3523,1-3523,37) */ -uint32_t __tmp_in_tmp531; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp531; -} -Arr1DIdxRowM(tmp531, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp531 : 0; -} - -uint32_t* tmp532 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp532 at (3526,1-3526,37) */ -uint32_t __tmp_in_tmp532; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp532; -} -Arr1DIdxRowM(tmp532, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp532 : 0; -} - -uint32_t* tmp533 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp533 at (3529,1-3529,37) */ -uint32_t __tmp_in_tmp533; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp533; -} -Arr1DIdxRowM(tmp533, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp533 : 0; -} - -uint32_t* tmp534 = make_array( (int32_t)800); -/* Variable to read the clear value corresponding to the input variable tmp534 at (3532,1-3532,37) */ -uint32_t __tmp_in_tmp534; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)800; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp534; -} -Arr1DIdxRowM(tmp534, (int32_t)800,i0) = (party == SERVER) ? __tmp_in_tmp534 : 0; -} - -uint32_t* tmp535 = make_array( (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp535 at (3535,1-3535,48) */ -uint32_t __tmp_in_tmp535; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)800; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp535; -} -Arr4DIdxRowM(tmp535, (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp535 : 0; -} -} -} -} - -uint32_t* tmp536 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp536 at (3538,1-3538,37) */ -uint32_t __tmp_in_tmp536; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp536; -} -Arr1DIdxRowM(tmp536, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp536 : 0; -} - -uint32_t* tmp537 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp537 at (3541,1-3541,37) */ -uint32_t __tmp_in_tmp537; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp537; -} -Arr1DIdxRowM(tmp537, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp537 : 0; -} - -uint32_t* tmp538 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp538 at (3544,1-3544,37) */ -uint32_t __tmp_in_tmp538; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp538; -} -Arr1DIdxRowM(tmp538, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp538 : 0; -} - -uint32_t* tmp539 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp539 at (3547,1-3547,37) */ -uint32_t __tmp_in_tmp539; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp539; -} -Arr1DIdxRowM(tmp539, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp539 : 0; -} - -uint32_t* tmp540 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp540 at (3550,1-3550,47) */ -uint32_t __tmp_in_tmp540; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp540; -} -Arr4DIdxRowM(tmp540, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp540 : 0; -} -} -} -} - -uint32_t* tmp541 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp541 at (3553,1-3553,37) */ -uint32_t __tmp_in_tmp541; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp541; -} -Arr1DIdxRowM(tmp541, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp541 : 0; -} - -uint32_t* tmp542 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp542 at (3556,1-3556,37) */ -uint32_t __tmp_in_tmp542; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp542; -} -Arr1DIdxRowM(tmp542, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp542 : 0; -} - -uint32_t* tmp543 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp543 at (3559,1-3559,37) */ -uint32_t __tmp_in_tmp543; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp543; -} -Arr1DIdxRowM(tmp543, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp543 : 0; -} - -uint32_t* tmp544 = make_array( (int32_t)832); -/* Variable to read the clear value corresponding to the input variable tmp544 at (3562,1-3562,37) */ -uint32_t __tmp_in_tmp544; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)832; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp544; -} -Arr1DIdxRowM(tmp544, (int32_t)832,i0) = (party == SERVER) ? __tmp_in_tmp544 : 0; -} - -uint32_t* tmp545 = make_array( (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp545 at (3565,1-3565,48) */ -uint32_t __tmp_in_tmp545; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)832; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp545; -} -Arr4DIdxRowM(tmp545, (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp545 : 0; -} -} -} -} - -uint32_t* tmp546 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp546 at (3568,1-3568,37) */ -uint32_t __tmp_in_tmp546; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp546; -} -Arr1DIdxRowM(tmp546, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp546 : 0; -} - -uint32_t* tmp547 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp547 at (3571,1-3571,37) */ -uint32_t __tmp_in_tmp547; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp547; -} -Arr1DIdxRowM(tmp547, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp547 : 0; -} - -uint32_t* tmp548 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp548 at (3574,1-3574,37) */ -uint32_t __tmp_in_tmp548; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp548; -} -Arr1DIdxRowM(tmp548, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp548 : 0; -} - -uint32_t* tmp549 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp549 at (3577,1-3577,37) */ -uint32_t __tmp_in_tmp549; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp549; -} -Arr1DIdxRowM(tmp549, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp549 : 0; -} - -uint32_t* tmp550 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp550 at (3580,1-3580,47) */ -uint32_t __tmp_in_tmp550; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp550; -} -Arr4DIdxRowM(tmp550, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp550 : 0; -} -} -} -} - -uint32_t* tmp551 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp551 at (3583,1-3583,37) */ -uint32_t __tmp_in_tmp551; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp551; -} -Arr1DIdxRowM(tmp551, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp551 : 0; -} - -uint32_t* tmp552 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp552 at (3586,1-3586,37) */ -uint32_t __tmp_in_tmp552; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp552; -} -Arr1DIdxRowM(tmp552, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp552 : 0; -} - -uint32_t* tmp553 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp553 at (3589,1-3589,37) */ -uint32_t __tmp_in_tmp553; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp553; -} -Arr1DIdxRowM(tmp553, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp553 : 0; -} - -uint32_t* tmp554 = make_array( (int32_t)864); -/* Variable to read the clear value corresponding to the input variable tmp554 at (3592,1-3592,37) */ -uint32_t __tmp_in_tmp554; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)864; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp554; -} -Arr1DIdxRowM(tmp554, (int32_t)864,i0) = (party == SERVER) ? __tmp_in_tmp554 : 0; -} - -uint32_t* tmp555 = make_array( (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp555 at (3595,1-3595,48) */ -uint32_t __tmp_in_tmp555; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)864; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp555; -} -Arr4DIdxRowM(tmp555, (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp555 : 0; -} -} -} -} - -uint32_t* tmp556 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp556 at (3598,1-3598,37) */ -uint32_t __tmp_in_tmp556; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp556; -} -Arr1DIdxRowM(tmp556, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp556 : 0; -} - -uint32_t* tmp557 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp557 at (3601,1-3601,37) */ -uint32_t __tmp_in_tmp557; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp557; -} -Arr1DIdxRowM(tmp557, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp557 : 0; -} - -uint32_t* tmp558 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp558 at (3604,1-3604,37) */ -uint32_t __tmp_in_tmp558; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp558; -} -Arr1DIdxRowM(tmp558, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp558 : 0; -} - -uint32_t* tmp559 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp559 at (3607,1-3607,37) */ -uint32_t __tmp_in_tmp559; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp559; -} -Arr1DIdxRowM(tmp559, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp559 : 0; -} - -uint32_t* tmp560 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp560 at (3610,1-3610,47) */ -uint32_t __tmp_in_tmp560; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp560; -} -Arr4DIdxRowM(tmp560, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp560 : 0; -} -} -} -} - -uint32_t* tmp561 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp561 at (3613,1-3613,37) */ -uint32_t __tmp_in_tmp561; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp561; -} -Arr1DIdxRowM(tmp561, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp561 : 0; -} - -uint32_t* tmp562 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp562 at (3616,1-3616,37) */ -uint32_t __tmp_in_tmp562; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp562; -} -Arr1DIdxRowM(tmp562, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp562 : 0; -} - -uint32_t* tmp563 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp563 at (3619,1-3619,37) */ -uint32_t __tmp_in_tmp563; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp563; -} -Arr1DIdxRowM(tmp563, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp563 : 0; -} - -uint32_t* tmp564 = make_array( (int32_t)896); -/* Variable to read the clear value corresponding to the input variable tmp564 at (3622,1-3622,37) */ -uint32_t __tmp_in_tmp564; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)896; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp564; -} -Arr1DIdxRowM(tmp564, (int32_t)896,i0) = (party == SERVER) ? __tmp_in_tmp564 : 0; -} - -uint32_t* tmp565 = make_array( (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp565 at (3625,1-3625,48) */ -uint32_t __tmp_in_tmp565; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)896; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp565; -} -Arr4DIdxRowM(tmp565, (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp565 : 0; -} -} -} -} - -uint32_t* tmp566 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp566 at (3628,1-3628,37) */ -uint32_t __tmp_in_tmp566; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp566; -} -Arr1DIdxRowM(tmp566, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp566 : 0; -} - -uint32_t* tmp567 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp567 at (3631,1-3631,37) */ -uint32_t __tmp_in_tmp567; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp567; -} -Arr1DIdxRowM(tmp567, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp567 : 0; -} - -uint32_t* tmp568 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp568 at (3634,1-3634,37) */ -uint32_t __tmp_in_tmp568; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp568; -} -Arr1DIdxRowM(tmp568, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp568 : 0; -} - -uint32_t* tmp569 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp569 at (3637,1-3637,37) */ -uint32_t __tmp_in_tmp569; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp569; -} -Arr1DIdxRowM(tmp569, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp569 : 0; -} - -uint32_t* tmp570 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp570 at (3640,1-3640,47) */ -uint32_t __tmp_in_tmp570; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp570; -} -Arr4DIdxRowM(tmp570, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp570 : 0; -} -} -} -} - -uint32_t* tmp571 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp571 at (3643,1-3643,37) */ -uint32_t __tmp_in_tmp571; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp571; -} -Arr1DIdxRowM(tmp571, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp571 : 0; -} - -uint32_t* tmp572 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp572 at (3646,1-3646,37) */ -uint32_t __tmp_in_tmp572; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp572; -} -Arr1DIdxRowM(tmp572, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp572 : 0; -} - -uint32_t* tmp573 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp573 at (3649,1-3649,37) */ -uint32_t __tmp_in_tmp573; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp573; -} -Arr1DIdxRowM(tmp573, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp573 : 0; -} - -uint32_t* tmp574 = make_array( (int32_t)928); -/* Variable to read the clear value corresponding to the input variable tmp574 at (3652,1-3652,37) */ -uint32_t __tmp_in_tmp574; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)928; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp574; -} -Arr1DIdxRowM(tmp574, (int32_t)928,i0) = (party == SERVER) ? __tmp_in_tmp574 : 0; -} - -uint32_t* tmp575 = make_array( (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp575 at (3655,1-3655,48) */ -uint32_t __tmp_in_tmp575; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)928; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp575; -} -Arr4DIdxRowM(tmp575, (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp575 : 0; -} -} -} -} - -uint32_t* tmp576 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp576 at (3658,1-3658,37) */ -uint32_t __tmp_in_tmp576; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp576; -} -Arr1DIdxRowM(tmp576, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp576 : 0; -} - -uint32_t* tmp577 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp577 at (3661,1-3661,37) */ -uint32_t __tmp_in_tmp577; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp577; -} -Arr1DIdxRowM(tmp577, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp577 : 0; -} - -uint32_t* tmp578 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp578 at (3664,1-3664,37) */ -uint32_t __tmp_in_tmp578; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp578; -} -Arr1DIdxRowM(tmp578, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp578 : 0; -} - -uint32_t* tmp579 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp579 at (3667,1-3667,37) */ -uint32_t __tmp_in_tmp579; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp579; -} -Arr1DIdxRowM(tmp579, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp579 : 0; -} - -uint32_t* tmp580 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp580 at (3670,1-3670,47) */ -uint32_t __tmp_in_tmp580; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp580; -} -Arr4DIdxRowM(tmp580, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp580 : 0; -} -} -} -} - -uint32_t* tmp581 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp581 at (3673,1-3673,37) */ -uint32_t __tmp_in_tmp581; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp581; -} -Arr1DIdxRowM(tmp581, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp581 : 0; -} - -uint32_t* tmp582 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp582 at (3676,1-3676,37) */ -uint32_t __tmp_in_tmp582; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp582; -} -Arr1DIdxRowM(tmp582, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp582 : 0; -} - -uint32_t* tmp583 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp583 at (3679,1-3679,37) */ -uint32_t __tmp_in_tmp583; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp583; -} -Arr1DIdxRowM(tmp583, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp583 : 0; -} - -uint32_t* tmp584 = make_array( (int32_t)960); -/* Variable to read the clear value corresponding to the input variable tmp584 at (3682,1-3682,37) */ -uint32_t __tmp_in_tmp584; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)960; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp584; -} -Arr1DIdxRowM(tmp584, (int32_t)960,i0) = (party == SERVER) ? __tmp_in_tmp584 : 0; -} - -uint32_t* tmp585 = make_array( (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp585 at (3685,1-3685,48) */ -uint32_t __tmp_in_tmp585; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)960; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp585; -} -Arr4DIdxRowM(tmp585, (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp585 : 0; -} -} -} -} - -uint32_t* tmp586 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp586 at (3688,1-3688,37) */ -uint32_t __tmp_in_tmp586; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp586; -} -Arr1DIdxRowM(tmp586, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp586 : 0; -} - -uint32_t* tmp587 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp587 at (3691,1-3691,37) */ -uint32_t __tmp_in_tmp587; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp587; -} -Arr1DIdxRowM(tmp587, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp587 : 0; -} - -uint32_t* tmp588 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp588 at (3694,1-3694,37) */ -uint32_t __tmp_in_tmp588; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp588; -} -Arr1DIdxRowM(tmp588, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp588 : 0; -} - -uint32_t* tmp589 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp589 at (3697,1-3697,37) */ -uint32_t __tmp_in_tmp589; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp589; -} -Arr1DIdxRowM(tmp589, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp589 : 0; -} - -uint32_t* tmp590 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp590 at (3700,1-3700,47) */ -uint32_t __tmp_in_tmp590; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp590; -} -Arr4DIdxRowM(tmp590, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp590 : 0; -} -} -} -} - -uint32_t* tmp591 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp591 at (3703,1-3703,37) */ -uint32_t __tmp_in_tmp591; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp591; -} -Arr1DIdxRowM(tmp591, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp591 : 0; -} - -uint32_t* tmp592 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp592 at (3706,1-3706,37) */ -uint32_t __tmp_in_tmp592; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp592; -} -Arr1DIdxRowM(tmp592, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp592 : 0; -} - -uint32_t* tmp593 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp593 at (3709,1-3709,37) */ -uint32_t __tmp_in_tmp593; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp593; -} -Arr1DIdxRowM(tmp593, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp593 : 0; -} - -uint32_t* tmp594 = make_array( (int32_t)992); -/* Variable to read the clear value corresponding to the input variable tmp594 at (3712,1-3712,37) */ -uint32_t __tmp_in_tmp594; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)992; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp594; -} -Arr1DIdxRowM(tmp594, (int32_t)992,i0) = (party == SERVER) ? __tmp_in_tmp594 : 0; -} - -uint32_t* tmp595 = make_array( (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp595 at (3715,1-3715,48) */ -uint32_t __tmp_in_tmp595; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)992; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp595; -} -Arr4DIdxRowM(tmp595, (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp595 : 0; -} -} -} -} - -uint32_t* tmp596 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp596 at (3718,1-3718,37) */ -uint32_t __tmp_in_tmp596; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp596; -} -Arr1DIdxRowM(tmp596, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp596 : 0; -} - -uint32_t* tmp597 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp597 at (3721,1-3721,37) */ -uint32_t __tmp_in_tmp597; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp597; -} -Arr1DIdxRowM(tmp597, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp597 : 0; -} - -uint32_t* tmp598 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp598 at (3724,1-3724,37) */ -uint32_t __tmp_in_tmp598; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp598; -} -Arr1DIdxRowM(tmp598, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp598 : 0; -} - -uint32_t* tmp599 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp599 at (3727,1-3727,37) */ -uint32_t __tmp_in_tmp599; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp599; -} -Arr1DIdxRowM(tmp599, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp599 : 0; -} - -uint32_t* tmp600 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp600 at (3730,1-3730,47) */ -uint32_t __tmp_in_tmp600; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp600; -} -Arr4DIdxRowM(tmp600, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp600 : 0; -} -} -} -} - -uint32_t* tmp601 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp601 at (3733,1-3733,38) */ -uint32_t __tmp_in_tmp601; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp601; -} -Arr1DIdxRowM(tmp601, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp601 : 0; -} - -uint32_t* tmp602 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp602 at (3736,1-3736,38) */ -uint32_t __tmp_in_tmp602; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp602; -} -Arr1DIdxRowM(tmp602, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp602 : 0; -} - -uint32_t* tmp603 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp603 at (3739,1-3739,38) */ -uint32_t __tmp_in_tmp603; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp603; -} -Arr1DIdxRowM(tmp603, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp603 : 0; -} - -uint32_t* tmp604 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp604 at (3742,1-3742,38) */ -uint32_t __tmp_in_tmp604; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp604; -} -Arr1DIdxRowM(tmp604, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp604 : 0; -} - -uint32_t* tmp605 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1000); -/* Variable to read the clear value corresponding to the input variable tmp605 at (3745,1-3745,50) */ -uint32_t __tmp_in_tmp605; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1024; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)1000; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp605; -} -Arr4DIdxRowM(tmp605, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1000,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp605 : 0; -} -} -} -} - -uint32_t* tmp606 = make_array( (int32_t)1000); -/* Variable to read the clear value corresponding to the input variable tmp606 at (3748,1-3748,38) */ -uint32_t __tmp_in_tmp606; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1000; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp606; -} -Arr1DIdxRowM(tmp606, (int32_t)1000,i0) = (party == SERVER) ? __tmp_in_tmp606 : 0; -} -StartComputation(); - -uint32_t* tmp607 = make_array( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, (int32_t)7, (int32_t)7, (int32_t)64, (int32_t)2, (int32_t)3, (int32_t)2, (int32_t)3, (int32_t)2, (int32_t)2, tmp0, tmp1, tmp607); -ClearMemSecret4( (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64, tmp1); -ClearMemSecret4( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, tmp0); - -uint32_t* tmp610 = make_array( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp607, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp607, tmp2, tmp3, (int32_t)0, (int32_t)11, tmp610); -ClearMemSecret1( (int32_t)64, tmp3); -ClearMemSecret4( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp607); -ClearMemSecret1( (int32_t)64, tmp2); - -uint32_t* tmp614 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -MaxPool( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp610, tmp614); -ClearMemSecret4( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp610); - -uint32_t* tmp616 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp614, tmp616, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp614); - -uint32_t* tmp618 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp616, tmp6, tmp7, (int32_t)0, (int32_t)11, tmp618); -ClearMemSecret1( (int32_t)64, tmp7); -ClearMemSecret1( (int32_t)64, tmp6); - -uint32_t* tmp621 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp618, tmp621, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp618); - -uint32_t* tmp623 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp621, tmp10, tmp623); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp621); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)128, tmp10); - -uint32_t* tmp626 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp623, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp623, tmp11, tmp12, (int32_t)0, (int32_t)11, tmp626); -ClearMemSecret1( (int32_t)128, tmp12); -ClearMemSecret1( (int32_t)128, tmp11); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp623); - -uint32_t* tmp630 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp626, tmp630, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp626); - -uint32_t* tmp632 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp630, tmp15, tmp632); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp15); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp630); - -int32_t tmp635 = (int32_t)3; - -uint32_t* tmp636 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp632, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp616, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp632, tmp635, tmp636); -ClearMemPublic(tmp635); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp632); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp616); - -uint32_t* tmp640 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp636, tmp16, tmp17, (int32_t)0, (int32_t)11, tmp640); -ClearMemSecret1( (int32_t)96, tmp16); -ClearMemSecret1( (int32_t)96, tmp17); - -uint32_t* tmp643 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp640, tmp643, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp640); - -uint32_t* tmp645 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp643, tmp20, tmp645); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)96, (int32_t)128, tmp20); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp643); - -uint32_t* tmp648 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp645, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp645, tmp21, tmp22, (int32_t)0, (int32_t)11, tmp648); -ClearMemSecret1( (int32_t)128, tmp22); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp645); -ClearMemSecret1( (int32_t)128, tmp21); - -uint32_t* tmp652 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp648, tmp652, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp648); - -uint32_t* tmp654 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp652, tmp25, tmp654); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp25); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp652); - -int32_t tmp657 = (int32_t)3; - -uint32_t* tmp658 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp654, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp636, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp654, tmp657, tmp658); -ClearMemPublic(tmp657); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)96, tmp636); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp654); - -uint32_t* tmp662 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp658, tmp26, tmp27, (int32_t)0, (int32_t)11, tmp662); -ClearMemSecret1( (int32_t)128, tmp27); -ClearMemSecret1( (int32_t)128, tmp26); - -uint32_t* tmp665 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp662, tmp665, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp662); - -uint32_t* tmp667 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp665, tmp30, tmp667); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp665); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128, tmp30); - -uint32_t* tmp670 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp667, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp667, tmp31, tmp32, (int32_t)0, (int32_t)11, tmp670); -ClearMemSecret1( (int32_t)128, tmp31); -ClearMemSecret1( (int32_t)128, tmp32); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp667); - -uint32_t* tmp674 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp670, tmp674, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp670); - -uint32_t* tmp676 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp674, tmp35, tmp676); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp674); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp35); - -int32_t tmp679 = (int32_t)3; - -uint32_t* tmp680 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp676, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp658, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp676, tmp679, tmp680); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp658); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp676); -ClearMemPublic(tmp679); - -uint32_t* tmp684 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp680, tmp36, tmp37, (int32_t)0, (int32_t)11, tmp684); -ClearMemSecret1( (int32_t)160, tmp37); -ClearMemSecret1( (int32_t)160, tmp36); - -uint32_t* tmp687 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp684, tmp687, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp684); - -uint32_t* tmp689 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp687, tmp40, tmp689); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128, tmp40); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp687); - -uint32_t* tmp692 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp689, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp689, tmp41, tmp42, (int32_t)0, (int32_t)11, tmp692); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp689); -ClearMemSecret1( (int32_t)128, tmp42); -ClearMemSecret1( (int32_t)128, tmp41); - -uint32_t* tmp696 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp692, tmp696, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp692); - -uint32_t* tmp698 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp696, tmp45, tmp698); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp45); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp696); - -int32_t tmp701 = (int32_t)3; - -uint32_t* tmp702 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp698, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp680, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp698, tmp701, tmp702); -ClearMemPublic(tmp701); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp698); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)160, tmp680); - -uint32_t* tmp706 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp702, tmp46, tmp47, (int32_t)0, (int32_t)11, tmp706); -ClearMemSecret1( (int32_t)192, tmp46); -ClearMemSecret1( (int32_t)192, tmp47); - -uint32_t* tmp709 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp706, tmp709, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp706); - -uint32_t* tmp711 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp709, tmp50, tmp711); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128, tmp50); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp709); - -uint32_t* tmp714 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp711, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp711, tmp51, tmp52, (int32_t)0, (int32_t)11, tmp714); -ClearMemSecret1( (int32_t)128, tmp51); -ClearMemSecret1( (int32_t)128, tmp52); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp711); - -uint32_t* tmp718 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp714, tmp718, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp714); - -uint32_t* tmp720 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp718, tmp55, tmp720); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp718); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp55); - -int32_t tmp723 = (int32_t)3; - -uint32_t* tmp724 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp720, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp702, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp720, tmp723, tmp724); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)192, tmp702); -ClearMemPublic(tmp723); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp720); - -uint32_t* tmp728 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp724, tmp56, tmp57, (int32_t)0, (int32_t)11, tmp728); -ClearMemSecret1( (int32_t)224, tmp56); -ClearMemSecret1( (int32_t)224, tmp57); - -uint32_t* tmp731 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp728, tmp731, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp728); - -uint32_t* tmp733 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp731, tmp60, tmp733); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp731); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128, tmp60); - -uint32_t* tmp736 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp733, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp733, tmp61, tmp62, (int32_t)0, (int32_t)11, tmp736); -ClearMemSecret1( (int32_t)128, tmp62); -ClearMemSecret1( (int32_t)128, tmp61); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp733); - -uint32_t* tmp740 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp736, tmp740, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp736); - -uint32_t* tmp742 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp740, tmp65, tmp742); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp740); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp65); - -int32_t tmp745 = (int32_t)3; - -uint32_t* tmp746 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp742, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp724, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp742, tmp745, tmp746); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)32, tmp742); -ClearMemPublic(tmp745); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)224, tmp724); - -uint32_t* tmp750 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp746, tmp66, tmp67, (int32_t)0, (int32_t)11, tmp750); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp746); -ClearMemSecret1( (int32_t)256, tmp67); -ClearMemSecret1( (int32_t)256, tmp66); - -uint32_t* tmp754 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp750, tmp754, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp750); - -uint32_t* tmp756 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp754, tmp70, tmp756); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp754); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp70); - -uint32_t* tmp759 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -AvgPool( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp756, tmp759); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp756); - -uint32_t* tmp761 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759, tmp71, tmp72, (int32_t)0, (int32_t)11, tmp761); -ClearMemSecret1( (int32_t)128, tmp72); -ClearMemSecret1( (int32_t)128, tmp71); - -uint32_t* tmp764 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp761, tmp764, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp761); - -uint32_t* tmp766 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp764, tmp75, tmp766); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp764); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)128, tmp75); - -uint32_t* tmp769 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp766, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp766, tmp76, tmp77, (int32_t)0, (int32_t)11, tmp769); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp766); -ClearMemSecret1( (int32_t)128, tmp76); -ClearMemSecret1( (int32_t)128, tmp77); - -uint32_t* tmp773 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp769, tmp773, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp769); - -uint32_t* tmp775 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp773, tmp80, tmp775); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp80); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp773); - -int32_t tmp778 = (int32_t)3; - -uint32_t* tmp779 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp775, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp775, tmp778, tmp779); -ClearMemPublic(tmp778); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp775); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp759); - -uint32_t* tmp783 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp779, tmp81, tmp82, (int32_t)0, (int32_t)11, tmp783); -ClearMemSecret1( (int32_t)160, tmp82); -ClearMemSecret1( (int32_t)160, tmp81); - -uint32_t* tmp786 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp783, tmp786, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp783); - -uint32_t* tmp788 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp786, tmp85, tmp788); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)160, (int32_t)128, tmp85); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp786); - -uint32_t* tmp791 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp788, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp788, tmp86, tmp87, (int32_t)0, (int32_t)11, tmp791); -ClearMemSecret1( (int32_t)128, tmp87); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp788); -ClearMemSecret1( (int32_t)128, tmp86); - -uint32_t* tmp795 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp791, tmp795, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp791); - -uint32_t* tmp797 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp795, tmp90, tmp797); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp90); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp795); - -int32_t tmp800 = (int32_t)3; - -uint32_t* tmp801 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp797, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp779, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp797, tmp800, tmp801); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)160, tmp779); -ClearMemPublic(tmp800); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp797); - -uint32_t* tmp805 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp801, tmp91, tmp92, (int32_t)0, (int32_t)11, tmp805); -ClearMemSecret1( (int32_t)192, tmp92); -ClearMemSecret1( (int32_t)192, tmp91); - -uint32_t* tmp808 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp805, tmp808, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp805); - -uint32_t* tmp810 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp808, tmp95, tmp810); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp808); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)128, tmp95); - -uint32_t* tmp813 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp810, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp810, tmp96, tmp97, (int32_t)0, (int32_t)11, tmp813); -ClearMemSecret1( (int32_t)128, tmp97); -ClearMemSecret1( (int32_t)128, tmp96); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp810); - -uint32_t* tmp817 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp813, tmp817, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp813); - -uint32_t* tmp819 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp817, tmp100, tmp819); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp817); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp100); - -int32_t tmp822 = (int32_t)3; - -uint32_t* tmp823 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp819, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp801, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp819, tmp822, tmp823); -ClearMemPublic(tmp822); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)192, tmp801); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp819); - -uint32_t* tmp827 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp823, tmp101, tmp102, (int32_t)0, (int32_t)11, tmp827); -ClearMemSecret1( (int32_t)224, tmp101); -ClearMemSecret1( (int32_t)224, tmp102); - -uint32_t* tmp830 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp827, tmp830, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp827); - -uint32_t* tmp832 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp830, tmp105, tmp832); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)224, (int32_t)128, tmp105); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp830); - -uint32_t* tmp835 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp832, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp832, tmp106, tmp107, (int32_t)0, (int32_t)11, tmp835); -ClearMemSecret1( (int32_t)128, tmp106); -ClearMemSecret1( (int32_t)128, tmp107); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp832); - -uint32_t* tmp839 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp835, tmp839, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp835); - -uint32_t* tmp841 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp839, tmp110, tmp841); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp839); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp110); - -int32_t tmp844 = (int32_t)3; - -uint32_t* tmp845 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp841, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp823, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp841, tmp844, tmp845); -ClearMemPublic(tmp844); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp841); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)224, tmp823); - -uint32_t* tmp849 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp845, tmp111, tmp112, (int32_t)0, (int32_t)11, tmp849); -ClearMemSecret1( (int32_t)256, tmp112); -ClearMemSecret1( (int32_t)256, tmp111); - -uint32_t* tmp852 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp849, tmp852, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp849); - -uint32_t* tmp854 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp852, tmp115, tmp854); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp115); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp852); - -uint32_t* tmp857 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp854, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp854, tmp116, tmp117, (int32_t)0, (int32_t)11, tmp857); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp854); -ClearMemSecret1( (int32_t)128, tmp117); -ClearMemSecret1( (int32_t)128, tmp116); - -uint32_t* tmp861 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp857, tmp861, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp857); - -uint32_t* tmp863 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp861, tmp120, tmp863); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp120); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp861); - -int32_t tmp866 = (int32_t)3; - -uint32_t* tmp867 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp863, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp845, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp863, tmp866, tmp867); -ClearMemPublic(tmp866); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp863); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp845); - -uint32_t* tmp871 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp867, tmp121, tmp122, (int32_t)0, (int32_t)11, tmp871); -ClearMemSecret1( (int32_t)288, tmp122); -ClearMemSecret1( (int32_t)288, tmp121); - -uint32_t* tmp874 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp871, tmp874, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp871); - -uint32_t* tmp876 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp874, tmp125, tmp876); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128, tmp125); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp874); - -uint32_t* tmp879 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp876, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp876, tmp126, tmp127, (int32_t)0, (int32_t)11, tmp879); -ClearMemSecret1( (int32_t)128, tmp127); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp876); -ClearMemSecret1( (int32_t)128, tmp126); - -uint32_t* tmp883 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp879, tmp883, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp879); - -uint32_t* tmp885 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp883, tmp130, tmp885); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp130); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp883); - -int32_t tmp888 = (int32_t)3; - -uint32_t* tmp889 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp885, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp867, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp885, tmp888, tmp889); -ClearMemPublic(tmp888); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp885); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)288, tmp867); - -uint32_t* tmp893 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp889, tmp131, tmp132, (int32_t)0, (int32_t)11, tmp893); -ClearMemSecret1( (int32_t)320, tmp132); -ClearMemSecret1( (int32_t)320, tmp131); - -uint32_t* tmp896 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp893, tmp896, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp893); - -uint32_t* tmp898 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp896, tmp135, tmp898); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128, tmp135); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp896); - -uint32_t* tmp901 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp898, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp898, tmp136, tmp137, (int32_t)0, (int32_t)11, tmp901); -ClearMemSecret1( (int32_t)128, tmp136); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp898); -ClearMemSecret1( (int32_t)128, tmp137); - -uint32_t* tmp905 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp901, tmp905, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp901); - -uint32_t* tmp907 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp905, tmp140, tmp907); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp140); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp905); - -int32_t tmp910 = (int32_t)3; - -uint32_t* tmp911 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp907, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp889, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp907, tmp910, tmp911); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)320, tmp889); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp907); -ClearMemPublic(tmp910); - -uint32_t* tmp915 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp911, tmp141, tmp142, (int32_t)0, (int32_t)11, tmp915); -ClearMemSecret1( (int32_t)352, tmp141); -ClearMemSecret1( (int32_t)352, tmp142); - -uint32_t* tmp918 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp915, tmp918, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp915); - -uint32_t* tmp920 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp918, tmp145, tmp920); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp918); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128, tmp145); - -uint32_t* tmp923 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp920, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp920, tmp146, tmp147, (int32_t)0, (int32_t)11, tmp923); -ClearMemSecret1( (int32_t)128, tmp147); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp920); -ClearMemSecret1( (int32_t)128, tmp146); - -uint32_t* tmp927 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp923, tmp927, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp923); - -uint32_t* tmp929 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp927, tmp150, tmp929); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp150); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp927); - -int32_t tmp932 = (int32_t)3; - -uint32_t* tmp933 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp929, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp911, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp929, tmp932, tmp933); -ClearMemPublic(tmp932); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp929); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)352, tmp911); - -uint32_t* tmp937 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp933, tmp151, tmp152, (int32_t)0, (int32_t)11, tmp937); -ClearMemSecret1( (int32_t)384, tmp152); -ClearMemSecret1( (int32_t)384, tmp151); - -uint32_t* tmp940 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp937, tmp940, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp937); - -uint32_t* tmp942 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp940, tmp155, tmp942); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp940); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128, tmp155); - -uint32_t* tmp945 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp942, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp942, tmp156, tmp157, (int32_t)0, (int32_t)11, tmp945); -ClearMemSecret1( (int32_t)128, tmp157); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp942); -ClearMemSecret1( (int32_t)128, tmp156); - -uint32_t* tmp949 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp945, tmp949, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp945); - -uint32_t* tmp951 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp949, tmp160, tmp951); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp949); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp160); - -int32_t tmp954 = (int32_t)3; - -uint32_t* tmp955 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp951, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp933, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp951, tmp954, tmp955); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)384, tmp933); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp951); -ClearMemPublic(tmp954); - -uint32_t* tmp959 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp955, tmp161, tmp162, (int32_t)0, (int32_t)11, tmp959); -ClearMemSecret1( (int32_t)416, tmp162); -ClearMemSecret1( (int32_t)416, tmp161); - -uint32_t* tmp962 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp959, tmp962, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp959); - -uint32_t* tmp964 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp962, tmp165, tmp964); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp962); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128, tmp165); - -uint32_t* tmp967 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp964, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp964, tmp166, tmp167, (int32_t)0, (int32_t)11, tmp967); -ClearMemSecret1( (int32_t)128, tmp167); -ClearMemSecret1( (int32_t)128, tmp166); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp964); - -uint32_t* tmp971 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp967, tmp971, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp967); - -uint32_t* tmp973 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp971, tmp170, tmp973); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp170); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp971); - -int32_t tmp976 = (int32_t)3; - -uint32_t* tmp977 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp973, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp955, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp973, tmp976, tmp977); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp973); -ClearMemPublic(tmp976); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)416, tmp955); - -uint32_t* tmp981 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp977, tmp171, tmp172, (int32_t)0, (int32_t)11, tmp981); -ClearMemSecret1( (int32_t)448, tmp172); -ClearMemSecret1( (int32_t)448, tmp171); - -uint32_t* tmp984 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp981, tmp984, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp981); - -uint32_t* tmp986 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp984, tmp175, tmp986); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128, tmp175); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp984); - -uint32_t* tmp989 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp986, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp986, tmp176, tmp177, (int32_t)0, (int32_t)11, tmp989); -ClearMemSecret1( (int32_t)128, tmp177); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp986); -ClearMemSecret1( (int32_t)128, tmp176); - -uint32_t* tmp993 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp989, tmp993, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp989); - -uint32_t* tmp995 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp993, tmp180, tmp995); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp993); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp180); - -int32_t tmp998 = (int32_t)3; - -uint32_t* tmp999 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp995, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp977, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp995, tmp998, tmp999); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp995); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)448, tmp977); -ClearMemPublic(tmp998); - -uint32_t* tmp1003 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp999, tmp181, tmp182, (int32_t)0, (int32_t)11, tmp1003); -ClearMemSecret1( (int32_t)480, tmp181); -ClearMemSecret1( (int32_t)480, tmp182); - -uint32_t* tmp1006 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp1003, tmp1006, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp1003); - -uint32_t* tmp1008 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1006, tmp185, tmp1008); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128, tmp185); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp1006); - -uint32_t* tmp1011 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1008, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1008, tmp186, tmp187, (int32_t)0, (int32_t)11, tmp1011); -ClearMemSecret1( (int32_t)128, tmp187); -ClearMemSecret1( (int32_t)128, tmp186); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1008); - -uint32_t* tmp1015 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1011, tmp1015, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1011); - -uint32_t* tmp1017 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1015, tmp190, tmp1017); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp190); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp1015); - -int32_t tmp1020 = (int32_t)3; - -uint32_t* tmp1021 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp1017, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp999, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp1017, tmp1020, tmp1021); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)32, tmp1017); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)480, tmp999); -ClearMemPublic(tmp1020); - -uint32_t* tmp1025 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1021, tmp191, tmp192, (int32_t)0, (int32_t)11, tmp1025); -ClearMemSecret1( (int32_t)512, tmp192); -ClearMemSecret1( (int32_t)512, tmp191); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1021); - -uint32_t* tmp1029 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1025, tmp1029, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1025); - -uint32_t* tmp1031 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1029, tmp195, tmp1031); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp1029); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256, tmp195); - -uint32_t* tmp1034 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -AvgPool( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp1031, tmp1034); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp1031); - -uint32_t* tmp1036 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034, tmp196, tmp197, (int32_t)0, (int32_t)11, tmp1036); -ClearMemSecret1( (int32_t)256, tmp196); -ClearMemSecret1( (int32_t)256, tmp197); - -uint32_t* tmp1039 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1036, tmp1039, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1036); - -uint32_t* tmp1041 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1039, tmp200, tmp1041); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1039); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp200); - -uint32_t* tmp1044 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1041, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1041, tmp201, tmp202, (int32_t)0, (int32_t)11, tmp1044); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1041); -ClearMemSecret1( (int32_t)128, tmp201); -ClearMemSecret1( (int32_t)128, tmp202); - -uint32_t* tmp1048 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1044, tmp1048, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1044); - -uint32_t* tmp1050 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1048, tmp205, tmp1050); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1048); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp205); - -int32_t tmp1053 = (int32_t)3; - -uint32_t* tmp1054 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1050, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1050, tmp1053, tmp1054); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp1034); -ClearMemPublic(tmp1053); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1050); - -uint32_t* tmp1058 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1054, tmp206, tmp207, (int32_t)0, (int32_t)11, tmp1058); -ClearMemSecret1( (int32_t)288, tmp207); -ClearMemSecret1( (int32_t)288, tmp206); - -uint32_t* tmp1061 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1058, tmp1061, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1058); - -uint32_t* tmp1063 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1061, tmp210, tmp1063); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)288, (int32_t)128, tmp210); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1061); - -uint32_t* tmp1066 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1063, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1063, tmp211, tmp212, (int32_t)0, (int32_t)11, tmp1066); -ClearMemSecret1( (int32_t)128, tmp212); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1063); -ClearMemSecret1( (int32_t)128, tmp211); - -uint32_t* tmp1070 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1066, tmp1070, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1066); - -uint32_t* tmp1072 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1070, tmp215, tmp1072); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1070); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp215); - -int32_t tmp1075 = (int32_t)3; - -uint32_t* tmp1076 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1072, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1054, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1072, tmp1075, tmp1076); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)288, tmp1054); -ClearMemPublic(tmp1075); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1072); - -uint32_t* tmp1080 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1076, tmp216, tmp217, (int32_t)0, (int32_t)11, tmp1080); -ClearMemSecret1( (int32_t)320, tmp217); -ClearMemSecret1( (int32_t)320, tmp216); - -uint32_t* tmp1083 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1080, tmp1083, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1080); - -uint32_t* tmp1085 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1083, tmp220, tmp1085); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)320, (int32_t)128, tmp220); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1083); - -uint32_t* tmp1088 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1085, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1085, tmp221, tmp222, (int32_t)0, (int32_t)11, tmp1088); -ClearMemSecret1( (int32_t)128, tmp221); -ClearMemSecret1( (int32_t)128, tmp222); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1085); - -uint32_t* tmp1092 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1088, tmp1092, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1088); - -uint32_t* tmp1094 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1092, tmp225, tmp1094); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp225); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1092); - -int32_t tmp1097 = (int32_t)3; - -uint32_t* tmp1098 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1094, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1076, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1094, tmp1097, tmp1098); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1094); -ClearMemPublic(tmp1097); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)320, tmp1076); - -uint32_t* tmp1102 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1098, tmp226, tmp227, (int32_t)0, (int32_t)11, tmp1102); -ClearMemSecret1( (int32_t)352, tmp226); -ClearMemSecret1( (int32_t)352, tmp227); - -uint32_t* tmp1105 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1102, tmp1105, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1102); - -uint32_t* tmp1107 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1105, tmp230, tmp1107); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1105); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)352, (int32_t)128, tmp230); - -uint32_t* tmp1110 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1107, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1107, tmp231, tmp232, (int32_t)0, (int32_t)11, tmp1110); -ClearMemSecret1( (int32_t)128, tmp232); -ClearMemSecret1( (int32_t)128, tmp231); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1107); - -uint32_t* tmp1114 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1110, tmp1114, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1110); - -uint32_t* tmp1116 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1114, tmp235, tmp1116); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp235); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1114); - -int32_t tmp1119 = (int32_t)3; - -uint32_t* tmp1120 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1116, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1098, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1116, tmp1119, tmp1120); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1116); -ClearMemPublic(tmp1119); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)352, tmp1098); - -uint32_t* tmp1124 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1120, tmp236, tmp237, (int32_t)0, (int32_t)11, tmp1124); -ClearMemSecret1( (int32_t)384, tmp236); -ClearMemSecret1( (int32_t)384, tmp237); - -uint32_t* tmp1127 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1124, tmp1127, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1124); - -uint32_t* tmp1129 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1127, tmp240, tmp1129); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)128, tmp240); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1127); - -uint32_t* tmp1132 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1129, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1129, tmp241, tmp242, (int32_t)0, (int32_t)11, tmp1132); -ClearMemSecret1( (int32_t)128, tmp242); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1129); -ClearMemSecret1( (int32_t)128, tmp241); - -uint32_t* tmp1136 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1132, tmp1136, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1132); - -uint32_t* tmp1138 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1136, tmp245, tmp1138); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1136); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp245); - -int32_t tmp1141 = (int32_t)3; - -uint32_t* tmp1142 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1138, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1120, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1138, tmp1141, tmp1142); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1138); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)384, tmp1120); -ClearMemPublic(tmp1141); - -uint32_t* tmp1146 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1142, tmp246, tmp247, (int32_t)0, (int32_t)11, tmp1146); -ClearMemSecret1( (int32_t)416, tmp247); -ClearMemSecret1( (int32_t)416, tmp246); - -uint32_t* tmp1149 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1146, tmp1149, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1146); - -uint32_t* tmp1151 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1149, tmp250, tmp1151); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)416, (int32_t)128, tmp250); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1149); - -uint32_t* tmp1154 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1151, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1151, tmp251, tmp252, (int32_t)0, (int32_t)11, tmp1154); -ClearMemSecret1( (int32_t)128, tmp251); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1151); -ClearMemSecret1( (int32_t)128, tmp252); - -uint32_t* tmp1158 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1154, tmp1158, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1154); - -uint32_t* tmp1160 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1158, tmp255, tmp1160); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp255); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1158); - -int32_t tmp1163 = (int32_t)3; - -uint32_t* tmp1164 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1160, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1142, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1160, tmp1163, tmp1164); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)416, tmp1142); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1160); -ClearMemPublic(tmp1163); - -uint32_t* tmp1168 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1164, tmp256, tmp257, (int32_t)0, (int32_t)11, tmp1168); -ClearMemSecret1( (int32_t)448, tmp257); -ClearMemSecret1( (int32_t)448, tmp256); - -uint32_t* tmp1171 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1168, tmp1171, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1168); - -uint32_t* tmp1173 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1171, tmp260, tmp1173); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)448, (int32_t)128, tmp260); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1171); - -uint32_t* tmp1176 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1173, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1173, tmp261, tmp262, (int32_t)0, (int32_t)11, tmp1176); -ClearMemSecret1( (int32_t)128, tmp261); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1173); -ClearMemSecret1( (int32_t)128, tmp262); - -uint32_t* tmp1180 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1176, tmp1180, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1176); - -uint32_t* tmp1182 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1180, tmp265, tmp1182); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp265); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1180); - -int32_t tmp1185 = (int32_t)3; - -uint32_t* tmp1186 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1182, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1164, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1182, tmp1185, tmp1186); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1182); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)448, tmp1164); -ClearMemPublic(tmp1185); - -uint32_t* tmp1190 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1186, tmp266, tmp267, (int32_t)0, (int32_t)11, tmp1190); -ClearMemSecret1( (int32_t)480, tmp267); -ClearMemSecret1( (int32_t)480, tmp266); - -uint32_t* tmp1193 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1190, tmp1193, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1190); - -uint32_t* tmp1195 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1193, tmp270, tmp1195); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)480, (int32_t)128, tmp270); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1193); - -uint32_t* tmp1198 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1195, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1195, tmp271, tmp272, (int32_t)0, (int32_t)11, tmp1198); -ClearMemSecret1( (int32_t)128, tmp271); -ClearMemSecret1( (int32_t)128, tmp272); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1195); - -uint32_t* tmp1202 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1198, tmp1202, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1198); - -uint32_t* tmp1204 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1202, tmp275, tmp1204); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1202); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp275); - -int32_t tmp1207 = (int32_t)3; - -uint32_t* tmp1208 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1204, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1186, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1204, tmp1207, tmp1208); -ClearMemPublic(tmp1207); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)480, tmp1186); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1204); - -uint32_t* tmp1212 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1208, tmp276, tmp277, (int32_t)0, (int32_t)11, tmp1212); -ClearMemSecret1( (int32_t)512, tmp277); -ClearMemSecret1( (int32_t)512, tmp276); - -uint32_t* tmp1215 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1212, tmp1215, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1212); - -uint32_t* tmp1217 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1215, tmp280, tmp1217); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1215); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp280); - -uint32_t* tmp1220 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1217, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1217, tmp281, tmp282, (int32_t)0, (int32_t)11, tmp1220); -ClearMemSecret1( (int32_t)128, tmp282); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1217); -ClearMemSecret1( (int32_t)128, tmp281); - -uint32_t* tmp1224 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1220, tmp1224, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1220); - -uint32_t* tmp1226 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1224, tmp285, tmp1226); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp285); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1224); - -int32_t tmp1229 = (int32_t)3; - -uint32_t* tmp1230 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1226, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1208, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1226, tmp1229, tmp1230); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1226); -ClearMemPublic(tmp1229); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1208); - -uint32_t* tmp1234 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1230, tmp286, tmp287, (int32_t)0, (int32_t)11, tmp1234); -ClearMemSecret1( (int32_t)544, tmp286); -ClearMemSecret1( (int32_t)544, tmp287); - -uint32_t* tmp1237 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1234, tmp1237, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1234); - -uint32_t* tmp1239 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1237, tmp290, tmp1239); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128, tmp290); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1237); - -uint32_t* tmp1242 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1239, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1239, tmp291, tmp292, (int32_t)0, (int32_t)11, tmp1242); -ClearMemSecret1( (int32_t)128, tmp292); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1239); -ClearMemSecret1( (int32_t)128, tmp291); - -uint32_t* tmp1246 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1242, tmp1246, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1242); - -uint32_t* tmp1248 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1246, tmp295, tmp1248); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp295); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1246); - -int32_t tmp1251 = (int32_t)3; - -uint32_t* tmp1252 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1248, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1230, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1248, tmp1251, tmp1252); -ClearMemPublic(tmp1251); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)544, tmp1230); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1248); - -uint32_t* tmp1256 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1252, tmp296, tmp297, (int32_t)0, (int32_t)11, tmp1256); -ClearMemSecret1( (int32_t)576, tmp296); -ClearMemSecret1( (int32_t)576, tmp297); - -uint32_t* tmp1259 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1256, tmp1259, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1256); - -uint32_t* tmp1261 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1259, tmp300, tmp1261); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1259); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128, tmp300); - -uint32_t* tmp1264 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1261, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1261, tmp301, tmp302, (int32_t)0, (int32_t)11, tmp1264); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1261); -ClearMemSecret1( (int32_t)128, tmp302); -ClearMemSecret1( (int32_t)128, tmp301); - -uint32_t* tmp1268 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1264, tmp1268, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1264); - -uint32_t* tmp1270 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1268, tmp305, tmp1270); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp305); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1268); - -int32_t tmp1273 = (int32_t)3; - -uint32_t* tmp1274 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1270, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1252, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1270, tmp1273, tmp1274); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1270); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)576, tmp1252); -ClearMemPublic(tmp1273); - -uint32_t* tmp1278 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1274, tmp306, tmp307, (int32_t)0, (int32_t)11, tmp1278); -ClearMemSecret1( (int32_t)608, tmp306); -ClearMemSecret1( (int32_t)608, tmp307); - -uint32_t* tmp1281 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1278, tmp1281, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1278); - -uint32_t* tmp1283 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1281, tmp310, tmp1283); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128, tmp310); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1281); - -uint32_t* tmp1286 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1283, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1283, tmp311, tmp312, (int32_t)0, (int32_t)11, tmp1286); -ClearMemSecret1( (int32_t)128, tmp311); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1283); -ClearMemSecret1( (int32_t)128, tmp312); - -uint32_t* tmp1290 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1286, tmp1290, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1286); - -uint32_t* tmp1292 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1290, tmp315, tmp1292); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1290); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp315); - -int32_t tmp1295 = (int32_t)3; - -uint32_t* tmp1296 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1292, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1274, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1292, tmp1295, tmp1296); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)608, tmp1274); -ClearMemPublic(tmp1295); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1292); - -uint32_t* tmp1300 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1296, tmp316, tmp317, (int32_t)0, (int32_t)11, tmp1300); -ClearMemSecret1( (int32_t)640, tmp316); -ClearMemSecret1( (int32_t)640, tmp317); - -uint32_t* tmp1303 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1300, tmp1303, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1300); - -uint32_t* tmp1305 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1303, tmp320, tmp1305); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1303); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128, tmp320); - -uint32_t* tmp1308 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1305, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1305, tmp321, tmp322, (int32_t)0, (int32_t)11, tmp1308); -ClearMemSecret1( (int32_t)128, tmp321); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1305); -ClearMemSecret1( (int32_t)128, tmp322); - -uint32_t* tmp1312 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1308, tmp1312, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1308); - -uint32_t* tmp1314 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1312, tmp325, tmp1314); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1312); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp325); - -int32_t tmp1317 = (int32_t)3; - -uint32_t* tmp1318 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1314, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1296, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1314, tmp1317, tmp1318); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1314); -ClearMemPublic(tmp1317); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)640, tmp1296); - -uint32_t* tmp1322 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1318, tmp326, tmp327, (int32_t)0, (int32_t)11, tmp1322); -ClearMemSecret1( (int32_t)672, tmp326); -ClearMemSecret1( (int32_t)672, tmp327); - -uint32_t* tmp1325 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1322, tmp1325, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1322); - -uint32_t* tmp1327 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1325, tmp330, tmp1327); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1325); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128, tmp330); - -uint32_t* tmp1330 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1327, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1327, tmp331, tmp332, (int32_t)0, (int32_t)11, tmp1330); -ClearMemSecret1( (int32_t)128, tmp332); -ClearMemSecret1( (int32_t)128, tmp331); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1327); - -uint32_t* tmp1334 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1330, tmp1334, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1330); - -uint32_t* tmp1336 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1334, tmp335, tmp1336); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1334); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp335); - -int32_t tmp1339 = (int32_t)3; - -uint32_t* tmp1340 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1336, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1318, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1336, tmp1339, tmp1340); -ClearMemPublic(tmp1339); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)672, tmp1318); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1336); - -uint32_t* tmp1344 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1340, tmp336, tmp337, (int32_t)0, (int32_t)11, tmp1344); -ClearMemSecret1( (int32_t)704, tmp336); -ClearMemSecret1( (int32_t)704, tmp337); - -uint32_t* tmp1347 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1344, tmp1347, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1344); - -uint32_t* tmp1349 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1347, tmp340, tmp1349); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128, tmp340); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1347); - -uint32_t* tmp1352 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1349, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1349, tmp341, tmp342, (int32_t)0, (int32_t)11, tmp1352); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1349); -ClearMemSecret1( (int32_t)128, tmp341); -ClearMemSecret1( (int32_t)128, tmp342); - -uint32_t* tmp1356 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1352, tmp1356, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1352); - -uint32_t* tmp1358 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1356, tmp345, tmp1358); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1356); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp345); - -int32_t tmp1361 = (int32_t)3; - -uint32_t* tmp1362 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1358, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1340, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1358, tmp1361, tmp1362); -ClearMemPublic(tmp1361); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)704, tmp1340); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1358); - -uint32_t* tmp1366 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1362, tmp346, tmp347, (int32_t)0, (int32_t)11, tmp1366); -ClearMemSecret1( (int32_t)736, tmp346); -ClearMemSecret1( (int32_t)736, tmp347); - -uint32_t* tmp1369 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1366, tmp1369, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1366); - -uint32_t* tmp1371 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1369, tmp350, tmp1371); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128, tmp350); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1369); - -uint32_t* tmp1374 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1371, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1371, tmp351, tmp352, (int32_t)0, (int32_t)11, tmp1374); -ClearMemSecret1( (int32_t)128, tmp352); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1371); -ClearMemSecret1( (int32_t)128, tmp351); - -uint32_t* tmp1378 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1374, tmp1378, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1374); - -uint32_t* tmp1380 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1378, tmp355, tmp1380); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp355); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1378); - -int32_t tmp1383 = (int32_t)3; - -uint32_t* tmp1384 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1380, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1362, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1380, tmp1383, tmp1384); -ClearMemPublic(tmp1383); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)736, tmp1362); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1380); - -uint32_t* tmp1388 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1384, tmp356, tmp357, (int32_t)0, (int32_t)11, tmp1388); -ClearMemSecret1( (int32_t)768, tmp356); -ClearMemSecret1( (int32_t)768, tmp357); - -uint32_t* tmp1391 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1388, tmp1391, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1388); - -uint32_t* tmp1393 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1391, tmp360, tmp1393); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128, tmp360); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1391); - -uint32_t* tmp1396 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1393, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1393, tmp361, tmp362, (int32_t)0, (int32_t)11, tmp1396); -ClearMemSecret1( (int32_t)128, tmp361); -ClearMemSecret1( (int32_t)128, tmp362); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1393); - -uint32_t* tmp1400 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1396, tmp1400, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1396); - -uint32_t* tmp1402 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1400, tmp365, tmp1402); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1400); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp365); - -int32_t tmp1405 = (int32_t)3; - -uint32_t* tmp1406 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1402, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1384, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1402, tmp1405, tmp1406); -ClearMemPublic(tmp1405); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1402); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)768, tmp1384); - -uint32_t* tmp1410 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1406, tmp366, tmp367, (int32_t)0, (int32_t)11, tmp1410); -ClearMemSecret1( (int32_t)800, tmp367); -ClearMemSecret1( (int32_t)800, tmp366); - -uint32_t* tmp1413 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1410, tmp1413, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1410); - -uint32_t* tmp1415 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1413, tmp370, tmp1415); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1413); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128, tmp370); - -uint32_t* tmp1418 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1415, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1415, tmp371, tmp372, (int32_t)0, (int32_t)11, tmp1418); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1415); -ClearMemSecret1( (int32_t)128, tmp372); -ClearMemSecret1( (int32_t)128, tmp371); - -uint32_t* tmp1422 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1418, tmp1422, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1418); - -uint32_t* tmp1424 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1422, tmp375, tmp1424); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp375); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1422); - -int32_t tmp1427 = (int32_t)3; - -uint32_t* tmp1428 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1424, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1406, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1424, tmp1427, tmp1428); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)800, tmp1406); -ClearMemPublic(tmp1427); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1424); - -uint32_t* tmp1432 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1428, tmp376, tmp377, (int32_t)0, (int32_t)11, tmp1432); -ClearMemSecret1( (int32_t)832, tmp376); -ClearMemSecret1( (int32_t)832, tmp377); - -uint32_t* tmp1435 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1432, tmp1435, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1432); - -uint32_t* tmp1437 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1435, tmp380, tmp1437); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1435); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128, tmp380); - -uint32_t* tmp1440 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1437, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1437, tmp381, tmp382, (int32_t)0, (int32_t)11, tmp1440); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1437); -ClearMemSecret1( (int32_t)128, tmp381); -ClearMemSecret1( (int32_t)128, tmp382); - -uint32_t* tmp1444 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1440, tmp1444, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1440); - -uint32_t* tmp1446 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1444, tmp385, tmp1446); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1444); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp385); - -int32_t tmp1449 = (int32_t)3; - -uint32_t* tmp1450 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1446, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1428, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1446, tmp1449, tmp1450); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)832, tmp1428); -ClearMemPublic(tmp1449); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1446); - -uint32_t* tmp1454 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1450, tmp386, tmp387, (int32_t)0, (int32_t)11, tmp1454); -ClearMemSecret1( (int32_t)864, tmp387); -ClearMemSecret1( (int32_t)864, tmp386); - -uint32_t* tmp1457 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1454, tmp1457, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1454); - -uint32_t* tmp1459 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1457, tmp390, tmp1459); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128, tmp390); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1457); - -uint32_t* tmp1462 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1459, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1459, tmp391, tmp392, (int32_t)0, (int32_t)11, tmp1462); -ClearMemSecret1( (int32_t)128, tmp392); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1459); -ClearMemSecret1( (int32_t)128, tmp391); - -uint32_t* tmp1466 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1462, tmp1466, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1462); - -uint32_t* tmp1468 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1466, tmp395, tmp1468); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp395); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1466); - -int32_t tmp1471 = (int32_t)3; - -uint32_t* tmp1472 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1468, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1450, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1468, tmp1471, tmp1472); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1468); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)864, tmp1450); -ClearMemPublic(tmp1471); - -uint32_t* tmp1476 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1472, tmp396, tmp397, (int32_t)0, (int32_t)11, tmp1476); -ClearMemSecret1( (int32_t)896, tmp397); -ClearMemSecret1( (int32_t)896, tmp396); - -uint32_t* tmp1479 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1476, tmp1479, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1476); - -uint32_t* tmp1481 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1479, tmp400, tmp1481); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128, tmp400); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1479); - -uint32_t* tmp1484 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1481, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1481, tmp401, tmp402, (int32_t)0, (int32_t)11, tmp1484); -ClearMemSecret1( (int32_t)128, tmp402); -ClearMemSecret1( (int32_t)128, tmp401); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1481); - -uint32_t* tmp1488 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1484, tmp1488, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1484); - -uint32_t* tmp1490 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1488, tmp405, tmp1490); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1488); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp405); - -int32_t tmp1493 = (int32_t)3; - -uint32_t* tmp1494 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1490, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1472, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1490, tmp1493, tmp1494); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1490); -ClearMemPublic(tmp1493); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)896, tmp1472); - -uint32_t* tmp1498 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1494, tmp406, tmp407, (int32_t)0, (int32_t)11, tmp1498); -ClearMemSecret1( (int32_t)928, tmp406); -ClearMemSecret1( (int32_t)928, tmp407); - -uint32_t* tmp1501 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1498, tmp1501, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1498); - -uint32_t* tmp1503 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1501, tmp410, tmp1503); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128, tmp410); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1501); - -uint32_t* tmp1506 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1503, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1503, tmp411, tmp412, (int32_t)0, (int32_t)11, tmp1506); -ClearMemSecret1( (int32_t)128, tmp411); -ClearMemSecret1( (int32_t)128, tmp412); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1503); - -uint32_t* tmp1510 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1506, tmp1510, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1506); - -uint32_t* tmp1512 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1510, tmp415, tmp1512); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1510); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp415); - -int32_t tmp1515 = (int32_t)3; - -uint32_t* tmp1516 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1512, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1494, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1512, tmp1515, tmp1516); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1512); -ClearMemPublic(tmp1515); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)928, tmp1494); - -uint32_t* tmp1520 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1516, tmp416, tmp417, (int32_t)0, (int32_t)11, tmp1520); -ClearMemSecret1( (int32_t)960, tmp417); -ClearMemSecret1( (int32_t)960, tmp416); - -uint32_t* tmp1523 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1520, tmp1523, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1520); - -uint32_t* tmp1525 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1523, tmp420, tmp1525); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1523); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128, tmp420); - -uint32_t* tmp1528 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1525, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1525, tmp421, tmp422, (int32_t)0, (int32_t)11, tmp1528); -ClearMemSecret1( (int32_t)128, tmp421); -ClearMemSecret1( (int32_t)128, tmp422); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1525); - -uint32_t* tmp1532 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1528, tmp1532, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1528); - -uint32_t* tmp1534 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1532, tmp425, tmp1534); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp425); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1532); - -int32_t tmp1537 = (int32_t)3; - -uint32_t* tmp1538 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1534, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1516, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1534, tmp1537, tmp1538); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)960, tmp1516); -ClearMemPublic(tmp1537); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1534); - -uint32_t* tmp1542 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1538, tmp426, tmp427, (int32_t)0, (int32_t)11, tmp1542); -ClearMemSecret1( (int32_t)992, tmp426); -ClearMemSecret1( (int32_t)992, tmp427); - -uint32_t* tmp1545 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1542, tmp1545, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1542); - -uint32_t* tmp1547 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1545, tmp430, tmp1547); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1545); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128, tmp430); - -uint32_t* tmp1550 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1547, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1547, tmp431, tmp432, (int32_t)0, (int32_t)11, tmp1550); -ClearMemSecret1( (int32_t)128, tmp431); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1547); -ClearMemSecret1( (int32_t)128, tmp432); - -uint32_t* tmp1554 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1550, tmp1554, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1550); - -uint32_t* tmp1556 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1554, tmp435, tmp1556); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp435); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)128, tmp1554); - -int32_t tmp1559 = (int32_t)3; - -uint32_t* tmp1560 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1556, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1538, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1556, tmp1559, tmp1560); -ClearMemPublic(tmp1559); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)992, tmp1538); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)32, tmp1556); - -uint32_t* tmp1564 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1560, tmp436, tmp437, (int32_t)0, (int32_t)11, tmp1564); -ClearMemSecret1( (int32_t)1024, tmp436); -ClearMemSecret1( (int32_t)1024, tmp437); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1560); - -uint32_t* tmp1568 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1564, tmp1568, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1564); - -uint32_t* tmp1570 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1568, tmp440, tmp1570); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp1568); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512, tmp440); - -uint32_t* tmp1573 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -AvgPool( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1570, tmp1573); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp1570); - -uint32_t* tmp1575 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573, tmp441, tmp442, (int32_t)0, (int32_t)11, tmp1575); -ClearMemSecret1( (int32_t)512, tmp441); -ClearMemSecret1( (int32_t)512, tmp442); - -uint32_t* tmp1578 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1575, tmp1578, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1575); - -uint32_t* tmp1580 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1578, tmp445, tmp1580); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1578); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp445); - -uint32_t* tmp1583 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1580, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1580, tmp446, tmp447, (int32_t)0, (int32_t)11, tmp1583); -ClearMemSecret1( (int32_t)128, tmp447); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1580); -ClearMemSecret1( (int32_t)128, tmp446); - -uint32_t* tmp1587 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1583, tmp1587, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1583); - -uint32_t* tmp1589 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1587, tmp450, tmp1589); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp450); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1587); - -int32_t tmp1592 = (int32_t)3; - -uint32_t* tmp1593 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1589, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1589, tmp1592, tmp1593); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp1573); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1589); -ClearMemPublic(tmp1592); - -uint32_t* tmp1597 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1593, tmp451, tmp452, (int32_t)0, (int32_t)11, tmp1597); -ClearMemSecret1( (int32_t)544, tmp451); -ClearMemSecret1( (int32_t)544, tmp452); - -uint32_t* tmp1600 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1597, tmp1600, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1597); - -uint32_t* tmp1602 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1600, tmp455, tmp1602); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)544, (int32_t)128, tmp455); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1600); - -uint32_t* tmp1605 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1602, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1602, tmp456, tmp457, (int32_t)0, (int32_t)11, tmp1605); -ClearMemSecret1( (int32_t)128, tmp456); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1602); -ClearMemSecret1( (int32_t)128, tmp457); - -uint32_t* tmp1609 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1605, tmp1609, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1605); - -uint32_t* tmp1611 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1609, tmp460, tmp1611); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp460); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1609); - -int32_t tmp1614 = (int32_t)3; - -uint32_t* tmp1615 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1611, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1593, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1611, tmp1614, tmp1615); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1611); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)544, tmp1593); -ClearMemPublic(tmp1614); - -uint32_t* tmp1619 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1615, tmp461, tmp462, (int32_t)0, (int32_t)11, tmp1619); -ClearMemSecret1( (int32_t)576, tmp462); -ClearMemSecret1( (int32_t)576, tmp461); - -uint32_t* tmp1622 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1619, tmp1622, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1619); - -uint32_t* tmp1624 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1622, tmp465, tmp1624); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1622); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)576, (int32_t)128, tmp465); - -uint32_t* tmp1627 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1624, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1624, tmp466, tmp467, (int32_t)0, (int32_t)11, tmp1627); -ClearMemSecret1( (int32_t)128, tmp466); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1624); -ClearMemSecret1( (int32_t)128, tmp467); - -uint32_t* tmp1631 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1627, tmp1631, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1627); - -uint32_t* tmp1633 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1631, tmp470, tmp1633); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp470); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1631); - -int32_t tmp1636 = (int32_t)3; - -uint32_t* tmp1637 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1633, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1615, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1633, tmp1636, tmp1637); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1633); -ClearMemPublic(tmp1636); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)576, tmp1615); - -uint32_t* tmp1641 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1637, tmp471, tmp472, (int32_t)0, (int32_t)11, tmp1641); -ClearMemSecret1( (int32_t)608, tmp472); -ClearMemSecret1( (int32_t)608, tmp471); - -uint32_t* tmp1644 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1641, tmp1644, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1641); - -uint32_t* tmp1646 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1644, tmp475, tmp1646); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1644); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)608, (int32_t)128, tmp475); - -uint32_t* tmp1649 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1646, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1646, tmp476, tmp477, (int32_t)0, (int32_t)11, tmp1649); -ClearMemSecret1( (int32_t)128, tmp476); -ClearMemSecret1( (int32_t)128, tmp477); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1646); - -uint32_t* tmp1653 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1649, tmp1653, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1649); - -uint32_t* tmp1655 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1653, tmp480, tmp1655); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp480); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1653); - -int32_t tmp1658 = (int32_t)3; - -uint32_t* tmp1659 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1655, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1637, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1655, tmp1658, tmp1659); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1655); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)608, tmp1637); -ClearMemPublic(tmp1658); - -uint32_t* tmp1663 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1659, tmp481, tmp482, (int32_t)0, (int32_t)11, tmp1663); -ClearMemSecret1( (int32_t)640, tmp482); -ClearMemSecret1( (int32_t)640, tmp481); - -uint32_t* tmp1666 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1663, tmp1666, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1663); - -uint32_t* tmp1668 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1666, tmp485, tmp1668); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1666); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)640, (int32_t)128, tmp485); - -uint32_t* tmp1671 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1668, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1668, tmp486, tmp487, (int32_t)0, (int32_t)11, tmp1671); -ClearMemSecret1( (int32_t)128, tmp486); -ClearMemSecret1( (int32_t)128, tmp487); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1668); - -uint32_t* tmp1675 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1671, tmp1675, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1671); - -uint32_t* tmp1677 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1675, tmp490, tmp1677); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp490); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1675); - -int32_t tmp1680 = (int32_t)3; - -uint32_t* tmp1681 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1677, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1659, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1677, tmp1680, tmp1681); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1677); -ClearMemPublic(tmp1680); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)640, tmp1659); - -uint32_t* tmp1685 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1681, tmp491, tmp492, (int32_t)0, (int32_t)11, tmp1685); -ClearMemSecret1( (int32_t)672, tmp491); -ClearMemSecret1( (int32_t)672, tmp492); - -uint32_t* tmp1688 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1685, tmp1688, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1685); - -uint32_t* tmp1690 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1688, tmp495, tmp1690); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1688); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)672, (int32_t)128, tmp495); - -uint32_t* tmp1693 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1690, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1690, tmp496, tmp497, (int32_t)0, (int32_t)11, tmp1693); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1690); -ClearMemSecret1( (int32_t)128, tmp496); -ClearMemSecret1( (int32_t)128, tmp497); - -uint32_t* tmp1697 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1693, tmp1697, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1693); - -uint32_t* tmp1699 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1697, tmp500, tmp1699); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1697); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp500); - -int32_t tmp1702 = (int32_t)3; - -uint32_t* tmp1703 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1699, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1681, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1699, tmp1702, tmp1703); -ClearMemPublic(tmp1702); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)672, tmp1681); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1699); - -uint32_t* tmp1707 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1703, tmp501, tmp502, (int32_t)0, (int32_t)11, tmp1707); -ClearMemSecret1( (int32_t)704, tmp502); -ClearMemSecret1( (int32_t)704, tmp501); - -uint32_t* tmp1710 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1707, tmp1710, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1707); - -uint32_t* tmp1712 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1710, tmp505, tmp1712); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1710); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)704, (int32_t)128, tmp505); - -uint32_t* tmp1715 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1712, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1712, tmp506, tmp507, (int32_t)0, (int32_t)11, tmp1715); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1712); -ClearMemSecret1( (int32_t)128, tmp506); -ClearMemSecret1( (int32_t)128, tmp507); - -uint32_t* tmp1719 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1715, tmp1719, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1715); - -uint32_t* tmp1721 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1719, tmp510, tmp1721); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1719); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp510); - -int32_t tmp1724 = (int32_t)3; - -uint32_t* tmp1725 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1721, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1703, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1721, tmp1724, tmp1725); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1721); -ClearMemPublic(tmp1724); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)704, tmp1703); - -uint32_t* tmp1729 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1725, tmp511, tmp512, (int32_t)0, (int32_t)11, tmp1729); -ClearMemSecret1( (int32_t)736, tmp511); -ClearMemSecret1( (int32_t)736, tmp512); - -uint32_t* tmp1732 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1729, tmp1732, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1729); - -uint32_t* tmp1734 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1732, tmp515, tmp1734); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)736, (int32_t)128, tmp515); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1732); - -uint32_t* tmp1737 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1734, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1734, tmp516, tmp517, (int32_t)0, (int32_t)11, tmp1737); -ClearMemSecret1( (int32_t)128, tmp517); -ClearMemSecret1( (int32_t)128, tmp516); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1734); - -uint32_t* tmp1741 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1737, tmp1741, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1737); - -uint32_t* tmp1743 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1741, tmp520, tmp1743); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp520); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1741); - -int32_t tmp1746 = (int32_t)3; - -uint32_t* tmp1747 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1743, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1725, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1743, tmp1746, tmp1747); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1743); -ClearMemPublic(tmp1746); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)736, tmp1725); - -uint32_t* tmp1751 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1747, tmp521, tmp522, (int32_t)0, (int32_t)11, tmp1751); -ClearMemSecret1( (int32_t)768, tmp522); -ClearMemSecret1( (int32_t)768, tmp521); - -uint32_t* tmp1754 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1751, tmp1754, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1751); - -uint32_t* tmp1756 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1754, tmp525, tmp1756); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1754); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)768, (int32_t)128, tmp525); - -uint32_t* tmp1759 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1756, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1756, tmp526, tmp527, (int32_t)0, (int32_t)11, tmp1759); -ClearMemSecret1( (int32_t)128, tmp527); -ClearMemSecret1( (int32_t)128, tmp526); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1756); - -uint32_t* tmp1763 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1759, tmp1763, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1759); - -uint32_t* tmp1765 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1763, tmp530, tmp1765); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp530); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1763); - -int32_t tmp1768 = (int32_t)3; - -uint32_t* tmp1769 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1765, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1747, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1765, tmp1768, tmp1769); -ClearMemPublic(tmp1768); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1765); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)768, tmp1747); - -uint32_t* tmp1773 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1769, tmp531, tmp532, (int32_t)0, (int32_t)11, tmp1773); -ClearMemSecret1( (int32_t)800, tmp531); -ClearMemSecret1( (int32_t)800, tmp532); - -uint32_t* tmp1776 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1773, tmp1776, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1773); - -uint32_t* tmp1778 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1776, tmp535, tmp1778); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)800, (int32_t)128, tmp535); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1776); - -uint32_t* tmp1781 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1778, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1778, tmp536, tmp537, (int32_t)0, (int32_t)11, tmp1781); -ClearMemSecret1( (int32_t)128, tmp536); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1778); -ClearMemSecret1( (int32_t)128, tmp537); - -uint32_t* tmp1785 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1781, tmp1785, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1781); - -uint32_t* tmp1787 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1785, tmp540, tmp1787); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp540); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1785); - -int32_t tmp1790 = (int32_t)3; - -uint32_t* tmp1791 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1787, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1769, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1787, tmp1790, tmp1791); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)800, tmp1769); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1787); -ClearMemPublic(tmp1790); - -uint32_t* tmp1795 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1791, tmp541, tmp542, (int32_t)0, (int32_t)11, tmp1795); -ClearMemSecret1( (int32_t)832, tmp542); -ClearMemSecret1( (int32_t)832, tmp541); - -uint32_t* tmp1798 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1795, tmp1798, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1795); - -uint32_t* tmp1800 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1798, tmp545, tmp1800); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1798); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)832, (int32_t)128, tmp545); - -uint32_t* tmp1803 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1800, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1800, tmp546, tmp547, (int32_t)0, (int32_t)11, tmp1803); -ClearMemSecret1( (int32_t)128, tmp546); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1800); -ClearMemSecret1( (int32_t)128, tmp547); - -uint32_t* tmp1807 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1803, tmp1807, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1803); - -uint32_t* tmp1809 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1807, tmp550, tmp1809); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp550); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1807); - -int32_t tmp1812 = (int32_t)3; - -uint32_t* tmp1813 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1809, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1791, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1809, tmp1812, tmp1813); -ClearMemPublic(tmp1812); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1809); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)832, tmp1791); - -uint32_t* tmp1817 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1813, tmp551, tmp552, (int32_t)0, (int32_t)11, tmp1817); -ClearMemSecret1( (int32_t)864, tmp551); -ClearMemSecret1( (int32_t)864, tmp552); - -uint32_t* tmp1820 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1817, tmp1820, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1817); - -uint32_t* tmp1822 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1820, tmp555, tmp1822); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1820); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)864, (int32_t)128, tmp555); - -uint32_t* tmp1825 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1822, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1822, tmp556, tmp557, (int32_t)0, (int32_t)11, tmp1825); -ClearMemSecret1( (int32_t)128, tmp557); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1822); -ClearMemSecret1( (int32_t)128, tmp556); - -uint32_t* tmp1829 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1825, tmp1829, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1825); - -uint32_t* tmp1831 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1829, tmp560, tmp1831); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp560); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1829); - -int32_t tmp1834 = (int32_t)3; - -uint32_t* tmp1835 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1831, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1813, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1831, tmp1834, tmp1835); -ClearMemPublic(tmp1834); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1831); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)864, tmp1813); - -uint32_t* tmp1839 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1835, tmp561, tmp562, (int32_t)0, (int32_t)11, tmp1839); -ClearMemSecret1( (int32_t)896, tmp562); -ClearMemSecret1( (int32_t)896, tmp561); - -uint32_t* tmp1842 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1839, tmp1842, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1839); - -uint32_t* tmp1844 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1842, tmp565, tmp1844); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1842); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)896, (int32_t)128, tmp565); - -uint32_t* tmp1847 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1844, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1844, tmp566, tmp567, (int32_t)0, (int32_t)11, tmp1847); -ClearMemSecret1( (int32_t)128, tmp566); -ClearMemSecret1( (int32_t)128, tmp567); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1844); - -uint32_t* tmp1851 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1847, tmp1851, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1847); - -uint32_t* tmp1853 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1851, tmp570, tmp1853); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp570); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1851); - -int32_t tmp1856 = (int32_t)3; - -uint32_t* tmp1857 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1853, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1835, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1853, tmp1856, tmp1857); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)896, tmp1835); -ClearMemPublic(tmp1856); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1853); - -uint32_t* tmp1861 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1857, tmp571, tmp572, (int32_t)0, (int32_t)11, tmp1861); -ClearMemSecret1( (int32_t)928, tmp571); -ClearMemSecret1( (int32_t)928, tmp572); - -uint32_t* tmp1864 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1861, tmp1864, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1861); - -uint32_t* tmp1866 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1864, tmp575, tmp1866); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1864); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)928, (int32_t)128, tmp575); - -uint32_t* tmp1869 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1866, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1866, tmp576, tmp577, (int32_t)0, (int32_t)11, tmp1869); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1866); -ClearMemSecret1( (int32_t)128, tmp577); -ClearMemSecret1( (int32_t)128, tmp576); - -uint32_t* tmp1873 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1869, tmp1873, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1869); - -uint32_t* tmp1875 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1873, tmp580, tmp1875); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1873); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp580); - -int32_t tmp1878 = (int32_t)3; - -uint32_t* tmp1879 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1875, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1857, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1875, tmp1878, tmp1879); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1875); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)928, tmp1857); -ClearMemPublic(tmp1878); - -uint32_t* tmp1883 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1879, tmp581, tmp582, (int32_t)0, (int32_t)11, tmp1883); -ClearMemSecret1( (int32_t)960, tmp581); -ClearMemSecret1( (int32_t)960, tmp582); - -uint32_t* tmp1886 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1883, tmp1886, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1883); - -uint32_t* tmp1888 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1886, tmp585, tmp1888); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)960, (int32_t)128, tmp585); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1886); - -uint32_t* tmp1891 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1888, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1888, tmp586, tmp587, (int32_t)0, (int32_t)11, tmp1891); -ClearMemSecret1( (int32_t)128, tmp586); -ClearMemSecret1( (int32_t)128, tmp587); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1888); - -uint32_t* tmp1895 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1891, tmp1895, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1891); - -uint32_t* tmp1897 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1895, tmp590, tmp1897); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp590); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1895); - -int32_t tmp1900 = (int32_t)3; - -uint32_t* tmp1901 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1897, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1879, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1897, tmp1900, tmp1901); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)960, tmp1879); -ClearMemPublic(tmp1900); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1897); - -uint32_t* tmp1905 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1901, tmp591, tmp592, (int32_t)0, (int32_t)11, tmp1905); -ClearMemSecret1( (int32_t)992, tmp591); -ClearMemSecret1( (int32_t)992, tmp592); - -uint32_t* tmp1908 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1905, tmp1908, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1905); - -uint32_t* tmp1910 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1908, tmp595, tmp1910); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)992, (int32_t)128, tmp595); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1908); - -uint32_t* tmp1913 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1910, (int32_t)11); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1910, tmp596, tmp597, (int32_t)0, (int32_t)11, tmp1913); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1910); -ClearMemSecret1( (int32_t)128, tmp596); -ClearMemSecret1( (int32_t)128, tmp597); - -uint32_t* tmp1917 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1913, tmp1917, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1913); - -uint32_t* tmp1919 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp1917, tmp600, tmp1919); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)32, tmp600); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)128, tmp1917); - -int32_t tmp1922 = (int32_t)3; - -uint32_t* tmp1923 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1919, (int32_t)11); -Concat2T444( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1901, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1919, tmp1922, tmp1923); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)992, tmp1901); -ClearMemPublic(tmp1922); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)32, tmp1919); - -uint32_t* tmp1927 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1923, tmp601, tmp602, (int32_t)0, (int32_t)11, tmp1927); -ClearMemSecret1( (int32_t)1024, tmp601); -ClearMemSecret1( (int32_t)1024, tmp602); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1923); - -uint32_t* tmp1931 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1927, tmp1931, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1927); - -uint32_t* tmp1933 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024); -AvgPool( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)7, (int32_t)7, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1931, tmp1933); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)1024, tmp1931); - -uint32_t* tmp1935 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000); -Conv2DWrapper( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)1000, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp1933, tmp605, tmp1935); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1024, tmp1933); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)1000, tmp605); - -uint32_t* tmp1938 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000); -ScaleUp1( (int32_t)1000, tmp606, (int32_t)11); -MatAddBroadCast4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1935, tmp606, tmp1938); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1935); -ClearMemSecret1( (int32_t)1000, tmp606); - -int32_t tmp1941 = (int32_t)3; - -uint32_t* tmp1942 = make_array( (int32_t)1, (int32_t)1, (int32_t)1); -ArgMax3( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1938, tmp1941, tmp1942); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp1938); -ClearMemPublic(tmp1941); -EndComputation(); -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1; i2++){ -cout << (funcReconstruct2PCCons(Arr3DIdxRowM(tmp1942, (int32_t)1, (int32_t)1, (int32_t)1,i0,i1,i2), 2)) << endl; -} -} -} -} - diff --git a/SCI/networks/main_minionn.cpp b/SCI/networks/main_minionn.cpp new file mode 100644 index 00000000..2c347998 --- /dev/null +++ b/SCI/networks/main_minionn.cpp @@ -0,0 +1,2631 @@ +/* +This is an autogenerated file, generated using the EzPC compiler. +*/ + +#define HACKY_RUN +// DISCLAIMER: These networks are just for comparative purposes +#include "library_fixed.h" +#include +using namespace std; + +int party = 0; +int port = 32000; +string address = "127.0.0.1"; +int num_threads = 4; +int32_t bitlength = 41; + +void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + SecretAdd(Arr2DIdxRowM(A, s1, s2, i1, i2), Arr1DIdxRowM(B, s2, i2)); + } + } +} + +void MatAdd2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = SecretAdd( + Arr2DIdxRowM(A, s1, s2, i1, i2), Arr2DIdxRowM(B, s1, s2, i1, i2)); + } + } +} + +void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr1DIdxRowM(B, s4, i4)); + } + } + } + } +} + +void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *A, + uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr4DIdxRowM(B, s1, s2, s3, s4, i1, i2, i3, i4)); + } + } + } + } +} + +void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr1DIdxRowM(B, s5, i5)); + } + } + } + } + } +} + +void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr5DIdxRowM(B, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5)); + } + } + } + } + } +} + +void CreateTensor1(int64_t s1, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(arr, s1, i1) = val; + } +} + +void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(arr, s1, s2, i1, i2) = val; + } + } +} + +void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = val; + } + } + } +} + +void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = val; + } + } + } + } +} + +void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(arr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = val; + } + } + } + } + } +} + +void CopyTensor1(int64_t s1, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(targetArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CopyTensor2(int64_t s1, int64_t s2, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(targetArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t *targetArr, + uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(targetArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *targetArr, uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(targetArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateIdentity11(int64_t s1, uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(newArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CreateIdentity22(int64_t s1, int64_t s2, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(newArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(newArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(newArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, + uint64_t *inArr, int64_t perDimSize, int64_t *beginIdx, + int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = + Arr2DIdxRowM(inArr, inps1, inps2, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j)); + } + } +} + +void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inArr, int64_t perDimSize, + int64_t *beginIdx, int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM( + inArr, inps1, inps2, inps3, inps4, inps5, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)2) + k), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)3) + l), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)4) + m)); + } + } + } + } + } +} + +void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, + uint64_t *inp1, int64_t inp2s1, int64_t inp2s2, uint64_t *inp2, + int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, (i1 - inp1s1), i2); + } + } else { + if ((i2 < inp1s2)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, i1, (i2 - inp1s2)); + } + } + } + } +} + +void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, + int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t *inp1, + int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, + uint64_t *inp2, int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = Arr4DIdxRowM( + inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, + (i1 - inp1s1), i2, i3, i4); + } + } else { + if ((axis == (int32_t)1)) { + if ((i2 < inp1s2)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, + (i2 - inp1s2), i3, i4); + } + } else { + if ((axis == (int32_t)2)) { + if ((i3 < inp1s3)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + (i3 - inp1s3), i4); + } + } else { + if ((i4 < inp1s4)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + i3, (i4 - inp1s4)); + } + } + } + } + } + } + } + } +} + +void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, + int64_t I2, int64_t I3, int64_t I4, uint64_t *inp, int64_t axis, + int64_t curCount, int64_t total, uint64_t *out) { + for (uint64_t o1 = (int32_t)0; o1 < O1; o1++) { + for (uint64_t o2 = (int32_t)0; o2 < O2; o2++) { + for (uint64_t o3 = (int32_t)0; o3 < O3; o3++) { + for (uint64_t o4 = (int32_t)0; o4 < O4; o4++) { + + int64_t i1 = o1; + + int64_t i2 = o2; + + int64_t i3 = o3; + + int64_t i4 = o4; + if ((axis == (int32_t)0)) { + i1 = (((I1 / total) * curCount) + o1); + } + if ((axis == (int32_t)1)) { + i2 = (((I2 / total) * curCount) + o2); + } + if ((axis == (int32_t)2)) { + i3 = (((I3 / total) * curCount) + o3); + } + if ((axis == (int32_t)3)) { + i4 = (((I4 / total) * curCount) + o4); + } + Arr4DIdxRowM(out, O1, O2, O3, O4, o1, o2, o3, o4) = + Arr4DIdxRowM(inp, I1, I2, I3, I4, i1, i2, i3, i4); + } + } + } + } +} + +void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CI, CO, fh, fw, ci, co); + } + } + } + } +} + +void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = ((int32_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); + Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, reshapedIPRows, + reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideH, int64_t strideW, int64_t outH, + int64_t outW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t GIS = (CI / G); + + int64_t GOS = (CO / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t cog = (int32_t)0; cog < GOS; cog++) { + for (uint64_t cig = (int32_t)0; cig < GIS; cig++) { + for (uint64_t g = (int32_t)0; g < G; g++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + + uint64_t val = ((int32_t)0); + + int64_t ci = ((GIS * g) + cig); + + int64_t co = ((GOS * g) + cog); + + int64_t curPosH = ((strideH * h) - zPadHLeft); + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + + int64_t curPosW = ((strideW * w) - zPadWLeft); + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && + (curPosH < H)) && + (curPosW < W))) { + val = SecretAdd( + val, + SecretMult(Arr4DIdxRowM(inputArr, N, H, W, CI, n, + curPosH, curPosW, ci), + Arr4DIdxRowM(filterArr, FH, FW, (CI / G), CO, + fh, fw, (ci / G), co))); + } + curPosW = (curPosW + (int32_t)1); + } + curPosH = (curPosH + (int32_t)1); + } + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co) = SecretAdd( + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co), val); + } + } + } + } + } + } +} + +void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, outH, outW, G, inputArr, + filterArr, outArr); +} + +void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + int64_t g, int64_t G, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t CIG = (CI / G); + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + + int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); + Arr2DIdxRowM(outputArr, (CO / G), ((FH * FW) * (CI / G)), co, + linIdx) = Arr4DIdxRowM(inputArr, FH, FW, (CI / G), CO, + fh, fw, ci, (co + startCO)); + } + } + } + } +} + +void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, int64_t g, int64_t G, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, + (co + startCO)) = + Arr2DIdxRowM(inputArr, (CO / G), ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, + int64_t FH, int64_t FW, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t g, int64_t G, + int64_t RRows, int64_t RCols, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + + int64_t CIG = (CI / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + + int64_t startCI = (g * CIG); + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = ((int32_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + (ci + startCI)); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CIG) + (fw * CIG)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t CIG = (CI / G); + + int64_t reshapedFilterRows = (CO / G); + + int64_t reshapedFilterCols = ((FH * FW) * CIG); + + int64_t reshapedIPRows = ((FH * FW) * CIG); + + int64_t outH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t outW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * outH) * outW); + for (uint64_t g = (int32_t)0; g < G; g++) { + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = + make_array(reshapedFilterRows, reshapedIPCols); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); + Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, + zPadWLeft, zPadWRight, strideH, strideW, g, G, + reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + } +} + +void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, + int64_t CO, uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CI, CO, fd, fh, fw, ci, co); + } + } + } + } + } +} + +void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, + int64_t finalW, int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t d = (int32_t)0; d < finalD; d++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr5DIdxRowM(outputArr, N, finalD, finalH, finalW, CO, n, d, h, w, + co) = + Arr2DIdxRowM(inputArr, CO, (((N * finalD) * finalH) * finalW), + co, + ((((((n * finalD) * finalH) * finalW) + + ((d * finalH) * finalW)) + + (h * finalW)) + + w)); + } + } + } + } + } +} + +void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideD, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadDLeft); + + int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= D)) || + ((curPosH < (int32_t)0) || (curPosH >= H))) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = ((int32_t)0); + } else { + val = Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, curPosD, + curPosH, curPosW, ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + + leftTopCornerD = (leftTopCornerD + strideD); + } + } +} + +void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, + int64_t strideH, int64_t strideW, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t newD = + ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = (((N * newD) * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); + Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = ((int32_t)0); + for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); + fd++) { + for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); + fh++) { + for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); + fw++) { + + int64_t curPosD = (fd - zPadDLeft); + + int64_t curPosH = (fh - zPadHLeft); + + int64_t curPosW = (fw - zPadWLeft); + if (((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W))) { + + int64_t curFilterPosD = (fd - (d * strideD)); + + int64_t curFilterPosH = (fh - (h * strideH)); + + int64_t curFilterPosW = (fw - (w * strideW)); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CI, CO, + curFilterPosD, curFilterPosH, + curFilterPosW, ci, co))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, uint64_t *outArr) { + + int64_t outD = + ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, outD, outH, outW, inputArr, filterArr, + outArr); +} + +void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, + int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CO, CI, ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } +} + +void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FH, int64_t FW, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = ((int32_t)0); + } else { + if ((((curPosH % strideH) == (int32_t)0) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = Arr4DIdxRowM(inputArr, N, HPrime, WPrime, CI, n, + idxInputH, idxInputW, ci); + } else { + val = ((int32_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + } +} + +void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, + int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t reshapedIPCols = ((N * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, + zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CO, CI, + ((FD - (int32_t)1) - fd), ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } + } +} + +void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadTrDLeft); + + int64_t DPrimeTilde = + (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); + + int64_t extremeRightBottomCornerD = + ((DPrimeTilde - (int32_t)1) + zPadTrDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || + ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = ((int32_t)0); + } else { + if (((((curPosD % strideD) == (int32_t)0) && + ((curPosH % strideH) == (int32_t)0)) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputD = (curPosD / strideD); + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = + Arr5DIdxRowM(inputArr, N, DPrime, HPrime, WPrime, CI, + n, idxInputD, idxInputH, idxInputW, ci); + } else { + val = ((int32_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + + leftTopCornerD = (leftTopCornerD + (int32_t)1); + } + } +} + +void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t reshapedIPCols = (((N * D) * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose3DReshapeInput( + N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, + zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, + int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = ((int32_t)0); + for (uint64_t fd = d; fd < (d + FD); fd++) { + for (uint64_t fh = h; fh < (h + FH); fh++) { + for (uint64_t fw = w; fw < (w + FW); fw++) { + + int64_t curPosD = ((fd - zPadDLeft) / strideD); + + int64_t curPosH = ((fh - zPadHLeft) / strideD); + + int64_t curPosW = ((fw - zPadWLeft) / strideD); + if ((((((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W)) && + (((fd - zPadDLeft) % strideD) == (int32_t)0)) && + (((fh - zPadHLeft) % strideH) == (int32_t)0)) && + (((fw - zPadWLeft) % strideW) == (int32_t)0))) { + + int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); + + int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); + + int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CO, CI, + curFilterPosD, curFilterPosH, + curFilterPosW, co, ci))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, + int64_t FW, int64_t CO, int64_t D, int64_t H, + int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, + zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, + zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, + D, H, W, inputArr, filterArr, outArr); +} + +void Transpose2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = Arr2DIdxRowM(inArr, s2, s1, j, i); + } + } +} + +void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, + int64_t inps2, int64_t inps3, int64_t inps4, uint64_t *inpArr, + int64_t pads1, int64_t pads2, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = + Arr4DIdxRowM(inpArr, inps1, inps2, inps3, inps4, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0))); + } else { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = ((int32_t)0); + } + } + } + } + } +} + +void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inpArr, int64_t pads1, int64_t pads2, + int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + + int64_t lbounds5 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)0); + + int64_t rbounds5excl = + (s5 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl)) && + (m >= lbounds5)) && + (m < rbounds5excl))) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM(inpArr, inps1, inps2, inps3, inps4, inps5, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0)), + (m - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)4, (int32_t)0))); + } else { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + ((int32_t)0); + } + } + } + } + } + } +} + +void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, + int64_t i2, int64_t i3, int64_t i4, uint64_t *inpArr, + int64_t pads, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = Arr1DIdxRowM(paddings, pads, (int32_t)0); + + int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings, pads, (int32_t)4)); + + int64_t lbounds2 = Arr1DIdxRowM(paddings, pads, (int32_t)1); + + int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings, pads, (int32_t)5)); + + int64_t lbounds3 = Arr1DIdxRowM(paddings, pads, (int32_t)2); + + int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings, pads, (int32_t)6)); + + int64_t lbounds4 = Arr1DIdxRowM(paddings, pads, (int32_t)3); + + int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings, pads, (int32_t)7)); + for (uint64_t i = (int32_t)0; i < o1; i++) { + for (uint64_t j = (int32_t)0; j < o2; j++) { + for (uint64_t k = (int32_t)0; k < o3; k++) { + for (uint64_t l = (int32_t)0; l < o4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = + Arr4DIdxRowM(inpArr, i1, i2, i3, i4, + (i - Arr1DIdxRowM(paddings, pads, (int32_t)0)), + (j - Arr1DIdxRowM(paddings, pads, (int32_t)1)), + (k - Arr1DIdxRowM(paddings, pads, (int32_t)2)), + (l - Arr1DIdxRowM(paddings, pads, (int32_t)3))); + } else { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = ((int32_t)0); + } + } + } + } + } +} + +void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < ins1; i++) { + for (uint64_t j = (int32_t)0; j < ins2; j++) { + for (uint64_t k = (int32_t)0; k < ins3; k++) { + for (uint64_t l = (int32_t)0; l < ins4; l++) { + + int64_t linIdx = + ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + + (k * ins4)) + + l); + + int64_t outIdx1 = (linIdx / s2); + + int64_t outIdx2 = (linIdx % s2); + Arr2DIdxRowM(outArr, s1, s2, outIdx1, outIdx2) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i, j, k, l); + } + } + } + } +} + +void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *inArr, uint64_t *multArr, uint64_t *biasArr, + int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, + uint64_t *outputArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s4, i4); + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s4); + for (uint64_t ii = (int32_t)0; ii < s4; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s4, ii) = Arr1DIdxRowM(biasArr, s4, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outputArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s4, i4)); + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s4, biasArrScaledUp); +} + +void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *inArr, uint64_t *multArr, + uint64_t *biasArr, int64_t multExprScaleDownSf, + int64_t biasExprScaleUpSf, uint64_t *outputArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s5, i5); + } + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s5); + for (uint64_t ii = (int32_t)0; ii < s5; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s5, ii) = Arr1DIdxRowM(biasArr, s5, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outputArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s5, i5)); + } + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s5, biasArrScaledUp); +} + +void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t *arr1, uint64_t *arr2, + uint64_t *outArr) { + + int64_t inpSize = (s1 * s2); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr1, s1, s2, i1, i2); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr2, s1, s2, i1, i2); + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr1, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr2, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr1, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr2, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, int64_t *axes, + uint64_t *outputArr) { + + int64_t divisor = (inS2 * inS3); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = ((int32_t)0); + for (uint64_t i = (int32_t)0; i < inS2; i++) { + for (uint64_t j = (int32_t)0; j < inS3; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i, j, i2)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, + int64_t axis1, int64_t axis2, uint64_t *outputArr) { + + int64_t divisor = (inS3 * inS4); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = ((int32_t)0); + for (uint64_t i = (int32_t)0; i < inS3; i++) { + for (uint64_t j = (int32_t)0; j < inS4; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i2, i, j)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, + uint64_t *inArr, int64_t dim, uint64_t *outArr) { + ArgMax(inArrS1, inArrS2, inArr, outArr); +} + +void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + int64_t dim, uint64_t *outArr) { + + int64_t size = ((ins1 * ins2) * ins3); + + uint64_t *reshapedInArr = make_array(size, ins4); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr2DIdxRowM(reshapedInArr, size, ins4, linIdx, i4) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i1, i2, i3, i4); + } + } + } + } + ArgMax(size, ins4, reshapedInArr, reshapedOutArr); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr3DIdxRowM(outArr, outs1, outs2, outs3, i1, i2, i3) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + ClearMemSecret2(size, ins4, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf, uint64_t doTruncation) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *inArr, + uint64_t *outArr, int64_t sf, uint64_t doTruncation) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *inArr, uint64_t *outArr, int64_t sf, + uint64_t doTruncation) { + + int64_t size = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Floor2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Floor(size, reshapedInArr, reshapedOutArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void ScaleUp1(int64_t s1, uint64_t *arr, int64_t sf) { ScaleUp(s1, arr, sf); } + +void ScaleUp2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown1(int64_t s1, uint64_t *arr, int64_t sf) { + ScaleDown(s1, arr, sf); +} + +void ScaleDown2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +int main(int argc, char **argv) { + ArgMapping amap; + + amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); + amap.arg("port", port, "Port Number"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + amap.arg("nt", num_threads, "Number of Threads"); + amap.arg("ell", bitlength, "Uniform Bitwidth"); + amap.parse(argc, argv); + + assert(party == SERVER || party == CLIENT); + + uint64_t *tmp0 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3); + /* Variable to read the clear value corresponding to the input variable tmp0 + * at (1583,1-1583,44) */ + uint64_t __tmp_in_tmp0; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)32; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)3; i3++) { + if ((party == CLIENT)) { + cin >> __tmp_in_tmp0; + } + Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3, + i0, i1, i2, i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; + } + } + } + } + + uint64_t *tmp1 = + make_array((int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp1 + * at (1586,1-1586,43) */ + uint64_t __tmp_in_tmp1; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)3; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp1; + } + Arr4DIdxRowM(tmp1, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; + } + } + } + } + + uint64_t *tmp2 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp2 + * at (1589,1-1589,44) */ + uint64_t __tmp_in_tmp2; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp2; + } + Arr4DIdxRowM(tmp2, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp2 : 0; + } + } + } + } + + uint64_t *tmp3 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp3 + * at (1592,1-1592,44) */ + uint64_t __tmp_in_tmp3; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp3; + } + Arr4DIdxRowM(tmp3, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp3 : 0; + } + } + } + } + + uint64_t *tmp4 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp4 + * at (1595,1-1595,44) */ + uint64_t __tmp_in_tmp4; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp4; + } + Arr4DIdxRowM(tmp4, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp4 : 0; + } + } + } + } + + uint64_t *tmp5 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp5 + * at (1598,1-1598,44) */ + uint64_t __tmp_in_tmp5; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp5; + } + Arr4DIdxRowM(tmp5, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp5 : 0; + } + } + } + } + + uint64_t *tmp6 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp6 + * at (1601,1-1601,44) */ + uint64_t __tmp_in_tmp6; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp6; + } + Arr4DIdxRowM(tmp6, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp6 : 0; + } + } + } + } + + uint64_t *tmp7 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp7 + * at (1604,1-1604,44) */ + uint64_t __tmp_in_tmp7; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp7; + } + Arr4DIdxRowM(tmp7, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; + } + } + } + } + + uint64_t *tmp8 = make_array((int32_t)1024, (int32_t)10); + /* Variable to read the clear value corresponding to the input variable tmp8 + * at (1607,1-1607,40) */ + uint64_t __tmp_in_tmp8; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)10; i1++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp8; + } + Arr2DIdxRowM(tmp8, (int32_t)1024, (int32_t)10, i0, i1) = + (party == SERVER) ? __tmp_in_tmp8 : 0; + } + } + + uint64_t *tmp9 = make_array((int32_t)10); + /* Variable to read the clear value corresponding to the input variable tmp9 + * at (1610,1-1610,34) */ + uint64_t __tmp_in_tmp9; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)10; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp9; + } + Arr1DIdxRowM(tmp9, (int32_t)10, i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; + } + StartComputation(); + + uint64_t *tmp10 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp0, tmp1, tmp10); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, tmp1); + ClearMemSecret4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3, tmp0); + + uint64_t *tmp13 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp10, tmp13, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp10); + + uint64_t *tmp15 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp13, tmp2, tmp15); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp2); + ClearMemSecret4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp13); + + uint64_t *tmp18 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp15, tmp18, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp15); + + uint64_t *tmp20 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); + AvgPool((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)2, + (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)32, (int32_t)32, + (int32_t)64, tmp18, tmp20); + ClearMemSecret4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp18); + + uint64_t *tmp22 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp20, tmp3, tmp22); + ClearMemSecret4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp20); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp3); + + uint64_t *tmp25 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp22, tmp25, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp22); + + uint64_t *tmp27 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp25, tmp4, tmp27); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp4); + ClearMemSecret4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp25); + + uint64_t *tmp30 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp27, tmp30, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp27); + + uint64_t *tmp32 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); + AvgPool((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)2, + (int32_t)2, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)16, + (int32_t)64, tmp30, tmp32); + ClearMemSecret4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp30); + + uint64_t *tmp34 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)0, (int32_t)1, (int32_t)0, + (int32_t)1, (int32_t)2, (int32_t)2, tmp32, tmp5, tmp34); + ClearMemSecret4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp32); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp5); + + uint64_t *tmp37 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp34, tmp37, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp34); + + uint64_t *tmp39 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp37, tmp6, tmp39); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64, tmp6); + ClearMemSecret4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp37); + + uint64_t *tmp42 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp39, tmp42, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp39); + + uint64_t *tmp44 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp42, tmp7, tmp44); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16, tmp7); + ClearMemSecret4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp42); + + uint64_t *tmp47 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, tmp44, tmp47, + (int32_t)11, 1); + ClearMemSecret4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, tmp44); + + int64_t *tmp49 = make_array((int32_t)2); + Arr1DIdxRowM(tmp49, (int32_t)2, (int64_t)0) = (int32_t)-1; + Arr1DIdxRowM(tmp49, (int32_t)2, (int64_t)1) = (int32_t)1024; + + uint64_t *tmp50 = make_array((int32_t)1, (int32_t)1024); + + int64_t i5; + + int64_t i4; + + int64_t i3; + + int64_t i2; + + int64_t i1; + + int64_t i0; + i0 = (int64_t)0; + i1 = (int64_t)0; + i2 = (int64_t)0; + i3 = (int64_t)0; + for (uint64_t i4 = (int32_t)0; i4 < (int32_t)1; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < (int32_t)1024; i5++) { + Arr2DIdxRowM(tmp50, (int32_t)1, (int32_t)1024, i4, i5) = + Arr4DIdxRowM(tmp47, (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, + i0, i1, i2, i3); + i3 = (i3 + (int64_t)1); + if ((i3 == (int64_t)16)) { + i3 = (int64_t)0; + i2 = (i2 + (int64_t)1); + if ((i2 == (int64_t)8)) { + i2 = (int64_t)0; + i1 = (i1 + (int64_t)1); + if ((i1 == (int64_t)8)) { + i1 = (int64_t)0; + i0 = (i0 + (int64_t)1); + } + } + } + } + } + ClearMemSecret4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, tmp47); + + uint64_t *tmp52 = make_array((int32_t)1, (int32_t)10); + MatMul2D((int32_t)1, (int32_t)1024, (int32_t)10, tmp50, tmp8, tmp52, 0); + ClearMemSecret2((int32_t)1024, (int32_t)10, tmp8); + ClearMemSecret2((int32_t)1, (int32_t)1024, tmp50); + + uint64_t *tmp55 = make_array((int32_t)1, (int32_t)10); + ScaleUp1((int32_t)10, tmp9, (int32_t)11); + MatAddBroadCast2((int32_t)1, (int32_t)10, tmp52, tmp9, tmp55); + ClearMemSecret1((int32_t)10, tmp9); + ClearMemSecret2((int32_t)1, (int32_t)10, tmp52); + + int64_t tmp58 = (int32_t)1; + + uint64_t *tmp59 = make_array((int32_t)1); + ArgMax1((int32_t)1, (int32_t)1, (int32_t)10, tmp55, tmp58, tmp59); + ClearMemSecret2((int32_t)1, (int32_t)10, tmp55); + ClearMemPublic(tmp58); + EndComputation(); + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + cout << (funcReconstruct2PCCons(Arr1DIdxRowM(tmp59, (int32_t)1, i0), 2)) + << endl; + } +} diff --git a/SCI/networks/main_minionn_field64.cpp b/SCI/networks/main_minionn_field64.cpp deleted file mode 100644 index 64903405..00000000 --- a/SCI/networks/main_minionn_field64.cpp +++ /dev/null @@ -1,2170 +0,0 @@ -/* -This is an autogenerated file, generated using the EzPC compiler. -*/ - - -#define BITLEN_41 -#define SCI_HE -#define HACKY_RUN - -#include "globals.h" -#include "functionalities_wrapper.h" -#include -using namespace std; - - -template -T* make_array(size_t s1){ -return new T[s1]; -} - -template -T* make_array(size_t s1, size_t s2){ -return new T[s1*s2]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3){ -return new T[s1*s2*s3]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){ -return new T[s1*s2*s3*s4]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){ -return new T[s1*s2*s3*s4*s5]; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr1DIdxRowM(B,s2,i2)); -} -} -} - -void MatAdd2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr2DIdxRowM(B,s1,s2,i1,i2)); -} -} -} - -void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr1DIdxRowM(B,s4,i4)); -} -} -} -} -} - -void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr4DIdxRowM(B,s1,s2,s3,s4,i1,i2,i3,i4)); -} -} -} -} -} - -void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr1DIdxRowM(B,s5,i5)); -} -} -} -} -} -} - -void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr5DIdxRowM(B,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5)); -} -} -} -} -} -} - -void CreateTensor1(int64_t s1, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(arr,s1,i1) = val; -} -} - -void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(arr,s1,s2,i1,i2) = val; -} -} -} - -void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = val; -} -} -} -} - -void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = val; -} -} -} -} -} - -void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(arr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = val; -} -} -} -} -} -} - -void CopyTensor1(int64_t s1, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(targetArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CopyTensor2(int64_t s1, int64_t s2, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(targetArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(targetArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(targetArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateIdentity11(int64_t s1, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(newArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CreateIdentity22(int64_t s1, int64_t s2, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(newArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(newArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(newArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,inps1,inps2,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j)); -} -} -} - -void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inArr,inps1,inps2,inps3,inps4,inps5,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)2) + k),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)3) + l),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)4) + m)); -} -} -} -} -} -} - -void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,(i1 - inp1s1),i2); -} -} else { -if ((i2 < inp1s2)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,i1,(i2 - inp1s2)); -} -} -} -} -} - -void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,(i1 - inp1s1),i2,i3,i4); -} -} else { -if ((axis == (int32_t)1)) { -if ((i2 < inp1s2)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,(i2 - inp1s2),i3,i4); -} -} else { -if ((axis == (int32_t)2)) { -if ((i3 < inp1s3)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,(i3 - inp1s3),i4); -} -} else { -if ((i4 < inp1s4)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,i3,(i4 - inp1s4)); -} -} -} -} -} -} -} -} -} - -void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, int64_t I2, int64_t I3, int64_t I4, uint64_t* inp, int64_t axis, int64_t curCount, int64_t total, uint64_t* out){ -for (uint64_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint64_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint64_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint64_t o4 = (int32_t)0; o4 < O4; o4++){ - -int64_t i1 = o1; - -int64_t i2 = o2; - -int64_t i3 = o3; - -int64_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (((I1 / total) * curCount) + o1); -} -if ((axis == (int32_t)1)) { -i2 = (((I2 / total) * curCount) + o2); -} -if ((axis == (int32_t)2)) { -i3 = (((I3 / total) * curCount) + o3); -} -if ((axis == (int32_t)3)) { -i4 = (((I4 / total) * curCount) + o4); -} -Arr4DIdxRowM(out,O1,O2,O3,O4,o1,o2,o3,o4) = Arr4DIdxRowM(inp,I1,I2,I3,I4,i1,i2,i3,i4); -} -} -} -} -} - -void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CI,CO,fh,fw,ci,co); -} -} -} -} -} - -void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = ( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t outH, int64_t outW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t GIS = (CI / G); - -int64_t GOS = (CO / G); -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint64_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint64_t g = (int32_t)0; g < G; g++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ - -uint64_t val = ( (int32_t)0); - -int64_t ci = ((GIS * g) + cig); - -int64_t co = ((GOS * g) + cog); - -int64_t curPosH = ((strideH * h) - zPadHLeft); -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ - -int64_t curPosW = ((strideW * w) - zPadWLeft); -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && (curPosH < H)) && (curPosW < W))) { -val = SecretAdd(val, SecretMult(Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci), Arr4DIdxRowM(filterArr,FH,FW,(CI / G),CO,fh,fw,(ci / G),co))); -} -curPosW = (curPosW + (int32_t)1); -} -curPosH = (curPosH + (int32_t)1); -} -Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co) = SecretAdd(Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co), val); -} -} -} -} -} -} -} - -void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t CIG = (CI / G); - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ - -int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); -Arr2DIdxRowM(outputArr,(CO / G),((FH * FW) * (CI / G)),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,(CI / G),CO,fh,fw,ci,(co + startCO)); -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,(co + startCO)) = Arr2DIdxRowM(inputArr,(CO / G),((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t g, int64_t G, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; - -int64_t CIG = (CI / G); -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); - -int64_t startCI = (g * CIG); -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = ( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,(ci + startCI)); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CIG) + (fw * CIG)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t CIG = (CI / G); - -int64_t reshapedFilterRows = (CO / G); - -int64_t reshapedFilterCols = ((FH * FW) * CIG); - -int64_t reshapedIPRows = ((FH * FW) * CIG); - -int64_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * outH) * outW); -for (uint64_t g = (int32_t)0; g < G; g++){ - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -} -} - -void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CI,CO,fd,fh,fw,ci,co); -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t d = (int32_t)0; d < finalD; d++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr5DIdxRowM(outputArr,N,finalD,finalH,finalW,CO,n,d,h,w,co) = Arr2DIdxRowM(inputArr,CO,(((N * finalD) * finalH) * finalW),co,((((((n * finalD) * finalH) * finalW) + ((d * finalH) * finalW)) + (h * finalW)) + w)); -} -} -} -} -} -} - -void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadDLeft); - -int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= D)) || ((curPosH < (int32_t)0) || (curPosH >= H))) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = ( (int32_t)0); -} else { -val = Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -leftTopCornerD = (leftTopCornerD + strideD); -} - -} -} - -void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = (((N * newD) * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = ( (int32_t)0); -for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); fd++){ -for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); fh++){ -for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); fw++){ - -int64_t curPosD = (fd - zPadDLeft); - -int64_t curPosH = (fh - zPadHLeft); - -int64_t curPosW = (fw - zPadWLeft); -if (((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W))) { - -int64_t curFilterPosD = (fd - (d * strideD)); - -int64_t curFilterPosH = (fh - (h * strideH)); - -int64_t curFilterPosW = (fw - (w * strideW)); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CI,CO,curFilterPosD,curFilterPosH,curFilterPosW,ci,co))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CO,CI,((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} - -void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = ( (int32_t)0); -} else { -if ((((curPosH % strideH) == (int32_t)0) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr4DIdxRowM(inputArr,N,HPrime,WPrime,CI,n,idxInputH,idxInputW,ci); -} else { -val = ( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -} -} - -void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t reshapedIPCols = ((N * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CO,CI,((FD - (int32_t)1) - fd),((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadTrDLeft); - -int64_t DPrimeTilde = (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); - -int64_t extremeRightBottomCornerD = ((DPrimeTilde - (int32_t)1) + zPadTrDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = ( (int32_t)0); -} else { -if (((((curPosD % strideD) == (int32_t)0) && ((curPosH % strideH) == (int32_t)0)) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputD = (curPosD / strideD); - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr5DIdxRowM(inputArr,N,DPrime,HPrime,WPrime,CI,n,idxInputD,idxInputH,idxInputW,ci); -} else { -val = ( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -leftTopCornerD = (leftTopCornerD + (int32_t)1); -} - -} -} - -void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t reshapedIPCols = (((N * D) * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = ( (int32_t)0); -for (uint64_t fd = d; fd < (d + FD); fd++){ -for (uint64_t fh = h; fh < (h + FH); fh++){ -for (uint64_t fw = w; fw < (w + FW); fw++){ - -int64_t curPosD = ((fd - zPadDLeft) / strideD); - -int64_t curPosH = ((fh - zPadHLeft) / strideD); - -int64_t curPosW = ((fw - zPadWLeft) / strideD); -if ((((((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W)) && (((fd - zPadDLeft) % strideD) == (int32_t)0)) && (((fh - zPadHLeft) % strideH) == (int32_t)0)) && (((fw - zPadWLeft) % strideW) == (int32_t)0))) { - -int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); - -int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); - -int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CO,CI,curFilterPosD,curFilterPosH,curFilterPosW,co,ci))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,s2,s1,j,i); -} -} -} - -void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = Arr4DIdxRowM(inpArr,inps1,inps2,inps3,inps4,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0))); -} else { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = ( (int32_t)0); -} -} -} -} -} -} - -void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); - -int64_t lbounds5 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0); - -int64_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl)) && (m >= lbounds5)) && (m < rbounds5excl))) { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inpArr,inps1,inps2,inps3,inps4,inps5,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0)),(m - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0))); -} else { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = ( (int32_t)0); -} -} -} -} -} -} -} - -void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, int64_t i2, int64_t i3, int64_t i4, uint64_t* inpArr, int64_t pads, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr1DIdxRowM(paddings,pads, (int32_t)0); - -int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings,pads, (int32_t)4)); - -int64_t lbounds2 = Arr1DIdxRowM(paddings,pads, (int32_t)1); - -int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings,pads, (int32_t)5)); - -int64_t lbounds3 = Arr1DIdxRowM(paddings,pads, (int32_t)2); - -int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings,pads, (int32_t)6)); - -int64_t lbounds4 = Arr1DIdxRowM(paddings,pads, (int32_t)3); - -int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings,pads, (int32_t)7)); -for (uint64_t i = (int32_t)0; i < o1; i++){ -for (uint64_t j = (int32_t)0; j < o2; j++){ -for (uint64_t k = (int32_t)0; k < o3; k++){ -for (uint64_t l = (int32_t)0; l < o4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = Arr4DIdxRowM(inpArr,i1,i2,i3,i4,(i - Arr1DIdxRowM(paddings,pads, (int32_t)0)),(j - Arr1DIdxRowM(paddings,pads, (int32_t)1)),(k - Arr1DIdxRowM(paddings,pads, (int32_t)2)),(l - Arr1DIdxRowM(paddings,pads, (int32_t)3))); -} else { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = ( (int32_t)0); -} -} -} -} -} -} - -void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < ins1; i++){ -for (uint64_t j = (int32_t)0; j < ins2; j++){ -for (uint64_t k = (int32_t)0; k < ins3; k++){ -for (uint64_t l = (int32_t)0; l < ins4; l++){ - -int64_t linIdx = ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + (k * ins4)) + l); - -int64_t outIdx1 = (linIdx / s2); - -int64_t outIdx2 = (linIdx % s2); -Arr2DIdxRowM(outArr,s1,s2,outIdx1,outIdx2) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i,j,k,l); -} -} -} -} -} - -void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s4,i4); -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s4); -for (uint64_t ii = (int32_t)0; ii < s4; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s4,ii) = Arr1DIdxRowM(biasArr,s4,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outputArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s4,i4)); -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s5,i5); -} -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s5); -for (uint64_t ii = (int32_t)0; ii < s5; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s5,ii) = Arr1DIdxRowM(biasArr,s5,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outputArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s5,i5)); -} -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s5, biasArrScaledUp); -} - -void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (s1 * s2); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr1,s1,s2,i1,i2); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr2,s1,s2,i1,i2); -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr1,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr2,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr1,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr2,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t* axes, uint64_t* outputArr){ - -int64_t divisor = (inS2 * inS3); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = ( (int32_t)0); -for (uint64_t i = (int32_t)0; i < inS2; i++){ -for (uint64_t j = (int32_t)0; j < inS3; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i,j,i2)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t axis1, int64_t axis2, uint64_t* outputArr){ - -int64_t divisor = (inS3 * inS4); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = ( (int32_t)0); -for (uint64_t i = (int32_t)0; i < inS3; i++){ -for (uint64_t j = (int32_t)0; j < inS4; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i2,i,j)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, uint64_t* inArr, int64_t dim, uint64_t* outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, int64_t dim, uint64_t* outArr){ - -int64_t size = ((ins1 * ins2) * ins3); - -uint64_t* reshapedInArr = make_array(size, ins4); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr2DIdxRowM(reshapedInArr,size,ins4,linIdx,i4) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i1,i2,i3,i4); -} -} -} -} -ArgMax(size, ins4, reshapedInArr, reshapedOutArr); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr3DIdxRowM(outArr,outs1,outs2,outs3,i1,i2,i3) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -ClearMemSecret2(size, ins4, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Floor2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Floor(size, reshapedInArr, reshapedOutArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void ScaleUp1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleUp(s1, arr, sf); -} - -void ScaleUp2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleDown(s1, arr, sf); -} - -void ScaleDown2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - - -int main(int argc, char** argv) -{ -ArgMapping amap; -int port = 32000; -string serverAddr = "127.0.0.1"; - -amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); -amap.arg("p", port, "Port Number"); -amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); -amap.parse(argc, argv); - -assert(party==sci::ALICE || party==sci::BOB); - -checkIfUsingEigen(); -for(int i=0;i(ioArr[i]); -prgInstanceArr[i] = new sci::PRG128(); -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); -if (i == 0) { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength); -} -else if (i == 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength); -} -else if (i & 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[1]); -} -else { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[0]); -} -} - -io = ioArr[0]; -iknpOT = new sci::IKNP(io); -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good -kkot = new sci::KKOT(io); -prg128Instance = new sci::PRG128(); -otpack = new sci::OTPack(io, party, baseForRelu, bitlength); - -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - -#ifdef SCI_OT -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack); -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -#endif - -#ifdef SCI_HE -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -heConvImpl = new ConvField(party,io); -heFCImpl = new FCField(party,io); -heProdImpl = new ElemWiseProdField(party, io); -assertFieldRun(); -#endif -#ifdef MULTITHREADED_NONLIN -#ifdef SCI_OT -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -} -#endif -#ifdef SCI_HE -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -} -#endif -#endif - -if (party==sci::ALICE){ -iknpOT->setup_send(); -iknpOTRoleReversed->setup_recv(); -} -else if (party==sci::BOB){ -iknpOT->setup_recv(); -iknpOTRoleReversed->setup_send(); -} -cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3); -/* Variable to read the clear value corresponding to the input variable tmp0 at (1583,1-1583,44) */ -uint64_t __tmp_in_tmp0; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)32; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)3; i3++){ -if ((party == CLIENT)) { -cin >> __tmp_in_tmp0; -} -Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3,i0,i1,i2,i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; -} -} -} -} - -uint64_t* tmp1 = make_array( (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp1 at (1586,1-1586,43) */ -uint64_t __tmp_in_tmp1; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)3; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp1; -} -Arr4DIdxRowM(tmp1, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; -} -} -} -} - -uint64_t* tmp2 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp2 at (1589,1-1589,44) */ -uint64_t __tmp_in_tmp2; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp2; -} -Arr4DIdxRowM(tmp2, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp2 : 0; -} -} -} -} - -uint64_t* tmp3 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp3 at (1592,1-1592,44) */ -uint64_t __tmp_in_tmp3; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp3; -} -Arr4DIdxRowM(tmp3, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp3 : 0; -} -} -} -} - -uint64_t* tmp4 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp4 at (1595,1-1595,44) */ -uint64_t __tmp_in_tmp4; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp4; -} -Arr4DIdxRowM(tmp4, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp4 : 0; -} -} -} -} - -uint64_t* tmp5 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp5 at (1598,1-1598,44) */ -uint64_t __tmp_in_tmp5; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp5; -} -Arr4DIdxRowM(tmp5, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp5 : 0; -} -} -} -} - -uint64_t* tmp6 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp6 at (1601,1-1601,44) */ -uint64_t __tmp_in_tmp6; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp6; -} -Arr4DIdxRowM(tmp6, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp6 : 0; -} -} -} -} - -uint64_t* tmp7 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp7 at (1604,1-1604,44) */ -uint64_t __tmp_in_tmp7; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp7; -} -Arr4DIdxRowM(tmp7, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; -} -} -} -} - -uint64_t* tmp8 = make_array( (int32_t)1024, (int32_t)10); -/* Variable to read the clear value corresponding to the input variable tmp8 at (1607,1-1607,40) */ -uint64_t __tmp_in_tmp8; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)10; i1++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp8; -} -Arr2DIdxRowM(tmp8, (int32_t)1024, (int32_t)10,i0,i1) = (party == SERVER) ? __tmp_in_tmp8 : 0; -} -} - -uint64_t* tmp9 = make_array( (int32_t)10); -/* Variable to read the clear value corresponding to the input variable tmp9 at (1610,1-1610,34) */ -uint64_t __tmp_in_tmp9; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)10; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp9; -} -Arr1DIdxRowM(tmp9, (int32_t)10,i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; -} -StartComputation(); - -uint64_t* tmp10 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp0, tmp1, tmp10); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, tmp1); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3, tmp0); - -uint64_t* tmp13 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp10, tmp13, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp10); - -uint64_t* tmp15 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp13, tmp2, tmp15); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp2); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp13); - -uint64_t* tmp18 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp15, tmp18, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp15); - -uint64_t* tmp20 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -AvgPool( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp18, tmp20); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp18); - -uint64_t* tmp22 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp20, tmp3, tmp22); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp20); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp3); - -uint64_t* tmp25 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp22, tmp25, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp22); - -uint64_t* tmp27 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp25, tmp4, tmp27); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp4); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp25); - -uint64_t* tmp30 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp27, tmp30, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp27); - -uint64_t* tmp32 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -AvgPool( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp30, tmp32); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp30); - -uint64_t* tmp34 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)2, (int32_t)2, tmp32, tmp5, tmp34); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp32); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp5); - -uint64_t* tmp37 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp34, tmp37, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp34); - -uint64_t* tmp39 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp37, tmp6, tmp39); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64, tmp6); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp37); - -uint64_t* tmp42 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp39, tmp42, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp39); - -uint64_t* tmp44 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp42, tmp7, tmp44); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16, tmp7); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp42); - -uint64_t* tmp47 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, tmp44, tmp47, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, tmp44); - -int64_t* tmp49 = make_array( (int32_t)2); -Arr1DIdxRowM(tmp49, (int32_t)2, (int64_t)0) = (int32_t)-1; -Arr1DIdxRowM(tmp49, (int32_t)2, (int64_t)1) = (int32_t)1024; - -uint64_t* tmp50 = make_array( (int32_t)1, (int32_t)1024); - -int64_t i5; - -int64_t i4; - -int64_t i3; - -int64_t i2; - -int64_t i1; - -int64_t i0; -i0 = (int64_t)0; -i1 = (int64_t)0; -i2 = (int64_t)0; -i3 = (int64_t)0; -for (uint64_t i4 = (int32_t)0; i4 < (int32_t)1; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < (int32_t)1024; i5++){ -Arr2DIdxRowM(tmp50, (int32_t)1, (int32_t)1024,i4,i5) = Arr4DIdxRowM(tmp47, (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16,i0,i1,i2,i3); -i3 = (i3 + (int64_t)1); -if ((i3 == (int64_t)16)) { -i3 = (int64_t)0; -i2 = (i2 + (int64_t)1); -if ((i2 == (int64_t)8)) { -i2 = (int64_t)0; -i1 = (i1 + (int64_t)1); -if ((i1 == (int64_t)8)) { -i1 = (int64_t)0; -i0 = (i0 + (int64_t)1); -} -} -} -} -} -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, tmp47); - -uint64_t* tmp52 = make_array( (int32_t)1, (int32_t)10); -MatMul2D( (int32_t)1, (int32_t)1024, (int32_t)10, tmp50, tmp8, tmp52, 0); -ClearMemSecret2( (int32_t)1024, (int32_t)10, tmp8); -ClearMemSecret2( (int32_t)1, (int32_t)1024, tmp50); - -uint64_t* tmp55 = make_array( (int32_t)1, (int32_t)10); -ScaleUp1( (int32_t)10, tmp9, (int32_t)11); -MatAddBroadCast2( (int32_t)1, (int32_t)10, tmp52, tmp9, tmp55); -ClearMemSecret1( (int32_t)10, tmp9); -ClearMemSecret2( (int32_t)1, (int32_t)10, tmp52); - -int64_t tmp58 = (int32_t)1; - -uint64_t* tmp59 = make_array( (int32_t)1); -ArgMax1( (int32_t)1, (int32_t)1, (int32_t)10, tmp55, tmp58, tmp59); -ClearMemSecret2( (int32_t)1, (int32_t)10, tmp55); -ClearMemPublic(tmp58); -EndComputation(); -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -cout << (funcReconstruct2PCCons(Arr1DIdxRowM(tmp59, (int32_t)1,i0), 2)) << endl; -} -} - diff --git a/SCI/networks/main_minionn_ring32.cpp b/SCI/networks/main_minionn_ring32.cpp deleted file mode 100644 index 8cdce115..00000000 --- a/SCI/networks/main_minionn_ring32.cpp +++ /dev/null @@ -1,2169 +0,0 @@ -/* -This is an autogenerated file, generated using the EzPC compiler. -*/ - - -#define BITLEN_32 -#define SCI_OT -#define HACKY_RUN - -#include "globals.h" -#include "functionalities_wrapper.h" -#include -using namespace std; - -template -T* make_array(size_t s1){ -return new T[s1]; -} - -template -T* make_array(size_t s1, size_t s2){ -return new T[s1*s2]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3){ -return new T[s1*s2*s3]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){ -return new T[s1*s2*s3*s4]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){ -return new T[s1*s2*s3*s4*s5]; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void MatAddBroadCast2(int32_t s1, int32_t s2, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr1DIdxRowM(B,s2,i2)); -} -} -} - -void MatAdd2(int32_t s1, int32_t s2, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr2DIdxRowM(B,s1,s2,i1,i2)); -} -} -} - -void MatAddBroadCast4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr1DIdxRowM(B,s4,i4)); -} -} -} -} -} - -void MatAdd4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr4DIdxRowM(B,s1,s2,s3,s4,i1,i2,i3,i4)); -} -} -} -} -} - -void MatAddBroadCast5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr1DIdxRowM(B,s5,i5)); -} -} -} -} -} -} - -void MatAdd5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr5DIdxRowM(B,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5)); -} -} -} -} -} -} - -void CreateTensor1(int32_t s1, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(arr,s1,i1) = val; -} -} - -void CreateTensor2(int32_t s1, int32_t s2, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(arr,s1,s2,i1,i2) = val; -} -} -} - -void CreateTensor3(int32_t s1, int32_t s2, int32_t s3, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = val; -} -} -} -} - -void CreateTensor4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = val; -} -} -} -} -} - -void CreateTensor5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(arr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = val; -} -} -} -} -} -} - -void CopyTensor1(int32_t s1, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(targetArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CopyTensor2(int32_t s1, int32_t s2, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(targetArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CopyTensor3(int32_t s1, int32_t s2, int32_t s3, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(targetArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CopyTensor4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(targetArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateIdentity11(int32_t s1, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(newArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CreateIdentity22(int32_t s1, int32_t s2, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(newArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CreateIdentity33(int32_t s1, int32_t s2, int32_t s3, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(newArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CreateIdentity44(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(newArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateCopy2211(int32_t s1, int32_t s2, int32_t inps1, int32_t inps2, uint32_t* inArr, int32_t perDimSize, int32_t* beginIdx, int32_t* sizeIdx, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,inps1,inps2,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j)); -} -} -} - -void CreateCopy5511(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, int32_t inps5, uint32_t* inArr, int32_t perDimSize, int32_t* beginIdx, int32_t* sizeIdx, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -for (uint32_t m = (int32_t)0; m < s5; m++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inArr,inps1,inps2,inps3,inps4,inps5,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)2) + k),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)3) + l),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)4) + m)); -} -} -} -} -} -} - -void Concat2T222(int32_t s1, int32_t s2, int32_t inp1s1, int32_t inp1s2, uint32_t* inp1, int32_t inp2s1, int32_t inp2s2, uint32_t* inp2, int32_t axis, uint32_t* outp){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,(i1 - inp1s1),i2); -} -} else { -if ((i2 < inp1s2)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,i1,(i2 - inp1s2)); -} -} -} -} -} - -void Concat2T444(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t inp1s1, int32_t inp1s2, int32_t inp1s3, int32_t inp1s4, uint32_t* inp1, int32_t inp2s1, int32_t inp2s2, int32_t inp2s3, int32_t inp2s4, uint32_t* inp2, int32_t axis, uint32_t* outp){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,(i1 - inp1s1),i2,i3,i4); -} -} else { -if ((axis == (int32_t)1)) { -if ((i2 < inp1s2)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,(i2 - inp1s2),i3,i4); -} -} else { -if ((axis == (int32_t)2)) { -if ((i3 < inp1s3)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,(i3 - inp1s3),i4); -} -} else { -if ((i4 < inp1s4)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,i3,(i4 - inp1s4)); -} -} -} -} -} -} -} -} -} - -void Split44(int32_t O1, int32_t O2, int32_t O3, int32_t O4, int32_t I1, int32_t I2, int32_t I3, int32_t I4, uint32_t* inp, int32_t axis, int32_t curCount, int32_t total, uint32_t* out){ -for (uint32_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint32_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint32_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint32_t o4 = (int32_t)0; o4 < O4; o4++){ - -int32_t i1 = o1; - -int32_t i2 = o2; - -int32_t i3 = o3; - -int32_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (((I1 / total) * curCount) + o1); -} -if ((axis == (int32_t)1)) { -i2 = (((I2 / total) * curCount) + o2); -} -if ((axis == (int32_t)2)) { -i3 = (((I3 / total) * curCount) + o3); -} -if ((axis == (int32_t)3)) { -i4 = (((I4 / total) * curCount) + o4); -} -Arr4DIdxRowM(out,O1,O2,O3,O4,o1,o2,o3,o4) = Arr4DIdxRowM(inp,I1,I2,I3,I4,i1,i2,i3,i4); -} -} -} -} -} - -void Conv2DReshapeFilter(int32_t FH, int32_t FW, int32_t CI, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CI,CO,fh,fw,ci,co); -} -} -} -} -} - -void Conv2DReshapeMatMulOP(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInput(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = ( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = ( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2D(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = ((FH * FW) * CI); - -int32_t reshapedIPRows = ((FH * FW) * CI); - -int32_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = ((N * newH) * newW); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t outH, int32_t outW, int32_t G, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t GIS = (CI / G); - -int32_t GOS = (CO / G); -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint32_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint32_t g = (int32_t)0; g < G; g++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ - -uint32_t val = ( (int32_t)0); - -int32_t ci = ((GIS * g) + cig); - -int32_t co = ((GOS * g) + cog); - -int32_t curPosH = ((strideH * h) - zPadHLeft); -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ - -int32_t curPosW = ((strideW * w) - zPadWLeft); -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && (curPosH < H)) && (curPosW < W))) { -val = SecretAdd(val, SecretMult(Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci), Arr4DIdxRowM(filterArr,FH,FW,(CI / G),CO,fh,fw,(ci / G),co))); -} -curPosW = (curPosW + (int32_t)1); -} -curPosH = (curPosH + (int32_t)1); -} -Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co) = SecretAdd(Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co), val); -} -} -} -} -} -} -} - -void Conv2DLoop(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t G, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int32_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup(int32_t FH, int32_t FW, int32_t CI, int32_t CO, int32_t g, int32_t G, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t CIG = (CI / G); - -int32_t COG = (CO / G); - -int32_t startCO = (g * COG); -for (uint32_t co = (int32_t)0; co < COG; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CIG; ci++){ - -int32_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); -Arr2DIdxRowM(outputArr,(CO / G),((FH * FW) * (CI / G)),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,(CI / G),CO,fh,fw,ci,(co + startCO)); -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, int32_t g, int32_t G, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t COG = (CO / G); - -int32_t startCO = (g * COG); -for (uint32_t co = (int32_t)0; co < COG; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,(co + startCO)) = Arr2DIdxRowM(inputArr,(CO / G),((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInputGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t g, int32_t G, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; - -int32_t CIG = (CI / G); -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = ( (int32_t)0); - -int32_t startCI = (g * CIG); -for (uint32_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = ( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,(ci + startCI)); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CIG) + (fw * CIG)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2DGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t G, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t CIG = (CI / G); - -int32_t reshapedFilterRows = (CO / G); - -int32_t reshapedFilterCols = ((FH * FW) * CIG); - -int32_t reshapedIPRows = ((FH * FW) * CIG); - -int32_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = ((N * outH) * outW); -for (uint32_t g = (int32_t)0; g < G; g++){ - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -} -} - -void Conv3DReshapeFilter(int32_t FD, int32_t FH, int32_t FW, int32_t CI, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CI,CO,fd,fh,fw,ci,co); -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP(int32_t N, int32_t finalD, int32_t finalH, int32_t finalW, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t d = (int32_t)0; d < finalD; d++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr5DIdxRowM(outputArr,N,finalD,finalH,finalW,CO,n,d,h,w,co) = Arr2DIdxRowM(inputArr,CO,(((N * finalD) * finalH) * finalW),co,((((((n * finalD) * finalH) * finalW) + ((d * finalH) * finalW)) + (h * finalW)) + w)); -} -} -} -} -} -} - -void Conv3DReshapeInput(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerD = ( (int32_t)0 - zPadDLeft); - -int32_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosD = (leftTopCornerD + fd); - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = ( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= D)) || ((curPosH < (int32_t)0) || (curPosH >= H))) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = ( (int32_t)0); -} else { -val = Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -leftTopCornerD = (leftTopCornerD + strideD); -} - -} -} - -void Conv3D(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int32_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int32_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); - -int32_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = (((N * newD) * newH) * newW); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t outD, int32_t outH, int32_t outW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t d = (int32_t)0; d < outD; d++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -uint32_t val = ( (int32_t)0); -for (uint32_t fd = (d * strideD); fd < ((d * strideD) + FD); fd++){ -for (uint32_t fh = (h * strideH); fh < ((h * strideH) + FH); fh++){ -for (uint32_t fw = (w * strideW); fw < ((w * strideW) + FW); fw++){ - -int32_t curPosD = (fd - zPadDLeft); - -int32_t curPosH = (fh - zPadHLeft); - -int32_t curPosW = (fw - zPadWLeft); -if (((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W))) { - -int32_t curFilterPosD = (fd - (d * strideD)); - -int32_t curFilterPosH = (fh - (h * strideH)); - -int32_t curFilterPosW = (fw - (w * strideW)); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CI,CO,curFilterPosD,curFilterPosH,curFilterPosW,ci,co))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void Conv3DLoop(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); - -int32_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int32_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void ConvTranspose2DReshapeFilter(int32_t FH, int32_t FW, int32_t CO, int32_t CI, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CO,CI,((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} - -void ConvTranspose2DReshapeInput(int32_t N, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FH, int32_t FW, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int32_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int32_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int32_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int32_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = ( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = ( (int32_t)0); -} else { -if ((((curPosH % strideH) == (int32_t)0) && ((curPosW % strideW) == (int32_t)0))) { - -int32_t idxInputH = (curPosH / strideH); - -int32_t idxInputW = (curPosW / strideW); -val = Arr4DIdxRowM(inputArr,N,HPrime,WPrime,CI,n,idxInputH,idxInputW,ci); -} else { -val = ( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -} -} - -void ConvTranspose2D(int32_t N, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t H, int32_t W, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = ((FH * FW) * CI); - -int32_t reshapedIPRows = ((FH * FW) * CI); - -int32_t reshapedIPCols = ((N * H) * W); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter(int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t CI, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CO,CI,((FD - (int32_t)1) - fd),((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerD = ( (int32_t)0 - zPadTrDLeft); - -int32_t DPrimeTilde = (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); - -int32_t extremeRightBottomCornerD = ((DPrimeTilde - (int32_t)1) + zPadTrDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int32_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int32_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int32_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int32_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int32_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosD = (leftTopCornerD + fd); - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = ( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = ( (int32_t)0); -} else { -if (((((curPosD % strideD) == (int32_t)0) && ((curPosH % strideH) == (int32_t)0)) && ((curPosW % strideW) == (int32_t)0))) { - -int32_t idxInputD = (curPosD / strideD); - -int32_t idxInputH = (curPosH / strideH); - -int32_t idxInputW = (curPosW / strideW); -val = Arr5DIdxRowM(inputArr,N,DPrime,HPrime,WPrime,CI,n,idxInputD,idxInputH,idxInputW,ci); -} else { -val = ( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -leftTopCornerD = (leftTopCornerD + (int32_t)1); -} - -} -} - -void ConvTranspose3D(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t D, int32_t H, int32_t W, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int32_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int32_t reshapedIPCols = (((N * D) * H) * W); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t outD, int32_t outH, int32_t outW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t d = (int32_t)0; d < outD; d++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -uint32_t val = ( (int32_t)0); -for (uint32_t fd = d; fd < (d + FD); fd++){ -for (uint32_t fh = h; fh < (h + FH); fh++){ -for (uint32_t fw = w; fw < (w + FW); fw++){ - -int32_t curPosD = ((fd - zPadDLeft) / strideD); - -int32_t curPosH = ((fh - zPadHLeft) / strideD); - -int32_t curPosW = ((fw - zPadWLeft) / strideD); -if ((((((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W)) && (((fd - zPadDLeft) % strideD) == (int32_t)0)) && (((fh - zPadHLeft) % strideH) == (int32_t)0)) && (((fw - zPadWLeft) % strideW) == (int32_t)0))) { - -int32_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); - -int32_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); - -int32_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CO,CI,curFilterPosD,curFilterPosH,curFilterPosW,co,ci))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t D, int32_t H, int32_t W, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ -ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2(int32_t s1, int32_t s2, uint32_t* inArr, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,s2,s1,j,i); -} -} -} - -void Pad442(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, uint32_t* inpArr, int32_t pads1, int32_t pads2, int32_t* paddings, uint32_t* outArr){ - -int32_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int32_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int32_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int32_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int32_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int32_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int32_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int32_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = Arr4DIdxRowM(inpArr,inps1,inps2,inps3,inps4,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0))); -} else { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = ( (int32_t)0); -} -} -} -} -} -} - -void Pad552(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, int32_t inps5, uint32_t* inpArr, int32_t pads1, int32_t pads2, int32_t* paddings, uint32_t* outArr){ - -int32_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int32_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int32_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int32_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int32_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int32_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int32_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int32_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); - -int32_t lbounds5 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0); - -int32_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)1)); -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -for (uint32_t m = (int32_t)0; m < s5; m++){ -if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl)) && (m >= lbounds5)) && (m < rbounds5excl))) { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inpArr,inps1,inps2,inps3,inps4,inps5,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0)),(m - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0))); -} else { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = ( (int32_t)0); -} -} -} -} -} -} -} - -void PadONNX441(int32_t o1, int32_t o2, int32_t o3, int32_t o4, int32_t i1, int32_t i2, int32_t i3, int32_t i4, uint32_t* inpArr, int32_t pads, int32_t* paddings, uint32_t* outArr){ - -int32_t lbounds1 = Arr1DIdxRowM(paddings,pads, (int32_t)0); - -int32_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings,pads, (int32_t)4)); - -int32_t lbounds2 = Arr1DIdxRowM(paddings,pads, (int32_t)1); - -int32_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings,pads, (int32_t)5)); - -int32_t lbounds3 = Arr1DIdxRowM(paddings,pads, (int32_t)2); - -int32_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings,pads, (int32_t)6)); - -int32_t lbounds4 = Arr1DIdxRowM(paddings,pads, (int32_t)3); - -int32_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings,pads, (int32_t)7)); -for (uint32_t i = (int32_t)0; i < o1; i++){ -for (uint32_t j = (int32_t)0; j < o2; j++){ -for (uint32_t k = (int32_t)0; k < o3; k++){ -for (uint32_t l = (int32_t)0; l < o4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = Arr4DIdxRowM(inpArr,i1,i2,i3,i4,(i - Arr1DIdxRowM(paddings,pads, (int32_t)0)),(j - Arr1DIdxRowM(paddings,pads, (int32_t)1)),(k - Arr1DIdxRowM(paddings,pads, (int32_t)2)),(l - Arr1DIdxRowM(paddings,pads, (int32_t)3))); -} else { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = ( (int32_t)0); -} -} -} -} -} -} - -void Squeeze24(int32_t s1, int32_t s2, int32_t dim1, int32_t dim2, int32_t ins1, int32_t ins2, int32_t ins3, int32_t ins4, uint32_t* inArr, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < ins1; i++){ -for (uint32_t j = (int32_t)0; j < ins2; j++){ -for (uint32_t k = (int32_t)0; k < ins3; k++){ -for (uint32_t l = (int32_t)0; l < ins4; l++){ - -int32_t linIdx = ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + (k * ins4)) + l); - -int32_t outIdx1 = (linIdx / s2); - -int32_t outIdx2 = (linIdx % s2); -Arr2DIdxRowM(outArr,s1,s2,outIdx1,outIdx2) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i,j,k,l); -} -} -} -} -} - -void FusedBatchNorm4411(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* inArr, uint32_t* multArr, uint32_t* biasArr, int32_t multExprScaleDownSf, int32_t biasExprScaleUpSf, uint32_t* outputArr){ - -int32_t inpSize = (((s1 * s2) * s3) * s4); - -uint32_t* inArrReshaped = make_array(inpSize); - -uint32_t* multArrReshaped = make_array(inpSize); - -uint32_t* multExprAns = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s4,i4); -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint32_t* biasArrScaledUp = make_array(s4); -for (uint32_t ii = (int32_t)0; ii < s4; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s4,ii) = Arr1DIdxRowM(biasArr,s4,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outputArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s4,i4)); -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* inArr, uint32_t* multArr, uint32_t* biasArr, int32_t multExprScaleDownSf, int32_t biasExprScaleUpSf, uint32_t* outputArr){ - -int32_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint32_t* inArrReshaped = make_array(inpSize); - -uint32_t* multArrReshaped = make_array(inpSize); - -uint32_t* multExprAns = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s5,i5); -} -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint32_t* biasArrScaledUp = make_array(s5); -for (uint32_t ii = (int32_t)0; ii < s5; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s5,ii) = Arr1DIdxRowM(biasArr,s5,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outputArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s5,i5)); -} -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s5, biasArrScaledUp); -} - -void ElemWiseMul2(int32_t s1, int32_t s2, uint32_t* arr1, uint32_t* arr2, uint32_t* outArr){ - -int32_t inpSize = (s1 * s2); - -uint32_t* arr1Reshaped = make_array(inpSize); - -uint32_t* arr2Reshaped = make_array(inpSize); - -uint32_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr1,s1,s2,i1,i2); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr2,s1,s2,i1,i2); -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* arr1, uint32_t* arr2, uint32_t* outArr){ - -int32_t inpSize = (((s1 * s2) * s3) * s4); - -uint32_t* arr1Reshaped = make_array(inpSize); - -uint32_t* arr2Reshaped = make_array(inpSize); - -uint32_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr1,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr2,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* arr1, uint32_t* arr2, uint32_t* outArr){ - -int32_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint32_t* arr1Reshaped = make_array(inpSize); - -uint32_t* arr2Reshaped = make_array(inpSize); - -uint32_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr1,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr2,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ReduceMean24(int32_t outS1, int32_t outS2, int32_t inS1, int32_t inS2, int32_t inS3, int32_t inS4, uint32_t* inputArr, int32_t* axes, uint32_t* outputArr){ - -int32_t divisor = (inS2 * inS3); - -int32_t outputSize = (outS1 * outS2); - -uint32_t* sumArr = make_array(outputSize); - -uint32_t* outputArrReshaped = make_array(outputSize); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint32_t summ = ( (int32_t)0); -for (uint32_t i = (int32_t)0; i < inS2; i++){ -for (uint32_t j = (int32_t)0; j < inS3; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i,j,i2)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24(int32_t outS1, int32_t outS2, int32_t inS1, int32_t inS2, int32_t inS3, int32_t inS4, uint32_t* inputArr, int32_t axis1, int32_t axis2, uint32_t* outputArr){ - -int32_t divisor = (inS3 * inS4); - -int32_t outputSize = (outS1 * outS2); - -uint32_t* sumArr = make_array(outputSize); - -uint32_t* outputArrReshaped = make_array(outputSize); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint32_t summ = ( (int32_t)0); -for (uint32_t i = (int32_t)0; i < inS3; i++){ -for (uint32_t j = (int32_t)0; j < inS4; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i2,i,j)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ArgMax1(int32_t outArrS1, int32_t inArrS1, int32_t inArrS2, uint32_t* inArr, int32_t dim, uint32_t* outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3(int32_t outs1, int32_t outs2, int32_t outs3, int32_t ins1, int32_t ins2, int32_t ins3, int32_t ins4, uint32_t* inArr, int32_t dim, uint32_t* outArr){ - -int32_t size = ((ins1 * ins2) * ins3); - -uint32_t* reshapedInArr = make_array(size, ins4); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < ins4; i4++){ - -int32_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr2DIdxRowM(reshapedInArr,size,ins4,linIdx,i4) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i1,i2,i3,i4); -} -} -} -} -ArgMax(size, ins4, reshapedInArr, reshapedOutArr); -for (uint32_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < ins3; i3++){ - -int32_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr3DIdxRowM(outArr,outs1,outs2,outs3,i1,i2,i3) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -ClearMemSecret2(size, ins4, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu2(int32_t s1, int32_t s2, uint32_t* inArr, uint32_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* inArr, uint32_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* inArr, uint32_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = ((((s1 * s2) * s3) * s4) * s5); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Floor2(int32_t s1, int32_t s2, uint32_t* inArr, uint32_t* outArr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Floor(size, reshapedInArr, reshapedOutArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void ScaleUp1(int32_t s1, uint32_t* arr, int32_t sf){ -ScaleUp(s1, arr, sf); -} - -void ScaleUp2(int32_t s1, int32_t s2, uint32_t* arr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp3(int32_t s1, int32_t s2, int32_t s3, uint32_t* arr, int32_t sf){ - -int32_t size = ((s1 * s2) * s3); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* arr, int32_t sf){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown1(int32_t s1, uint32_t* arr, int32_t sf){ -ScaleDown(s1, arr, sf); -} - -void ScaleDown2(int32_t s1, int32_t s2, uint32_t* arr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown3(int32_t s1, int32_t s2, int32_t s3, uint32_t* arr, int32_t sf){ - -int32_t size = ((s1 * s2) * s3); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* arr, int32_t sf){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - - -int main(int argc, char** argv) -{ -ArgMapping amap; -int port = 32000; -string serverAddr = "127.0.0.1"; - -amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); -amap.arg("p", port, "Port Number"); -amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); -amap.parse(argc, argv); - -assert(party==sci::ALICE || party==sci::BOB); - -checkIfUsingEigen(); -for(int i=0;i(ioArr[i]); -prgInstanceArr[i] = new sci::PRG128(); -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); -if (i == 0) { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength); -} -else if (i == 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength); -} -else if (i & 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[1]); -} -else { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[0]); -} -} - -io = ioArr[0]; -iknpOT = new sci::IKNP(io); -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good -kkot = new sci::KKOT(io); -prg128Instance = new sci::PRG128(); -otpack = new sci::OTPack(io, party, baseForRelu, bitlength); - -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - -#ifdef SCI_OT -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack); -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -#endif - -#ifdef SCI_HE -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -heConvImpl = new ConvField(party,io); -heFCImpl = new FCField(party,io); -heProdImpl = new ElemWiseProdField(party, io); -assertFieldRun(); -#endif -#ifdef MULTITHREADED_NONLIN -#ifdef SCI_OT -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -} -#endif -#ifdef SCI_HE -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -} -#endif -#endif - -if (party==sci::ALICE){ -iknpOT->setup_send(); -iknpOTRoleReversed->setup_recv(); -} -else if (party==sci::BOB){ -iknpOT->setup_recv(); -iknpOTRoleReversed->setup_send(); -} -cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3); -/* Variable to read the clear value corresponding to the input variable tmp0 at (1583,1-1583,44) */ -uint32_t __tmp_in_tmp0; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)32; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)3; i3++){ -if ((party == CLIENT)) { -cin >> __tmp_in_tmp0; -} -Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3,i0,i1,i2,i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; -} -} -} -} - -uint32_t* tmp1 = make_array( (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp1 at (1586,1-1586,43) */ -uint32_t __tmp_in_tmp1; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)3; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp1; -} -Arr4DIdxRowM(tmp1, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; -} -} -} -} - -uint32_t* tmp2 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp2 at (1589,1-1589,44) */ -uint32_t __tmp_in_tmp2; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp2; -} -Arr4DIdxRowM(tmp2, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp2 : 0; -} -} -} -} - -uint32_t* tmp3 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp3 at (1592,1-1592,44) */ -uint32_t __tmp_in_tmp3; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp3; -} -Arr4DIdxRowM(tmp3, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp3 : 0; -} -} -} -} - -uint32_t* tmp4 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp4 at (1595,1-1595,44) */ -uint32_t __tmp_in_tmp4; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp4; -} -Arr4DIdxRowM(tmp4, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp4 : 0; -} -} -} -} - -uint32_t* tmp5 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp5 at (1598,1-1598,44) */ -uint32_t __tmp_in_tmp5; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp5; -} -Arr4DIdxRowM(tmp5, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp5 : 0; -} -} -} -} - -uint32_t* tmp6 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp6 at (1601,1-1601,44) */ -uint32_t __tmp_in_tmp6; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp6; -} -Arr4DIdxRowM(tmp6, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp6 : 0; -} -} -} -} - -uint32_t* tmp7 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp7 at (1604,1-1604,44) */ -uint32_t __tmp_in_tmp7; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp7; -} -Arr4DIdxRowM(tmp7, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; -} -} -} -} - -uint32_t* tmp8 = make_array( (int32_t)1024, (int32_t)10); -/* Variable to read the clear value corresponding to the input variable tmp8 at (1607,1-1607,40) */ -uint32_t __tmp_in_tmp8; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)10; i1++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp8; -} -Arr2DIdxRowM(tmp8, (int32_t)1024, (int32_t)10,i0,i1) = (party == SERVER) ? __tmp_in_tmp8 : 0; -} -} - -uint32_t* tmp9 = make_array( (int32_t)10); -/* Variable to read the clear value corresponding to the input variable tmp9 at (1610,1-1610,34) */ -uint32_t __tmp_in_tmp9; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)10; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp9; -} -Arr1DIdxRowM(tmp9, (int32_t)10,i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; -} -StartComputation(); - -uint32_t* tmp10 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp0, tmp1, tmp10); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3, tmp0); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, tmp1); - -uint32_t* tmp13 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp10, tmp13, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp10); - -uint32_t* tmp15 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp13, tmp2, tmp15); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp13); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp2); - -uint32_t* tmp18 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp15, tmp18, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp15); - -uint32_t* tmp20 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -AvgPool( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp18, tmp20); -ClearMemSecret4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)64, tmp18); - -uint32_t* tmp22 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp20, tmp3, tmp22); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp3); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp20); - -uint32_t* tmp25 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp22, tmp25, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp22); - -uint32_t* tmp27 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp25, tmp4, tmp27); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp25); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp4); - -uint32_t* tmp30 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp27, tmp30, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp27); - -uint32_t* tmp32 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64); -AvgPool( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)2, (int32_t)2, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp30, tmp32); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp30); - -uint32_t* tmp34 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)2, (int32_t)2, tmp32, tmp5, tmp34); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp5); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)64, tmp32); - -uint32_t* tmp37 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp34, tmp37, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp34); - -uint32_t* tmp39 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp37, tmp6, tmp39); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp37); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64, tmp6); - -uint32_t* tmp42 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp39, tmp42, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp39); - -uint32_t* tmp44 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp42, tmp7, tmp44); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16, tmp7); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp42); - -uint32_t* tmp47 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, tmp44, tmp47, (int32_t)11, 1); -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, tmp44); - -int32_t* tmp49 = make_array( (int32_t)2); -Arr1DIdxRowM(tmp49, (int32_t)2, (int32_t)0) = (int32_t)-1; -Arr1DIdxRowM(tmp49, (int32_t)2, (int32_t)1) = (int32_t)1024; - -uint32_t* tmp50 = make_array( (int32_t)1, (int32_t)1024); - -int32_t i5; - -int32_t i4; - -int32_t i3; - -int32_t i2; - -int32_t i1; - -int32_t i0; -i0 = (int32_t)0; -i1 = (int32_t)0; -i2 = (int32_t)0; -i3 = (int32_t)0; -for (uint32_t i4 = (int32_t)0; i4 < (int32_t)1; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < (int32_t)1024; i5++){ -Arr2DIdxRowM(tmp50, (int32_t)1, (int32_t)1024,i4,i5) = Arr4DIdxRowM(tmp47, (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16,i0,i1,i2,i3); -i3 = (i3 + (int32_t)1); -if ((i3 == (int32_t)16)) { -i3 = (int32_t)0; -i2 = (i2 + (int32_t)1); -if ((i2 == (int32_t)8)) { -i2 = (int32_t)0; -i1 = (i1 + (int32_t)1); -if ((i1 == (int32_t)8)) { -i1 = (int32_t)0; -i0 = (i0 + (int32_t)1); -} -} -} -} -} -ClearMemSecret4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)16, tmp47); - -uint32_t* tmp52 = make_array( (int32_t)1, (int32_t)10); -MatMul2D( (int32_t)1, (int32_t)1024, (int32_t)10, tmp50, tmp8, tmp52, 0); -ClearMemSecret2( (int32_t)1024, (int32_t)10, tmp8); -ClearMemSecret2( (int32_t)1, (int32_t)1024, tmp50); - -uint32_t* tmp55 = make_array( (int32_t)1, (int32_t)10); -ScaleUp1( (int32_t)10, tmp9, (int32_t)11); -MatAddBroadCast2( (int32_t)1, (int32_t)10, tmp52, tmp9, tmp55); -ClearMemSecret1( (int32_t)10, tmp9); -ClearMemSecret2( (int32_t)1, (int32_t)10, tmp52); - -int32_t tmp58 = (int32_t)1; - -uint32_t* tmp59 = make_array( (int32_t)1); -ArgMax1( (int32_t)1, (int32_t)1, (int32_t)10, tmp55, tmp58, tmp59); -ClearMemPublic(tmp58); -ClearMemSecret2( (int32_t)1, (int32_t)10, tmp55); -EndComputation(); -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -cout << (funcReconstruct2PCCons(Arr1DIdxRowM(tmp59, (int32_t)1,i0), 2)) << endl; -} -} - diff --git a/SCI/networks/main_resnet32_cifar.cpp b/SCI/networks/main_resnet32_cifar.cpp new file mode 100644 index 00000000..47f00250 --- /dev/null +++ b/SCI/networks/main_resnet32_cifar.cpp @@ -0,0 +1,5988 @@ +/* +This is an autogenerated file, generated using the EzPC compiler. +*/ + +#define HACKY_RUN +// DISCLAIMER: These networks are just for comparative purposes +#include "library_fixed.h" +#include +using namespace std; + +int party = 0; +int port = 32000; +string address = "127.0.0.1"; +int num_threads = 4; +int32_t bitlength = 41; + +void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + SecretAdd(Arr2DIdxRowM(A, s1, s2, i1, i2), Arr1DIdxRowM(B, s2, i2)); + } + } +} + +void MatAdd2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = SecretAdd( + Arr2DIdxRowM(A, s1, s2, i1, i2), Arr2DIdxRowM(B, s1, s2, i1, i2)); + } + } +} + +void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr1DIdxRowM(B, s4, i4)); + } + } + } + } +} + +void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *A, + uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr4DIdxRowM(B, s1, s2, s3, s4, i1, i2, i3, i4)); + } + } + } + } +} + +void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr1DIdxRowM(B, s5, i5)); + } + } + } + } + } +} + +void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr5DIdxRowM(B, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5)); + } + } + } + } + } +} + +void CreateTensor1(int64_t s1, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(arr, s1, i1) = val; + } +} + +void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(arr, s1, s2, i1, i2) = val; + } + } +} + +void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = val; + } + } + } +} + +void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = val; + } + } + } + } +} + +void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(arr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = val; + } + } + } + } + } +} + +void CopyTensor1(int64_t s1, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(targetArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CopyTensor2(int64_t s1, int64_t s2, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(targetArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t *targetArr, + uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(targetArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *targetArr, uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(targetArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateIdentity11(int64_t s1, uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(newArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CreateIdentity22(int64_t s1, int64_t s2, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(newArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(newArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(newArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, + uint64_t *inArr, int64_t perDimSize, int64_t *beginIdx, + int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = + Arr2DIdxRowM(inArr, inps1, inps2, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j)); + } + } +} + +void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inArr, int64_t perDimSize, + int64_t *beginIdx, int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM( + inArr, inps1, inps2, inps3, inps4, inps5, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)2) + k), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)3) + l), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)4) + m)); + } + } + } + } + } +} + +void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, + uint64_t *inp1, int64_t inp2s1, int64_t inp2s2, uint64_t *inp2, + int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, (i1 - inp1s1), i2); + } + } else { + if ((i2 < inp1s2)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, i1, (i2 - inp1s2)); + } + } + } + } +} + +void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, + int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t *inp1, + int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, + uint64_t *inp2, int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = Arr4DIdxRowM( + inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, + (i1 - inp1s1), i2, i3, i4); + } + } else { + if ((axis == (int32_t)1)) { + if ((i2 < inp1s2)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, + (i2 - inp1s2), i3, i4); + } + } else { + if ((axis == (int32_t)2)) { + if ((i3 < inp1s3)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + (i3 - inp1s3), i4); + } + } else { + if ((i4 < inp1s4)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + i3, (i4 - inp1s4)); + } + } + } + } + } + } + } + } +} + +void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, + int64_t I2, int64_t I3, int64_t I4, uint64_t *inp, int64_t axis, + int64_t curCount, int64_t total, uint64_t *out) { + for (uint64_t o1 = (int32_t)0; o1 < O1; o1++) { + for (uint64_t o2 = (int32_t)0; o2 < O2; o2++) { + for (uint64_t o3 = (int32_t)0; o3 < O3; o3++) { + for (uint64_t o4 = (int32_t)0; o4 < O4; o4++) { + + int64_t i1 = o1; + + int64_t i2 = o2; + + int64_t i3 = o3; + + int64_t i4 = o4; + if ((axis == (int32_t)0)) { + i1 = (((I1 / total) * curCount) + o1); + } + if ((axis == (int32_t)1)) { + i2 = (((I2 / total) * curCount) + o2); + } + if ((axis == (int32_t)2)) { + i3 = (((I3 / total) * curCount) + o3); + } + if ((axis == (int32_t)3)) { + i4 = (((I4 / total) * curCount) + o4); + } + Arr4DIdxRowM(out, O1, O2, O3, O4, o1, o2, o3, o4) = + Arr4DIdxRowM(inp, I1, I2, I3, I4, i1, i2, i3, i4); + } + } + } + } +} + +void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CI, CO, fh, fw, ci, co); + } + } + } + } +} + +void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = ((int32_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); + Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, reshapedIPRows, + reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideH, int64_t strideW, int64_t outH, + int64_t outW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t GIS = (CI / G); + + int64_t GOS = (CO / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t cog = (int32_t)0; cog < GOS; cog++) { + for (uint64_t cig = (int32_t)0; cig < GIS; cig++) { + for (uint64_t g = (int32_t)0; g < G; g++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + + uint64_t val = ((int32_t)0); + + int64_t ci = ((GIS * g) + cig); + + int64_t co = ((GOS * g) + cog); + + int64_t curPosH = ((strideH * h) - zPadHLeft); + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + + int64_t curPosW = ((strideW * w) - zPadWLeft); + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && + (curPosH < H)) && + (curPosW < W))) { + val = SecretAdd( + val, + SecretMult(Arr4DIdxRowM(inputArr, N, H, W, CI, n, + curPosH, curPosW, ci), + Arr4DIdxRowM(filterArr, FH, FW, (CI / G), CO, + fh, fw, (ci / G), co))); + } + curPosW = (curPosW + (int32_t)1); + } + curPosH = (curPosH + (int32_t)1); + } + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co) = SecretAdd( + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co), val); + } + } + } + } + } + } +} + +void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, outH, outW, G, inputArr, + filterArr, outArr); +} + +void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + int64_t g, int64_t G, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t CIG = (CI / G); + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + + int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); + Arr2DIdxRowM(outputArr, (CO / G), ((FH * FW) * (CI / G)), co, + linIdx) = Arr4DIdxRowM(inputArr, FH, FW, (CI / G), CO, + fh, fw, ci, (co + startCO)); + } + } + } + } +} + +void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, int64_t g, int64_t G, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, + (co + startCO)) = + Arr2DIdxRowM(inputArr, (CO / G), ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, + int64_t FH, int64_t FW, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t g, int64_t G, + int64_t RRows, int64_t RCols, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + + int64_t CIG = (CI / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + + int64_t startCI = (g * CIG); + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = ((int32_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + (ci + startCI)); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CIG) + (fw * CIG)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t CIG = (CI / G); + + int64_t reshapedFilterRows = (CO / G); + + int64_t reshapedFilterCols = ((FH * FW) * CIG); + + int64_t reshapedIPRows = ((FH * FW) * CIG); + + int64_t outH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t outW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * outH) * outW); + for (uint64_t g = (int32_t)0; g < G; g++) { + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = + make_array(reshapedFilterRows, reshapedIPCols); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); + Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, + zPadWLeft, zPadWRight, strideH, strideW, g, G, + reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + } +} + +void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, + int64_t CO, uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CI, CO, fd, fh, fw, ci, co); + } + } + } + } + } +} + +void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, + int64_t finalW, int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t d = (int32_t)0; d < finalD; d++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr5DIdxRowM(outputArr, N, finalD, finalH, finalW, CO, n, d, h, w, + co) = + Arr2DIdxRowM(inputArr, CO, (((N * finalD) * finalH) * finalW), + co, + ((((((n * finalD) * finalH) * finalW) + + ((d * finalH) * finalW)) + + (h * finalW)) + + w)); + } + } + } + } + } +} + +void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideD, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadDLeft); + + int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= D)) || + ((curPosH < (int32_t)0) || (curPosH >= H))) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = ((int32_t)0); + } else { + val = Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, curPosD, + curPosH, curPosW, ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + + leftTopCornerD = (leftTopCornerD + strideD); + } + } +} + +void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, + int64_t strideH, int64_t strideW, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t newD = + ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = (((N * newD) * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); + Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = ((int32_t)0); + for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); + fd++) { + for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); + fh++) { + for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); + fw++) { + + int64_t curPosD = (fd - zPadDLeft); + + int64_t curPosH = (fh - zPadHLeft); + + int64_t curPosW = (fw - zPadWLeft); + if (((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W))) { + + int64_t curFilterPosD = (fd - (d * strideD)); + + int64_t curFilterPosH = (fh - (h * strideH)); + + int64_t curFilterPosW = (fw - (w * strideW)); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CI, CO, + curFilterPosD, curFilterPosH, + curFilterPosW, ci, co))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, uint64_t *outArr) { + + int64_t outD = + ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, outD, outH, outW, inputArr, filterArr, + outArr); +} + +void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, + int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CO, CI, ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } +} + +void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FH, int64_t FW, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = ((int32_t)0); + } else { + if ((((curPosH % strideH) == (int32_t)0) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = Arr4DIdxRowM(inputArr, N, HPrime, WPrime, CI, n, + idxInputH, idxInputW, ci); + } else { + val = ((int32_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + } +} + +void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, + int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t reshapedIPCols = ((N * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, + zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CO, CI, + ((FD - (int32_t)1) - fd), ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } + } +} + +void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadTrDLeft); + + int64_t DPrimeTilde = + (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); + + int64_t extremeRightBottomCornerD = + ((DPrimeTilde - (int32_t)1) + zPadTrDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = ((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || + ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = ((int32_t)0); + } else { + if (((((curPosD % strideD) == (int32_t)0) && + ((curPosH % strideH) == (int32_t)0)) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputD = (curPosD / strideD); + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = + Arr5DIdxRowM(inputArr, N, DPrime, HPrime, WPrime, CI, + n, idxInputD, idxInputH, idxInputW, ci); + } else { + val = ((int32_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + + leftTopCornerD = (leftTopCornerD + (int32_t)1); + } + } +} + +void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t reshapedIPCols = (((N * D) * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose3DReshapeInput( + N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, + zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, + int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = ((int32_t)0); + for (uint64_t fd = d; fd < (d + FD); fd++) { + for (uint64_t fh = h; fh < (h + FH); fh++) { + for (uint64_t fw = w; fw < (w + FW); fw++) { + + int64_t curPosD = ((fd - zPadDLeft) / strideD); + + int64_t curPosH = ((fh - zPadHLeft) / strideD); + + int64_t curPosW = ((fw - zPadWLeft) / strideD); + if ((((((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W)) && + (((fd - zPadDLeft) % strideD) == (int32_t)0)) && + (((fh - zPadHLeft) % strideH) == (int32_t)0)) && + (((fw - zPadWLeft) % strideW) == (int32_t)0))) { + + int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); + + int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); + + int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CO, CI, + curFilterPosD, curFilterPosH, + curFilterPosW, co, ci))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, + int64_t FW, int64_t CO, int64_t D, int64_t H, + int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, + zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, + zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, + D, H, W, inputArr, filterArr, outArr); +} + +void Transpose2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = Arr2DIdxRowM(inArr, s2, s1, j, i); + } + } +} + +void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, + int64_t inps2, int64_t inps3, int64_t inps4, uint64_t *inpArr, + int64_t pads1, int64_t pads2, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = + Arr4DIdxRowM(inpArr, inps1, inps2, inps3, inps4, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0))); + } else { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = ((int32_t)0); + } + } + } + } + } +} + +void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inpArr, int64_t pads1, int64_t pads2, + int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + + int64_t lbounds5 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)0); + + int64_t rbounds5excl = + (s5 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl)) && + (m >= lbounds5)) && + (m < rbounds5excl))) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM(inpArr, inps1, inps2, inps3, inps4, inps5, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0)), + (m - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)4, (int32_t)0))); + } else { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + ((int32_t)0); + } + } + } + } + } + } +} + +void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, + int64_t i2, int64_t i3, int64_t i4, uint64_t *inpArr, + int64_t pads, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = Arr1DIdxRowM(paddings, pads, (int32_t)0); + + int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings, pads, (int32_t)4)); + + int64_t lbounds2 = Arr1DIdxRowM(paddings, pads, (int32_t)1); + + int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings, pads, (int32_t)5)); + + int64_t lbounds3 = Arr1DIdxRowM(paddings, pads, (int32_t)2); + + int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings, pads, (int32_t)6)); + + int64_t lbounds4 = Arr1DIdxRowM(paddings, pads, (int32_t)3); + + int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings, pads, (int32_t)7)); + for (uint64_t i = (int32_t)0; i < o1; i++) { + for (uint64_t j = (int32_t)0; j < o2; j++) { + for (uint64_t k = (int32_t)0; k < o3; k++) { + for (uint64_t l = (int32_t)0; l < o4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = + Arr4DIdxRowM(inpArr, i1, i2, i3, i4, + (i - Arr1DIdxRowM(paddings, pads, (int32_t)0)), + (j - Arr1DIdxRowM(paddings, pads, (int32_t)1)), + (k - Arr1DIdxRowM(paddings, pads, (int32_t)2)), + (l - Arr1DIdxRowM(paddings, pads, (int32_t)3))); + } else { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = ((int32_t)0); + } + } + } + } + } +} + +void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < ins1; i++) { + for (uint64_t j = (int32_t)0; j < ins2; j++) { + for (uint64_t k = (int32_t)0; k < ins3; k++) { + for (uint64_t l = (int32_t)0; l < ins4; l++) { + + int64_t linIdx = + ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + + (k * ins4)) + + l); + + int64_t outIdx1 = (linIdx / s2); + + int64_t outIdx2 = (linIdx % s2); + Arr2DIdxRowM(outArr, s1, s2, outIdx1, outIdx2) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i, j, k, l); + } + } + } + } +} + +void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *inArr, uint64_t *multArr, uint64_t *biasArr, + int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, + uint64_t *outputArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s4, i4); + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s4); + for (uint64_t ii = (int32_t)0; ii < s4; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s4, ii) = Arr1DIdxRowM(biasArr, s4, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outputArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s4, i4)); + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s4, biasArrScaledUp); +} + +void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *inArr, uint64_t *multArr, + uint64_t *biasArr, int64_t multExprScaleDownSf, + int64_t biasExprScaleUpSf, uint64_t *outputArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s5, i5); + } + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s5); + for (uint64_t ii = (int32_t)0; ii < s5; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s5, ii) = Arr1DIdxRowM(biasArr, s5, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outputArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s5, i5)); + } + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s5, biasArrScaledUp); +} + +void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t *arr1, uint64_t *arr2, + uint64_t *outArr) { + + int64_t inpSize = (s1 * s2); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr1, s1, s2, i1, i2); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr2, s1, s2, i1, i2); + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr1, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr2, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr1, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr2, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, int64_t *axes, + uint64_t *outputArr) { + + int64_t divisor = (inS2 * inS3); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = ((int32_t)0); + for (uint64_t i = (int32_t)0; i < inS2; i++) { + for (uint64_t j = (int32_t)0; j < inS3; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i, j, i2)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, + int64_t axis1, int64_t axis2, uint64_t *outputArr) { + + int64_t divisor = (inS3 * inS4); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = ((int32_t)0); + for (uint64_t i = (int32_t)0; i < inS3; i++) { + for (uint64_t j = (int32_t)0; j < inS4; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i2, i, j)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, + uint64_t *inArr, int64_t dim, uint64_t *outArr) { + ArgMax(inArrS1, inArrS2, inArr, outArr); +} + +void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + int64_t dim, uint64_t *outArr) { + + int64_t size = ((ins1 * ins2) * ins3); + + uint64_t *reshapedInArr = make_array(size, ins4); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr2DIdxRowM(reshapedInArr, size, ins4, linIdx, i4) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i1, i2, i3, i4); + } + } + } + } + ArgMax(size, ins4, reshapedInArr, reshapedOutArr); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr3DIdxRowM(outArr, outs1, outs2, outs3, i1, i2, i3) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + ClearMemSecret2(size, ins4, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf, uint64_t doTruncation) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *inArr, + uint64_t *outArr, int64_t sf, uint64_t doTruncation) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *inArr, uint64_t *outArr, int64_t sf, + uint64_t doTruncation) { + + int64_t size = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Floor2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Floor(size, reshapedInArr, reshapedOutArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void ScaleUp1(int64_t s1, uint64_t *arr, int64_t sf) { ScaleUp(s1, arr, sf); } + +void ScaleUp2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown1(int64_t s1, uint64_t *arr, int64_t sf) { + ScaleDown(s1, arr, sf); +} + +void ScaleDown2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +int main(int argc, char **argv) { + ArgMapping amap; + + amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); + amap.arg("port", port, "Port Number"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + amap.arg("nt", num_threads, "Number of Threads"); + amap.arg("ell", bitlength, "Uniform Bitwidth"); + amap.parse(argc, argv); + + assert(party == SERVER || party == CLIENT); + + uint64_t *tmp0 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3); + /* Variable to read the clear value corresponding to the input variable tmp0 + * at (497,1-497,45) */ + uint32_t __tmp_in_tmp0; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)32; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)3; i3++) { + if ((party == CLIENT)) { + cin >> __tmp_in_tmp0; + } + Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3, + i0, i1, i2, i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; + } + } + } + } + + uint64_t *tmp1 = + make_array((int32_t)3, (int32_t)3, (int32_t)3, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp1 + * at (500,1-500,44) */ + uint32_t __tmp_in_tmp1; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)3; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp1; + } + Arr4DIdxRowM(tmp1, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; + } + } + } + } + + uint64_t *tmp2 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp2 + * at (503,1-503,35) */ + uint32_t __tmp_in_tmp2; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp2; + } + Arr1DIdxRowM(tmp2, (int32_t)16, i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; + } + + uint64_t *tmp3 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp3 + * at (506,1-506,35) */ + uint32_t __tmp_in_tmp3; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp3; + } + Arr1DIdxRowM(tmp3, (int32_t)16, i0) = (party == SERVER) ? __tmp_in_tmp3 : 0; + } + + uint64_t *tmp4 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp4 + * at (509,1-509,35) */ + uint32_t __tmp_in_tmp4; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp4; + } + Arr1DIdxRowM(tmp4, (int32_t)16, i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; + } + + uint64_t *tmp5 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp5 + * at (512,1-512,35) */ + uint32_t __tmp_in_tmp5; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp5; + } + Arr1DIdxRowM(tmp5, (int32_t)16, i0) = (party == SERVER) ? __tmp_in_tmp5 : 0; + } + + uint64_t *tmp6 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp6 + * at (515,1-515,35) */ + uint32_t __tmp_in_tmp6; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp6; + } + Arr1DIdxRowM(tmp6, (int32_t)16, i0) = (party == SERVER) ? __tmp_in_tmp6 : 0; + } + + uint64_t *tmp7 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp7 + * at (518,1-518,45) */ + uint32_t __tmp_in_tmp7; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp7; + } + Arr4DIdxRowM(tmp7, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; + } + } + } + } + + uint64_t *tmp8 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp8 + * at (521,1-521,35) */ + uint32_t __tmp_in_tmp8; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp8; + } + Arr1DIdxRowM(tmp8, (int32_t)16, i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; + } + + uint64_t *tmp9 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp9 + * at (524,1-524,35) */ + uint32_t __tmp_in_tmp9; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp9; + } + Arr1DIdxRowM(tmp9, (int32_t)16, i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; + } + + uint64_t *tmp10 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp10 + * at (527,1-527,36) */ + uint32_t __tmp_in_tmp10; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp10; + } + Arr1DIdxRowM(tmp10, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp10 : 0; + } + + uint64_t *tmp11 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp11 + * at (530,1-530,36) */ + uint32_t __tmp_in_tmp11; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp11; + } + Arr1DIdxRowM(tmp11, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp11 : 0; + } + + uint64_t *tmp12 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp12 + * at (533,1-533,36) */ + uint32_t __tmp_in_tmp12; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp12; + } + Arr1DIdxRowM(tmp12, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp12 : 0; + } + + uint64_t *tmp13 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp13 + * at (536,1-536,46) */ + uint32_t __tmp_in_tmp13; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp13; + } + Arr4DIdxRowM(tmp13, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp13 : 0; + } + } + } + } + + uint64_t *tmp14 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp14 + * at (539,1-539,36) */ + uint32_t __tmp_in_tmp14; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp14; + } + Arr1DIdxRowM(tmp14, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp14 : 0; + } + + uint64_t *tmp15 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp15 + * at (542,1-542,36) */ + uint32_t __tmp_in_tmp15; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp15; + } + Arr1DIdxRowM(tmp15, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp15 : 0; + } + + uint64_t *tmp16 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp16 + * at (545,1-545,36) */ + uint32_t __tmp_in_tmp16; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp16; + } + Arr1DIdxRowM(tmp16, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp16 : 0; + } + + uint64_t *tmp17 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp17 + * at (548,1-548,36) */ + uint32_t __tmp_in_tmp17; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp17; + } + Arr1DIdxRowM(tmp17, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp17 : 0; + } + + uint64_t *tmp18 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp18 + * at (551,1-551,36) */ + uint32_t __tmp_in_tmp18; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp18; + } + Arr1DIdxRowM(tmp18, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp18 : 0; + } + + uint64_t *tmp19 = + make_array((int32_t)1, (int32_t)1, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp19 + * at (554,1-554,46) */ + uint32_t __tmp_in_tmp19; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp19; + } + Arr4DIdxRowM(tmp19, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp19 : 0; + } + } + } + } + + uint64_t *tmp20 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp20 + * at (557,1-557,36) */ + uint32_t __tmp_in_tmp20; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp20; + } + Arr1DIdxRowM(tmp20, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp20 : 0; + } + + uint64_t *tmp21 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp21 + * at (560,1-560,36) */ + uint32_t __tmp_in_tmp21; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp21; + } + Arr1DIdxRowM(tmp21, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp21 : 0; + } + + uint64_t *tmp22 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp22 + * at (563,1-563,36) */ + uint32_t __tmp_in_tmp22; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp22; + } + Arr1DIdxRowM(tmp22, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp22 : 0; + } + + uint64_t *tmp23 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp23 + * at (566,1-566,36) */ + uint32_t __tmp_in_tmp23; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp23; + } + Arr1DIdxRowM(tmp23, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp23 : 0; + } + + uint64_t *tmp24 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp24 + * at (569,1-569,36) */ + uint32_t __tmp_in_tmp24; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp24; + } + Arr1DIdxRowM(tmp24, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp24 : 0; + } + + uint64_t *tmp25 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp25 + * at (572,1-572,46) */ + uint32_t __tmp_in_tmp25; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp25; + } + Arr4DIdxRowM(tmp25, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp25 : 0; + } + } + } + } + + uint64_t *tmp26 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp26 + * at (575,1-575,36) */ + uint32_t __tmp_in_tmp26; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp26; + } + Arr1DIdxRowM(tmp26, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp26 : 0; + } + + uint64_t *tmp27 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp27 + * at (578,1-578,36) */ + uint32_t __tmp_in_tmp27; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp27; + } + Arr1DIdxRowM(tmp27, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp27 : 0; + } + + uint64_t *tmp28 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp28 + * at (581,1-581,36) */ + uint32_t __tmp_in_tmp28; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp28; + } + Arr1DIdxRowM(tmp28, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp28 : 0; + } + + uint64_t *tmp29 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp29 + * at (584,1-584,36) */ + uint32_t __tmp_in_tmp29; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp29; + } + Arr1DIdxRowM(tmp29, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp29 : 0; + } + + uint64_t *tmp30 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp30 + * at (587,1-587,36) */ + uint32_t __tmp_in_tmp30; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp30; + } + Arr1DIdxRowM(tmp30, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp30 : 0; + } + + uint64_t *tmp31 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp31 + * at (590,1-590,46) */ + uint32_t __tmp_in_tmp31; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp31; + } + Arr4DIdxRowM(tmp31, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp31 : 0; + } + } + } + } + + uint64_t *tmp32 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp32 + * at (593,1-593,36) */ + uint32_t __tmp_in_tmp32; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp32; + } + Arr1DIdxRowM(tmp32, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp32 : 0; + } + + uint64_t *tmp33 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp33 + * at (596,1-596,36) */ + uint32_t __tmp_in_tmp33; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp33; + } + Arr1DIdxRowM(tmp33, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp33 : 0; + } + + uint64_t *tmp34 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp34 + * at (599,1-599,36) */ + uint32_t __tmp_in_tmp34; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp34; + } + Arr1DIdxRowM(tmp34, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp34 : 0; + } + + uint64_t *tmp35 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp35 + * at (602,1-602,36) */ + uint32_t __tmp_in_tmp35; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp35; + } + Arr1DIdxRowM(tmp35, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp35 : 0; + } + + uint64_t *tmp36 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp36 + * at (605,1-605,36) */ + uint32_t __tmp_in_tmp36; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp36; + } + Arr1DIdxRowM(tmp36, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp36 : 0; + } + + uint64_t *tmp37 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp37 + * at (608,1-608,46) */ + uint32_t __tmp_in_tmp37; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp37; + } + Arr4DIdxRowM(tmp37, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp37 : 0; + } + } + } + } + + uint64_t *tmp38 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp38 + * at (611,1-611,36) */ + uint32_t __tmp_in_tmp38; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp38; + } + Arr1DIdxRowM(tmp38, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp38 : 0; + } + + uint64_t *tmp39 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp39 + * at (614,1-614,36) */ + uint32_t __tmp_in_tmp39; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp39; + } + Arr1DIdxRowM(tmp39, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp39 : 0; + } + + uint64_t *tmp40 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp40 + * at (617,1-617,36) */ + uint32_t __tmp_in_tmp40; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp40; + } + Arr1DIdxRowM(tmp40, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp40 : 0; + } + + uint64_t *tmp41 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp41 + * at (620,1-620,36) */ + uint32_t __tmp_in_tmp41; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp41; + } + Arr1DIdxRowM(tmp41, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp41 : 0; + } + + uint64_t *tmp42 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp42 + * at (623,1-623,36) */ + uint32_t __tmp_in_tmp42; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp42; + } + Arr1DIdxRowM(tmp42, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp42 : 0; + } + + uint64_t *tmp43 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp43 + * at (626,1-626,46) */ + uint32_t __tmp_in_tmp43; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp43; + } + Arr4DIdxRowM(tmp43, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp43 : 0; + } + } + } + } + + uint64_t *tmp44 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp44 + * at (629,1-629,36) */ + uint32_t __tmp_in_tmp44; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp44; + } + Arr1DIdxRowM(tmp44, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp44 : 0; + } + + uint64_t *tmp45 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp45 + * at (632,1-632,36) */ + uint32_t __tmp_in_tmp45; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp45; + } + Arr1DIdxRowM(tmp45, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp45 : 0; + } + + uint64_t *tmp46 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp46 + * at (635,1-635,36) */ + uint32_t __tmp_in_tmp46; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp46; + } + Arr1DIdxRowM(tmp46, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp46 : 0; + } + + uint64_t *tmp47 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp47 + * at (638,1-638,36) */ + uint32_t __tmp_in_tmp47; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp47; + } + Arr1DIdxRowM(tmp47, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp47 : 0; + } + + uint64_t *tmp48 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp48 + * at (641,1-641,36) */ + uint32_t __tmp_in_tmp48; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp48; + } + Arr1DIdxRowM(tmp48, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp48 : 0; + } + + uint64_t *tmp49 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp49 + * at (644,1-644,46) */ + uint32_t __tmp_in_tmp49; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp49; + } + Arr4DIdxRowM(tmp49, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp49 : 0; + } + } + } + } + + uint64_t *tmp50 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp50 + * at (647,1-647,36) */ + uint32_t __tmp_in_tmp50; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp50; + } + Arr1DIdxRowM(tmp50, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp50 : 0; + } + + uint64_t *tmp51 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp51 + * at (650,1-650,36) */ + uint32_t __tmp_in_tmp51; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp51; + } + Arr1DIdxRowM(tmp51, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp51 : 0; + } + + uint64_t *tmp52 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp52 + * at (653,1-653,36) */ + uint32_t __tmp_in_tmp52; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp52; + } + Arr1DIdxRowM(tmp52, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp52 : 0; + } + + uint64_t *tmp53 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp53 + * at (656,1-656,36) */ + uint32_t __tmp_in_tmp53; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp53; + } + Arr1DIdxRowM(tmp53, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp53 : 0; + } + + uint64_t *tmp54 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp54 + * at (659,1-659,36) */ + uint32_t __tmp_in_tmp54; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp54; + } + Arr1DIdxRowM(tmp54, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp54 : 0; + } + + uint64_t *tmp55 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp55 + * at (662,1-662,46) */ + uint32_t __tmp_in_tmp55; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp55; + } + Arr4DIdxRowM(tmp55, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp55 : 0; + } + } + } + } + + uint64_t *tmp56 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp56 + * at (665,1-665,36) */ + uint32_t __tmp_in_tmp56; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp56; + } + Arr1DIdxRowM(tmp56, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp56 : 0; + } + + uint64_t *tmp57 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp57 + * at (668,1-668,36) */ + uint32_t __tmp_in_tmp57; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp57; + } + Arr1DIdxRowM(tmp57, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp57 : 0; + } + + uint64_t *tmp58 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp58 + * at (671,1-671,36) */ + uint32_t __tmp_in_tmp58; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp58; + } + Arr1DIdxRowM(tmp58, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp58 : 0; + } + + uint64_t *tmp59 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp59 + * at (674,1-674,36) */ + uint32_t __tmp_in_tmp59; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp59; + } + Arr1DIdxRowM(tmp59, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp59 : 0; + } + + uint64_t *tmp60 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp60 + * at (677,1-677,36) */ + uint32_t __tmp_in_tmp60; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp60; + } + Arr1DIdxRowM(tmp60, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp60 : 0; + } + + uint64_t *tmp61 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp61 + * at (680,1-680,46) */ + uint32_t __tmp_in_tmp61; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp61; + } + Arr4DIdxRowM(tmp61, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp61 : 0; + } + } + } + } + + uint64_t *tmp62 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp62 + * at (683,1-683,36) */ + uint32_t __tmp_in_tmp62; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp62; + } + Arr1DIdxRowM(tmp62, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp62 : 0; + } + + uint64_t *tmp63 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp63 + * at (686,1-686,36) */ + uint32_t __tmp_in_tmp63; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp63; + } + Arr1DIdxRowM(tmp63, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp63 : 0; + } + + uint64_t *tmp64 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp64 + * at (689,1-689,36) */ + uint32_t __tmp_in_tmp64; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp64; + } + Arr1DIdxRowM(tmp64, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp64 : 0; + } + + uint64_t *tmp65 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp65 + * at (692,1-692,36) */ + uint32_t __tmp_in_tmp65; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp65; + } + Arr1DIdxRowM(tmp65, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp65 : 0; + } + + uint64_t *tmp66 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp66 + * at (695,1-695,36) */ + uint32_t __tmp_in_tmp66; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp66; + } + Arr1DIdxRowM(tmp66, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp66 : 0; + } + + uint64_t *tmp67 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp67 + * at (698,1-698,46) */ + uint32_t __tmp_in_tmp67; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp67; + } + Arr4DIdxRowM(tmp67, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp67 : 0; + } + } + } + } + + uint64_t *tmp68 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp68 + * at (701,1-701,36) */ + uint32_t __tmp_in_tmp68; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp68; + } + Arr1DIdxRowM(tmp68, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp68 : 0; + } + + uint64_t *tmp69 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp69 + * at (704,1-704,36) */ + uint32_t __tmp_in_tmp69; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp69; + } + Arr1DIdxRowM(tmp69, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp69 : 0; + } + + uint64_t *tmp70 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp70 + * at (707,1-707,36) */ + uint32_t __tmp_in_tmp70; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp70; + } + Arr1DIdxRowM(tmp70, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp70 : 0; + } + + uint64_t *tmp71 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp71 + * at (710,1-710,36) */ + uint32_t __tmp_in_tmp71; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp71; + } + Arr1DIdxRowM(tmp71, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp71 : 0; + } + + uint64_t *tmp72 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp72 + * at (713,1-713,36) */ + uint32_t __tmp_in_tmp72; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp72; + } + Arr1DIdxRowM(tmp72, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp72 : 0; + } + + uint64_t *tmp73 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp73 + * at (716,1-716,46) */ + uint32_t __tmp_in_tmp73; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp73; + } + Arr4DIdxRowM(tmp73, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp73 : 0; + } + } + } + } + + uint64_t *tmp74 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp74 + * at (719,1-719,36) */ + uint32_t __tmp_in_tmp74; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp74; + } + Arr1DIdxRowM(tmp74, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp74 : 0; + } + + uint64_t *tmp75 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp75 + * at (722,1-722,36) */ + uint32_t __tmp_in_tmp75; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp75; + } + Arr1DIdxRowM(tmp75, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp75 : 0; + } + + uint64_t *tmp76 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp76 + * at (725,1-725,36) */ + uint32_t __tmp_in_tmp76; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp76; + } + Arr1DIdxRowM(tmp76, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp76 : 0; + } + + uint64_t *tmp77 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp77 + * at (728,1-728,36) */ + uint32_t __tmp_in_tmp77; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp77; + } + Arr1DIdxRowM(tmp77, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp77 : 0; + } + + uint64_t *tmp78 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp78 + * at (731,1-731,36) */ + uint32_t __tmp_in_tmp78; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp78; + } + Arr1DIdxRowM(tmp78, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp78 : 0; + } + + uint64_t *tmp79 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp79 + * at (734,1-734,46) */ + uint32_t __tmp_in_tmp79; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp79; + } + Arr4DIdxRowM(tmp79, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp79 : 0; + } + } + } + } + + uint64_t *tmp80 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp80 + * at (737,1-737,36) */ + uint32_t __tmp_in_tmp80; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp80; + } + Arr1DIdxRowM(tmp80, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp80 : 0; + } + + uint64_t *tmp81 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp81 + * at (740,1-740,36) */ + uint32_t __tmp_in_tmp81; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp81; + } + Arr1DIdxRowM(tmp81, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp81 : 0; + } + + uint64_t *tmp82 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp82 + * at (743,1-743,36) */ + uint32_t __tmp_in_tmp82; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp82; + } + Arr1DIdxRowM(tmp82, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp82 : 0; + } + + uint64_t *tmp83 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp83 + * at (746,1-746,36) */ + uint32_t __tmp_in_tmp83; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp83; + } + Arr1DIdxRowM(tmp83, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp83 : 0; + } + + uint64_t *tmp84 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp84 + * at (749,1-749,36) */ + uint32_t __tmp_in_tmp84; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp84; + } + Arr1DIdxRowM(tmp84, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp84 : 0; + } + + uint64_t *tmp85 = + make_array((int32_t)1, (int32_t)1, (int32_t)16, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp85 + * at (752,1-752,46) */ + uint32_t __tmp_in_tmp85; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp85; + } + Arr4DIdxRowM(tmp85, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp85 : 0; + } + } + } + } + + uint64_t *tmp86 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp86 + * at (755,1-755,36) */ + uint32_t __tmp_in_tmp86; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp86; + } + Arr1DIdxRowM(tmp86, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp86 : 0; + } + + uint64_t *tmp87 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp87 + * at (758,1-758,36) */ + uint32_t __tmp_in_tmp87; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp87; + } + Arr1DIdxRowM(tmp87, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp87 : 0; + } + + uint64_t *tmp88 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp88 + * at (761,1-761,36) */ + uint32_t __tmp_in_tmp88; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp88; + } + Arr1DIdxRowM(tmp88, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp88 : 0; + } + + uint64_t *tmp89 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp89 + * at (764,1-764,36) */ + uint32_t __tmp_in_tmp89; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp89; + } + Arr1DIdxRowM(tmp89, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp89 : 0; + } + + uint64_t *tmp90 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp90 + * at (767,1-767,36) */ + uint32_t __tmp_in_tmp90; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp90; + } + Arr1DIdxRowM(tmp90, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp90 : 0; + } + + uint64_t *tmp91 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp91 + * at (770,1-770,46) */ + uint32_t __tmp_in_tmp91; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp91; + } + Arr4DIdxRowM(tmp91, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp91 : 0; + } + } + } + } + + uint64_t *tmp92 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp92 + * at (773,1-773,36) */ + uint32_t __tmp_in_tmp92; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp92; + } + Arr1DIdxRowM(tmp92, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp92 : 0; + } + + uint64_t *tmp93 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp93 + * at (776,1-776,36) */ + uint32_t __tmp_in_tmp93; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp93; + } + Arr1DIdxRowM(tmp93, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp93 : 0; + } + + uint64_t *tmp94 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp94 + * at (779,1-779,36) */ + uint32_t __tmp_in_tmp94; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp94; + } + Arr1DIdxRowM(tmp94, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp94 : 0; + } + + uint64_t *tmp95 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp95 + * at (782,1-782,36) */ + uint32_t __tmp_in_tmp95; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp95; + } + Arr1DIdxRowM(tmp95, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp95 : 0; + } + + uint64_t *tmp96 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp96 + * at (785,1-785,36) */ + uint32_t __tmp_in_tmp96; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp96; + } + Arr1DIdxRowM(tmp96, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp96 : 0; + } + + uint64_t *tmp97 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp97 + * at (788,1-788,46) */ + uint32_t __tmp_in_tmp97; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp97; + } + Arr4DIdxRowM(tmp97, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp97 : 0; + } + } + } + } + + uint64_t *tmp98 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp98 + * at (791,1-791,36) */ + uint32_t __tmp_in_tmp98; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp98; + } + Arr1DIdxRowM(tmp98, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp98 : 0; + } + + uint64_t *tmp99 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp99 + * at (794,1-794,36) */ + uint32_t __tmp_in_tmp99; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp99; + } + Arr1DIdxRowM(tmp99, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp99 : 0; + } + + uint64_t *tmp100 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp100 + * at (797,1-797,37) */ + uint32_t __tmp_in_tmp100; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp100; + } + Arr1DIdxRowM(tmp100, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp100 : 0; + } + + uint64_t *tmp101 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp101 + * at (800,1-800,37) */ + uint32_t __tmp_in_tmp101; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp101; + } + Arr1DIdxRowM(tmp101, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp101 : 0; + } + + uint64_t *tmp102 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp102 + * at (803,1-803,37) */ + uint32_t __tmp_in_tmp102; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp102; + } + Arr1DIdxRowM(tmp102, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp102 : 0; + } + + uint64_t *tmp103 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp103 + * at (806,1-806,47) */ + uint32_t __tmp_in_tmp103; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp103; + } + Arr4DIdxRowM(tmp103, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp103 : 0; + } + } + } + } + + uint64_t *tmp104 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp104 + * at (809,1-809,37) */ + uint32_t __tmp_in_tmp104; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp104; + } + Arr1DIdxRowM(tmp104, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp104 : 0; + } + + uint64_t *tmp105 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp105 + * at (812,1-812,37) */ + uint32_t __tmp_in_tmp105; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp105; + } + Arr1DIdxRowM(tmp105, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp105 : 0; + } + + uint64_t *tmp106 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp106 + * at (815,1-815,37) */ + uint32_t __tmp_in_tmp106; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp106; + } + Arr1DIdxRowM(tmp106, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp106 : 0; + } + + uint64_t *tmp107 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp107 + * at (818,1-818,37) */ + uint32_t __tmp_in_tmp107; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp107; + } + Arr1DIdxRowM(tmp107, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp107 : 0; + } + + uint64_t *tmp108 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp108 + * at (821,1-821,37) */ + uint32_t __tmp_in_tmp108; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp108; + } + Arr1DIdxRowM(tmp108, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp108 : 0; + } + + uint64_t *tmp109 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp109 + * at (824,1-824,47) */ + uint32_t __tmp_in_tmp109; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp109; + } + Arr4DIdxRowM(tmp109, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp109 : 0; + } + } + } + } + + uint64_t *tmp110 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp110 + * at (827,1-827,37) */ + uint32_t __tmp_in_tmp110; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp110; + } + Arr1DIdxRowM(tmp110, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp110 : 0; + } + + uint64_t *tmp111 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp111 + * at (830,1-830,37) */ + uint32_t __tmp_in_tmp111; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp111; + } + Arr1DIdxRowM(tmp111, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp111 : 0; + } + + uint64_t *tmp112 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp112 + * at (833,1-833,37) */ + uint32_t __tmp_in_tmp112; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp112; + } + Arr1DIdxRowM(tmp112, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp112 : 0; + } + + uint64_t *tmp113 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp113 + * at (836,1-836,37) */ + uint32_t __tmp_in_tmp113; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp113; + } + Arr1DIdxRowM(tmp113, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp113 : 0; + } + + uint64_t *tmp114 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp114 + * at (839,1-839,37) */ + uint32_t __tmp_in_tmp114; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp114; + } + Arr1DIdxRowM(tmp114, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp114 : 0; + } + + uint64_t *tmp115 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp115 + * at (842,1-842,47) */ + uint32_t __tmp_in_tmp115; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp115; + } + Arr4DIdxRowM(tmp115, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp115 : 0; + } + } + } + } + + uint64_t *tmp116 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp116 + * at (845,1-845,37) */ + uint32_t __tmp_in_tmp116; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp116; + } + Arr1DIdxRowM(tmp116, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp116 : 0; + } + + uint64_t *tmp117 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp117 + * at (848,1-848,37) */ + uint32_t __tmp_in_tmp117; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp117; + } + Arr1DIdxRowM(tmp117, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp117 : 0; + } + + uint64_t *tmp118 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp118 + * at (851,1-851,37) */ + uint32_t __tmp_in_tmp118; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp118; + } + Arr1DIdxRowM(tmp118, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp118 : 0; + } + + uint64_t *tmp119 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp119 + * at (854,1-854,37) */ + uint32_t __tmp_in_tmp119; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp119; + } + Arr1DIdxRowM(tmp119, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp119 : 0; + } + + uint64_t *tmp120 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp120 + * at (857,1-857,37) */ + uint32_t __tmp_in_tmp120; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp120; + } + Arr1DIdxRowM(tmp120, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp120 : 0; + } + + uint64_t *tmp121 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp121 + * at (860,1-860,47) */ + uint32_t __tmp_in_tmp121; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp121; + } + Arr4DIdxRowM(tmp121, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp121 : 0; + } + } + } + } + + uint64_t *tmp122 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp122 + * at (863,1-863,37) */ + uint32_t __tmp_in_tmp122; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp122; + } + Arr1DIdxRowM(tmp122, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp122 : 0; + } + + uint64_t *tmp123 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp123 + * at (866,1-866,37) */ + uint32_t __tmp_in_tmp123; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp123; + } + Arr1DIdxRowM(tmp123, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp123 : 0; + } + + uint64_t *tmp124 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp124 + * at (869,1-869,37) */ + uint32_t __tmp_in_tmp124; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp124; + } + Arr1DIdxRowM(tmp124, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp124 : 0; + } + + uint64_t *tmp125 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp125 + * at (872,1-872,37) */ + uint32_t __tmp_in_tmp125; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp125; + } + Arr1DIdxRowM(tmp125, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp125 : 0; + } + + uint64_t *tmp126 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp126 + * at (875,1-875,37) */ + uint32_t __tmp_in_tmp126; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp126; + } + Arr1DIdxRowM(tmp126, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp126 : 0; + } + + uint64_t *tmp127 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp127 + * at (878,1-878,47) */ + uint32_t __tmp_in_tmp127; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp127; + } + Arr4DIdxRowM(tmp127, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp127 : 0; + } + } + } + } + + uint64_t *tmp128 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp128 + * at (881,1-881,37) */ + uint32_t __tmp_in_tmp128; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp128; + } + Arr1DIdxRowM(tmp128, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp128 : 0; + } + + uint64_t *tmp129 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp129 + * at (884,1-884,37) */ + uint32_t __tmp_in_tmp129; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp129; + } + Arr1DIdxRowM(tmp129, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp129 : 0; + } + + uint64_t *tmp130 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp130 + * at (887,1-887,37) */ + uint32_t __tmp_in_tmp130; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp130; + } + Arr1DIdxRowM(tmp130, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp130 : 0; + } + + uint64_t *tmp131 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp131 + * at (890,1-890,37) */ + uint32_t __tmp_in_tmp131; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp131; + } + Arr1DIdxRowM(tmp131, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp131 : 0; + } + + uint64_t *tmp132 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp132 + * at (893,1-893,37) */ + uint32_t __tmp_in_tmp132; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp132; + } + Arr1DIdxRowM(tmp132, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp132 : 0; + } + + uint64_t *tmp133 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp133 + * at (896,1-896,47) */ + uint32_t __tmp_in_tmp133; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp133; + } + Arr4DIdxRowM(tmp133, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp133 : 0; + } + } + } + } + + uint64_t *tmp134 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp134 + * at (899,1-899,37) */ + uint32_t __tmp_in_tmp134; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp134; + } + Arr1DIdxRowM(tmp134, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp134 : 0; + } + + uint64_t *tmp135 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp135 + * at (902,1-902,37) */ + uint32_t __tmp_in_tmp135; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp135; + } + Arr1DIdxRowM(tmp135, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp135 : 0; + } + + uint64_t *tmp136 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp136 + * at (905,1-905,37) */ + uint32_t __tmp_in_tmp136; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp136; + } + Arr1DIdxRowM(tmp136, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp136 : 0; + } + + uint64_t *tmp137 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp137 + * at (908,1-908,37) */ + uint32_t __tmp_in_tmp137; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp137; + } + Arr1DIdxRowM(tmp137, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp137 : 0; + } + + uint64_t *tmp138 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp138 + * at (911,1-911,37) */ + uint32_t __tmp_in_tmp138; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp138; + } + Arr1DIdxRowM(tmp138, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp138 : 0; + } + + uint64_t *tmp139 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp139 + * at (914,1-914,47) */ + uint32_t __tmp_in_tmp139; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp139; + } + Arr4DIdxRowM(tmp139, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp139 : 0; + } + } + } + } + + uint64_t *tmp140 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp140 + * at (917,1-917,37) */ + uint32_t __tmp_in_tmp140; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp140; + } + Arr1DIdxRowM(tmp140, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp140 : 0; + } + + uint64_t *tmp141 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp141 + * at (920,1-920,37) */ + uint32_t __tmp_in_tmp141; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp141; + } + Arr1DIdxRowM(tmp141, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp141 : 0; + } + + uint64_t *tmp142 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp142 + * at (923,1-923,37) */ + uint32_t __tmp_in_tmp142; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp142; + } + Arr1DIdxRowM(tmp142, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp142 : 0; + } + + uint64_t *tmp143 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp143 + * at (926,1-926,37) */ + uint32_t __tmp_in_tmp143; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp143; + } + Arr1DIdxRowM(tmp143, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp143 : 0; + } + + uint64_t *tmp144 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp144 + * at (929,1-929,37) */ + uint32_t __tmp_in_tmp144; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp144; + } + Arr1DIdxRowM(tmp144, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp144 : 0; + } + + uint64_t *tmp145 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp145 + * at (932,1-932,47) */ + uint32_t __tmp_in_tmp145; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp145; + } + Arr4DIdxRowM(tmp145, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp145 : 0; + } + } + } + } + + uint64_t *tmp146 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp146 + * at (935,1-935,37) */ + uint32_t __tmp_in_tmp146; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp146; + } + Arr1DIdxRowM(tmp146, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp146 : 0; + } + + uint64_t *tmp147 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp147 + * at (938,1-938,37) */ + uint32_t __tmp_in_tmp147; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp147; + } + Arr1DIdxRowM(tmp147, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp147 : 0; + } + + uint64_t *tmp148 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp148 + * at (941,1-941,37) */ + uint32_t __tmp_in_tmp148; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp148; + } + Arr1DIdxRowM(tmp148, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp148 : 0; + } + + uint64_t *tmp149 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp149 + * at (944,1-944,37) */ + uint32_t __tmp_in_tmp149; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp149; + } + Arr1DIdxRowM(tmp149, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp149 : 0; + } + + uint64_t *tmp150 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp150 + * at (947,1-947,37) */ + uint32_t __tmp_in_tmp150; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp150; + } + Arr1DIdxRowM(tmp150, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp150 : 0; + } + + uint64_t *tmp151 = + make_array((int32_t)1, (int32_t)1, (int32_t)32, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp151 + * at (950,1-950,47) */ + uint32_t __tmp_in_tmp151; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp151; + } + Arr4DIdxRowM(tmp151, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp151 : 0; + } + } + } + } + + uint64_t *tmp152 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp152 + * at (953,1-953,37) */ + uint32_t __tmp_in_tmp152; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp152; + } + Arr1DIdxRowM(tmp152, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp152 : 0; + } + + uint64_t *tmp153 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp153 + * at (956,1-956,37) */ + uint32_t __tmp_in_tmp153; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp153; + } + Arr1DIdxRowM(tmp153, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp153 : 0; + } + + uint64_t *tmp154 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp154 + * at (959,1-959,37) */ + uint32_t __tmp_in_tmp154; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp154; + } + Arr1DIdxRowM(tmp154, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp154 : 0; + } + + uint64_t *tmp155 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp155 + * at (962,1-962,37) */ + uint32_t __tmp_in_tmp155; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp155; + } + Arr1DIdxRowM(tmp155, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp155 : 0; + } + + uint64_t *tmp156 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp156 + * at (965,1-965,37) */ + uint32_t __tmp_in_tmp156; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp156; + } + Arr1DIdxRowM(tmp156, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp156 : 0; + } + + uint64_t *tmp157 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp157 + * at (968,1-968,47) */ + uint32_t __tmp_in_tmp157; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp157; + } + Arr4DIdxRowM(tmp157, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp157 : 0; + } + } + } + } + + uint64_t *tmp158 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp158 + * at (971,1-971,37) */ + uint32_t __tmp_in_tmp158; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp158; + } + Arr1DIdxRowM(tmp158, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp158 : 0; + } + + uint64_t *tmp159 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp159 + * at (974,1-974,37) */ + uint32_t __tmp_in_tmp159; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp159; + } + Arr1DIdxRowM(tmp159, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp159 : 0; + } + + uint64_t *tmp160 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp160 + * at (977,1-977,37) */ + uint32_t __tmp_in_tmp160; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp160; + } + Arr1DIdxRowM(tmp160, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp160 : 0; + } + + uint64_t *tmp161 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp161 + * at (980,1-980,37) */ + uint32_t __tmp_in_tmp161; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp161; + } + Arr1DIdxRowM(tmp161, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp161 : 0; + } + + uint64_t *tmp162 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp162 + * at (983,1-983,37) */ + uint32_t __tmp_in_tmp162; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp162; + } + Arr1DIdxRowM(tmp162, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp162 : 0; + } + + uint64_t *tmp163 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp163 + * at (986,1-986,47) */ + uint32_t __tmp_in_tmp163; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp163; + } + Arr4DIdxRowM(tmp163, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp163 : 0; + } + } + } + } + + uint64_t *tmp164 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp164 + * at (989,1-989,37) */ + uint32_t __tmp_in_tmp164; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp164; + } + Arr1DIdxRowM(tmp164, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp164 : 0; + } + + uint64_t *tmp165 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp165 + * at (992,1-992,37) */ + uint32_t __tmp_in_tmp165; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp165; + } + Arr1DIdxRowM(tmp165, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp165 : 0; + } + + uint64_t *tmp166 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp166 + * at (995,1-995,37) */ + uint32_t __tmp_in_tmp166; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp166; + } + Arr1DIdxRowM(tmp166, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp166 : 0; + } + + uint64_t *tmp167 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp167 + * at (998,1-998,37) */ + uint32_t __tmp_in_tmp167; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp167; + } + Arr1DIdxRowM(tmp167, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp167 : 0; + } + + uint64_t *tmp168 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp168 + * at (1001,1-1001,37) */ + uint32_t __tmp_in_tmp168; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp168; + } + Arr1DIdxRowM(tmp168, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp168 : 0; + } + + uint64_t *tmp169 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp169 + * at (1004,1-1004,47) */ + uint32_t __tmp_in_tmp169; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp169; + } + Arr4DIdxRowM(tmp169, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp169 : 0; + } + } + } + } + + uint64_t *tmp170 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp170 + * at (1007,1-1007,37) */ + uint32_t __tmp_in_tmp170; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp170; + } + Arr1DIdxRowM(tmp170, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp170 : 0; + } + + uint64_t *tmp171 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp171 + * at (1010,1-1010,37) */ + uint32_t __tmp_in_tmp171; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp171; + } + Arr1DIdxRowM(tmp171, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp171 : 0; + } + + uint64_t *tmp172 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp172 + * at (1013,1-1013,37) */ + uint32_t __tmp_in_tmp172; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp172; + } + Arr1DIdxRowM(tmp172, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp172 : 0; + } + + uint64_t *tmp173 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp173 + * at (1016,1-1016,37) */ + uint32_t __tmp_in_tmp173; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp173; + } + Arr1DIdxRowM(tmp173, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp173 : 0; + } + + uint64_t *tmp174 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp174 + * at (1019,1-1019,37) */ + uint32_t __tmp_in_tmp174; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp174; + } + Arr1DIdxRowM(tmp174, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp174 : 0; + } + + uint64_t *tmp175 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp175 + * at (1022,1-1022,47) */ + uint32_t __tmp_in_tmp175; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp175; + } + Arr4DIdxRowM(tmp175, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp175 : 0; + } + } + } + } + + uint64_t *tmp176 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp176 + * at (1025,1-1025,37) */ + uint32_t __tmp_in_tmp176; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp176; + } + Arr1DIdxRowM(tmp176, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp176 : 0; + } + + uint64_t *tmp177 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp177 + * at (1028,1-1028,37) */ + uint32_t __tmp_in_tmp177; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp177; + } + Arr1DIdxRowM(tmp177, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp177 : 0; + } + + uint64_t *tmp178 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp178 + * at (1031,1-1031,37) */ + uint32_t __tmp_in_tmp178; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp178; + } + Arr1DIdxRowM(tmp178, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp178 : 0; + } + + uint64_t *tmp179 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp179 + * at (1034,1-1034,37) */ + uint32_t __tmp_in_tmp179; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp179; + } + Arr1DIdxRowM(tmp179, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp179 : 0; + } + + uint64_t *tmp180 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp180 + * at (1037,1-1037,37) */ + uint32_t __tmp_in_tmp180; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp180; + } + Arr1DIdxRowM(tmp180, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp180 : 0; + } + + uint64_t *tmp181 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp181 + * at (1040,1-1040,47) */ + uint32_t __tmp_in_tmp181; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp181; + } + Arr4DIdxRowM(tmp181, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp181 : 0; + } + } + } + } + + uint64_t *tmp182 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp182 + * at (1043,1-1043,37) */ + uint32_t __tmp_in_tmp182; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp182; + } + Arr1DIdxRowM(tmp182, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp182 : 0; + } + + uint64_t *tmp183 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp183 + * at (1046,1-1046,37) */ + uint32_t __tmp_in_tmp183; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp183; + } + Arr1DIdxRowM(tmp183, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp183 : 0; + } + + uint64_t *tmp184 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp184 + * at (1049,1-1049,37) */ + uint32_t __tmp_in_tmp184; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp184; + } + Arr1DIdxRowM(tmp184, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp184 : 0; + } + + uint64_t *tmp185 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp185 + * at (1052,1-1052,37) */ + uint32_t __tmp_in_tmp185; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp185; + } + Arr1DIdxRowM(tmp185, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp185 : 0; + } + + uint64_t *tmp186 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp186 + * at (1055,1-1055,37) */ + uint32_t __tmp_in_tmp186; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp186; + } + Arr1DIdxRowM(tmp186, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp186 : 0; + } + + uint64_t *tmp187 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp187 + * at (1058,1-1058,47) */ + uint32_t __tmp_in_tmp187; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp187; + } + Arr4DIdxRowM(tmp187, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp187 : 0; + } + } + } + } + + uint64_t *tmp188 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp188 + * at (1061,1-1061,37) */ + uint32_t __tmp_in_tmp188; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp188; + } + Arr1DIdxRowM(tmp188, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp188 : 0; + } + + uint64_t *tmp189 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp189 + * at (1064,1-1064,37) */ + uint32_t __tmp_in_tmp189; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp189; + } + Arr1DIdxRowM(tmp189, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp189 : 0; + } + + uint64_t *tmp190 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp190 + * at (1067,1-1067,37) */ + uint32_t __tmp_in_tmp190; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp190; + } + Arr1DIdxRowM(tmp190, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp190 : 0; + } + + uint64_t *tmp191 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp191 + * at (1070,1-1070,37) */ + uint32_t __tmp_in_tmp191; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp191; + } + Arr1DIdxRowM(tmp191, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp191 : 0; + } + + uint64_t *tmp192 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp192 + * at (1073,1-1073,37) */ + uint32_t __tmp_in_tmp192; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp192; + } + Arr1DIdxRowM(tmp192, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp192 : 0; + } + + uint64_t *tmp193 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp193 + * at (1076,1-1076,47) */ + uint32_t __tmp_in_tmp193; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp193; + } + Arr4DIdxRowM(tmp193, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp193 : 0; + } + } + } + } + + uint64_t *tmp194 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp194 + * at (1079,1-1079,37) */ + uint32_t __tmp_in_tmp194; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp194; + } + Arr1DIdxRowM(tmp194, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp194 : 0; + } + + uint64_t *tmp195 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp195 + * at (1082,1-1082,37) */ + uint32_t __tmp_in_tmp195; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp195; + } + Arr1DIdxRowM(tmp195, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp195 : 0; + } + + uint64_t *tmp196 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp196 + * at (1085,1-1085,37) */ + uint32_t __tmp_in_tmp196; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp196; + } + Arr1DIdxRowM(tmp196, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp196 : 0; + } + + uint64_t *tmp197 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp197 + * at (1088,1-1088,37) */ + uint32_t __tmp_in_tmp197; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp197; + } + Arr1DIdxRowM(tmp197, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp197 : 0; + } + + uint64_t *tmp198 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp198 + * at (1091,1-1091,37) */ + uint32_t __tmp_in_tmp198; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp198; + } + Arr1DIdxRowM(tmp198, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp198 : 0; + } + + uint64_t *tmp199 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp199 + * at (1094,1-1094,47) */ + uint32_t __tmp_in_tmp199; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++) { + for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++) { + for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp199; + } + Arr4DIdxRowM(tmp199, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp199 : 0; + } + } + } + } + + uint64_t *tmp200 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp200 + * at (1097,1-1097,37) */ + uint32_t __tmp_in_tmp200; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp200; + } + Arr1DIdxRowM(tmp200, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp200 : 0; + } + + uint64_t *tmp201 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp201 + * at (1100,1-1100,37) */ + uint32_t __tmp_in_tmp201; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp201; + } + Arr1DIdxRowM(tmp201, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp201 : 0; + } + + uint64_t *tmp202 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp202 + * at (1103,1-1103,37) */ + uint32_t __tmp_in_tmp202; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp202; + } + Arr1DIdxRowM(tmp202, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp202 : 0; + } + + uint64_t *tmp203 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp203 + * at (1106,1-1106,37) */ + uint32_t __tmp_in_tmp203; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp203; + } + Arr1DIdxRowM(tmp203, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp203 : 0; + } + + uint64_t *tmp204 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp204 + * at (1109,1-1109,37) */ + uint32_t __tmp_in_tmp204; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp204; + } + Arr1DIdxRowM(tmp204, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp204 : 0; + } + + uint64_t *tmp205 = make_array((int32_t)64, (int32_t)100); + /* Variable to read the clear value corresponding to the input variable tmp205 + * at (1112,1-1112,42) */ + uint32_t __tmp_in_tmp205; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)100; i1++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp205; + } + Arr2DIdxRowM(tmp205, (int32_t)64, (int32_t)100, i0, i1) = + (party == SERVER) ? __tmp_in_tmp205 : 0; + } + } + + uint64_t *tmp206 = make_array((int32_t)100); + /* Variable to read the clear value corresponding to the input variable tmp206 + * at (1115,1-1115,38) */ + uint32_t __tmp_in_tmp206; + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)100; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp206; + } + Arr1DIdxRowM(tmp206, (int32_t)100, i0) = + (party == SERVER) ? __tmp_in_tmp206 : 0; + } + StartComputation(); + + int64_t *tmp207 = make_array((int32_t)4, (int32_t)2); + Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)0, (int32_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)0, (int32_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)1, (int32_t)0) = + (int32_t)1; + Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)1, (int32_t)1) = + (int32_t)1; + Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)2, (int32_t)0) = + (int32_t)1; + Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)2, (int32_t)1) = + (int32_t)1; + Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)3, (int32_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)3, (int32_t)1) = + (int32_t)0; + + uint64_t *tmp208 = + make_array((int32_t)1, (int32_t)34, (int32_t)34, (int32_t)3); + Pad442((int32_t)1, (int32_t)34, (int32_t)34, (int32_t)3, (int32_t)1, + (int32_t)32, (int32_t)32, (int32_t)3, tmp0, (int32_t)4, (int32_t)2, + tmp207, tmp208); + + uint64_t *tmp212 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)34, (int32_t)34, (int32_t)3, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp208, tmp1, tmp212); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp212, + // (int32_t)11); + + uint64_t *tmp216 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp212, + tmp2, tmp216); + + uint64_t *tmp223 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp216, + tmp3, tmp4, 0, (int32_t)11, tmp223); + + uint64_t *tmp227 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp223, tmp227, + (int32_t)11, 1); + + uint64_t *tmp230 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp227, tmp7, tmp230); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp230, + // (int32_t)11); + + uint64_t *tmp233 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp230, + tmp8, tmp233); + + uint64_t *tmp240 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp233, + tmp9, tmp10, 0, (int32_t)11, tmp240); + + uint64_t *tmp244 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp240, tmp244, + (int32_t)11, 1); + + uint64_t *tmp247 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp244, tmp13, tmp247); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp247, + // (int32_t)11); + + uint64_t *tmp251 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp247, + tmp14, tmp251); + + uint64_t *tmp258 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp251, + tmp15, tmp16, 0, (int32_t)11, tmp258); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp258, + // (int32_t)11); + + uint64_t *tmp263 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)1, + (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp227, tmp19, tmp263); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp263, + // (int32_t)11); + + uint64_t *tmp267 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp263, + tmp20, tmp267); + + uint64_t *tmp274 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp267, + tmp21, tmp22, 0, (int32_t)11, tmp274); + + uint64_t *tmp278 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + // ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp258, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp258, tmp274, + tmp278); + + uint64_t *tmp281 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp278, tmp281, + (int32_t)11, 1); + + uint64_t *tmp284 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp281, tmp25, tmp284); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp284, + // (int32_t)11); + + uint64_t *tmp287 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp284, + tmp26, tmp287); + + uint64_t *tmp294 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp287, + tmp27, tmp28, 0, (int32_t)11, tmp294); + + uint64_t *tmp298 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp294, tmp298, + (int32_t)11, 1); + + uint64_t *tmp301 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp298, tmp31, tmp301); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp301, + // (int32_t)11); + + uint64_t *tmp305 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp301, + tmp32, tmp305); + + uint64_t *tmp312 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp305, + tmp33, tmp34, 0, (int32_t)11, tmp312); + + uint64_t *tmp316 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + // ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp281, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp312, tmp281, + tmp316); + + uint64_t *tmp319 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp316, tmp319, + (int32_t)11, 1); + + uint64_t *tmp322 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp319, tmp37, tmp322); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp322, + // (int32_t)11); + + uint64_t *tmp325 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp322, + tmp38, tmp325); + + uint64_t *tmp332 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp325, + tmp39, tmp40, 0, (int32_t)11, tmp332); + + uint64_t *tmp336 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp332, tmp336, + (int32_t)11, 1); + + uint64_t *tmp339 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp336, tmp43, tmp339); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp339, + // (int32_t)11); + + uint64_t *tmp343 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp339, + tmp44, tmp343); + + uint64_t *tmp350 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp343, + tmp45, tmp46, 0, (int32_t)11, tmp350); + + uint64_t *tmp354 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + // ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp319, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp350, tmp319, + tmp354); + + uint64_t *tmp357 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp354, tmp357, + (int32_t)11, 1); + + uint64_t *tmp360 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp357, tmp49, tmp360); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp360, + // (int32_t)11); + + uint64_t *tmp363 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp360, + tmp50, tmp363); + + uint64_t *tmp370 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp363, + tmp51, tmp52, 0, (int32_t)11, tmp370); + + uint64_t *tmp374 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp370, tmp374, + (int32_t)11, 1); + + uint64_t *tmp377 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp374, tmp55, tmp377); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp377, + // (int32_t)11); + + uint64_t *tmp381 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp377, + tmp56, tmp381); + + uint64_t *tmp388 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp381, + tmp57, tmp58, 0, (int32_t)11, tmp388); + + uint64_t *tmp392 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + // ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp357, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp388, tmp357, + tmp392); + + uint64_t *tmp395 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp392, tmp395, + (int32_t)11, 1); + + uint64_t *tmp398 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp395, tmp61, tmp398); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp398, + // (int32_t)11); + + uint64_t *tmp401 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp398, + tmp62, tmp401); + + uint64_t *tmp408 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp401, + tmp63, tmp64, 0, (int32_t)11, tmp408); + + uint64_t *tmp412 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp408, tmp412, + (int32_t)11, 1); + + uint64_t *tmp415 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp412, tmp67, tmp415); + // ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp415, + // (int32_t)11); + + uint64_t *tmp419 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + MatAddBroadCast4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp415, + tmp68, tmp419); + + uint64_t *tmp426 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + FusedBatchNorm4411((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp419, + tmp69, tmp70, 0, (int32_t)11, tmp426); + + uint64_t *tmp430 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + // ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp395, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp426, tmp395, + tmp430); + + uint64_t *tmp433 = + make_array((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); + Relu4((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp430, tmp433, + (int32_t)11, 1); + + uint64_t *tmp436 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)0, (int32_t)1, (int32_t)0, + (int32_t)1, (int32_t)2, (int32_t)2, tmp433, tmp73, tmp436); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp436, + // (int32_t)11); + + uint64_t *tmp439 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp436, + tmp74, tmp439); + + uint64_t *tmp446 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp439, + tmp75, tmp76, 0, (int32_t)11, tmp446); + + uint64_t *tmp450 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp446, tmp450, + (int32_t)11, 1); + + uint64_t *tmp453 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp450, tmp79, tmp453); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp453, + // (int32_t)11); + + uint64_t *tmp457 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp453, + tmp80, tmp457); + + uint64_t *tmp464 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp457, + tmp81, tmp82, 0, (int32_t)11, tmp464); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp464, + // (int32_t)11); + + uint64_t *tmp469 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)1, + (int32_t)1, (int32_t)32, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp433, tmp85, tmp469); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp469, + // (int32_t)11); + + uint64_t *tmp473 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp469, + tmp86, tmp473); + + uint64_t *tmp480 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp473, + tmp87, tmp88, 0, (int32_t)11, tmp480); + + uint64_t *tmp484 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + // ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp464, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp464, tmp480, + tmp484); + + uint64_t *tmp487 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp484, tmp487, + (int32_t)11, 1); + + uint64_t *tmp490 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp487, tmp91, tmp490); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp490, + // (int32_t)11); + + uint64_t *tmp493 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp490, + tmp92, tmp493); + + uint64_t *tmp500 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp493, + tmp93, tmp94, 0, (int32_t)11, tmp500); + + uint64_t *tmp504 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp500, tmp504, + (int32_t)11, 1); + + uint64_t *tmp507 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp504, tmp97, tmp507); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp507, + // (int32_t)11); + + uint64_t *tmp511 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp507, + tmp98, tmp511); + + uint64_t *tmp518 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp511, + tmp99, tmp100, 0, (int32_t)11, tmp518); + + uint64_t *tmp522 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + // ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp487, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp518, tmp487, + tmp522); + + uint64_t *tmp525 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp522, tmp525, + (int32_t)11, 1); + + uint64_t *tmp528 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp525, tmp103, tmp528); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp528, + // (int32_t)11); + + uint64_t *tmp531 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp528, + tmp104, tmp531); + + uint64_t *tmp538 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp531, + tmp105, tmp106, 0, (int32_t)11, tmp538); + + uint64_t *tmp542 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp538, tmp542, + (int32_t)11, 1); + + uint64_t *tmp545 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp542, tmp109, tmp545); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp545, + // (int32_t)11); + + uint64_t *tmp549 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp545, + tmp110, tmp549); + + uint64_t *tmp556 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp549, + tmp111, tmp112, 0, (int32_t)11, tmp556); + + uint64_t *tmp560 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + // ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp525, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp556, tmp525, + tmp560); + + uint64_t *tmp563 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp560, tmp563, + (int32_t)11, 1); + + uint64_t *tmp566 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp563, tmp115, tmp566); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp566, + // (int32_t)11); + + uint64_t *tmp569 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp566, + tmp116, tmp569); + + uint64_t *tmp576 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp569, + tmp117, tmp118, 0, (int32_t)11, tmp576); + + uint64_t *tmp580 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp576, tmp580, + (int32_t)11, 1); + + uint64_t *tmp583 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp580, tmp121, tmp583); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp583, + // (int32_t)11); + + uint64_t *tmp587 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp583, + tmp122, tmp587); + + uint64_t *tmp594 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp587, + tmp123, tmp124, 0, (int32_t)11, tmp594); + + uint64_t *tmp598 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + // ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp563, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp594, tmp563, + tmp598); + + uint64_t *tmp601 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp598, tmp601, + (int32_t)11, 1); + + uint64_t *tmp604 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp601, tmp127, tmp604); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp604, + // (int32_t)11); + + uint64_t *tmp607 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp604, + tmp128, tmp607); + + uint64_t *tmp614 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp607, + tmp129, tmp130, 0, (int32_t)11, tmp614); + + uint64_t *tmp618 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp614, tmp618, + (int32_t)11, 1); + + uint64_t *tmp621 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp618, tmp133, tmp621); + // ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp621, + // (int32_t)11); + + uint64_t *tmp625 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + MatAddBroadCast4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp621, + tmp134, tmp625); + + uint64_t *tmp632 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + FusedBatchNorm4411((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp625, + tmp135, tmp136, 0, (int32_t)11, tmp632); + + uint64_t *tmp636 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + // ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp601, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp632, tmp601, + tmp636); + + uint64_t *tmp639 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); + Relu4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp636, tmp639, + (int32_t)11, 1); + + uint64_t *tmp642 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)0, (int32_t)1, (int32_t)0, + (int32_t)1, (int32_t)2, (int32_t)2, tmp639, tmp139, tmp642); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp642, + // (int32_t)11); + + uint64_t *tmp645 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp642, + tmp140, tmp645); + + uint64_t *tmp652 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp645, + tmp141, tmp142, 0, (int32_t)11, tmp652); + + uint64_t *tmp656 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp652, tmp656, + (int32_t)11, 1); + + uint64_t *tmp659 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp656, tmp145, tmp659); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp659, + // (int32_t)11); + + uint64_t *tmp663 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp659, + tmp146, tmp663); + + uint64_t *tmp670 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp663, + tmp147, tmp148, 0, (int32_t)11, tmp670); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp670, + // (int32_t)11); + + uint64_t *tmp675 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)1, + (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp639, tmp151, tmp675); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp675, + // (int32_t)11); + + uint64_t *tmp679 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp675, + tmp152, tmp679); + + uint64_t *tmp686 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp679, + tmp153, tmp154, 0, (int32_t)11, tmp686); + + uint64_t *tmp690 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + // ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp670, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp670, tmp686, + tmp690); + + uint64_t *tmp693 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp690, tmp693, + (int32_t)11, 1); + + uint64_t *tmp696 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp693, tmp157, tmp696); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp696, + // (int32_t)11); + + uint64_t *tmp699 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp696, + tmp158, tmp699); + + uint64_t *tmp706 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp699, + tmp159, tmp160, 0, (int32_t)11, tmp706); + + uint64_t *tmp710 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp706, tmp710, + (int32_t)11, 1); + + uint64_t *tmp713 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp710, tmp163, tmp713); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp713, + // (int32_t)11); + + uint64_t *tmp717 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp713, + tmp164, tmp717); + + uint64_t *tmp724 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp717, + tmp165, tmp166, 0, (int32_t)11, tmp724); + + uint64_t *tmp728 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + // ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp693, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp724, tmp693, + tmp728); + + uint64_t *tmp731 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp728, tmp731, + (int32_t)11, 1); + + uint64_t *tmp734 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp731, tmp169, tmp734); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp734, + // (int32_t)11); + + uint64_t *tmp737 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp734, + tmp170, tmp737); + + uint64_t *tmp744 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp737, + tmp171, tmp172, 0, (int32_t)11, tmp744); + + uint64_t *tmp748 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp744, tmp748, + (int32_t)11, 1); + + uint64_t *tmp751 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp748, tmp175, tmp751); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp751, + // (int32_t)11); + + uint64_t *tmp755 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp751, + tmp176, tmp755); + + uint64_t *tmp762 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp755, + tmp177, tmp178, 0, (int32_t)11, tmp762); + + uint64_t *tmp766 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + // ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp731, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp762, tmp731, + tmp766); + + uint64_t *tmp769 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp766, tmp769, + (int32_t)11, 1); + + uint64_t *tmp772 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp769, tmp181, tmp772); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp772, + // (int32_t)11); + + uint64_t *tmp775 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp772, + tmp182, tmp775); + + uint64_t *tmp782 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp775, + tmp183, tmp184, 0, (int32_t)11, tmp782); + + uint64_t *tmp786 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp782, tmp786, + (int32_t)11, 1); + + uint64_t *tmp789 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp786, tmp187, tmp789); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp789, + // (int32_t)11); + + uint64_t *tmp793 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp789, + tmp188, tmp793); + + uint64_t *tmp800 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp793, + tmp189, tmp190, 0, (int32_t)11, tmp800); + + uint64_t *tmp804 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + // ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp769, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp800, tmp769, + tmp804); + + uint64_t *tmp807 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp804, tmp807, + (int32_t)11, 1); + + uint64_t *tmp810 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp807, tmp193, tmp810); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp810, + // (int32_t)11); + + uint64_t *tmp813 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp810, + tmp194, tmp813); + + uint64_t *tmp820 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp813, + tmp195, tmp196, 0, (int32_t)11, tmp820); + + uint64_t *tmp824 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp820, tmp824, + (int32_t)11, 1); + + uint64_t *tmp827 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp824, tmp199, tmp827); + // ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp827, + // (int32_t)11); + + uint64_t *tmp831 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + MatAddBroadCast4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp827, + tmp200, tmp831); + + uint64_t *tmp838 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + FusedBatchNorm4411((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp831, + tmp201, tmp202, 0, (int32_t)11, tmp838); + + uint64_t *tmp842 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + // ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp807, + // (int32_t)11); + MatAdd4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp838, tmp807, + tmp842); + + uint64_t *tmp845 = + make_array((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); + Relu4((int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp842, tmp845, + (int32_t)11, 1); + + uint64_t *tmp847 = + make_array((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)64); + AvgPool((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)8, + (int32_t)8, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)8, (int32_t)8, + (int32_t)64, tmp845, tmp847); + + uint64_t *tmp849 = make_array((int32_t)4); + + int64_t *tmp850 = make_array((int32_t)1); + CreateTensor1((int32_t)1, (int32_t)0, tmp850); + + int64_t *tmp851 = make_array((int32_t)1); + CreateTensor1((int32_t)1, (int32_t)1, tmp851); + + int64_t *tmp852 = make_array((int32_t)1); + CreateTensor1((int32_t)1, (int32_t)1, tmp852); + + uint64_t *tmp855 = make_array((int32_t)1, (int32_t)64); + + int32_t i5; + + int32_t i4; + + int32_t i3; + + int32_t i2; + + int32_t i1; + + int32_t i0; + i0 = (int32_t)0; + i1 = (int32_t)0; + i2 = (int32_t)0; + i3 = (int32_t)0; + for (uint32_t i4 = (int32_t)0; i4 < (int32_t)1; i4++) { + for (uint32_t i5 = (int32_t)0; i5 < (int32_t)64; i5++) { + Arr2DIdxRowM(tmp855, (int32_t)1, (int32_t)64, i4, i5) = + Arr4DIdxRowM(tmp847, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)64, + i0, i1, i2, i3); + i3 = (i3 + (int32_t)1); + if ((i3 == (int32_t)64)) { + i3 = (int32_t)0; + i2 = (i2 + (int32_t)1); + if ((i2 == (int32_t)1)) { + i2 = (int32_t)0; + i1 = (i1 + (int32_t)1); + if ((i1 == (int32_t)1)) { + i1 = (int32_t)0; + i0 = (i0 + (int32_t)1); + } + } + } + } + } + + uint64_t *tmp858 = make_array((int32_t)1, (int32_t)100); + MatMul2D((int32_t)1, (int32_t)64, (int32_t)100, tmp855, tmp205, tmp858, + false); + + uint64_t *tmp862 = make_array((int32_t)1, (int32_t)100); + MatAddBroadCast2((int32_t)1, (int32_t)100, tmp858, tmp206, tmp862); + EndComputation(); + for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++) { + for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)100; i1++) { + cout << (funcReconstruct2PCCons( + Arr2DIdxRowM(tmp862, (int32_t)1, (int32_t)100, i0, i1), 2)) + << endl; + } + } +} diff --git a/SCI/networks/main_resnet32_cifar_field64.cpp b/SCI/networks/main_resnet32_cifar_field64.cpp deleted file mode 100644 index f325b176..00000000 --- a/SCI/networks/main_resnet32_cifar_field64.cpp +++ /dev/null @@ -1,4738 +0,0 @@ -/* -This is an autogenerated file, generated using the EzPC compiler. -*/ -#define LAN_EXEC - -#define BITLEN_41 -#define SCI_HE -#define HACKY_RUN - -#include "globals.h" -#include "functionalities_wrapper.h" -#include -using namespace std; - - -template -T* make_array(size_t s1){ -return new T[s1]; -} - -template -T* make_array(size_t s1, size_t s2){ -return new T[s1*s2]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3){ -return new T[s1*s2*s3]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){ -return new T[s1*s2*s3*s4]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){ -return new T[s1*s2*s3*s4*s5]; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr1DIdxRowM(B,s2,i2)); -} -} -} - -void MatAdd2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr2DIdxRowM(B,s1,s2,i1,i2)); -} -} -} - -void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr1DIdxRowM(B,s4,i4)); -} -} -} -} -} - -void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr4DIdxRowM(B,s1,s2,s3,s4,i1,i2,i3,i4)); -} -} -} -} -} - -void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr1DIdxRowM(B,s5,i5)); -} -} -} -} -} -} - -void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr5DIdxRowM(B,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5)); -} -} -} -} -} -} - -void CreateTensor1(int64_t s1, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(arr,s1,i1) = val; -} -} - -void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(arr,s1,s2,i1,i2) = val; -} -} -} - -void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = val; -} -} -} -} - -void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = val; -} -} -} -} -} - -void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(arr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = val; -} -} -} -} -} -} - -void CopyTensor1(int64_t s1, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(targetArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CopyTensor2(int64_t s1, int64_t s2, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(targetArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(targetArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(targetArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateIdentity11(int64_t s1, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(newArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CreateIdentity22(int64_t s1, int64_t s2, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(newArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(newArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(newArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,inps1,inps2,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j)); -} -} -} - -void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inArr,inps1,inps2,inps3,inps4,inps5,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)2) + k),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)3) + l),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)4) + m)); -} -} -} -} -} -} - -void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,(i1 - inp1s1),i2); -} -} else { -if ((i2 < inp1s2)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,i1,(i2 - inp1s2)); -} -} -} -} -} - -void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,(i1 - inp1s1),i2,i3,i4); -} -} else { -if ((axis == (int32_t)1)) { -if ((i2 < inp1s2)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,(i2 - inp1s2),i3,i4); -} -} else { -if ((axis == (int32_t)2)) { -if ((i3 < inp1s3)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,(i3 - inp1s3),i4); -} -} else { -if ((i4 < inp1s4)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,i3,(i4 - inp1s4)); -} -} -} -} -} -} -} -} -} - -void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, int64_t I2, int64_t I3, int64_t I4, uint64_t* inp, int64_t axis, int64_t curCount, int64_t total, uint64_t* out){ -for (uint64_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint64_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint64_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint64_t o4 = (int32_t)0; o4 < O4; o4++){ - -int64_t i1 = o1; - -int64_t i2 = o2; - -int64_t i3 = o3; - -int64_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (((I1 / total) * curCount) + o1); -} -if ((axis == (int32_t)1)) { -i2 = (((I2 / total) * curCount) + o2); -} -if ((axis == (int32_t)2)) { -i3 = (((I3 / total) * curCount) + o3); -} -if ((axis == (int32_t)3)) { -i4 = (((I4 / total) * curCount) + o4); -} -Arr4DIdxRowM(out,O1,O2,O3,O4,o1,o2,o3,o4) = Arr4DIdxRowM(inp,I1,I2,I3,I4,i1,i2,i3,i4); -} -} -} -} -} - -void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CI,CO,fh,fw,ci,co); -} -} -} -} -} - -void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = ( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t outH, int64_t outW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t GIS = (CI / G); - -int64_t GOS = (CO / G); -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint64_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint64_t g = (int32_t)0; g < G; g++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ - -uint64_t val = ( (int32_t)0); - -int64_t ci = ((GIS * g) + cig); - -int64_t co = ((GOS * g) + cog); - -int64_t curPosH = ((strideH * h) - zPadHLeft); -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ - -int64_t curPosW = ((strideW * w) - zPadWLeft); -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && (curPosH < H)) && (curPosW < W))) { -val = SecretAdd(val, SecretMult(Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci), Arr4DIdxRowM(filterArr,FH,FW,(CI / G),CO,fh,fw,(ci / G),co))); -} -curPosW = (curPosW + (int32_t)1); -} -curPosH = (curPosH + (int32_t)1); -} -Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co) = SecretAdd(Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co), val); -} -} -} -} -} -} -} - -void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t CIG = (CI / G); - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ - -int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); -Arr2DIdxRowM(outputArr,(CO / G),((FH * FW) * (CI / G)),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,(CI / G),CO,fh,fw,ci,(co + startCO)); -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,(co + startCO)) = Arr2DIdxRowM(inputArr,(CO / G),((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t g, int64_t G, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; - -int64_t CIG = (CI / G); -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); - -int64_t startCI = (g * CIG); -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = ( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,(ci + startCI)); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CIG) + (fw * CIG)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t CIG = (CI / G); - -int64_t reshapedFilterRows = (CO / G); - -int64_t reshapedFilterCols = ((FH * FW) * CIG); - -int64_t reshapedIPRows = ((FH * FW) * CIG); - -int64_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * outH) * outW); -for (uint64_t g = (int32_t)0; g < G; g++){ - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -} -} - -void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CI,CO,fd,fh,fw,ci,co); -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t d = (int32_t)0; d < finalD; d++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr5DIdxRowM(outputArr,N,finalD,finalH,finalW,CO,n,d,h,w,co) = Arr2DIdxRowM(inputArr,CO,(((N * finalD) * finalH) * finalW),co,((((((n * finalD) * finalH) * finalW) + ((d * finalH) * finalW)) + (h * finalW)) + w)); -} -} -} -} -} -} - -void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadDLeft); - -int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= D)) || ((curPosH < (int32_t)0) || (curPosH >= H))) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = ( (int32_t)0); -} else { -val = Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -leftTopCornerD = (leftTopCornerD + strideD); -} - -} -} - -void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = (((N * newD) * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = ( (int32_t)0); -for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); fd++){ -for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); fh++){ -for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); fw++){ - -int64_t curPosD = (fd - zPadDLeft); - -int64_t curPosH = (fh - zPadHLeft); - -int64_t curPosW = (fw - zPadWLeft); -if (((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W))) { - -int64_t curFilterPosD = (fd - (d * strideD)); - -int64_t curFilterPosH = (fh - (h * strideH)); - -int64_t curFilterPosW = (fw - (w * strideW)); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CI,CO,curFilterPosD,curFilterPosH,curFilterPosW,ci,co))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CO,CI,((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} - -void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = ( (int32_t)0); -} else { -if ((((curPosH % strideH) == (int32_t)0) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr4DIdxRowM(inputArr,N,HPrime,WPrime,CI,n,idxInputH,idxInputW,ci); -} else { -val = ( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -} -} - -void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t reshapedIPCols = ((N * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CO,CI,((FD - (int32_t)1) - fd),((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadTrDLeft); - -int64_t DPrimeTilde = (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); - -int64_t extremeRightBottomCornerD = ((DPrimeTilde - (int32_t)1) + zPadTrDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = ( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = ( (int32_t)0); -} else { -if (((((curPosD % strideD) == (int32_t)0) && ((curPosH % strideH) == (int32_t)0)) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputD = (curPosD / strideD); - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr5DIdxRowM(inputArr,N,DPrime,HPrime,WPrime,CI,n,idxInputD,idxInputH,idxInputW,ci); -} else { -val = ( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -leftTopCornerD = (leftTopCornerD + (int32_t)1); -} - -} -} - -void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t reshapedIPCols = (((N * D) * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = ( (int32_t)0); -for (uint64_t fd = d; fd < (d + FD); fd++){ -for (uint64_t fh = h; fh < (h + FH); fh++){ -for (uint64_t fw = w; fw < (w + FW); fw++){ - -int64_t curPosD = ((fd - zPadDLeft) / strideD); - -int64_t curPosH = ((fh - zPadHLeft) / strideD); - -int64_t curPosW = ((fw - zPadWLeft) / strideD); -if ((((((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W)) && (((fd - zPadDLeft) % strideD) == (int32_t)0)) && (((fh - zPadHLeft) % strideH) == (int32_t)0)) && (((fw - zPadWLeft) % strideW) == (int32_t)0))) { - -int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); - -int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); - -int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CO,CI,curFilterPosD,curFilterPosH,curFilterPosW,co,ci))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,s2,s1,j,i); -} -} -} - -void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = Arr4DIdxRowM(inpArr,inps1,inps2,inps3,inps4,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0))); -} else { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = ( (int32_t)0); -} -} -} -} -} -} - -void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); - -int64_t lbounds5 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0); - -int64_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl)) && (m >= lbounds5)) && (m < rbounds5excl))) { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inpArr,inps1,inps2,inps3,inps4,inps5,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0)),(m - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0))); -} else { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = ( (int32_t)0); -} -} -} -} -} -} -} - -void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, int64_t i2, int64_t i3, int64_t i4, uint64_t* inpArr, int64_t pads, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr1DIdxRowM(paddings,pads, (int32_t)0); - -int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings,pads, (int32_t)4)); - -int64_t lbounds2 = Arr1DIdxRowM(paddings,pads, (int32_t)1); - -int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings,pads, (int32_t)5)); - -int64_t lbounds3 = Arr1DIdxRowM(paddings,pads, (int32_t)2); - -int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings,pads, (int32_t)6)); - -int64_t lbounds4 = Arr1DIdxRowM(paddings,pads, (int32_t)3); - -int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings,pads, (int32_t)7)); -for (uint64_t i = (int32_t)0; i < o1; i++){ -for (uint64_t j = (int32_t)0; j < o2; j++){ -for (uint64_t k = (int32_t)0; k < o3; k++){ -for (uint64_t l = (int32_t)0; l < o4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = Arr4DIdxRowM(inpArr,i1,i2,i3,i4,(i - Arr1DIdxRowM(paddings,pads, (int32_t)0)),(j - Arr1DIdxRowM(paddings,pads, (int32_t)1)),(k - Arr1DIdxRowM(paddings,pads, (int32_t)2)),(l - Arr1DIdxRowM(paddings,pads, (int32_t)3))); -} else { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = ( (int32_t)0); -} -} -} -} -} -} - -void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < ins1; i++){ -for (uint64_t j = (int32_t)0; j < ins2; j++){ -for (uint64_t k = (int32_t)0; k < ins3; k++){ -for (uint64_t l = (int32_t)0; l < ins4; l++){ - -int64_t linIdx = ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + (k * ins4)) + l); - -int64_t outIdx1 = (linIdx / s2); - -int64_t outIdx2 = (linIdx % s2); -Arr2DIdxRowM(outArr,s1,s2,outIdx1,outIdx2) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i,j,k,l); -} -} -} -} -} - -void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s4,i4); -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s4); -for (uint64_t ii = (int32_t)0; ii < s4; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s4,ii) = Arr1DIdxRowM(biasArr,s4,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outputArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s4,i4)); -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s5,i5); -} -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s5); -for (uint64_t ii = (int32_t)0; ii < s5; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s5,ii) = Arr1DIdxRowM(biasArr,s5,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outputArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s5,i5)); -} -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s5, biasArrScaledUp); -} - -void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (s1 * s2); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr1,s1,s2,i1,i2); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr2,s1,s2,i1,i2); -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr1,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr2,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr1,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr2,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t* axes, uint64_t* outputArr){ - -int64_t divisor = (inS2 * inS3); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = ( (int32_t)0); -for (uint64_t i = (int32_t)0; i < inS2; i++){ -for (uint64_t j = (int32_t)0; j < inS3; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i,j,i2)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t axis1, int64_t axis2, uint64_t* outputArr){ - -int64_t divisor = (inS3 * inS4); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = ( (int32_t)0); -for (uint64_t i = (int32_t)0; i < inS3; i++){ -for (uint64_t j = (int32_t)0; j < inS4; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i2,i,j)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, uint64_t* inArr, int64_t dim, uint64_t* outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, int64_t dim, uint64_t* outArr){ - -int64_t size = ((ins1 * ins2) * ins3); - -uint64_t* reshapedInArr = make_array(size, ins4); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr2DIdxRowM(reshapedInArr,size,ins4,linIdx,i4) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i1,i2,i3,i4); -} -} -} -} -ArgMax(size, ins4, reshapedInArr, reshapedOutArr); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr3DIdxRowM(outArr,outs1,outs2,outs3,i1,i2,i3) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -ClearMemSecret2(size, ins4, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Floor2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Floor(size, reshapedInArr, reshapedOutArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void ScaleUp1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleUp(s1, arr, sf); -} - -void ScaleUp2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleDown(s1, arr, sf); -} - -void ScaleDown2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -int main(int argc, char** argv) -{ -ArgMapping amap; -int port = 32000; -string serverAddr = "127.0.0.1"; - -amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); -amap.arg("p", port, "Port Number"); -amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); -amap.parse(argc, argv); - -assert(party==sci::ALICE || party==sci::BOB); - -checkIfUsingEigen(); -for(int i=0;i(ioArr[i]); -prgInstanceArr[i] = new sci::PRG128(); -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); -if (i == 0) { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength); -} -else if (i == 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength); -} -else if (i & 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[1]); -} -else { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[0]); -} -} - -io = ioArr[0]; -iknpOT = new sci::IKNP(io); -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good -kkot = new sci::KKOT(io); -prg128Instance = new sci::PRG128(); -otpack = new sci::OTPack(io, party, baseForRelu, bitlength); - -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - -#ifdef SCI_OT -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack); -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -#endif - -#ifdef SCI_HE -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -heConvImpl = new ConvField(party,io); -heFCImpl = new FCField(party,io); -heProdImpl = new ElemWiseProdField(party, io); -assertFieldRun(); -#endif -#ifdef MULTITHREADED_NONLIN -#ifdef SCI_OT -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -} -#endif -#ifdef SCI_HE -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -} -#endif -#endif - -if (party==sci::ALICE){ -iknpOT->setup_send(); -iknpOTRoleReversed->setup_recv(); -} -else if (party==sci::BOB){ -iknpOT->setup_recv(); -iknpOTRoleReversed->setup_send(); -} -cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3); -/* Variable to read the clear value corresponding to the input variable tmp0 at (497,1-497,45) */ -uint32_t __tmp_in_tmp0; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)32; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)3; i3++){ -if ((party == CLIENT)) { -cin >> __tmp_in_tmp0; -} -Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3,i0,i1,i2,i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; -} -} -} -} - -uint64_t* tmp1 = make_array( (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp1 at (500,1-500,44) */ -uint32_t __tmp_in_tmp1; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)3; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp1; -} -Arr4DIdxRowM(tmp1, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; -} -} -} -} - -uint64_t* tmp2 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp2 at (503,1-503,35) */ -uint32_t __tmp_in_tmp2; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp2; -} -Arr1DIdxRowM(tmp2, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; -} - -uint64_t* tmp3 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp3 at (506,1-506,35) */ -uint32_t __tmp_in_tmp3; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp3; -} -Arr1DIdxRowM(tmp3, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp3 : 0; -} - -uint64_t* tmp4 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp4 at (509,1-509,35) */ -uint32_t __tmp_in_tmp4; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp4; -} -Arr1DIdxRowM(tmp4, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; -} - -uint64_t* tmp5 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp5 at (512,1-512,35) */ -uint32_t __tmp_in_tmp5; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp5; -} -Arr1DIdxRowM(tmp5, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp5 : 0; -} - -uint64_t* tmp6 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp6 at (515,1-515,35) */ -uint32_t __tmp_in_tmp6; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp6; -} -Arr1DIdxRowM(tmp6, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp6 : 0; -} - -uint64_t* tmp7 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp7 at (518,1-518,45) */ -uint32_t __tmp_in_tmp7; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp7; -} -Arr4DIdxRowM(tmp7, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; -} -} -} -} - -uint64_t* tmp8 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp8 at (521,1-521,35) */ -uint32_t __tmp_in_tmp8; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp8; -} -Arr1DIdxRowM(tmp8, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; -} - -uint64_t* tmp9 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp9 at (524,1-524,35) */ -uint32_t __tmp_in_tmp9; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp9; -} -Arr1DIdxRowM(tmp9, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; -} - -uint64_t* tmp10 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp10 at (527,1-527,36) */ -uint32_t __tmp_in_tmp10; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp10; -} -Arr1DIdxRowM(tmp10, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp10 : 0; -} - -uint64_t* tmp11 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp11 at (530,1-530,36) */ -uint32_t __tmp_in_tmp11; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp11; -} -Arr1DIdxRowM(tmp11, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp11 : 0; -} - -uint64_t* tmp12 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp12 at (533,1-533,36) */ -uint32_t __tmp_in_tmp12; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp12; -} -Arr1DIdxRowM(tmp12, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp12 : 0; -} - -uint64_t* tmp13 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp13 at (536,1-536,46) */ -uint32_t __tmp_in_tmp13; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp13; -} -Arr4DIdxRowM(tmp13, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp13 : 0; -} -} -} -} - -uint64_t* tmp14 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp14 at (539,1-539,36) */ -uint32_t __tmp_in_tmp14; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp14; -} -Arr1DIdxRowM(tmp14, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp14 : 0; -} - -uint64_t* tmp15 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp15 at (542,1-542,36) */ -uint32_t __tmp_in_tmp15; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp15; -} -Arr1DIdxRowM(tmp15, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp15 : 0; -} - -uint64_t* tmp16 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp16 at (545,1-545,36) */ -uint32_t __tmp_in_tmp16; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp16; -} -Arr1DIdxRowM(tmp16, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp16 : 0; -} - -uint64_t* tmp17 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp17 at (548,1-548,36) */ -uint32_t __tmp_in_tmp17; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp17; -} -Arr1DIdxRowM(tmp17, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp17 : 0; -} - -uint64_t* tmp18 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp18 at (551,1-551,36) */ -uint32_t __tmp_in_tmp18; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp18; -} -Arr1DIdxRowM(tmp18, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp18 : 0; -} - -uint64_t* tmp19 = make_array( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp19 at (554,1-554,46) */ -uint32_t __tmp_in_tmp19; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp19; -} -Arr4DIdxRowM(tmp19, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp19 : 0; -} -} -} -} - -uint64_t* tmp20 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp20 at (557,1-557,36) */ -uint32_t __tmp_in_tmp20; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp20; -} -Arr1DIdxRowM(tmp20, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp20 : 0; -} - -uint64_t* tmp21 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp21 at (560,1-560,36) */ -uint32_t __tmp_in_tmp21; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp21; -} -Arr1DIdxRowM(tmp21, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp21 : 0; -} - -uint64_t* tmp22 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp22 at (563,1-563,36) */ -uint32_t __tmp_in_tmp22; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp22; -} -Arr1DIdxRowM(tmp22, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp22 : 0; -} - -uint64_t* tmp23 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp23 at (566,1-566,36) */ -uint32_t __tmp_in_tmp23; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp23; -} -Arr1DIdxRowM(tmp23, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp23 : 0; -} - -uint64_t* tmp24 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp24 at (569,1-569,36) */ -uint32_t __tmp_in_tmp24; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp24; -} -Arr1DIdxRowM(tmp24, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp24 : 0; -} - -uint64_t* tmp25 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp25 at (572,1-572,46) */ -uint32_t __tmp_in_tmp25; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp25; -} -Arr4DIdxRowM(tmp25, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp25 : 0; -} -} -} -} - -uint64_t* tmp26 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp26 at (575,1-575,36) */ -uint32_t __tmp_in_tmp26; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp26; -} -Arr1DIdxRowM(tmp26, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp26 : 0; -} - -uint64_t* tmp27 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp27 at (578,1-578,36) */ -uint32_t __tmp_in_tmp27; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp27; -} -Arr1DIdxRowM(tmp27, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp27 : 0; -} - -uint64_t* tmp28 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp28 at (581,1-581,36) */ -uint32_t __tmp_in_tmp28; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp28; -} -Arr1DIdxRowM(tmp28, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp28 : 0; -} - -uint64_t* tmp29 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp29 at (584,1-584,36) */ -uint32_t __tmp_in_tmp29; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp29; -} -Arr1DIdxRowM(tmp29, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp29 : 0; -} - -uint64_t* tmp30 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp30 at (587,1-587,36) */ -uint32_t __tmp_in_tmp30; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp30; -} -Arr1DIdxRowM(tmp30, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp30 : 0; -} - -uint64_t* tmp31 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp31 at (590,1-590,46) */ -uint32_t __tmp_in_tmp31; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp31; -} -Arr4DIdxRowM(tmp31, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp31 : 0; -} -} -} -} - -uint64_t* tmp32 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp32 at (593,1-593,36) */ -uint32_t __tmp_in_tmp32; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp32; -} -Arr1DIdxRowM(tmp32, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp32 : 0; -} - -uint64_t* tmp33 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp33 at (596,1-596,36) */ -uint32_t __tmp_in_tmp33; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp33; -} -Arr1DIdxRowM(tmp33, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp33 : 0; -} - -uint64_t* tmp34 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp34 at (599,1-599,36) */ -uint32_t __tmp_in_tmp34; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp34; -} -Arr1DIdxRowM(tmp34, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp34 : 0; -} - -uint64_t* tmp35 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp35 at (602,1-602,36) */ -uint32_t __tmp_in_tmp35; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp35; -} -Arr1DIdxRowM(tmp35, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp35 : 0; -} - -uint64_t* tmp36 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp36 at (605,1-605,36) */ -uint32_t __tmp_in_tmp36; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp36; -} -Arr1DIdxRowM(tmp36, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp36 : 0; -} - -uint64_t* tmp37 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp37 at (608,1-608,46) */ -uint32_t __tmp_in_tmp37; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp37; -} -Arr4DIdxRowM(tmp37, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp37 : 0; -} -} -} -} - -uint64_t* tmp38 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp38 at (611,1-611,36) */ -uint32_t __tmp_in_tmp38; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp38; -} -Arr1DIdxRowM(tmp38, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp38 : 0; -} - -uint64_t* tmp39 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp39 at (614,1-614,36) */ -uint32_t __tmp_in_tmp39; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp39; -} -Arr1DIdxRowM(tmp39, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp39 : 0; -} - -uint64_t* tmp40 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp40 at (617,1-617,36) */ -uint32_t __tmp_in_tmp40; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp40; -} -Arr1DIdxRowM(tmp40, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp40 : 0; -} - -uint64_t* tmp41 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp41 at (620,1-620,36) */ -uint32_t __tmp_in_tmp41; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp41; -} -Arr1DIdxRowM(tmp41, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp41 : 0; -} - -uint64_t* tmp42 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp42 at (623,1-623,36) */ -uint32_t __tmp_in_tmp42; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp42; -} -Arr1DIdxRowM(tmp42, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp42 : 0; -} - -uint64_t* tmp43 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp43 at (626,1-626,46) */ -uint32_t __tmp_in_tmp43; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp43; -} -Arr4DIdxRowM(tmp43, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp43 : 0; -} -} -} -} - -uint64_t* tmp44 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp44 at (629,1-629,36) */ -uint32_t __tmp_in_tmp44; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp44; -} -Arr1DIdxRowM(tmp44, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp44 : 0; -} - -uint64_t* tmp45 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp45 at (632,1-632,36) */ -uint32_t __tmp_in_tmp45; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp45; -} -Arr1DIdxRowM(tmp45, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp45 : 0; -} - -uint64_t* tmp46 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp46 at (635,1-635,36) */ -uint32_t __tmp_in_tmp46; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp46; -} -Arr1DIdxRowM(tmp46, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp46 : 0; -} - -uint64_t* tmp47 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp47 at (638,1-638,36) */ -uint32_t __tmp_in_tmp47; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp47; -} -Arr1DIdxRowM(tmp47, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp47 : 0; -} - -uint64_t* tmp48 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp48 at (641,1-641,36) */ -uint32_t __tmp_in_tmp48; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp48; -} -Arr1DIdxRowM(tmp48, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp48 : 0; -} - -uint64_t* tmp49 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp49 at (644,1-644,46) */ -uint32_t __tmp_in_tmp49; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp49; -} -Arr4DIdxRowM(tmp49, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp49 : 0; -} -} -} -} - -uint64_t* tmp50 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp50 at (647,1-647,36) */ -uint32_t __tmp_in_tmp50; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp50; -} -Arr1DIdxRowM(tmp50, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp50 : 0; -} - -uint64_t* tmp51 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp51 at (650,1-650,36) */ -uint32_t __tmp_in_tmp51; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp51; -} -Arr1DIdxRowM(tmp51, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp51 : 0; -} - -uint64_t* tmp52 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp52 at (653,1-653,36) */ -uint32_t __tmp_in_tmp52; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp52; -} -Arr1DIdxRowM(tmp52, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp52 : 0; -} - -uint64_t* tmp53 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp53 at (656,1-656,36) */ -uint32_t __tmp_in_tmp53; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp53; -} -Arr1DIdxRowM(tmp53, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp53 : 0; -} - -uint64_t* tmp54 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp54 at (659,1-659,36) */ -uint32_t __tmp_in_tmp54; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp54; -} -Arr1DIdxRowM(tmp54, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp54 : 0; -} - -uint64_t* tmp55 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp55 at (662,1-662,46) */ -uint32_t __tmp_in_tmp55; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp55; -} -Arr4DIdxRowM(tmp55, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp55 : 0; -} -} -} -} - -uint64_t* tmp56 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp56 at (665,1-665,36) */ -uint32_t __tmp_in_tmp56; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp56; -} -Arr1DIdxRowM(tmp56, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp56 : 0; -} - -uint64_t* tmp57 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp57 at (668,1-668,36) */ -uint32_t __tmp_in_tmp57; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp57; -} -Arr1DIdxRowM(tmp57, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp57 : 0; -} - -uint64_t* tmp58 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp58 at (671,1-671,36) */ -uint32_t __tmp_in_tmp58; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp58; -} -Arr1DIdxRowM(tmp58, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp58 : 0; -} - -uint64_t* tmp59 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp59 at (674,1-674,36) */ -uint32_t __tmp_in_tmp59; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp59; -} -Arr1DIdxRowM(tmp59, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp59 : 0; -} - -uint64_t* tmp60 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp60 at (677,1-677,36) */ -uint32_t __tmp_in_tmp60; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp60; -} -Arr1DIdxRowM(tmp60, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp60 : 0; -} - -uint64_t* tmp61 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp61 at (680,1-680,46) */ -uint32_t __tmp_in_tmp61; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp61; -} -Arr4DIdxRowM(tmp61, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp61 : 0; -} -} -} -} - -uint64_t* tmp62 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp62 at (683,1-683,36) */ -uint32_t __tmp_in_tmp62; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp62; -} -Arr1DIdxRowM(tmp62, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp62 : 0; -} - -uint64_t* tmp63 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp63 at (686,1-686,36) */ -uint32_t __tmp_in_tmp63; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp63; -} -Arr1DIdxRowM(tmp63, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp63 : 0; -} - -uint64_t* tmp64 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp64 at (689,1-689,36) */ -uint32_t __tmp_in_tmp64; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp64; -} -Arr1DIdxRowM(tmp64, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp64 : 0; -} - -uint64_t* tmp65 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp65 at (692,1-692,36) */ -uint32_t __tmp_in_tmp65; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp65; -} -Arr1DIdxRowM(tmp65, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp65 : 0; -} - -uint64_t* tmp66 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp66 at (695,1-695,36) */ -uint32_t __tmp_in_tmp66; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp66; -} -Arr1DIdxRowM(tmp66, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp66 : 0; -} - -uint64_t* tmp67 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp67 at (698,1-698,46) */ -uint32_t __tmp_in_tmp67; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp67; -} -Arr4DIdxRowM(tmp67, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp67 : 0; -} -} -} -} - -uint64_t* tmp68 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp68 at (701,1-701,36) */ -uint32_t __tmp_in_tmp68; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp68; -} -Arr1DIdxRowM(tmp68, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp68 : 0; -} - -uint64_t* tmp69 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp69 at (704,1-704,36) */ -uint32_t __tmp_in_tmp69; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp69; -} -Arr1DIdxRowM(tmp69, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp69 : 0; -} - -uint64_t* tmp70 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp70 at (707,1-707,36) */ -uint32_t __tmp_in_tmp70; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp70; -} -Arr1DIdxRowM(tmp70, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp70 : 0; -} - -uint64_t* tmp71 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp71 at (710,1-710,36) */ -uint32_t __tmp_in_tmp71; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp71; -} -Arr1DIdxRowM(tmp71, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp71 : 0; -} - -uint64_t* tmp72 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp72 at (713,1-713,36) */ -uint32_t __tmp_in_tmp72; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp72; -} -Arr1DIdxRowM(tmp72, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp72 : 0; -} - -uint64_t* tmp73 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp73 at (716,1-716,46) */ -uint32_t __tmp_in_tmp73; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp73; -} -Arr4DIdxRowM(tmp73, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp73 : 0; -} -} -} -} - -uint64_t* tmp74 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp74 at (719,1-719,36) */ -uint32_t __tmp_in_tmp74; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp74; -} -Arr1DIdxRowM(tmp74, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp74 : 0; -} - -uint64_t* tmp75 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp75 at (722,1-722,36) */ -uint32_t __tmp_in_tmp75; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp75; -} -Arr1DIdxRowM(tmp75, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp75 : 0; -} - -uint64_t* tmp76 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp76 at (725,1-725,36) */ -uint32_t __tmp_in_tmp76; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp76; -} -Arr1DIdxRowM(tmp76, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp76 : 0; -} - -uint64_t* tmp77 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp77 at (728,1-728,36) */ -uint32_t __tmp_in_tmp77; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp77; -} -Arr1DIdxRowM(tmp77, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp77 : 0; -} - -uint64_t* tmp78 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp78 at (731,1-731,36) */ -uint32_t __tmp_in_tmp78; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp78; -} -Arr1DIdxRowM(tmp78, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp78 : 0; -} - -uint64_t* tmp79 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp79 at (734,1-734,46) */ -uint32_t __tmp_in_tmp79; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp79; -} -Arr4DIdxRowM(tmp79, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp79 : 0; -} -} -} -} - -uint64_t* tmp80 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp80 at (737,1-737,36) */ -uint32_t __tmp_in_tmp80; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp80; -} -Arr1DIdxRowM(tmp80, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp80 : 0; -} - -uint64_t* tmp81 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp81 at (740,1-740,36) */ -uint32_t __tmp_in_tmp81; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp81; -} -Arr1DIdxRowM(tmp81, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp81 : 0; -} - -uint64_t* tmp82 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp82 at (743,1-743,36) */ -uint32_t __tmp_in_tmp82; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp82; -} -Arr1DIdxRowM(tmp82, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp82 : 0; -} - -uint64_t* tmp83 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp83 at (746,1-746,36) */ -uint32_t __tmp_in_tmp83; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp83; -} -Arr1DIdxRowM(tmp83, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp83 : 0; -} - -uint64_t* tmp84 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp84 at (749,1-749,36) */ -uint32_t __tmp_in_tmp84; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp84; -} -Arr1DIdxRowM(tmp84, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp84 : 0; -} - -uint64_t* tmp85 = make_array( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp85 at (752,1-752,46) */ -uint32_t __tmp_in_tmp85; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp85; -} -Arr4DIdxRowM(tmp85, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp85 : 0; -} -} -} -} - -uint64_t* tmp86 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp86 at (755,1-755,36) */ -uint32_t __tmp_in_tmp86; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp86; -} -Arr1DIdxRowM(tmp86, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp86 : 0; -} - -uint64_t* tmp87 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp87 at (758,1-758,36) */ -uint32_t __tmp_in_tmp87; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp87; -} -Arr1DIdxRowM(tmp87, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp87 : 0; -} - -uint64_t* tmp88 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp88 at (761,1-761,36) */ -uint32_t __tmp_in_tmp88; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp88; -} -Arr1DIdxRowM(tmp88, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp88 : 0; -} - -uint64_t* tmp89 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp89 at (764,1-764,36) */ -uint32_t __tmp_in_tmp89; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp89; -} -Arr1DIdxRowM(tmp89, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp89 : 0; -} - -uint64_t* tmp90 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp90 at (767,1-767,36) */ -uint32_t __tmp_in_tmp90; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp90; -} -Arr1DIdxRowM(tmp90, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp90 : 0; -} - -uint64_t* tmp91 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp91 at (770,1-770,46) */ -uint32_t __tmp_in_tmp91; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp91; -} -Arr4DIdxRowM(tmp91, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp91 : 0; -} -} -} -} - -uint64_t* tmp92 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp92 at (773,1-773,36) */ -uint32_t __tmp_in_tmp92; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp92; -} -Arr1DIdxRowM(tmp92, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp92 : 0; -} - -uint64_t* tmp93 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp93 at (776,1-776,36) */ -uint32_t __tmp_in_tmp93; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp93; -} -Arr1DIdxRowM(tmp93, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp93 : 0; -} - -uint64_t* tmp94 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp94 at (779,1-779,36) */ -uint32_t __tmp_in_tmp94; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp94; -} -Arr1DIdxRowM(tmp94, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp94 : 0; -} - -uint64_t* tmp95 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp95 at (782,1-782,36) */ -uint32_t __tmp_in_tmp95; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp95; -} -Arr1DIdxRowM(tmp95, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp95 : 0; -} - -uint64_t* tmp96 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp96 at (785,1-785,36) */ -uint32_t __tmp_in_tmp96; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp96; -} -Arr1DIdxRowM(tmp96, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp96 : 0; -} - -uint64_t* tmp97 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp97 at (788,1-788,46) */ -uint32_t __tmp_in_tmp97; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp97; -} -Arr4DIdxRowM(tmp97, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp97 : 0; -} -} -} -} - -uint64_t* tmp98 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp98 at (791,1-791,36) */ -uint32_t __tmp_in_tmp98; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp98; -} -Arr1DIdxRowM(tmp98, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp98 : 0; -} - -uint64_t* tmp99 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp99 at (794,1-794,36) */ -uint32_t __tmp_in_tmp99; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp99; -} -Arr1DIdxRowM(tmp99, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp99 : 0; -} - -uint64_t* tmp100 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp100 at (797,1-797,37) */ -uint32_t __tmp_in_tmp100; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp100; -} -Arr1DIdxRowM(tmp100, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp100 : 0; -} - -uint64_t* tmp101 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp101 at (800,1-800,37) */ -uint32_t __tmp_in_tmp101; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp101; -} -Arr1DIdxRowM(tmp101, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp101 : 0; -} - -uint64_t* tmp102 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp102 at (803,1-803,37) */ -uint32_t __tmp_in_tmp102; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp102; -} -Arr1DIdxRowM(tmp102, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp102 : 0; -} - -uint64_t* tmp103 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp103 at (806,1-806,47) */ -uint32_t __tmp_in_tmp103; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp103; -} -Arr4DIdxRowM(tmp103, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp103 : 0; -} -} -} -} - -uint64_t* tmp104 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp104 at (809,1-809,37) */ -uint32_t __tmp_in_tmp104; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp104; -} -Arr1DIdxRowM(tmp104, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp104 : 0; -} - -uint64_t* tmp105 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp105 at (812,1-812,37) */ -uint32_t __tmp_in_tmp105; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp105; -} -Arr1DIdxRowM(tmp105, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp105 : 0; -} - -uint64_t* tmp106 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp106 at (815,1-815,37) */ -uint32_t __tmp_in_tmp106; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp106; -} -Arr1DIdxRowM(tmp106, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp106 : 0; -} - -uint64_t* tmp107 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp107 at (818,1-818,37) */ -uint32_t __tmp_in_tmp107; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp107; -} -Arr1DIdxRowM(tmp107, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp107 : 0; -} - -uint64_t* tmp108 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp108 at (821,1-821,37) */ -uint32_t __tmp_in_tmp108; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp108; -} -Arr1DIdxRowM(tmp108, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp108 : 0; -} - -uint64_t* tmp109 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp109 at (824,1-824,47) */ -uint32_t __tmp_in_tmp109; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp109; -} -Arr4DIdxRowM(tmp109, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp109 : 0; -} -} -} -} - -uint64_t* tmp110 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp110 at (827,1-827,37) */ -uint32_t __tmp_in_tmp110; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp110; -} -Arr1DIdxRowM(tmp110, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp110 : 0; -} - -uint64_t* tmp111 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp111 at (830,1-830,37) */ -uint32_t __tmp_in_tmp111; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp111; -} -Arr1DIdxRowM(tmp111, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp111 : 0; -} - -uint64_t* tmp112 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp112 at (833,1-833,37) */ -uint32_t __tmp_in_tmp112; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp112; -} -Arr1DIdxRowM(tmp112, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp112 : 0; -} - -uint64_t* tmp113 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp113 at (836,1-836,37) */ -uint32_t __tmp_in_tmp113; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp113; -} -Arr1DIdxRowM(tmp113, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp113 : 0; -} - -uint64_t* tmp114 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp114 at (839,1-839,37) */ -uint32_t __tmp_in_tmp114; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp114; -} -Arr1DIdxRowM(tmp114, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp114 : 0; -} - -uint64_t* tmp115 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp115 at (842,1-842,47) */ -uint32_t __tmp_in_tmp115; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp115; -} -Arr4DIdxRowM(tmp115, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp115 : 0; -} -} -} -} - -uint64_t* tmp116 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp116 at (845,1-845,37) */ -uint32_t __tmp_in_tmp116; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp116; -} -Arr1DIdxRowM(tmp116, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp116 : 0; -} - -uint64_t* tmp117 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp117 at (848,1-848,37) */ -uint32_t __tmp_in_tmp117; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp117; -} -Arr1DIdxRowM(tmp117, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp117 : 0; -} - -uint64_t* tmp118 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp118 at (851,1-851,37) */ -uint32_t __tmp_in_tmp118; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp118; -} -Arr1DIdxRowM(tmp118, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp118 : 0; -} - -uint64_t* tmp119 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp119 at (854,1-854,37) */ -uint32_t __tmp_in_tmp119; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp119; -} -Arr1DIdxRowM(tmp119, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp119 : 0; -} - -uint64_t* tmp120 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp120 at (857,1-857,37) */ -uint32_t __tmp_in_tmp120; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp120; -} -Arr1DIdxRowM(tmp120, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp120 : 0; -} - -uint64_t* tmp121 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp121 at (860,1-860,47) */ -uint32_t __tmp_in_tmp121; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp121; -} -Arr4DIdxRowM(tmp121, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp121 : 0; -} -} -} -} - -uint64_t* tmp122 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp122 at (863,1-863,37) */ -uint32_t __tmp_in_tmp122; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp122; -} -Arr1DIdxRowM(tmp122, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp122 : 0; -} - -uint64_t* tmp123 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp123 at (866,1-866,37) */ -uint32_t __tmp_in_tmp123; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp123; -} -Arr1DIdxRowM(tmp123, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp123 : 0; -} - -uint64_t* tmp124 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp124 at (869,1-869,37) */ -uint32_t __tmp_in_tmp124; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp124; -} -Arr1DIdxRowM(tmp124, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp124 : 0; -} - -uint64_t* tmp125 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp125 at (872,1-872,37) */ -uint32_t __tmp_in_tmp125; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp125; -} -Arr1DIdxRowM(tmp125, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp125 : 0; -} - -uint64_t* tmp126 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp126 at (875,1-875,37) */ -uint32_t __tmp_in_tmp126; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp126; -} -Arr1DIdxRowM(tmp126, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp126 : 0; -} - -uint64_t* tmp127 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp127 at (878,1-878,47) */ -uint32_t __tmp_in_tmp127; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp127; -} -Arr4DIdxRowM(tmp127, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp127 : 0; -} -} -} -} - -uint64_t* tmp128 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp128 at (881,1-881,37) */ -uint32_t __tmp_in_tmp128; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp128; -} -Arr1DIdxRowM(tmp128, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp128 : 0; -} - -uint64_t* tmp129 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp129 at (884,1-884,37) */ -uint32_t __tmp_in_tmp129; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp129; -} -Arr1DIdxRowM(tmp129, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp129 : 0; -} - -uint64_t* tmp130 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp130 at (887,1-887,37) */ -uint32_t __tmp_in_tmp130; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp130; -} -Arr1DIdxRowM(tmp130, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp130 : 0; -} - -uint64_t* tmp131 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp131 at (890,1-890,37) */ -uint32_t __tmp_in_tmp131; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp131; -} -Arr1DIdxRowM(tmp131, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp131 : 0; -} - -uint64_t* tmp132 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp132 at (893,1-893,37) */ -uint32_t __tmp_in_tmp132; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp132; -} -Arr1DIdxRowM(tmp132, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp132 : 0; -} - -uint64_t* tmp133 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp133 at (896,1-896,47) */ -uint32_t __tmp_in_tmp133; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp133; -} -Arr4DIdxRowM(tmp133, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp133 : 0; -} -} -} -} - -uint64_t* tmp134 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp134 at (899,1-899,37) */ -uint32_t __tmp_in_tmp134; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp134; -} -Arr1DIdxRowM(tmp134, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp134 : 0; -} - -uint64_t* tmp135 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp135 at (902,1-902,37) */ -uint32_t __tmp_in_tmp135; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp135; -} -Arr1DIdxRowM(tmp135, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp135 : 0; -} - -uint64_t* tmp136 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp136 at (905,1-905,37) */ -uint32_t __tmp_in_tmp136; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp136; -} -Arr1DIdxRowM(tmp136, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp136 : 0; -} - -uint64_t* tmp137 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp137 at (908,1-908,37) */ -uint32_t __tmp_in_tmp137; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp137; -} -Arr1DIdxRowM(tmp137, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp137 : 0; -} - -uint64_t* tmp138 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp138 at (911,1-911,37) */ -uint32_t __tmp_in_tmp138; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp138; -} -Arr1DIdxRowM(tmp138, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp138 : 0; -} - -uint64_t* tmp139 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp139 at (914,1-914,47) */ -uint32_t __tmp_in_tmp139; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp139; -} -Arr4DIdxRowM(tmp139, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp139 : 0; -} -} -} -} - -uint64_t* tmp140 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp140 at (917,1-917,37) */ -uint32_t __tmp_in_tmp140; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp140; -} -Arr1DIdxRowM(tmp140, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp140 : 0; -} - -uint64_t* tmp141 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp141 at (920,1-920,37) */ -uint32_t __tmp_in_tmp141; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp141; -} -Arr1DIdxRowM(tmp141, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp141 : 0; -} - -uint64_t* tmp142 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp142 at (923,1-923,37) */ -uint32_t __tmp_in_tmp142; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp142; -} -Arr1DIdxRowM(tmp142, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp142 : 0; -} - -uint64_t* tmp143 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp143 at (926,1-926,37) */ -uint32_t __tmp_in_tmp143; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp143; -} -Arr1DIdxRowM(tmp143, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp143 : 0; -} - -uint64_t* tmp144 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp144 at (929,1-929,37) */ -uint32_t __tmp_in_tmp144; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp144; -} -Arr1DIdxRowM(tmp144, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp144 : 0; -} - -uint64_t* tmp145 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp145 at (932,1-932,47) */ -uint32_t __tmp_in_tmp145; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp145; -} -Arr4DIdxRowM(tmp145, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp145 : 0; -} -} -} -} - -uint64_t* tmp146 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp146 at (935,1-935,37) */ -uint32_t __tmp_in_tmp146; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp146; -} -Arr1DIdxRowM(tmp146, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp146 : 0; -} - -uint64_t* tmp147 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp147 at (938,1-938,37) */ -uint32_t __tmp_in_tmp147; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp147; -} -Arr1DIdxRowM(tmp147, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp147 : 0; -} - -uint64_t* tmp148 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp148 at (941,1-941,37) */ -uint32_t __tmp_in_tmp148; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp148; -} -Arr1DIdxRowM(tmp148, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp148 : 0; -} - -uint64_t* tmp149 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp149 at (944,1-944,37) */ -uint32_t __tmp_in_tmp149; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp149; -} -Arr1DIdxRowM(tmp149, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp149 : 0; -} - -uint64_t* tmp150 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp150 at (947,1-947,37) */ -uint32_t __tmp_in_tmp150; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp150; -} -Arr1DIdxRowM(tmp150, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp150 : 0; -} - -uint64_t* tmp151 = make_array( (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp151 at (950,1-950,47) */ -uint32_t __tmp_in_tmp151; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp151; -} -Arr4DIdxRowM(tmp151, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp151 : 0; -} -} -} -} - -uint64_t* tmp152 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp152 at (953,1-953,37) */ -uint32_t __tmp_in_tmp152; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp152; -} -Arr1DIdxRowM(tmp152, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp152 : 0; -} - -uint64_t* tmp153 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp153 at (956,1-956,37) */ -uint32_t __tmp_in_tmp153; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp153; -} -Arr1DIdxRowM(tmp153, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp153 : 0; -} - -uint64_t* tmp154 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp154 at (959,1-959,37) */ -uint32_t __tmp_in_tmp154; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp154; -} -Arr1DIdxRowM(tmp154, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp154 : 0; -} - -uint64_t* tmp155 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp155 at (962,1-962,37) */ -uint32_t __tmp_in_tmp155; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp155; -} -Arr1DIdxRowM(tmp155, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp155 : 0; -} - -uint64_t* tmp156 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp156 at (965,1-965,37) */ -uint32_t __tmp_in_tmp156; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp156; -} -Arr1DIdxRowM(tmp156, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp156 : 0; -} - -uint64_t* tmp157 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp157 at (968,1-968,47) */ -uint32_t __tmp_in_tmp157; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp157; -} -Arr4DIdxRowM(tmp157, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp157 : 0; -} -} -} -} - -uint64_t* tmp158 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp158 at (971,1-971,37) */ -uint32_t __tmp_in_tmp158; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp158; -} -Arr1DIdxRowM(tmp158, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp158 : 0; -} - -uint64_t* tmp159 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp159 at (974,1-974,37) */ -uint32_t __tmp_in_tmp159; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp159; -} -Arr1DIdxRowM(tmp159, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp159 : 0; -} - -uint64_t* tmp160 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp160 at (977,1-977,37) */ -uint32_t __tmp_in_tmp160; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp160; -} -Arr1DIdxRowM(tmp160, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp160 : 0; -} - -uint64_t* tmp161 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp161 at (980,1-980,37) */ -uint32_t __tmp_in_tmp161; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp161; -} -Arr1DIdxRowM(tmp161, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp161 : 0; -} - -uint64_t* tmp162 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp162 at (983,1-983,37) */ -uint32_t __tmp_in_tmp162; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp162; -} -Arr1DIdxRowM(tmp162, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp162 : 0; -} - -uint64_t* tmp163 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp163 at (986,1-986,47) */ -uint32_t __tmp_in_tmp163; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp163; -} -Arr4DIdxRowM(tmp163, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp163 : 0; -} -} -} -} - -uint64_t* tmp164 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp164 at (989,1-989,37) */ -uint32_t __tmp_in_tmp164; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp164; -} -Arr1DIdxRowM(tmp164, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp164 : 0; -} - -uint64_t* tmp165 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp165 at (992,1-992,37) */ -uint32_t __tmp_in_tmp165; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp165; -} -Arr1DIdxRowM(tmp165, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp165 : 0; -} - -uint64_t* tmp166 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp166 at (995,1-995,37) */ -uint32_t __tmp_in_tmp166; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp166; -} -Arr1DIdxRowM(tmp166, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp166 : 0; -} - -uint64_t* tmp167 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp167 at (998,1-998,37) */ -uint32_t __tmp_in_tmp167; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp167; -} -Arr1DIdxRowM(tmp167, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp167 : 0; -} - -uint64_t* tmp168 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp168 at (1001,1-1001,37) */ -uint32_t __tmp_in_tmp168; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp168; -} -Arr1DIdxRowM(tmp168, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp168 : 0; -} - -uint64_t* tmp169 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp169 at (1004,1-1004,47) */ -uint32_t __tmp_in_tmp169; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp169; -} -Arr4DIdxRowM(tmp169, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp169 : 0; -} -} -} -} - -uint64_t* tmp170 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp170 at (1007,1-1007,37) */ -uint32_t __tmp_in_tmp170; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp170; -} -Arr1DIdxRowM(tmp170, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp170 : 0; -} - -uint64_t* tmp171 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp171 at (1010,1-1010,37) */ -uint32_t __tmp_in_tmp171; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp171; -} -Arr1DIdxRowM(tmp171, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp171 : 0; -} - -uint64_t* tmp172 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp172 at (1013,1-1013,37) */ -uint32_t __tmp_in_tmp172; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp172; -} -Arr1DIdxRowM(tmp172, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp172 : 0; -} - -uint64_t* tmp173 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp173 at (1016,1-1016,37) */ -uint32_t __tmp_in_tmp173; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp173; -} -Arr1DIdxRowM(tmp173, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp173 : 0; -} - -uint64_t* tmp174 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp174 at (1019,1-1019,37) */ -uint32_t __tmp_in_tmp174; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp174; -} -Arr1DIdxRowM(tmp174, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp174 : 0; -} - -uint64_t* tmp175 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp175 at (1022,1-1022,47) */ -uint32_t __tmp_in_tmp175; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp175; -} -Arr4DIdxRowM(tmp175, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp175 : 0; -} -} -} -} - -uint64_t* tmp176 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp176 at (1025,1-1025,37) */ -uint32_t __tmp_in_tmp176; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp176; -} -Arr1DIdxRowM(tmp176, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp176 : 0; -} - -uint64_t* tmp177 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp177 at (1028,1-1028,37) */ -uint32_t __tmp_in_tmp177; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp177; -} -Arr1DIdxRowM(tmp177, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp177 : 0; -} - -uint64_t* tmp178 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp178 at (1031,1-1031,37) */ -uint32_t __tmp_in_tmp178; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp178; -} -Arr1DIdxRowM(tmp178, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp178 : 0; -} - -uint64_t* tmp179 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp179 at (1034,1-1034,37) */ -uint32_t __tmp_in_tmp179; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp179; -} -Arr1DIdxRowM(tmp179, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp179 : 0; -} - -uint64_t* tmp180 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp180 at (1037,1-1037,37) */ -uint32_t __tmp_in_tmp180; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp180; -} -Arr1DIdxRowM(tmp180, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp180 : 0; -} - -uint64_t* tmp181 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp181 at (1040,1-1040,47) */ -uint32_t __tmp_in_tmp181; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp181; -} -Arr4DIdxRowM(tmp181, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp181 : 0; -} -} -} -} - -uint64_t* tmp182 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp182 at (1043,1-1043,37) */ -uint32_t __tmp_in_tmp182; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp182; -} -Arr1DIdxRowM(tmp182, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp182 : 0; -} - -uint64_t* tmp183 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp183 at (1046,1-1046,37) */ -uint32_t __tmp_in_tmp183; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp183; -} -Arr1DIdxRowM(tmp183, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp183 : 0; -} - -uint64_t* tmp184 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp184 at (1049,1-1049,37) */ -uint32_t __tmp_in_tmp184; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp184; -} -Arr1DIdxRowM(tmp184, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp184 : 0; -} - -uint64_t* tmp185 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp185 at (1052,1-1052,37) */ -uint32_t __tmp_in_tmp185; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp185; -} -Arr1DIdxRowM(tmp185, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp185 : 0; -} - -uint64_t* tmp186 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp186 at (1055,1-1055,37) */ -uint32_t __tmp_in_tmp186; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp186; -} -Arr1DIdxRowM(tmp186, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp186 : 0; -} - -uint64_t* tmp187 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp187 at (1058,1-1058,47) */ -uint32_t __tmp_in_tmp187; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp187; -} -Arr4DIdxRowM(tmp187, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp187 : 0; -} -} -} -} - -uint64_t* tmp188 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp188 at (1061,1-1061,37) */ -uint32_t __tmp_in_tmp188; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp188; -} -Arr1DIdxRowM(tmp188, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp188 : 0; -} - -uint64_t* tmp189 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp189 at (1064,1-1064,37) */ -uint32_t __tmp_in_tmp189; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp189; -} -Arr1DIdxRowM(tmp189, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp189 : 0; -} - -uint64_t* tmp190 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp190 at (1067,1-1067,37) */ -uint32_t __tmp_in_tmp190; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp190; -} -Arr1DIdxRowM(tmp190, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp190 : 0; -} - -uint64_t* tmp191 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp191 at (1070,1-1070,37) */ -uint32_t __tmp_in_tmp191; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp191; -} -Arr1DIdxRowM(tmp191, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp191 : 0; -} - -uint64_t* tmp192 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp192 at (1073,1-1073,37) */ -uint32_t __tmp_in_tmp192; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp192; -} -Arr1DIdxRowM(tmp192, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp192 : 0; -} - -uint64_t* tmp193 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp193 at (1076,1-1076,47) */ -uint32_t __tmp_in_tmp193; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp193; -} -Arr4DIdxRowM(tmp193, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp193 : 0; -} -} -} -} - -uint64_t* tmp194 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp194 at (1079,1-1079,37) */ -uint32_t __tmp_in_tmp194; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp194; -} -Arr1DIdxRowM(tmp194, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp194 : 0; -} - -uint64_t* tmp195 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp195 at (1082,1-1082,37) */ -uint32_t __tmp_in_tmp195; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp195; -} -Arr1DIdxRowM(tmp195, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp195 : 0; -} - -uint64_t* tmp196 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp196 at (1085,1-1085,37) */ -uint32_t __tmp_in_tmp196; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp196; -} -Arr1DIdxRowM(tmp196, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp196 : 0; -} - -uint64_t* tmp197 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp197 at (1088,1-1088,37) */ -uint32_t __tmp_in_tmp197; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp197; -} -Arr1DIdxRowM(tmp197, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp197 : 0; -} - -uint64_t* tmp198 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp198 at (1091,1-1091,37) */ -uint32_t __tmp_in_tmp198; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp198; -} -Arr1DIdxRowM(tmp198, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp198 : 0; -} - -uint64_t* tmp199 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp199 at (1094,1-1094,47) */ -uint32_t __tmp_in_tmp199; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp199; -} -Arr4DIdxRowM(tmp199, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp199 : 0; -} -} -} -} - -uint64_t* tmp200 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp200 at (1097,1-1097,37) */ -uint32_t __tmp_in_tmp200; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp200; -} -Arr1DIdxRowM(tmp200, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp200 : 0; -} - -uint64_t* tmp201 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp201 at (1100,1-1100,37) */ -uint32_t __tmp_in_tmp201; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp201; -} -Arr1DIdxRowM(tmp201, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp201 : 0; -} - -uint64_t* tmp202 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp202 at (1103,1-1103,37) */ -uint32_t __tmp_in_tmp202; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp202; -} -Arr1DIdxRowM(tmp202, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp202 : 0; -} - -uint64_t* tmp203 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp203 at (1106,1-1106,37) */ -uint32_t __tmp_in_tmp203; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp203; -} -Arr1DIdxRowM(tmp203, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp203 : 0; -} - -uint64_t* tmp204 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp204 at (1109,1-1109,37) */ -uint32_t __tmp_in_tmp204; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp204; -} -Arr1DIdxRowM(tmp204, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp204 : 0; -} - -uint64_t* tmp205 = make_array( (int32_t)64, (int32_t)100); -/* Variable to read the clear value corresponding to the input variable tmp205 at (1112,1-1112,42) */ -uint32_t __tmp_in_tmp205; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)100; i1++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp205; -} -Arr2DIdxRowM(tmp205, (int32_t)64, (int32_t)100,i0,i1) = (party == SERVER) ? __tmp_in_tmp205 : 0; -} -} - -uint64_t* tmp206 = make_array( (int32_t)100); -/* Variable to read the clear value corresponding to the input variable tmp206 at (1115,1-1115,38) */ -uint32_t __tmp_in_tmp206; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)100; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp206; -} -Arr1DIdxRowM(tmp206, (int32_t)100,i0) = (party == SERVER) ? __tmp_in_tmp206 : 0; -} -StartComputation(); - -int64_t* tmp207 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)0, (int32_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)0, (int32_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)1, (int32_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)1, (int32_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)2, (int32_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)2, (int32_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)3, (int32_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp207, (int32_t)4, (int32_t)2, (int32_t)3, (int32_t)1) = (int32_t)0; - -uint64_t* tmp208 = make_array( (int32_t)1, (int32_t)34, (int32_t)34, (int32_t)3); -Pad442( (int32_t)1, (int32_t)34, (int32_t)34, (int32_t)3, (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)3, tmp0, (int32_t)4, (int32_t)2, tmp207, tmp208); - -uint64_t* tmp212 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)34, (int32_t)34, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp208, tmp1, tmp212); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp212, (int32_t)11); - -uint64_t* tmp216 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp212, tmp2, tmp216); - -uint64_t* tmp223 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp216, tmp3, tmp4, 0, (int32_t)11, tmp223); - -uint64_t* tmp227 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp223, tmp227, (int32_t)11, 1); - -uint64_t* tmp230 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp227, tmp7, tmp230); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp230, (int32_t)11); - -uint64_t* tmp233 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp230, tmp8, tmp233); - -uint64_t* tmp240 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp233, tmp9, tmp10, 0, (int32_t)11, tmp240); - -uint64_t* tmp244 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp240, tmp244, (int32_t)11, 1); - -uint64_t* tmp247 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp244, tmp13, tmp247); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp247, (int32_t)11); - -uint64_t* tmp251 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp247, tmp14, tmp251); - -uint64_t* tmp258 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp251, tmp15, tmp16, 0, (int32_t)11, tmp258); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp258, (int32_t)11); - -uint64_t* tmp263 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp227, tmp19, tmp263); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp263, (int32_t)11); - -uint64_t* tmp267 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp263, tmp20, tmp267); - -uint64_t* tmp274 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp267, tmp21, tmp22, 0, (int32_t)11, tmp274); - -uint64_t* tmp278 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -// ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp258, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp258, tmp274, tmp278); - -uint64_t* tmp281 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp278, tmp281, (int32_t)11, 1); - -uint64_t* tmp284 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp281, tmp25, tmp284); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp284, (int32_t)11); - -uint64_t* tmp287 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp284, tmp26, tmp287); - -uint64_t* tmp294 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp287, tmp27, tmp28, 0, (int32_t)11, tmp294); - -uint64_t* tmp298 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp294, tmp298, (int32_t)11, 1); - -uint64_t* tmp301 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp298, tmp31, tmp301); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp301, (int32_t)11); - -uint64_t* tmp305 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp301, tmp32, tmp305); - -uint64_t* tmp312 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp305, tmp33, tmp34, 0, (int32_t)11, tmp312); - -uint64_t* tmp316 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -// ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp281, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp312, tmp281, tmp316); - -uint64_t* tmp319 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp316, tmp319, (int32_t)11, 1); - -uint64_t* tmp322 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp319, tmp37, tmp322); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp322, (int32_t)11); - -uint64_t* tmp325 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp322, tmp38, tmp325); - -uint64_t* tmp332 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp325, tmp39, tmp40, 0, (int32_t)11, tmp332); - -uint64_t* tmp336 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp332, tmp336, (int32_t)11, 1); - -uint64_t* tmp339 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp336, tmp43, tmp339); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp339, (int32_t)11); - -uint64_t* tmp343 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp339, tmp44, tmp343); - -uint64_t* tmp350 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp343, tmp45, tmp46, 0, (int32_t)11, tmp350); - -uint64_t* tmp354 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -// ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp319, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp350, tmp319, tmp354); - -uint64_t* tmp357 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp354, tmp357, (int32_t)11, 1); - -uint64_t* tmp360 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp357, tmp49, tmp360); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp360, (int32_t)11); - -uint64_t* tmp363 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp360, tmp50, tmp363); - -uint64_t* tmp370 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp363, tmp51, tmp52, 0, (int32_t)11, tmp370); - -uint64_t* tmp374 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp370, tmp374, (int32_t)11, 1); - -uint64_t* tmp377 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp374, tmp55, tmp377); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp377, (int32_t)11); - -uint64_t* tmp381 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp377, tmp56, tmp381); - -uint64_t* tmp388 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp381, tmp57, tmp58, 0, (int32_t)11, tmp388); - -uint64_t* tmp392 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -// ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp357, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp388, tmp357, tmp392); - -uint64_t* tmp395 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp392, tmp395, (int32_t)11, 1); - -uint64_t* tmp398 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp395, tmp61, tmp398); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp398, (int32_t)11); - -uint64_t* tmp401 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp398, tmp62, tmp401); - -uint64_t* tmp408 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp401, tmp63, tmp64, 0, (int32_t)11, tmp408); - -uint64_t* tmp412 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp408, tmp412, (int32_t)11, 1); - -uint64_t* tmp415 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp412, tmp67, tmp415); -// ScaleDown4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp415, (int32_t)11); - -uint64_t* tmp419 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -MatAddBroadCast4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp415, tmp68, tmp419); - -uint64_t* tmp426 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -FusedBatchNorm4411( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp419, tmp69, tmp70, 0, (int32_t)11, tmp426); - -uint64_t* tmp430 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -// ScaleUp4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp395, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp426, tmp395, tmp430); - -uint64_t* tmp433 = make_array( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16); -Relu4( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, tmp430, tmp433, (int32_t)11, 1); - -uint64_t* tmp436 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)2, (int32_t)2, tmp433, tmp73, tmp436); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp436, (int32_t)11); - -uint64_t* tmp439 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp436, tmp74, tmp439); - -uint64_t* tmp446 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp439, tmp75, tmp76, 0, (int32_t)11, tmp446); - -uint64_t* tmp450 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp446, tmp450, (int32_t)11, 1); - -uint64_t* tmp453 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp450, tmp79, tmp453); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp453, (int32_t)11); - -uint64_t* tmp457 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp453, tmp80, tmp457); - -uint64_t* tmp464 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp457, tmp81, tmp82, 0, (int32_t)11, tmp464); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp464, (int32_t)11); - -uint64_t* tmp469 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)32, (int32_t)32, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp433, tmp85, tmp469); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp469, (int32_t)11); - -uint64_t* tmp473 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp469, tmp86, tmp473); - -uint64_t* tmp480 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp473, tmp87, tmp88, 0, (int32_t)11, tmp480); - -uint64_t* tmp484 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -// ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp464, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp464, tmp480, tmp484); - -uint64_t* tmp487 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp484, tmp487, (int32_t)11, 1); - -uint64_t* tmp490 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp487, tmp91, tmp490); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp490, (int32_t)11); - -uint64_t* tmp493 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp490, tmp92, tmp493); - -uint64_t* tmp500 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp493, tmp93, tmp94, 0, (int32_t)11, tmp500); - -uint64_t* tmp504 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp500, tmp504, (int32_t)11, 1); - -uint64_t* tmp507 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp504, tmp97, tmp507); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp507, (int32_t)11); - -uint64_t* tmp511 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp507, tmp98, tmp511); - -uint64_t* tmp518 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp511, tmp99, tmp100, 0, (int32_t)11, tmp518); - -uint64_t* tmp522 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -// ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp487, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp518, tmp487, tmp522); - -uint64_t* tmp525 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp522, tmp525, (int32_t)11, 1); - -uint64_t* tmp528 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp525, tmp103, tmp528); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp528, (int32_t)11); - -uint64_t* tmp531 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp528, tmp104, tmp531); - -uint64_t* tmp538 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp531, tmp105, tmp106, 0, (int32_t)11, tmp538); - -uint64_t* tmp542 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp538, tmp542, (int32_t)11, 1); - -uint64_t* tmp545 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp542, tmp109, tmp545); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp545, (int32_t)11); - -uint64_t* tmp549 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp545, tmp110, tmp549); - -uint64_t* tmp556 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp549, tmp111, tmp112, 0, (int32_t)11, tmp556); - -uint64_t* tmp560 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -// ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp525, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp556, tmp525, tmp560); - -uint64_t* tmp563 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp560, tmp563, (int32_t)11, 1); - -uint64_t* tmp566 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp563, tmp115, tmp566); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp566, (int32_t)11); - -uint64_t* tmp569 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp566, tmp116, tmp569); - -uint64_t* tmp576 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp569, tmp117, tmp118, 0, (int32_t)11, tmp576); - -uint64_t* tmp580 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp576, tmp580, (int32_t)11, 1); - -uint64_t* tmp583 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp580, tmp121, tmp583); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp583, (int32_t)11); - -uint64_t* tmp587 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp583, tmp122, tmp587); - -uint64_t* tmp594 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp587, tmp123, tmp124, 0, (int32_t)11, tmp594); - -uint64_t* tmp598 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -// ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp563, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp594, tmp563, tmp598); - -uint64_t* tmp601 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp598, tmp601, (int32_t)11, 1); - -uint64_t* tmp604 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp601, tmp127, tmp604); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp604, (int32_t)11); - -uint64_t* tmp607 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp604, tmp128, tmp607); - -uint64_t* tmp614 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp607, tmp129, tmp130, 0, (int32_t)11, tmp614); - -uint64_t* tmp618 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp614, tmp618, (int32_t)11, 1); - -uint64_t* tmp621 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp618, tmp133, tmp621); -// ScaleDown4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp621, (int32_t)11); - -uint64_t* tmp625 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -MatAddBroadCast4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp621, tmp134, tmp625); - -uint64_t* tmp632 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -FusedBatchNorm4411( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp625, tmp135, tmp136, 0, (int32_t)11, tmp632); - -uint64_t* tmp636 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -// ScaleUp4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp601, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp632, tmp601, tmp636); - -uint64_t* tmp639 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32); -Relu4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, tmp636, tmp639, (int32_t)11, 1); - -uint64_t* tmp642 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)2, (int32_t)2, tmp639, tmp139, tmp642); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp642, (int32_t)11); - -uint64_t* tmp645 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp642, tmp140, tmp645); - -uint64_t* tmp652 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp645, tmp141, tmp142, 0, (int32_t)11, tmp652); - -uint64_t* tmp656 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp652, tmp656, (int32_t)11, 1); - -uint64_t* tmp659 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp656, tmp145, tmp659); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp659, (int32_t)11); - -uint64_t* tmp663 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp659, tmp146, tmp663); - -uint64_t* tmp670 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp663, tmp147, tmp148, 0, (int32_t)11, tmp670); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp670, (int32_t)11); - -uint64_t* tmp675 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp639, tmp151, tmp675); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp675, (int32_t)11); - -uint64_t* tmp679 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp675, tmp152, tmp679); - -uint64_t* tmp686 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp679, tmp153, tmp154, 0, (int32_t)11, tmp686); - -uint64_t* tmp690 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -// ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp670, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp670, tmp686, tmp690); - -uint64_t* tmp693 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp690, tmp693, (int32_t)11, 1); - -uint64_t* tmp696 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp693, tmp157, tmp696); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp696, (int32_t)11); - -uint64_t* tmp699 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp696, tmp158, tmp699); - -uint64_t* tmp706 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp699, tmp159, tmp160, 0, (int32_t)11, tmp706); - -uint64_t* tmp710 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp706, tmp710, (int32_t)11, 1); - -uint64_t* tmp713 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp710, tmp163, tmp713); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp713, (int32_t)11); - -uint64_t* tmp717 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp713, tmp164, tmp717); - -uint64_t* tmp724 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp717, tmp165, tmp166, 0, (int32_t)11, tmp724); - -uint64_t* tmp728 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -// ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp693, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp724, tmp693, tmp728); - -uint64_t* tmp731 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp728, tmp731, (int32_t)11, 1); - -uint64_t* tmp734 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp731, tmp169, tmp734); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp734, (int32_t)11); - -uint64_t* tmp737 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp734, tmp170, tmp737); - -uint64_t* tmp744 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp737, tmp171, tmp172, 0, (int32_t)11, tmp744); - -uint64_t* tmp748 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp744, tmp748, (int32_t)11, 1); - -uint64_t* tmp751 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp748, tmp175, tmp751); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp751, (int32_t)11); - -uint64_t* tmp755 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp751, tmp176, tmp755); - -uint64_t* tmp762 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp755, tmp177, tmp178, 0, (int32_t)11, tmp762); - -uint64_t* tmp766 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -// ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp731, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp762, tmp731, tmp766); - -uint64_t* tmp769 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp766, tmp769, (int32_t)11, 1); - -uint64_t* tmp772 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp769, tmp181, tmp772); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp772, (int32_t)11); - -uint64_t* tmp775 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp772, tmp182, tmp775); - -uint64_t* tmp782 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp775, tmp183, tmp184, 0, (int32_t)11, tmp782); - -uint64_t* tmp786 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp782, tmp786, (int32_t)11, 1); - -uint64_t* tmp789 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp786, tmp187, tmp789); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp789, (int32_t)11); - -uint64_t* tmp793 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp789, tmp188, tmp793); - -uint64_t* tmp800 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp793, tmp189, tmp190, 0, (int32_t)11, tmp800); - -uint64_t* tmp804 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -// ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp769, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp800, tmp769, tmp804); - -uint64_t* tmp807 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp804, tmp807, (int32_t)11, 1); - -uint64_t* tmp810 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp807, tmp193, tmp810); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp810, (int32_t)11); - -uint64_t* tmp813 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp810, tmp194, tmp813); - -uint64_t* tmp820 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp813, tmp195, tmp196, 0, (int32_t)11, tmp820); - -uint64_t* tmp824 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp820, tmp824, (int32_t)11, 1); - -uint64_t* tmp827 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp824, tmp199, tmp827); -// ScaleDown4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp827, (int32_t)11); - -uint64_t* tmp831 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -MatAddBroadCast4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp827, tmp200, tmp831); - -uint64_t* tmp838 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -FusedBatchNorm4411( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp831, tmp201, tmp202, 0, (int32_t)11, tmp838); - -uint64_t* tmp842 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -// ScaleUp4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp807, (int32_t)11); -MatAdd4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp838, tmp807, tmp842); - -uint64_t* tmp845 = make_array( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64); -Relu4( (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp842, tmp845, (int32_t)11, 1); - -uint64_t* tmp847 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)64); -AvgPool( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)8, (int32_t)8, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)8, (int32_t)8, (int32_t)64, tmp845, tmp847); - -uint64_t* tmp849 = make_array( (int32_t)4); - -int64_t* tmp850 = make_array( (int32_t)1); -CreateTensor1( (int32_t)1, (int32_t)0, tmp850); - -int64_t* tmp851 = make_array( (int32_t)1); -CreateTensor1( (int32_t)1, (int32_t)1, tmp851); - -int64_t* tmp852 = make_array( (int32_t)1); -CreateTensor1( (int32_t)1, (int32_t)1, tmp852); - -uint64_t* tmp855 = make_array( (int32_t)1, (int32_t)64); - -int32_t i5; - -int32_t i4; - -int32_t i3; - -int32_t i2; - -int32_t i1; - -int32_t i0; -i0 = (int32_t)0; -i1 = (int32_t)0; -i2 = (int32_t)0; -i3 = (int32_t)0; -for (uint32_t i4 = (int32_t)0; i4 < (int32_t)1; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < (int32_t)64; i5++){ -Arr2DIdxRowM(tmp855, (int32_t)1, (int32_t)64,i4,i5) = Arr4DIdxRowM(tmp847, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)64,i0,i1,i2,i3); -i3 = (i3 + (int32_t)1); -if ((i3 == (int32_t)64)) { -i3 = (int32_t)0; -i2 = (i2 + (int32_t)1); -if ((i2 == (int32_t)1)) { -i2 = (int32_t)0; -i1 = (i1 + (int32_t)1); -if ((i1 == (int32_t)1)) { -i1 = (int32_t)0; -i0 = (i0 + (int32_t)1); -} -} -} -} -} - -uint64_t* tmp858 = make_array( (int32_t)1, (int32_t)100); -MatMul2D( (int32_t)1, (int32_t)64, (int32_t)100, tmp855, tmp205, tmp858, false); - -uint64_t* tmp862 = make_array( (int32_t)1, (int32_t)100); -MatAddBroadCast2( (int32_t)1, (int32_t)100, tmp858, tmp206, tmp862); -EndComputation(); -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)100; i1++){ -cout << (funcReconstruct2PCCons(Arr2DIdxRowM(tmp862, (int32_t)1, (int32_t)100,i0,i1), 2)) << endl; -} -} -} - diff --git a/SCI/networks/main_resnet50.cpp b/SCI/networks/main_resnet50.cpp new file mode 100644 index 00000000..2beb26a6 --- /dev/null +++ b/SCI/networks/main_resnet50.cpp @@ -0,0 +1,7272 @@ +/* +This is an autogenerated file, generated using the EzPC compiler. +*/ + +#include "library_fixed.h" +#include +using namespace std; + +int party = 0; +int port = 32000; +string address = "127.0.0.1"; +int num_threads = 4; +int32_t bitlength = 37; + +void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + SecretAdd(Arr2DIdxRowM(A, s1, s2, i1, i2), Arr1DIdxRowM(B, s2, i2)); + } + } +} + +void MatAdd2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = SecretAdd( + Arr2DIdxRowM(A, s1, s2, i1, i2), Arr2DIdxRowM(B, s1, s2, i1, i2)); + } + } +} + +void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr1DIdxRowM(B, s4, i4)); + } + } + } + } +} + +void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *A, + uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr4DIdxRowM(B, s1, s2, s3, s4, i1, i2, i3, i4)); + } + } + } + } +} + +void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr1DIdxRowM(B, s5, i5)); + } + } + } + } + } +} + +void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr5DIdxRowM(B, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5)); + } + } + } + } + } +} + +void CreateTensor1(int64_t s1, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(arr, s1, i1) = val; + } +} + +void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(arr, s1, s2, i1, i2) = val; + } + } +} + +void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = val; + } + } + } +} + +void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = val; + } + } + } + } +} + +void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(arr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = val; + } + } + } + } + } +} + +void CopyTensor1(int64_t s1, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(targetArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CopyTensor2(int64_t s1, int64_t s2, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(targetArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t *targetArr, + uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(targetArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *targetArr, uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(targetArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateIdentity11(int64_t s1, uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(newArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CreateIdentity22(int64_t s1, int64_t s2, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(newArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(newArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(newArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, + uint64_t *inArr, int64_t perDimSize, int64_t *beginIdx, + int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = + Arr2DIdxRowM(inArr, inps1, inps2, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j)); + } + } +} + +void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inArr, int64_t perDimSize, + int64_t *beginIdx, int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM( + inArr, inps1, inps2, inps3, inps4, inps5, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)2) + k), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)3) + l), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)4) + m)); + } + } + } + } + } +} + +void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, + uint64_t *inp1, int64_t inp2s1, int64_t inp2s2, uint64_t *inp2, + int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, (i1 - inp1s1), i2); + } + } else { + if ((i2 < inp1s2)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, i1, (i2 - inp1s2)); + } + } + } + } +} + +void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, + int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t *inp1, + int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, + uint64_t *inp2, int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = Arr4DIdxRowM( + inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, + (i1 - inp1s1), i2, i3, i4); + } + } else { + if ((axis == (int32_t)1)) { + if ((i2 < inp1s2)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, + (i2 - inp1s2), i3, i4); + } + } else { + if ((axis == (int32_t)2)) { + if ((i3 < inp1s3)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + (i3 - inp1s3), i4); + } + } else { + if ((i4 < inp1s4)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + i3, (i4 - inp1s4)); + } + } + } + } + } + } + } + } +} + +void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, + int64_t I2, int64_t I3, int64_t I4, uint64_t *inp, int64_t axis, + int64_t curCount, int64_t total, uint64_t *out) { + for (uint64_t o1 = (int32_t)0; o1 < O1; o1++) { + for (uint64_t o2 = (int32_t)0; o2 < O2; o2++) { + for (uint64_t o3 = (int32_t)0; o3 < O3; o3++) { + for (uint64_t o4 = (int32_t)0; o4 < O4; o4++) { + + int64_t i1 = o1; + + int64_t i2 = o2; + + int64_t i3 = o3; + + int64_t i4 = o4; + if ((axis == (int32_t)0)) { + i1 = (((I1 / total) * curCount) + o1); + } + if ((axis == (int32_t)1)) { + i2 = (((I2 / total) * curCount) + o2); + } + if ((axis == (int32_t)2)) { + i3 = (((I3 / total) * curCount) + o3); + } + if ((axis == (int32_t)3)) { + i4 = (((I4 / total) * curCount) + o4); + } + Arr4DIdxRowM(out, O1, O2, O3, O4, o1, o2, o3, o4) = + Arr4DIdxRowM(inp, I1, I2, I3, I4, i1, i2, i3, i4); + } + } + } + } +} + +void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CI, CO, fh, fw, ci, co); + } + } + } + } +} + +void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int64_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int64_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); + Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, reshapedIPRows, + reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideH, int64_t strideW, int64_t outH, + int64_t outW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t GIS = (CI / G); + + int64_t GOS = (CO / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t cog = (int32_t)0; cog < GOS; cog++) { + for (uint64_t cig = (int32_t)0; cig < GIS; cig++) { + for (uint64_t g = (int32_t)0; g < G; g++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + + uint64_t val = funcSSCons((int64_t)0); + + int64_t ci = ((GIS * g) + cig); + + int64_t co = ((GOS * g) + cog); + + int64_t curPosH = ((strideH * h) - zPadHLeft); + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + + int64_t curPosW = ((strideW * w) - zPadWLeft); + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && + (curPosH < H)) && + (curPosW < W))) { + val = SecretAdd( + val, + SecretMult(Arr4DIdxRowM(inputArr, N, H, W, CI, n, + curPosH, curPosW, ci), + Arr4DIdxRowM(filterArr, FH, FW, (CI / G), CO, + fh, fw, (ci / G), co))); + } + curPosW = (curPosW + (int32_t)1); + } + curPosH = (curPosH + (int32_t)1); + } + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co) = SecretAdd( + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co), val); + } + } + } + } + } + } +} + +void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, outH, outW, G, inputArr, + filterArr, outArr); +} + +void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + int64_t g, int64_t G, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t CIG = (CI / G); + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + + int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); + Arr2DIdxRowM(outputArr, (CO / G), ((FH * FW) * (CI / G)), co, + linIdx) = Arr4DIdxRowM(inputArr, FH, FW, (CI / G), CO, + fh, fw, ci, (co + startCO)); + } + } + } + } +} + +void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, int64_t g, int64_t G, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, + (co + startCO)) = + Arr2DIdxRowM(inputArr, (CO / G), ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, + int64_t FH, int64_t FW, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t g, int64_t G, + int64_t RRows, int64_t RCols, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + + int64_t CIG = (CI / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int64_t)0); + + int64_t startCI = (g * CIG); + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int64_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + (ci + startCI)); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CIG) + (fw * CIG)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t CIG = (CI / G); + + int64_t reshapedFilterRows = (CO / G); + + int64_t reshapedFilterCols = ((FH * FW) * CIG); + + int64_t reshapedIPRows = ((FH * FW) * CIG); + + int64_t outH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t outW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * outH) * outW); + for (uint64_t g = (int32_t)0; g < G; g++) { + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = + make_array(reshapedFilterRows, reshapedIPCols); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); + Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, + zPadWLeft, zPadWRight, strideH, strideW, g, G, + reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); + } +} + +void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, + int64_t CO, uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CI, CO, fd, fh, fw, ci, co); + } + } + } + } + } +} + +void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, + int64_t finalW, int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t d = (int32_t)0; d < finalD; d++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr5DIdxRowM(outputArr, N, finalD, finalH, finalW, CO, n, d, h, w, + co) = + Arr2DIdxRowM(inputArr, CO, (((N * finalD) * finalH) * finalW), + co, + ((((((n * finalD) * finalH) * finalW) + + ((d * finalH) * finalW)) + + (h * finalW)) + + w)); + } + } + } + } + } +} + +void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideD, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadDLeft); + + int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int64_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= D)) || + ((curPosH < (int32_t)0) || (curPosH >= H))) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int64_t)0); + } else { + val = Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, curPosD, + curPosH, curPosW, ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + + leftTopCornerD = (leftTopCornerD + strideD); + } + } +} + +void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, + int64_t strideH, int64_t strideW, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t newD = + ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = (((N * newD) * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); + Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = funcSSCons((int64_t)0); + for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); + fd++) { + for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); + fh++) { + for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); + fw++) { + + int64_t curPosD = (fd - zPadDLeft); + + int64_t curPosH = (fh - zPadHLeft); + + int64_t curPosW = (fw - zPadWLeft); + if (((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W))) { + + int64_t curFilterPosD = (fd - (d * strideD)); + + int64_t curFilterPosH = (fh - (h * strideH)); + + int64_t curFilterPosW = (fw - (w * strideW)); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CI, CO, + curFilterPosD, curFilterPosH, + curFilterPosW, ci, co))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, uint64_t *outArr) { + + int64_t outD = + ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, outD, outH, outW, inputArr, filterArr, + outArr); +} + +void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, + int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CO, CI, ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } +} + +void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FH, int64_t FW, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int64_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = funcSSCons((int64_t)0); + } else { + if ((((curPosH % strideH) == (int32_t)0) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = Arr4DIdxRowM(inputArr, N, HPrime, WPrime, CI, n, + idxInputH, idxInputW, ci); + } else { + val = funcSSCons((int64_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + } +} + +void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, + int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t reshapedIPCols = ((N * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, + zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CO, CI, + ((FD - (int32_t)1) - fd), ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } + } +} + +void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadTrDLeft); + + int64_t DPrimeTilde = + (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); + + int64_t extremeRightBottomCornerD = + ((DPrimeTilde - (int32_t)1) + zPadTrDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int64_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || + ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = funcSSCons((int64_t)0); + } else { + if (((((curPosD % strideD) == (int32_t)0) && + ((curPosH % strideH) == (int32_t)0)) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputD = (curPosD / strideD); + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = + Arr5DIdxRowM(inputArr, N, DPrime, HPrime, WPrime, CI, + n, idxInputD, idxInputH, idxInputW, ci); + } else { + val = funcSSCons((int64_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + + leftTopCornerD = (leftTopCornerD + (int32_t)1); + } + } +} + +void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t reshapedIPCols = (((N * D) * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose3DReshapeInput( + N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, + zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, + int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = funcSSCons((int64_t)0); + for (uint64_t fd = d; fd < (d + FD); fd++) { + for (uint64_t fh = h; fh < (h + FH); fh++) { + for (uint64_t fw = w; fw < (w + FW); fw++) { + + int64_t curPosD = ((fd - zPadDLeft) / strideD); + + int64_t curPosH = ((fh - zPadHLeft) / strideD); + + int64_t curPosW = ((fw - zPadWLeft) / strideD); + if ((((((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W)) && + (((fd - zPadDLeft) % strideD) == (int32_t)0)) && + (((fh - zPadHLeft) % strideH) == (int32_t)0)) && + (((fw - zPadWLeft) % strideW) == (int32_t)0))) { + + int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); + + int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); + + int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CO, CI, + curFilterPosD, curFilterPosH, + curFilterPosW, co, ci))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, + int64_t FW, int64_t CO, int64_t D, int64_t H, + int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, + zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, + zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, + D, H, W, inputArr, filterArr, outArr); +} + +void Transpose2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = Arr2DIdxRowM(inArr, s2, s1, j, i); + } + } +} + +void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, + int64_t inps2, int64_t inps3, int64_t inps4, uint64_t *inpArr, + int64_t pads1, int64_t pads2, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = + Arr4DIdxRowM(inpArr, inps1, inps2, inps3, inps4, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0))); + } else { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = + funcSSCons((int64_t)0); + } + } + } + } + } +} + +void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inpArr, int64_t pads1, int64_t pads2, + int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + + int64_t lbounds5 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)0); + + int64_t rbounds5excl = + (s5 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl)) && + (m >= lbounds5)) && + (m < rbounds5excl))) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM(inpArr, inps1, inps2, inps3, inps4, inps5, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0)), + (m - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)4, (int32_t)0))); + } else { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + funcSSCons((int64_t)0); + } + } + } + } + } + } +} + +void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, + int64_t i2, int64_t i3, int64_t i4, uint64_t *inpArr, + int64_t pads, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = Arr1DIdxRowM(paddings, pads, (int32_t)0); + + int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings, pads, (int32_t)4)); + + int64_t lbounds2 = Arr1DIdxRowM(paddings, pads, (int32_t)1); + + int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings, pads, (int32_t)5)); + + int64_t lbounds3 = Arr1DIdxRowM(paddings, pads, (int32_t)2); + + int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings, pads, (int32_t)6)); + + int64_t lbounds4 = Arr1DIdxRowM(paddings, pads, (int32_t)3); + + int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings, pads, (int32_t)7)); + for (uint64_t i = (int32_t)0; i < o1; i++) { + for (uint64_t j = (int32_t)0; j < o2; j++) { + for (uint64_t k = (int32_t)0; k < o3; k++) { + for (uint64_t l = (int32_t)0; l < o4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = + Arr4DIdxRowM(inpArr, i1, i2, i3, i4, + (i - Arr1DIdxRowM(paddings, pads, (int32_t)0)), + (j - Arr1DIdxRowM(paddings, pads, (int32_t)1)), + (k - Arr1DIdxRowM(paddings, pads, (int32_t)2)), + (l - Arr1DIdxRowM(paddings, pads, (int32_t)3))); + } else { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = + funcSSCons((int64_t)0); + } + } + } + } + } +} + +void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < ins1; i++) { + for (uint64_t j = (int32_t)0; j < ins2; j++) { + for (uint64_t k = (int32_t)0; k < ins3; k++) { + for (uint64_t l = (int32_t)0; l < ins4; l++) { + + int64_t linIdx = + ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + + (k * ins4)) + + l); + + int64_t outIdx1 = (linIdx / s2); + + int64_t outIdx2 = (linIdx % s2); + Arr2DIdxRowM(outArr, s1, s2, outIdx1, outIdx2) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i, j, k, l); + } + } + } + } +} + +void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *inArr, uint64_t *multArr, uint64_t *biasArr, + int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, + uint64_t *outputArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s4, i4); + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s4); + for (uint64_t ii = (int32_t)0; ii < s4; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s4, ii) = Arr1DIdxRowM(biasArr, s4, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outputArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s4, i4)); + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s4, biasArrScaledUp); +} + +void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *inArr, uint64_t *multArr, + uint64_t *biasArr, int64_t multExprScaleDownSf, + int64_t biasExprScaleUpSf, uint64_t *outputArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s5, i5); + } + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s5); + for (uint64_t ii = (int32_t)0; ii < s5; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s5, ii) = Arr1DIdxRowM(biasArr, s5, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outputArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s5, i5)); + } + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s5, biasArrScaledUp); +} + +void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t *arr1, uint64_t *arr2, + uint64_t *outArr) { + + int64_t inpSize = (s1 * s2); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr1, s1, s2, i1, i2); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr2, s1, s2, i1, i2); + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr1, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr2, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr1, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr2, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, int64_t *axes, + uint64_t *outputArr) { + + int64_t divisor = (inS2 * inS3); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = funcSSCons((int64_t)0); + for (uint64_t i = (int32_t)0; i < inS2; i++) { + for (uint64_t j = (int32_t)0; j < inS3; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i, j, i2)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, + int64_t axis1, int64_t axis2, uint64_t *outputArr) { + + int64_t divisor = (inS3 * inS4); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = funcSSCons((int64_t)0); + for (uint64_t i = (int32_t)0; i < inS3; i++) { + for (uint64_t j = (int32_t)0; j < inS4; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i2, i, j)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, + uint64_t *inArr, int64_t dim, uint64_t *outArr) { + ArgMax(inArrS1, inArrS2, inArr, outArr); +} + +void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + int64_t dim, uint64_t *outArr) { + + int64_t size = ((ins1 * ins2) * ins3); + + uint64_t *reshapedInArr = make_array(size, ins4); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr2DIdxRowM(reshapedInArr, size, ins4, linIdx, i4) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i1, i2, i3, i4); + } + } + } + } + ArgMax(size, ins4, reshapedInArr, reshapedOutArr); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr3DIdxRowM(outArr, outs1, outs2, outs3, i1, i2, i3) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + ClearMemSecret2(size, ins4, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf, uint64_t doTruncation) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *inArr, + uint64_t *outArr, int64_t sf, uint64_t doTruncation) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *inArr, uint64_t *outArr, int64_t sf, + uint64_t doTruncation) { + + int64_t size = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Floor2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Floor(size, reshapedInArr, reshapedOutArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void ScaleUp1(int64_t s1, uint64_t *arr, int64_t sf) { ScaleUp(s1, arr, sf); } + +void ScaleUp2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown1(int64_t s1, uint64_t *arr, int64_t sf) { + ScaleDown(s1, arr, sf); +} + +void ScaleDown2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +int main(int argc, char **argv) { + ArgMapping amap; + + amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); + amap.arg("port", port, "Port Number"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + amap.arg("nt", num_threads, "Number of Threads"); + amap.arg("ell", bitlength, "Uniform Bitwidth"); + amap.parse(argc, argv); + + assert(party == SERVER || party == CLIENT); + + uint64_t *tmp0 = + make_array((int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3); + /* Variable to read the clear value corresponding to the input variable tmp0 + * at (1930,1-1930,46) */ + uint64_t __tmp_in_tmp0; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)224; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)224; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)3; i3++) { + if ((party == CLIENT)) { + cin >> __tmp_in_tmp0; + } + Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, + i0, i1, i2, i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; + } + } + } + } + + uint64_t *tmp1 = + make_array((int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp1 + * at (1933,1-1933,43) */ + uint64_t __tmp_in_tmp1; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)7; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)7; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)3; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp1; + } + Arr4DIdxRowM(tmp1, (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; + } + } + } + } + + uint64_t *tmp2 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp2 + * at (1936,1-1936,34) */ + uint64_t __tmp_in_tmp2; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp2; + } + Arr1DIdxRowM(tmp2, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; + } + + uint64_t *tmp3 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp3 + * at (1939,1-1939,34) */ + uint64_t __tmp_in_tmp3; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp3; + } + Arr1DIdxRowM(tmp3, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp3 : 0; + } + + uint64_t *tmp4 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp4 + * at (1942,1-1942,34) */ + uint64_t __tmp_in_tmp4; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp4; + } + Arr1DIdxRowM(tmp4, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; + } + + uint64_t *tmp5 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp5 + * at (1945,1-1945,34) */ + uint64_t __tmp_in_tmp5; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp5; + } + Arr1DIdxRowM(tmp5, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp5 : 0; + } + + uint64_t *tmp6 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp6 + * at (1948,1-1948,45) */ + uint64_t __tmp_in_tmp6; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp6; + } + Arr4DIdxRowM(tmp6, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp6 : 0; + } + } + } + } + + uint64_t *tmp7 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp7 + * at (1951,1-1951,44) */ + uint64_t __tmp_in_tmp7; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp7; + } + Arr4DIdxRowM(tmp7, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; + } + } + } + } + + uint64_t *tmp8 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp8 + * at (1954,1-1954,34) */ + uint64_t __tmp_in_tmp8; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp8; + } + Arr1DIdxRowM(tmp8, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; + } + + uint64_t *tmp9 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp9 + * at (1957,1-1957,34) */ + uint64_t __tmp_in_tmp9; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp9; + } + Arr1DIdxRowM(tmp9, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; + } + + uint64_t *tmp10 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp10 + * at (1960,1-1960,35) */ + uint64_t __tmp_in_tmp10; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp10; + } + Arr1DIdxRowM(tmp10, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp10 : 0; + } + + uint64_t *tmp11 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp11 + * at (1963,1-1963,35) */ + uint64_t __tmp_in_tmp11; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp11; + } + Arr1DIdxRowM(tmp11, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp11 : 0; + } + + uint64_t *tmp12 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp12 + * at (1966,1-1966,45) */ + uint64_t __tmp_in_tmp12; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp12; + } + Arr4DIdxRowM(tmp12, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp12 : 0; + } + } + } + } + + uint64_t *tmp13 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp13 + * at (1969,1-1969,35) */ + uint64_t __tmp_in_tmp13; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp13; + } + Arr1DIdxRowM(tmp13, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp13 : 0; + } + + uint64_t *tmp14 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp14 + * at (1972,1-1972,35) */ + uint64_t __tmp_in_tmp14; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp14; + } + Arr1DIdxRowM(tmp14, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp14 : 0; + } + + uint64_t *tmp15 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp15 + * at (1975,1-1975,35) */ + uint64_t __tmp_in_tmp15; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp15; + } + Arr1DIdxRowM(tmp15, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp15 : 0; + } + + uint64_t *tmp16 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp16 + * at (1978,1-1978,35) */ + uint64_t __tmp_in_tmp16; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp16; + } + Arr1DIdxRowM(tmp16, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp16 : 0; + } + + uint64_t *tmp17 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp17 + * at (1981,1-1981,46) */ + uint64_t __tmp_in_tmp17; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp17; + } + Arr4DIdxRowM(tmp17, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp17 : 0; + } + } + } + } + + uint64_t *tmp18 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp18 + * at (1984,1-1984,36) */ + uint64_t __tmp_in_tmp18; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp18; + } + Arr1DIdxRowM(tmp18, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp18 : 0; + } + + uint64_t *tmp19 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp19 + * at (1987,1-1987,36) */ + uint64_t __tmp_in_tmp19; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp19; + } + Arr1DIdxRowM(tmp19, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp19 : 0; + } + + uint64_t *tmp20 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp20 + * at (1990,1-1990,36) */ + uint64_t __tmp_in_tmp20; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp20; + } + Arr1DIdxRowM(tmp20, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp20 : 0; + } + + uint64_t *tmp21 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp21 + * at (1993,1-1993,36) */ + uint64_t __tmp_in_tmp21; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp21; + } + Arr1DIdxRowM(tmp21, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp21 : 0; + } + + uint64_t *tmp22 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp22 + * at (1996,1-1996,46) */ + uint64_t __tmp_in_tmp22; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp22; + } + Arr4DIdxRowM(tmp22, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp22 : 0; + } + } + } + } + + uint64_t *tmp23 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp23 + * at (1999,1-1999,35) */ + uint64_t __tmp_in_tmp23; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp23; + } + Arr1DIdxRowM(tmp23, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp23 : 0; + } + + uint64_t *tmp24 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp24 + * at (2002,1-2002,35) */ + uint64_t __tmp_in_tmp24; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp24; + } + Arr1DIdxRowM(tmp24, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp24 : 0; + } + + uint64_t *tmp25 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp25 + * at (2005,1-2005,35) */ + uint64_t __tmp_in_tmp25; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp25; + } + Arr1DIdxRowM(tmp25, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp25 : 0; + } + + uint64_t *tmp26 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp26 + * at (2008,1-2008,35) */ + uint64_t __tmp_in_tmp26; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp26; + } + Arr1DIdxRowM(tmp26, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp26 : 0; + } + + uint64_t *tmp27 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp27 + * at (2011,1-2011,45) */ + uint64_t __tmp_in_tmp27; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp27; + } + Arr4DIdxRowM(tmp27, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp27 : 0; + } + } + } + } + + uint64_t *tmp28 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp28 + * at (2014,1-2014,35) */ + uint64_t __tmp_in_tmp28; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp28; + } + Arr1DIdxRowM(tmp28, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp28 : 0; + } + + uint64_t *tmp29 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp29 + * at (2017,1-2017,35) */ + uint64_t __tmp_in_tmp29; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp29; + } + Arr1DIdxRowM(tmp29, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp29 : 0; + } + + uint64_t *tmp30 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp30 + * at (2020,1-2020,35) */ + uint64_t __tmp_in_tmp30; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp30; + } + Arr1DIdxRowM(tmp30, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp30 : 0; + } + + uint64_t *tmp31 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp31 + * at (2023,1-2023,35) */ + uint64_t __tmp_in_tmp31; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp31; + } + Arr1DIdxRowM(tmp31, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp31 : 0; + } + + uint64_t *tmp32 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp32 + * at (2026,1-2026,46) */ + uint64_t __tmp_in_tmp32; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp32; + } + Arr4DIdxRowM(tmp32, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp32 : 0; + } + } + } + } + + uint64_t *tmp33 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp33 + * at (2029,1-2029,36) */ + uint64_t __tmp_in_tmp33; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp33; + } + Arr1DIdxRowM(tmp33, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp33 : 0; + } + + uint64_t *tmp34 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp34 + * at (2032,1-2032,36) */ + uint64_t __tmp_in_tmp34; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp34; + } + Arr1DIdxRowM(tmp34, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp34 : 0; + } + + uint64_t *tmp35 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp35 + * at (2035,1-2035,36) */ + uint64_t __tmp_in_tmp35; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp35; + } + Arr1DIdxRowM(tmp35, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp35 : 0; + } + + uint64_t *tmp36 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp36 + * at (2038,1-2038,36) */ + uint64_t __tmp_in_tmp36; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp36; + } + Arr1DIdxRowM(tmp36, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp36 : 0; + } + + uint64_t *tmp37 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp37 + * at (2041,1-2041,46) */ + uint64_t __tmp_in_tmp37; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp37; + } + Arr4DIdxRowM(tmp37, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp37 : 0; + } + } + } + } + + uint64_t *tmp38 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp38 + * at (2044,1-2044,35) */ + uint64_t __tmp_in_tmp38; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp38; + } + Arr1DIdxRowM(tmp38, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp38 : 0; + } + + uint64_t *tmp39 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp39 + * at (2047,1-2047,35) */ + uint64_t __tmp_in_tmp39; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp39; + } + Arr1DIdxRowM(tmp39, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp39 : 0; + } + + uint64_t *tmp40 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp40 + * at (2050,1-2050,35) */ + uint64_t __tmp_in_tmp40; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp40; + } + Arr1DIdxRowM(tmp40, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp40 : 0; + } + + uint64_t *tmp41 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp41 + * at (2053,1-2053,35) */ + uint64_t __tmp_in_tmp41; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp41; + } + Arr1DIdxRowM(tmp41, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp41 : 0; + } + + uint64_t *tmp42 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp42 + * at (2056,1-2056,45) */ + uint64_t __tmp_in_tmp42; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp42; + } + Arr4DIdxRowM(tmp42, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp42 : 0; + } + } + } + } + + uint64_t *tmp43 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp43 + * at (2059,1-2059,35) */ + uint64_t __tmp_in_tmp43; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp43; + } + Arr1DIdxRowM(tmp43, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp43 : 0; + } + + uint64_t *tmp44 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp44 + * at (2062,1-2062,35) */ + uint64_t __tmp_in_tmp44; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp44; + } + Arr1DIdxRowM(tmp44, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp44 : 0; + } + + uint64_t *tmp45 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp45 + * at (2065,1-2065,35) */ + uint64_t __tmp_in_tmp45; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp45; + } + Arr1DIdxRowM(tmp45, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp45 : 0; + } + + uint64_t *tmp46 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp46 + * at (2068,1-2068,35) */ + uint64_t __tmp_in_tmp46; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp46; + } + Arr1DIdxRowM(tmp46, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp46 : 0; + } + + uint64_t *tmp47 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp47 + * at (2071,1-2071,46) */ + uint64_t __tmp_in_tmp47; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp47; + } + Arr4DIdxRowM(tmp47, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp47 : 0; + } + } + } + } + + uint64_t *tmp48 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp48 + * at (2074,1-2074,36) */ + uint64_t __tmp_in_tmp48; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp48; + } + Arr1DIdxRowM(tmp48, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp48 : 0; + } + + uint64_t *tmp49 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp49 + * at (2077,1-2077,36) */ + uint64_t __tmp_in_tmp49; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp49; + } + Arr1DIdxRowM(tmp49, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp49 : 0; + } + + uint64_t *tmp50 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp50 + * at (2080,1-2080,36) */ + uint64_t __tmp_in_tmp50; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp50; + } + Arr1DIdxRowM(tmp50, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp50 : 0; + } + + uint64_t *tmp51 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp51 + * at (2083,1-2083,36) */ + uint64_t __tmp_in_tmp51; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp51; + } + Arr1DIdxRowM(tmp51, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp51 : 0; + } + + uint64_t *tmp52 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp52 + * at (2086,1-2086,47) */ + uint64_t __tmp_in_tmp52; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp52; + } + Arr4DIdxRowM(tmp52, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp52 : 0; + } + } + } + } + + uint64_t *tmp53 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp53 + * at (2089,1-2089,47) */ + uint64_t __tmp_in_tmp53; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp53; + } + Arr4DIdxRowM(tmp53, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp53 : 0; + } + } + } + } + + uint64_t *tmp54 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp54 + * at (2092,1-2092,36) */ + uint64_t __tmp_in_tmp54; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp54; + } + Arr1DIdxRowM(tmp54, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp54 : 0; + } + + uint64_t *tmp55 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp55 + * at (2095,1-2095,36) */ + uint64_t __tmp_in_tmp55; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp55; + } + Arr1DIdxRowM(tmp55, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp55 : 0; + } + + uint64_t *tmp56 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp56 + * at (2098,1-2098,36) */ + uint64_t __tmp_in_tmp56; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp56; + } + Arr1DIdxRowM(tmp56, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp56 : 0; + } + + uint64_t *tmp57 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp57 + * at (2101,1-2101,36) */ + uint64_t __tmp_in_tmp57; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp57; + } + Arr1DIdxRowM(tmp57, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp57 : 0; + } + + uint64_t *tmp58 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp58 + * at (2104,1-2104,47) */ + uint64_t __tmp_in_tmp58; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp58; + } + Arr4DIdxRowM(tmp58, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp58 : 0; + } + } + } + } + + uint64_t *tmp59 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp59 + * at (2107,1-2107,36) */ + uint64_t __tmp_in_tmp59; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp59; + } + Arr1DIdxRowM(tmp59, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp59 : 0; + } + + uint64_t *tmp60 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp60 + * at (2110,1-2110,36) */ + uint64_t __tmp_in_tmp60; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp60; + } + Arr1DIdxRowM(tmp60, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp60 : 0; + } + + uint64_t *tmp61 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp61 + * at (2113,1-2113,36) */ + uint64_t __tmp_in_tmp61; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp61; + } + Arr1DIdxRowM(tmp61, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp61 : 0; + } + + uint64_t *tmp62 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp62 + * at (2116,1-2116,36) */ + uint64_t __tmp_in_tmp62; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp62; + } + Arr1DIdxRowM(tmp62, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp62 : 0; + } + + uint64_t *tmp63 = + make_array((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp63 + * at (2119,1-2119,47) */ + uint64_t __tmp_in_tmp63; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp63; + } + Arr4DIdxRowM(tmp63, (int32_t)1, (int32_t)1, (int32_t)128, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp63 : 0; + } + } + } + } + + uint64_t *tmp64 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp64 + * at (2122,1-2122,36) */ + uint64_t __tmp_in_tmp64; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp64; + } + Arr1DIdxRowM(tmp64, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp64 : 0; + } + + uint64_t *tmp65 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp65 + * at (2125,1-2125,36) */ + uint64_t __tmp_in_tmp65; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp65; + } + Arr1DIdxRowM(tmp65, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp65 : 0; + } + + uint64_t *tmp66 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp66 + * at (2128,1-2128,36) */ + uint64_t __tmp_in_tmp66; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp66; + } + Arr1DIdxRowM(tmp66, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp66 : 0; + } + + uint64_t *tmp67 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp67 + * at (2131,1-2131,36) */ + uint64_t __tmp_in_tmp67; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp67; + } + Arr1DIdxRowM(tmp67, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp67 : 0; + } + + uint64_t *tmp68 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp68 + * at (2134,1-2134,47) */ + uint64_t __tmp_in_tmp68; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp68; + } + Arr4DIdxRowM(tmp68, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp68 : 0; + } + } + } + } + + uint64_t *tmp69 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp69 + * at (2137,1-2137,36) */ + uint64_t __tmp_in_tmp69; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp69; + } + Arr1DIdxRowM(tmp69, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp69 : 0; + } + + uint64_t *tmp70 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp70 + * at (2140,1-2140,36) */ + uint64_t __tmp_in_tmp70; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp70; + } + Arr1DIdxRowM(tmp70, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp70 : 0; + } + + uint64_t *tmp71 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp71 + * at (2143,1-2143,36) */ + uint64_t __tmp_in_tmp71; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp71; + } + Arr1DIdxRowM(tmp71, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp71 : 0; + } + + uint64_t *tmp72 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp72 + * at (2146,1-2146,36) */ + uint64_t __tmp_in_tmp72; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp72; + } + Arr1DIdxRowM(tmp72, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp72 : 0; + } + + uint64_t *tmp73 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp73 + * at (2149,1-2149,47) */ + uint64_t __tmp_in_tmp73; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp73; + } + Arr4DIdxRowM(tmp73, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp73 : 0; + } + } + } + } + + uint64_t *tmp74 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp74 + * at (2152,1-2152,36) */ + uint64_t __tmp_in_tmp74; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp74; + } + Arr1DIdxRowM(tmp74, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp74 : 0; + } + + uint64_t *tmp75 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp75 + * at (2155,1-2155,36) */ + uint64_t __tmp_in_tmp75; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp75; + } + Arr1DIdxRowM(tmp75, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp75 : 0; + } + + uint64_t *tmp76 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp76 + * at (2158,1-2158,36) */ + uint64_t __tmp_in_tmp76; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp76; + } + Arr1DIdxRowM(tmp76, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp76 : 0; + } + + uint64_t *tmp77 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp77 + * at (2161,1-2161,36) */ + uint64_t __tmp_in_tmp77; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp77; + } + Arr1DIdxRowM(tmp77, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp77 : 0; + } + + uint64_t *tmp78 = + make_array((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp78 + * at (2164,1-2164,47) */ + uint64_t __tmp_in_tmp78; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp78; + } + Arr4DIdxRowM(tmp78, (int32_t)1, (int32_t)1, (int32_t)128, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp78 : 0; + } + } + } + } + + uint64_t *tmp79 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp79 + * at (2167,1-2167,36) */ + uint64_t __tmp_in_tmp79; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp79; + } + Arr1DIdxRowM(tmp79, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp79 : 0; + } + + uint64_t *tmp80 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp80 + * at (2170,1-2170,36) */ + uint64_t __tmp_in_tmp80; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp80; + } + Arr1DIdxRowM(tmp80, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp80 : 0; + } + + uint64_t *tmp81 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp81 + * at (2173,1-2173,36) */ + uint64_t __tmp_in_tmp81; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp81; + } + Arr1DIdxRowM(tmp81, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp81 : 0; + } + + uint64_t *tmp82 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp82 + * at (2176,1-2176,36) */ + uint64_t __tmp_in_tmp82; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp82; + } + Arr1DIdxRowM(tmp82, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp82 : 0; + } + + uint64_t *tmp83 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp83 + * at (2179,1-2179,47) */ + uint64_t __tmp_in_tmp83; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp83; + } + Arr4DIdxRowM(tmp83, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp83 : 0; + } + } + } + } + + uint64_t *tmp84 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp84 + * at (2182,1-2182,36) */ + uint64_t __tmp_in_tmp84; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp84; + } + Arr1DIdxRowM(tmp84, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp84 : 0; + } + + uint64_t *tmp85 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp85 + * at (2185,1-2185,36) */ + uint64_t __tmp_in_tmp85; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp85; + } + Arr1DIdxRowM(tmp85, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp85 : 0; + } + + uint64_t *tmp86 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp86 + * at (2188,1-2188,36) */ + uint64_t __tmp_in_tmp86; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp86; + } + Arr1DIdxRowM(tmp86, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp86 : 0; + } + + uint64_t *tmp87 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp87 + * at (2191,1-2191,36) */ + uint64_t __tmp_in_tmp87; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp87; + } + Arr1DIdxRowM(tmp87, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp87 : 0; + } + + uint64_t *tmp88 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp88 + * at (2194,1-2194,47) */ + uint64_t __tmp_in_tmp88; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp88; + } + Arr4DIdxRowM(tmp88, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp88 : 0; + } + } + } + } + + uint64_t *tmp89 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp89 + * at (2197,1-2197,36) */ + uint64_t __tmp_in_tmp89; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp89; + } + Arr1DIdxRowM(tmp89, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp89 : 0; + } + + uint64_t *tmp90 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp90 + * at (2200,1-2200,36) */ + uint64_t __tmp_in_tmp90; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp90; + } + Arr1DIdxRowM(tmp90, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp90 : 0; + } + + uint64_t *tmp91 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp91 + * at (2203,1-2203,36) */ + uint64_t __tmp_in_tmp91; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp91; + } + Arr1DIdxRowM(tmp91, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp91 : 0; + } + + uint64_t *tmp92 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp92 + * at (2206,1-2206,36) */ + uint64_t __tmp_in_tmp92; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp92; + } + Arr1DIdxRowM(tmp92, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp92 : 0; + } + + uint64_t *tmp93 = + make_array((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp93 + * at (2209,1-2209,47) */ + uint64_t __tmp_in_tmp93; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp93; + } + Arr4DIdxRowM(tmp93, (int32_t)1, (int32_t)1, (int32_t)128, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp93 : 0; + } + } + } + } + + uint64_t *tmp94 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp94 + * at (2212,1-2212,36) */ + uint64_t __tmp_in_tmp94; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp94; + } + Arr1DIdxRowM(tmp94, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp94 : 0; + } + + uint64_t *tmp95 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp95 + * at (2215,1-2215,36) */ + uint64_t __tmp_in_tmp95; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp95; + } + Arr1DIdxRowM(tmp95, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp95 : 0; + } + + uint64_t *tmp96 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp96 + * at (2218,1-2218,36) */ + uint64_t __tmp_in_tmp96; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp96; + } + Arr1DIdxRowM(tmp96, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp96 : 0; + } + + uint64_t *tmp97 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp97 + * at (2221,1-2221,36) */ + uint64_t __tmp_in_tmp97; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp97; + } + Arr1DIdxRowM(tmp97, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp97 : 0; + } + + uint64_t *tmp98 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp98 + * at (2224,1-2224,47) */ + uint64_t __tmp_in_tmp98; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp98; + } + Arr4DIdxRowM(tmp98, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp98 : 0; + } + } + } + } + + uint64_t *tmp99 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp99 + * at (2227,1-2227,36) */ + uint64_t __tmp_in_tmp99; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp99; + } + Arr1DIdxRowM(tmp99, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp99 : 0; + } + + uint64_t *tmp100 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp100 + * at (2230,1-2230,37) */ + uint64_t __tmp_in_tmp100; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp100; + } + Arr1DIdxRowM(tmp100, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp100 : 0; + } + + uint64_t *tmp101 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp101 + * at (2233,1-2233,37) */ + uint64_t __tmp_in_tmp101; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp101; + } + Arr1DIdxRowM(tmp101, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp101 : 0; + } + + uint64_t *tmp102 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp102 + * at (2236,1-2236,37) */ + uint64_t __tmp_in_tmp102; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp102; + } + Arr1DIdxRowM(tmp102, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp102 : 0; + } + + uint64_t *tmp103 = + make_array((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp103 + * at (2239,1-2239,48) */ + uint64_t __tmp_in_tmp103; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp103; + } + Arr4DIdxRowM(tmp103, (int32_t)3, (int32_t)3, (int32_t)128, + (int32_t)128, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp103 : 0; + } + } + } + } + + uint64_t *tmp104 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp104 + * at (2242,1-2242,37) */ + uint64_t __tmp_in_tmp104; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp104; + } + Arr1DIdxRowM(tmp104, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp104 : 0; + } + + uint64_t *tmp105 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp105 + * at (2245,1-2245,37) */ + uint64_t __tmp_in_tmp105; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp105; + } + Arr1DIdxRowM(tmp105, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp105 : 0; + } + + uint64_t *tmp106 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp106 + * at (2248,1-2248,37) */ + uint64_t __tmp_in_tmp106; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp106; + } + Arr1DIdxRowM(tmp106, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp106 : 0; + } + + uint64_t *tmp107 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp107 + * at (2251,1-2251,37) */ + uint64_t __tmp_in_tmp107; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp107; + } + Arr1DIdxRowM(tmp107, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp107 : 0; + } + + uint64_t *tmp108 = + make_array((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp108 + * at (2254,1-2254,48) */ + uint64_t __tmp_in_tmp108; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp108; + } + Arr4DIdxRowM(tmp108, (int32_t)1, (int32_t)1, (int32_t)128, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp108 : 0; + } + } + } + } + + uint64_t *tmp109 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp109 + * at (2257,1-2257,37) */ + uint64_t __tmp_in_tmp109; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp109; + } + Arr1DIdxRowM(tmp109, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp109 : 0; + } + + uint64_t *tmp110 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp110 + * at (2260,1-2260,37) */ + uint64_t __tmp_in_tmp110; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp110; + } + Arr1DIdxRowM(tmp110, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp110 : 0; + } + + uint64_t *tmp111 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp111 + * at (2263,1-2263,37) */ + uint64_t __tmp_in_tmp111; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp111; + } + Arr1DIdxRowM(tmp111, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp111 : 0; + } + + uint64_t *tmp112 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp112 + * at (2266,1-2266,37) */ + uint64_t __tmp_in_tmp112; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp112; + } + Arr1DIdxRowM(tmp112, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp112 : 0; + } + + uint64_t *tmp113 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp113 + * at (2269,1-2269,49) */ + uint64_t __tmp_in_tmp113; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp113; + } + Arr4DIdxRowM(tmp113, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)1024, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp113 : 0; + } + } + } + } + + uint64_t *tmp114 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp114 + * at (2272,1-2272,48) */ + uint64_t __tmp_in_tmp114; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp114; + } + Arr4DIdxRowM(tmp114, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp114 : 0; + } + } + } + } + + uint64_t *tmp115 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp115 + * at (2275,1-2275,37) */ + uint64_t __tmp_in_tmp115; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp115; + } + Arr1DIdxRowM(tmp115, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp115 : 0; + } + + uint64_t *tmp116 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp116 + * at (2278,1-2278,37) */ + uint64_t __tmp_in_tmp116; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp116; + } + Arr1DIdxRowM(tmp116, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp116 : 0; + } + + uint64_t *tmp117 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp117 + * at (2281,1-2281,37) */ + uint64_t __tmp_in_tmp117; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp117; + } + Arr1DIdxRowM(tmp117, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp117 : 0; + } + + uint64_t *tmp118 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp118 + * at (2284,1-2284,37) */ + uint64_t __tmp_in_tmp118; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp118; + } + Arr1DIdxRowM(tmp118, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp118 : 0; + } + + uint64_t *tmp119 = + make_array((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp119 + * at (2287,1-2287,48) */ + uint64_t __tmp_in_tmp119; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp119; + } + Arr4DIdxRowM(tmp119, (int32_t)3, (int32_t)3, (int32_t)256, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp119 : 0; + } + } + } + } + + uint64_t *tmp120 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp120 + * at (2290,1-2290,37) */ + uint64_t __tmp_in_tmp120; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp120; + } + Arr1DIdxRowM(tmp120, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp120 : 0; + } + + uint64_t *tmp121 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp121 + * at (2293,1-2293,37) */ + uint64_t __tmp_in_tmp121; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp121; + } + Arr1DIdxRowM(tmp121, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp121 : 0; + } + + uint64_t *tmp122 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp122 + * at (2296,1-2296,37) */ + uint64_t __tmp_in_tmp122; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp122; + } + Arr1DIdxRowM(tmp122, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp122 : 0; + } + + uint64_t *tmp123 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp123 + * at (2299,1-2299,37) */ + uint64_t __tmp_in_tmp123; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp123; + } + Arr1DIdxRowM(tmp123, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp123 : 0; + } + + uint64_t *tmp124 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp124 + * at (2302,1-2302,49) */ + uint64_t __tmp_in_tmp124; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp124; + } + Arr4DIdxRowM(tmp124, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)1024, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp124 : 0; + } + } + } + } + + uint64_t *tmp125 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp125 + * at (2305,1-2305,38) */ + uint64_t __tmp_in_tmp125; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp125; + } + Arr1DIdxRowM(tmp125, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp125 : 0; + } + + uint64_t *tmp126 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp126 + * at (2308,1-2308,38) */ + uint64_t __tmp_in_tmp126; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp126; + } + Arr1DIdxRowM(tmp126, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp126 : 0; + } + + uint64_t *tmp127 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp127 + * at (2311,1-2311,38) */ + uint64_t __tmp_in_tmp127; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp127; + } + Arr1DIdxRowM(tmp127, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp127 : 0; + } + + uint64_t *tmp128 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp128 + * at (2314,1-2314,38) */ + uint64_t __tmp_in_tmp128; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp128; + } + Arr1DIdxRowM(tmp128, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp128 : 0; + } + + uint64_t *tmp129 = + make_array((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp129 + * at (2317,1-2317,49) */ + uint64_t __tmp_in_tmp129; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp129; + } + Arr4DIdxRowM(tmp129, (int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp129 : 0; + } + } + } + } + + uint64_t *tmp130 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp130 + * at (2320,1-2320,37) */ + uint64_t __tmp_in_tmp130; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp130; + } + Arr1DIdxRowM(tmp130, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp130 : 0; + } + + uint64_t *tmp131 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp131 + * at (2323,1-2323,37) */ + uint64_t __tmp_in_tmp131; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp131; + } + Arr1DIdxRowM(tmp131, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp131 : 0; + } + + uint64_t *tmp132 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp132 + * at (2326,1-2326,37) */ + uint64_t __tmp_in_tmp132; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp132; + } + Arr1DIdxRowM(tmp132, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp132 : 0; + } + + uint64_t *tmp133 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp133 + * at (2329,1-2329,37) */ + uint64_t __tmp_in_tmp133; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp133; + } + Arr1DIdxRowM(tmp133, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp133 : 0; + } + + uint64_t *tmp134 = + make_array((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp134 + * at (2332,1-2332,48) */ + uint64_t __tmp_in_tmp134; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp134; + } + Arr4DIdxRowM(tmp134, (int32_t)3, (int32_t)3, (int32_t)256, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp134 : 0; + } + } + } + } + + uint64_t *tmp135 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp135 + * at (2335,1-2335,37) */ + uint64_t __tmp_in_tmp135; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp135; + } + Arr1DIdxRowM(tmp135, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp135 : 0; + } + + uint64_t *tmp136 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp136 + * at (2338,1-2338,37) */ + uint64_t __tmp_in_tmp136; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp136; + } + Arr1DIdxRowM(tmp136, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp136 : 0; + } + + uint64_t *tmp137 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp137 + * at (2341,1-2341,37) */ + uint64_t __tmp_in_tmp137; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp137; + } + Arr1DIdxRowM(tmp137, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp137 : 0; + } + + uint64_t *tmp138 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp138 + * at (2344,1-2344,37) */ + uint64_t __tmp_in_tmp138; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp138; + } + Arr1DIdxRowM(tmp138, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp138 : 0; + } + + uint64_t *tmp139 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp139 + * at (2347,1-2347,49) */ + uint64_t __tmp_in_tmp139; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp139; + } + Arr4DIdxRowM(tmp139, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)1024, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp139 : 0; + } + } + } + } + + uint64_t *tmp140 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp140 + * at (2350,1-2350,38) */ + uint64_t __tmp_in_tmp140; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp140; + } + Arr1DIdxRowM(tmp140, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp140 : 0; + } + + uint64_t *tmp141 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp141 + * at (2353,1-2353,38) */ + uint64_t __tmp_in_tmp141; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp141; + } + Arr1DIdxRowM(tmp141, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp141 : 0; + } + + uint64_t *tmp142 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp142 + * at (2356,1-2356,38) */ + uint64_t __tmp_in_tmp142; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp142; + } + Arr1DIdxRowM(tmp142, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp142 : 0; + } + + uint64_t *tmp143 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp143 + * at (2359,1-2359,38) */ + uint64_t __tmp_in_tmp143; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp143; + } + Arr1DIdxRowM(tmp143, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp143 : 0; + } + + uint64_t *tmp144 = + make_array((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp144 + * at (2362,1-2362,49) */ + uint64_t __tmp_in_tmp144; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp144; + } + Arr4DIdxRowM(tmp144, (int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp144 : 0; + } + } + } + } + + uint64_t *tmp145 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp145 + * at (2365,1-2365,37) */ + uint64_t __tmp_in_tmp145; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp145; + } + Arr1DIdxRowM(tmp145, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp145 : 0; + } + + uint64_t *tmp146 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp146 + * at (2368,1-2368,37) */ + uint64_t __tmp_in_tmp146; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp146; + } + Arr1DIdxRowM(tmp146, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp146 : 0; + } + + uint64_t *tmp147 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp147 + * at (2371,1-2371,37) */ + uint64_t __tmp_in_tmp147; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp147; + } + Arr1DIdxRowM(tmp147, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp147 : 0; + } + + uint64_t *tmp148 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp148 + * at (2374,1-2374,37) */ + uint64_t __tmp_in_tmp148; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp148; + } + Arr1DIdxRowM(tmp148, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp148 : 0; + } + + uint64_t *tmp149 = + make_array((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp149 + * at (2377,1-2377,48) */ + uint64_t __tmp_in_tmp149; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp149; + } + Arr4DIdxRowM(tmp149, (int32_t)3, (int32_t)3, (int32_t)256, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp149 : 0; + } + } + } + } + + uint64_t *tmp150 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp150 + * at (2380,1-2380,37) */ + uint64_t __tmp_in_tmp150; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp150; + } + Arr1DIdxRowM(tmp150, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp150 : 0; + } + + uint64_t *tmp151 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp151 + * at (2383,1-2383,37) */ + uint64_t __tmp_in_tmp151; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp151; + } + Arr1DIdxRowM(tmp151, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp151 : 0; + } + + uint64_t *tmp152 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp152 + * at (2386,1-2386,37) */ + uint64_t __tmp_in_tmp152; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp152; + } + Arr1DIdxRowM(tmp152, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp152 : 0; + } + + uint64_t *tmp153 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp153 + * at (2389,1-2389,37) */ + uint64_t __tmp_in_tmp153; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp153; + } + Arr1DIdxRowM(tmp153, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp153 : 0; + } + + uint64_t *tmp154 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp154 + * at (2392,1-2392,49) */ + uint64_t __tmp_in_tmp154; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp154; + } + Arr4DIdxRowM(tmp154, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)1024, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp154 : 0; + } + } + } + } + + uint64_t *tmp155 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp155 + * at (2395,1-2395,38) */ + uint64_t __tmp_in_tmp155; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp155; + } + Arr1DIdxRowM(tmp155, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp155 : 0; + } + + uint64_t *tmp156 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp156 + * at (2398,1-2398,38) */ + uint64_t __tmp_in_tmp156; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp156; + } + Arr1DIdxRowM(tmp156, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp156 : 0; + } + + uint64_t *tmp157 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp157 + * at (2401,1-2401,38) */ + uint64_t __tmp_in_tmp157; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp157; + } + Arr1DIdxRowM(tmp157, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp157 : 0; + } + + uint64_t *tmp158 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp158 + * at (2404,1-2404,38) */ + uint64_t __tmp_in_tmp158; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp158; + } + Arr1DIdxRowM(tmp158, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp158 : 0; + } + + uint64_t *tmp159 = + make_array((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp159 + * at (2407,1-2407,49) */ + uint64_t __tmp_in_tmp159; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp159; + } + Arr4DIdxRowM(tmp159, (int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp159 : 0; + } + } + } + } + + uint64_t *tmp160 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp160 + * at (2410,1-2410,37) */ + uint64_t __tmp_in_tmp160; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp160; + } + Arr1DIdxRowM(tmp160, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp160 : 0; + } + + uint64_t *tmp161 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp161 + * at (2413,1-2413,37) */ + uint64_t __tmp_in_tmp161; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp161; + } + Arr1DIdxRowM(tmp161, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp161 : 0; + } + + uint64_t *tmp162 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp162 + * at (2416,1-2416,37) */ + uint64_t __tmp_in_tmp162; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp162; + } + Arr1DIdxRowM(tmp162, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp162 : 0; + } + + uint64_t *tmp163 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp163 + * at (2419,1-2419,37) */ + uint64_t __tmp_in_tmp163; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp163; + } + Arr1DIdxRowM(tmp163, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp163 : 0; + } + + uint64_t *tmp164 = + make_array((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp164 + * at (2422,1-2422,48) */ + uint64_t __tmp_in_tmp164; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp164; + } + Arr4DIdxRowM(tmp164, (int32_t)3, (int32_t)3, (int32_t)256, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp164 : 0; + } + } + } + } + + uint64_t *tmp165 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp165 + * at (2425,1-2425,37) */ + uint64_t __tmp_in_tmp165; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp165; + } + Arr1DIdxRowM(tmp165, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp165 : 0; + } + + uint64_t *tmp166 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp166 + * at (2428,1-2428,37) */ + uint64_t __tmp_in_tmp166; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp166; + } + Arr1DIdxRowM(tmp166, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp166 : 0; + } + + uint64_t *tmp167 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp167 + * at (2431,1-2431,37) */ + uint64_t __tmp_in_tmp167; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp167; + } + Arr1DIdxRowM(tmp167, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp167 : 0; + } + + uint64_t *tmp168 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp168 + * at (2434,1-2434,37) */ + uint64_t __tmp_in_tmp168; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp168; + } + Arr1DIdxRowM(tmp168, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp168 : 0; + } + + uint64_t *tmp169 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp169 + * at (2437,1-2437,49) */ + uint64_t __tmp_in_tmp169; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp169; + } + Arr4DIdxRowM(tmp169, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)1024, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp169 : 0; + } + } + } + } + + uint64_t *tmp170 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp170 + * at (2440,1-2440,38) */ + uint64_t __tmp_in_tmp170; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp170; + } + Arr1DIdxRowM(tmp170, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp170 : 0; + } + + uint64_t *tmp171 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp171 + * at (2443,1-2443,38) */ + uint64_t __tmp_in_tmp171; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp171; + } + Arr1DIdxRowM(tmp171, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp171 : 0; + } + + uint64_t *tmp172 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp172 + * at (2446,1-2446,38) */ + uint64_t __tmp_in_tmp172; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp172; + } + Arr1DIdxRowM(tmp172, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp172 : 0; + } + + uint64_t *tmp173 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp173 + * at (2449,1-2449,38) */ + uint64_t __tmp_in_tmp173; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp173; + } + Arr1DIdxRowM(tmp173, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp173 : 0; + } + + uint64_t *tmp174 = + make_array((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp174 + * at (2452,1-2452,49) */ + uint64_t __tmp_in_tmp174; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp174; + } + Arr4DIdxRowM(tmp174, (int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp174 : 0; + } + } + } + } + + uint64_t *tmp175 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp175 + * at (2455,1-2455,37) */ + uint64_t __tmp_in_tmp175; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp175; + } + Arr1DIdxRowM(tmp175, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp175 : 0; + } + + uint64_t *tmp176 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp176 + * at (2458,1-2458,37) */ + uint64_t __tmp_in_tmp176; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp176; + } + Arr1DIdxRowM(tmp176, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp176 : 0; + } + + uint64_t *tmp177 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp177 + * at (2461,1-2461,37) */ + uint64_t __tmp_in_tmp177; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp177; + } + Arr1DIdxRowM(tmp177, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp177 : 0; + } + + uint64_t *tmp178 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp178 + * at (2464,1-2464,37) */ + uint64_t __tmp_in_tmp178; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp178; + } + Arr1DIdxRowM(tmp178, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp178 : 0; + } + + uint64_t *tmp179 = + make_array((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp179 + * at (2467,1-2467,48) */ + uint64_t __tmp_in_tmp179; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp179; + } + Arr4DIdxRowM(tmp179, (int32_t)3, (int32_t)3, (int32_t)256, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp179 : 0; + } + } + } + } + + uint64_t *tmp180 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp180 + * at (2470,1-2470,37) */ + uint64_t __tmp_in_tmp180; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp180; + } + Arr1DIdxRowM(tmp180, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp180 : 0; + } + + uint64_t *tmp181 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp181 + * at (2473,1-2473,37) */ + uint64_t __tmp_in_tmp181; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp181; + } + Arr1DIdxRowM(tmp181, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp181 : 0; + } + + uint64_t *tmp182 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp182 + * at (2476,1-2476,37) */ + uint64_t __tmp_in_tmp182; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp182; + } + Arr1DIdxRowM(tmp182, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp182 : 0; + } + + uint64_t *tmp183 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp183 + * at (2479,1-2479,37) */ + uint64_t __tmp_in_tmp183; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp183; + } + Arr1DIdxRowM(tmp183, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp183 : 0; + } + + uint64_t *tmp184 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp184 + * at (2482,1-2482,49) */ + uint64_t __tmp_in_tmp184; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp184; + } + Arr4DIdxRowM(tmp184, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)1024, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp184 : 0; + } + } + } + } + + uint64_t *tmp185 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp185 + * at (2485,1-2485,38) */ + uint64_t __tmp_in_tmp185; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp185; + } + Arr1DIdxRowM(tmp185, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp185 : 0; + } + + uint64_t *tmp186 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp186 + * at (2488,1-2488,38) */ + uint64_t __tmp_in_tmp186; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp186; + } + Arr1DIdxRowM(tmp186, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp186 : 0; + } + + uint64_t *tmp187 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp187 + * at (2491,1-2491,38) */ + uint64_t __tmp_in_tmp187; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp187; + } + Arr1DIdxRowM(tmp187, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp187 : 0; + } + + uint64_t *tmp188 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp188 + * at (2494,1-2494,38) */ + uint64_t __tmp_in_tmp188; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp188; + } + Arr1DIdxRowM(tmp188, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp188 : 0; + } + + uint64_t *tmp189 = + make_array((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp189 + * at (2497,1-2497,49) */ + uint64_t __tmp_in_tmp189; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp189; + } + Arr4DIdxRowM(tmp189, (int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp189 : 0; + } + } + } + } + + uint64_t *tmp190 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp190 + * at (2500,1-2500,37) */ + uint64_t __tmp_in_tmp190; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp190; + } + Arr1DIdxRowM(tmp190, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp190 : 0; + } + + uint64_t *tmp191 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp191 + * at (2503,1-2503,37) */ + uint64_t __tmp_in_tmp191; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp191; + } + Arr1DIdxRowM(tmp191, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp191 : 0; + } + + uint64_t *tmp192 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp192 + * at (2506,1-2506,37) */ + uint64_t __tmp_in_tmp192; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp192; + } + Arr1DIdxRowM(tmp192, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp192 : 0; + } + + uint64_t *tmp193 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp193 + * at (2509,1-2509,37) */ + uint64_t __tmp_in_tmp193; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp193; + } + Arr1DIdxRowM(tmp193, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp193 : 0; + } + + uint64_t *tmp194 = + make_array((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp194 + * at (2512,1-2512,48) */ + uint64_t __tmp_in_tmp194; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp194; + } + Arr4DIdxRowM(tmp194, (int32_t)3, (int32_t)3, (int32_t)256, + (int32_t)256, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp194 : 0; + } + } + } + } + + uint64_t *tmp195 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp195 + * at (2515,1-2515,37) */ + uint64_t __tmp_in_tmp195; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp195; + } + Arr1DIdxRowM(tmp195, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp195 : 0; + } + + uint64_t *tmp196 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp196 + * at (2518,1-2518,37) */ + uint64_t __tmp_in_tmp196; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp196; + } + Arr1DIdxRowM(tmp196, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp196 : 0; + } + + uint64_t *tmp197 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp197 + * at (2521,1-2521,37) */ + uint64_t __tmp_in_tmp197; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp197; + } + Arr1DIdxRowM(tmp197, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp197 : 0; + } + + uint64_t *tmp198 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp198 + * at (2524,1-2524,37) */ + uint64_t __tmp_in_tmp198; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp198; + } + Arr1DIdxRowM(tmp198, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp198 : 0; + } + + uint64_t *tmp199 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp199 + * at (2527,1-2527,49) */ + uint64_t __tmp_in_tmp199; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp199; + } + Arr4DIdxRowM(tmp199, (int32_t)1, (int32_t)1, (int32_t)256, + (int32_t)1024, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp199 : 0; + } + } + } + } + + uint64_t *tmp200 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp200 + * at (2530,1-2530,38) */ + uint64_t __tmp_in_tmp200; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp200; + } + Arr1DIdxRowM(tmp200, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp200 : 0; + } + + uint64_t *tmp201 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp201 + * at (2533,1-2533,38) */ + uint64_t __tmp_in_tmp201; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp201; + } + Arr1DIdxRowM(tmp201, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp201 : 0; + } + + uint64_t *tmp202 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp202 + * at (2536,1-2536,38) */ + uint64_t __tmp_in_tmp202; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp202; + } + Arr1DIdxRowM(tmp202, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp202 : 0; + } + + uint64_t *tmp203 = make_array((int32_t)1024); + /* Variable to read the clear value corresponding to the input variable tmp203 + * at (2539,1-2539,38) */ + uint64_t __tmp_in_tmp203; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp203; + } + Arr1DIdxRowM(tmp203, (int32_t)1024, i0) = + (party == SERVER) ? __tmp_in_tmp203 : 0; + } + + uint64_t *tmp204 = make_array((int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp204 + * at (2542,1-2542,50) */ + uint64_t __tmp_in_tmp204; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)2048; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp204; + } + Arr4DIdxRowM(tmp204, (int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)2048, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp204 : 0; + } + } + } + } + + uint64_t *tmp205 = + make_array((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp205 + * at (2545,1-2545,49) */ + uint64_t __tmp_in_tmp205; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp205; + } + Arr4DIdxRowM(tmp205, (int32_t)1, (int32_t)1, (int32_t)1024, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp205 : 0; + } + } + } + } + + uint64_t *tmp206 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp206 + * at (2548,1-2548,37) */ + uint64_t __tmp_in_tmp206; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp206; + } + Arr1DIdxRowM(tmp206, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp206 : 0; + } + + uint64_t *tmp207 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp207 + * at (2551,1-2551,37) */ + uint64_t __tmp_in_tmp207; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp207; + } + Arr1DIdxRowM(tmp207, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp207 : 0; + } + + uint64_t *tmp208 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp208 + * at (2554,1-2554,37) */ + uint64_t __tmp_in_tmp208; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp208; + } + Arr1DIdxRowM(tmp208, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp208 : 0; + } + + uint64_t *tmp209 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp209 + * at (2557,1-2557,37) */ + uint64_t __tmp_in_tmp209; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp209; + } + Arr1DIdxRowM(tmp209, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp209 : 0; + } + + uint64_t *tmp210 = + make_array((int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp210 + * at (2560,1-2560,48) */ + uint64_t __tmp_in_tmp210; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp210; + } + Arr4DIdxRowM(tmp210, (int32_t)3, (int32_t)3, (int32_t)512, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp210 : 0; + } + } + } + } + + uint64_t *tmp211 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp211 + * at (2563,1-2563,37) */ + uint64_t __tmp_in_tmp211; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp211; + } + Arr1DIdxRowM(tmp211, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp211 : 0; + } + + uint64_t *tmp212 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp212 + * at (2566,1-2566,37) */ + uint64_t __tmp_in_tmp212; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp212; + } + Arr1DIdxRowM(tmp212, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp212 : 0; + } + + uint64_t *tmp213 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp213 + * at (2569,1-2569,37) */ + uint64_t __tmp_in_tmp213; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp213; + } + Arr1DIdxRowM(tmp213, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp213 : 0; + } + + uint64_t *tmp214 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp214 + * at (2572,1-2572,37) */ + uint64_t __tmp_in_tmp214; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp214; + } + Arr1DIdxRowM(tmp214, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp214 : 0; + } + + uint64_t *tmp215 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp215 + * at (2575,1-2575,49) */ + uint64_t __tmp_in_tmp215; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)2048; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp215; + } + Arr4DIdxRowM(tmp215, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)2048, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp215 : 0; + } + } + } + } + + uint64_t *tmp216 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp216 + * at (2578,1-2578,38) */ + uint64_t __tmp_in_tmp216; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp216; + } + Arr1DIdxRowM(tmp216, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp216 : 0; + } + + uint64_t *tmp217 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp217 + * at (2581,1-2581,38) */ + uint64_t __tmp_in_tmp217; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp217; + } + Arr1DIdxRowM(tmp217, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp217 : 0; + } + + uint64_t *tmp218 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp218 + * at (2584,1-2584,38) */ + uint64_t __tmp_in_tmp218; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp218; + } + Arr1DIdxRowM(tmp218, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp218 : 0; + } + + uint64_t *tmp219 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp219 + * at (2587,1-2587,38) */ + uint64_t __tmp_in_tmp219; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp219; + } + Arr1DIdxRowM(tmp219, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp219 : 0; + } + + uint64_t *tmp220 = + make_array((int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp220 + * at (2590,1-2590,49) */ + uint64_t __tmp_in_tmp220; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)2048; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp220; + } + Arr4DIdxRowM(tmp220, (int32_t)1, (int32_t)1, (int32_t)2048, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp220 : 0; + } + } + } + } + + uint64_t *tmp221 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp221 + * at (2593,1-2593,37) */ + uint64_t __tmp_in_tmp221; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp221; + } + Arr1DIdxRowM(tmp221, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp221 : 0; + } + + uint64_t *tmp222 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp222 + * at (2596,1-2596,37) */ + uint64_t __tmp_in_tmp222; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp222; + } + Arr1DIdxRowM(tmp222, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp222 : 0; + } + + uint64_t *tmp223 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp223 + * at (2599,1-2599,37) */ + uint64_t __tmp_in_tmp223; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp223; + } + Arr1DIdxRowM(tmp223, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp223 : 0; + } + + uint64_t *tmp224 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp224 + * at (2602,1-2602,37) */ + uint64_t __tmp_in_tmp224; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp224; + } + Arr1DIdxRowM(tmp224, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp224 : 0; + } + + uint64_t *tmp225 = + make_array((int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp225 + * at (2605,1-2605,48) */ + uint64_t __tmp_in_tmp225; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp225; + } + Arr4DIdxRowM(tmp225, (int32_t)3, (int32_t)3, (int32_t)512, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp225 : 0; + } + } + } + } + + uint64_t *tmp226 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp226 + * at (2608,1-2608,37) */ + uint64_t __tmp_in_tmp226; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp226; + } + Arr1DIdxRowM(tmp226, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp226 : 0; + } + + uint64_t *tmp227 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp227 + * at (2611,1-2611,37) */ + uint64_t __tmp_in_tmp227; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp227; + } + Arr1DIdxRowM(tmp227, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp227 : 0; + } + + uint64_t *tmp228 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp228 + * at (2614,1-2614,37) */ + uint64_t __tmp_in_tmp228; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp228; + } + Arr1DIdxRowM(tmp228, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp228 : 0; + } + + uint64_t *tmp229 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp229 + * at (2617,1-2617,37) */ + uint64_t __tmp_in_tmp229; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp229; + } + Arr1DIdxRowM(tmp229, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp229 : 0; + } + + uint64_t *tmp230 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp230 + * at (2620,1-2620,49) */ + uint64_t __tmp_in_tmp230; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)2048; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp230; + } + Arr4DIdxRowM(tmp230, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)2048, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp230 : 0; + } + } + } + } + + uint64_t *tmp231 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp231 + * at (2623,1-2623,38) */ + uint64_t __tmp_in_tmp231; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp231; + } + Arr1DIdxRowM(tmp231, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp231 : 0; + } + + uint64_t *tmp232 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp232 + * at (2626,1-2626,38) */ + uint64_t __tmp_in_tmp232; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp232; + } + Arr1DIdxRowM(tmp232, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp232 : 0; + } + + uint64_t *tmp233 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp233 + * at (2629,1-2629,38) */ + uint64_t __tmp_in_tmp233; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp233; + } + Arr1DIdxRowM(tmp233, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp233 : 0; + } + + uint64_t *tmp234 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp234 + * at (2632,1-2632,38) */ + uint64_t __tmp_in_tmp234; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp234; + } + Arr1DIdxRowM(tmp234, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp234 : 0; + } + + uint64_t *tmp235 = + make_array((int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp235 + * at (2635,1-2635,49) */ + uint64_t __tmp_in_tmp235; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)2048; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp235; + } + Arr4DIdxRowM(tmp235, (int32_t)1, (int32_t)1, (int32_t)2048, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp235 : 0; + } + } + } + } + + uint64_t *tmp236 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp236 + * at (2638,1-2638,37) */ + uint64_t __tmp_in_tmp236; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp236; + } + Arr1DIdxRowM(tmp236, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp236 : 0; + } + + uint64_t *tmp237 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp237 + * at (2641,1-2641,37) */ + uint64_t __tmp_in_tmp237; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp237; + } + Arr1DIdxRowM(tmp237, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp237 : 0; + } + + uint64_t *tmp238 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp238 + * at (2644,1-2644,37) */ + uint64_t __tmp_in_tmp238; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp238; + } + Arr1DIdxRowM(tmp238, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp238 : 0; + } + + uint64_t *tmp239 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp239 + * at (2647,1-2647,37) */ + uint64_t __tmp_in_tmp239; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp239; + } + Arr1DIdxRowM(tmp239, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp239 : 0; + } + + uint64_t *tmp240 = + make_array((int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp240 + * at (2650,1-2650,48) */ + uint64_t __tmp_in_tmp240; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp240; + } + Arr4DIdxRowM(tmp240, (int32_t)3, (int32_t)3, (int32_t)512, + (int32_t)512, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp240 : 0; + } + } + } + } + + uint64_t *tmp241 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp241 + * at (2653,1-2653,37) */ + uint64_t __tmp_in_tmp241; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp241; + } + Arr1DIdxRowM(tmp241, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp241 : 0; + } + + uint64_t *tmp242 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp242 + * at (2656,1-2656,37) */ + uint64_t __tmp_in_tmp242; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp242; + } + Arr1DIdxRowM(tmp242, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp242 : 0; + } + + uint64_t *tmp243 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp243 + * at (2659,1-2659,37) */ + uint64_t __tmp_in_tmp243; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp243; + } + Arr1DIdxRowM(tmp243, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp243 : 0; + } + + uint64_t *tmp244 = make_array((int32_t)512); + /* Variable to read the clear value corresponding to the input variable tmp244 + * at (2662,1-2662,37) */ + uint64_t __tmp_in_tmp244; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp244; + } + Arr1DIdxRowM(tmp244, (int32_t)512, i0) = + (party == SERVER) ? __tmp_in_tmp244 : 0; + } + + uint64_t *tmp245 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp245 + * at (2665,1-2665,49) */ + uint64_t __tmp_in_tmp245; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)2048; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp245; + } + Arr4DIdxRowM(tmp245, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)2048, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp245 : 0; + } + } + } + } + + uint64_t *tmp246 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp246 + * at (2668,1-2668,38) */ + uint64_t __tmp_in_tmp246; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp246; + } + Arr1DIdxRowM(tmp246, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp246 : 0; + } + + uint64_t *tmp247 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp247 + * at (2671,1-2671,38) */ + uint64_t __tmp_in_tmp247; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp247; + } + Arr1DIdxRowM(tmp247, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp247 : 0; + } + + uint64_t *tmp248 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp248 + * at (2674,1-2674,38) */ + uint64_t __tmp_in_tmp248; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp248; + } + Arr1DIdxRowM(tmp248, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp248 : 0; + } + + uint64_t *tmp249 = make_array((int32_t)2048); + /* Variable to read the clear value corresponding to the input variable tmp249 + * at (2677,1-2677,38) */ + uint64_t __tmp_in_tmp249; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp249; + } + Arr1DIdxRowM(tmp249, (int32_t)2048, i0) = + (party == SERVER) ? __tmp_in_tmp249 : 0; + } + + uint64_t *tmp250 = make_array((int32_t)2048, (int32_t)1001); + /* Variable to read the clear value corresponding to the input variable tmp250 + * at (2680,1-2680,44) */ + uint64_t __tmp_in_tmp250; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1001; i1++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp250; + } + Arr2DIdxRowM(tmp250, (int32_t)2048, (int32_t)1001, i0, i1) = + (party == SERVER) ? __tmp_in_tmp250 : 0; + } + } + + uint64_t *tmp251 = make_array((int32_t)1001); + /* Variable to read the clear value corresponding to the input variable tmp251 + * at (2683,1-2683,38) */ + uint64_t __tmp_in_tmp251; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1001; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp251; + } + Arr1DIdxRowM(tmp251, (int32_t)1001, i0) = + (party == SERVER) ? __tmp_in_tmp251 : 0; + } + StartComputation(); + + int64_t *tmp252 = make_array((int32_t)4, (int32_t)2); + Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = + (int32_t)3; + Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = + (int32_t)3; + Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = + (int32_t)3; + Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = + (int32_t)3; + Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = + (int32_t)0; + + uint64_t *tmp253 = + make_array((int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3); + Pad442((int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3, (int32_t)1, + (int32_t)224, (int32_t)224, (int32_t)3, tmp0, (int32_t)4, (int32_t)2, + tmp252, tmp253); + ClearMemPublic2((int32_t)4, (int32_t)2, tmp252); + ClearMemSecret4((int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, tmp0); + + uint64_t *tmp256 = + make_array((int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3, (int32_t)7, + (int32_t)7, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp253, tmp1, tmp256); + ClearMemSecret4((int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3, tmp253); + ClearMemSecret4((int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64, tmp1); + + uint64_t *tmp259 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + MaxPool((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, + (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)112, (int32_t)112, + (int32_t)64, tmp256, tmp259); + ClearMemSecret4((int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp256); + + uint64_t *tmp261 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp259, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp259, + tmp2, tmp3, (int32_t)0, (int32_t)12, tmp261); + ClearMemSecret1((int32_t)64, tmp3); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp259); + ClearMemSecret1((int32_t)64, tmp2); + + uint64_t *tmp265 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp261, tmp265, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp261); + + uint64_t *tmp267 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp265, tmp6, tmp267); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp6); + + uint64_t *tmp269 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp265, tmp7, tmp269); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp265); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64, tmp7); + + uint64_t *tmp272 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp269, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp269, + tmp8, tmp9, (int32_t)0, (int32_t)12, tmp272); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp269); + ClearMemSecret1((int32_t)64, tmp9); + ClearMemSecret1((int32_t)64, tmp8); + + uint64_t *tmp276 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp272, tmp276, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp272); + + uint64_t *tmp278 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp276, tmp12, tmp278); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp276); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp12); + + uint64_t *tmp281 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp278, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp278, + tmp13, tmp14, (int32_t)0, (int32_t)12, tmp281); + ClearMemSecret1((int32_t)64, tmp13); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp278); + ClearMemSecret1((int32_t)64, tmp14); + + uint64_t *tmp285 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp281, tmp285, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp281); + + uint64_t *tmp287 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp285, tmp17, tmp287); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp285); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp17); + + uint64_t *tmp290 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + MatAdd4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp287, tmp267, + tmp290); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp287); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp267); + + uint64_t *tmp293 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290, + tmp18, tmp19, (int32_t)0, (int32_t)12, tmp293); + ClearMemSecret1((int32_t)256, tmp18); + ClearMemSecret1((int32_t)256, tmp19); + + uint64_t *tmp296 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp293, tmp296, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp293); + + uint64_t *tmp298 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp296, tmp22, tmp298); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64, tmp22); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp296); + + uint64_t *tmp301 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp298, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp298, + tmp23, tmp24, (int32_t)0, (int32_t)12, tmp301); + ClearMemSecret1((int32_t)64, tmp24); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp298); + ClearMemSecret1((int32_t)64, tmp23); + + uint64_t *tmp305 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp301, tmp305, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp301); + + uint64_t *tmp307 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp305, tmp27, tmp307); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp305); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp27); + + uint64_t *tmp310 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp307, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp307, + tmp28, tmp29, (int32_t)0, (int32_t)12, tmp310); + ClearMemSecret1((int32_t)64, tmp29); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp307); + ClearMemSecret1((int32_t)64, tmp28); + + uint64_t *tmp314 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp310, tmp314, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp310); + + uint64_t *tmp316 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp314, tmp32, tmp316); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp314); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp32); + + uint64_t *tmp319 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + ScaleUp4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp316, tmp290, + tmp319); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp316); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290); + + uint64_t *tmp322 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319, + tmp33, tmp34, (int32_t)0, (int32_t)12, tmp322); + ClearMemSecret1((int32_t)256, tmp34); + ClearMemSecret1((int32_t)256, tmp33); + + uint64_t *tmp325 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp322, tmp325, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp322); + + uint64_t *tmp327 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp325, tmp37, tmp327); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64, tmp37); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp325); + + uint64_t *tmp330 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp327, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp327, + tmp38, tmp39, (int32_t)0, (int32_t)12, tmp330); + ClearMemSecret1((int32_t)64, tmp38); + ClearMemSecret1((int32_t)64, tmp39); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp327); + + uint64_t *tmp334 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp330, tmp334, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp330); + + uint64_t *tmp336 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp334, tmp42, tmp336); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp42); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp334); + + uint64_t *tmp339 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp336, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp336, + tmp43, tmp44, (int32_t)0, (int32_t)12, tmp339); + ClearMemSecret1((int32_t)64, tmp44); + ClearMemSecret1((int32_t)64, tmp43); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp336); + + uint64_t *tmp343 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp339, tmp343, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp339); + + uint64_t *tmp345 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp343, tmp47, tmp345); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp47); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp343); + + uint64_t *tmp348 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + ScaleUp4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp345, tmp319, + tmp348); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp345); + + uint64_t *tmp351 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp348, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp348, + tmp48, tmp49, (int32_t)0, (int32_t)12, tmp351); + ClearMemSecret1((int32_t)256, tmp48); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp348); + ClearMemSecret1((int32_t)256, tmp49); + + uint64_t *tmp355 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp351, tmp355, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp351); + + int64_t *tmp357 = make_array((int32_t)4, (int32_t)2); + Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = + (int32_t)0; + + uint64_t *tmp358 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); + Pad442((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)256, tmp355, (int32_t)4, (int32_t)2, + tmp357, tmp358); + ClearMemPublic2((int32_t)4, (int32_t)2, tmp357); + + uint64_t *tmp360 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp358, tmp52, tmp360); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)512, tmp52); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp358); + + uint64_t *tmp363 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp355, tmp53, tmp363); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp53); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp355); + + uint64_t *tmp366 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp363, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp363, + tmp54, tmp55, (int32_t)0, (int32_t)12, tmp366); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp363); + ClearMemSecret1((int32_t)128, tmp54); + ClearMemSecret1((int32_t)128, tmp55); + + uint64_t *tmp370 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp366, tmp370, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp366); + + int64_t *tmp372 = make_array((int32_t)4, (int32_t)2); + Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = + (int32_t)1; + Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = + (int32_t)1; + Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = + (int32_t)1; + Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = + (int32_t)1; + Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = + (int32_t)0; + + uint64_t *tmp373 = + make_array((int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128); + Pad442((int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)128, tmp370, (int32_t)4, (int32_t)2, + tmp372, tmp373); + ClearMemPublic2((int32_t)4, (int32_t)2, tmp372); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp370); + + uint64_t *tmp376 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp373, tmp58, tmp376); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp58); + ClearMemSecret4((int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128, tmp373); + + uint64_t *tmp379 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp376, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp376, + tmp59, tmp60, (int32_t)0, (int32_t)12, tmp379); + ClearMemSecret1((int32_t)128, tmp59); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp376); + ClearMemSecret1((int32_t)128, tmp60); + + uint64_t *tmp383 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp379, tmp383, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp379); + + uint64_t *tmp385 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, + (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp383, tmp63, tmp385); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp63); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp383); + + uint64_t *tmp388 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + MatAdd4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp385, tmp360, + tmp388); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp385); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp360); + + uint64_t *tmp391 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388, + tmp64, tmp65, (int32_t)0, (int32_t)12, tmp391); + ClearMemSecret1((int32_t)512, tmp64); + ClearMemSecret1((int32_t)512, tmp65); + + uint64_t *tmp394 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp391, tmp394, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp391); + + uint64_t *tmp396 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp394, tmp68, tmp396); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp394); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp68); + + uint64_t *tmp399 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp396, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp396, + tmp69, tmp70, (int32_t)0, (int32_t)12, tmp399); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp396); + ClearMemSecret1((int32_t)128, tmp69); + ClearMemSecret1((int32_t)128, tmp70); + + uint64_t *tmp403 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp399, tmp403, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp399); + + uint64_t *tmp405 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp403, tmp73, tmp405); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp73); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp403); + + uint64_t *tmp408 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp405, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp405, + tmp74, tmp75, (int32_t)0, (int32_t)12, tmp408); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp405); + ClearMemSecret1((int32_t)128, tmp75); + ClearMemSecret1((int32_t)128, tmp74); + + uint64_t *tmp412 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp408, tmp412, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp408); + + uint64_t *tmp414 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, + (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp412, tmp78, tmp414); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp78); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp412); + + uint64_t *tmp417 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + ScaleUp4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp414, tmp388, + tmp417); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp414); + + uint64_t *tmp420 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417, + tmp79, tmp80, (int32_t)0, (int32_t)12, tmp420); + ClearMemSecret1((int32_t)512, tmp80); + ClearMemSecret1((int32_t)512, tmp79); + + uint64_t *tmp423 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp420, tmp423, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp420); + + uint64_t *tmp425 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp423, tmp83, tmp425); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp83); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp423); + + uint64_t *tmp428 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp425, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp425, + tmp84, tmp85, (int32_t)0, (int32_t)12, tmp428); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp425); + ClearMemSecret1((int32_t)128, tmp84); + ClearMemSecret1((int32_t)128, tmp85); + + uint64_t *tmp432 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp428, tmp432, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp428); + + uint64_t *tmp434 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp432, tmp88, tmp434); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp88); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp432); + + uint64_t *tmp437 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp434, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp434, + tmp89, tmp90, (int32_t)0, (int32_t)12, tmp437); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp434); + ClearMemSecret1((int32_t)128, tmp89); + ClearMemSecret1((int32_t)128, tmp90); + + uint64_t *tmp441 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp437, tmp441, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp437); + + uint64_t *tmp443 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, + (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp441, tmp93, tmp443); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp93); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp441); + + uint64_t *tmp446 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + ScaleUp4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp443, tmp417, + tmp446); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp443); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417); + + uint64_t *tmp449 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446, + tmp94, tmp95, (int32_t)0, (int32_t)12, tmp449); + ClearMemSecret1((int32_t)512, tmp95); + ClearMemSecret1((int32_t)512, tmp94); + + uint64_t *tmp452 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp449, tmp452, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp449); + + uint64_t *tmp454 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp452, tmp98, tmp454); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp98); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp452); + + uint64_t *tmp457 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp454, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp454, + tmp99, tmp100, (int32_t)0, (int32_t)12, tmp457); + ClearMemSecret1((int32_t)128, tmp99); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp454); + ClearMemSecret1((int32_t)128, tmp100); + + uint64_t *tmp461 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp457, tmp461, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp457); + + uint64_t *tmp463 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp461, tmp103, tmp463); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp461); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp103); + + uint64_t *tmp466 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp463, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp463, + tmp104, tmp105, (int32_t)0, (int32_t)12, tmp466); + ClearMemSecret1((int32_t)128, tmp105); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp463); + ClearMemSecret1((int32_t)128, tmp104); + + uint64_t *tmp470 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp466, tmp470, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp466); + + uint64_t *tmp472 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, + (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp470, tmp108, tmp472); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp108); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp470); + + uint64_t *tmp475 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + ScaleUp4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp472, tmp446, + tmp475); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp472); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446); + + uint64_t *tmp478 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp475, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp475, + tmp109, tmp110, (int32_t)0, (int32_t)12, tmp478); + ClearMemSecret1((int32_t)512, tmp109); + ClearMemSecret1((int32_t)512, tmp110); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp475); + + uint64_t *tmp482 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp478, tmp482, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp478); + + int64_t *tmp484 = make_array((int32_t)4, (int32_t)2); + Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = + (int32_t)0; + + uint64_t *tmp485 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); + Pad442((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)512, tmp482, (int32_t)4, (int32_t)2, + tmp484, tmp485); + ClearMemPublic2((int32_t)4, (int32_t)2, tmp484); + + uint64_t *tmp487 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp485, tmp113, tmp487); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1024, tmp113); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp485); + + uint64_t *tmp490 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp482, tmp114, tmp490); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256, tmp114); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp482); + + uint64_t *tmp493 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp490, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp490, + tmp115, tmp116, (int32_t)0, (int32_t)12, tmp493); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp490); + ClearMemSecret1((int32_t)256, tmp115); + ClearMemSecret1((int32_t)256, tmp116); + + uint64_t *tmp497 = + make_array((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); + Relu4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp493, tmp497, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp493); + + int64_t *tmp499 = make_array((int32_t)4, (int32_t)2); + Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = + (int32_t)1; + Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = + (int32_t)1; + Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = + (int32_t)1; + Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = + (int32_t)1; + Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = + (int32_t)0; + + uint64_t *tmp500 = + make_array((int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256); + Pad442((int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256, (int32_t)1, + (int32_t)28, (int32_t)28, (int32_t)256, tmp497, (int32_t)4, (int32_t)2, + tmp499, tmp500); + ClearMemPublic2((int32_t)4, (int32_t)2, tmp499); + ClearMemSecret4((int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp497); + + uint64_t *tmp503 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256, (int32_t)3, + (int32_t)3, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp500, tmp119, tmp503); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp119); + ClearMemSecret4((int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256, tmp500); + + uint64_t *tmp506 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp503, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp503, + tmp120, tmp121, (int32_t)0, (int32_t)12, tmp506); + ClearMemSecret1((int32_t)256, tmp120); + ClearMemSecret1((int32_t)256, tmp121); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp503); + + uint64_t *tmp510 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp506, tmp510, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp506); + + uint64_t *tmp512 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp510, tmp124, tmp512); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp124); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp510); + + uint64_t *tmp515 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + MatAdd4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp512, tmp487, + tmp515); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp512); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp487); + + uint64_t *tmp518 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, + tmp515, tmp125, tmp126, (int32_t)0, (int32_t)12, tmp518); + ClearMemSecret1((int32_t)1024, tmp126); + ClearMemSecret1((int32_t)1024, tmp125); + + uint64_t *tmp521 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp518, tmp521, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp518); + + uint64_t *tmp523 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp521, tmp129, tmp523); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp129); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp521); + + uint64_t *tmp526 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp523, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp523, + tmp130, tmp131, (int32_t)0, (int32_t)12, tmp526); + ClearMemSecret1((int32_t)256, tmp131); + ClearMemSecret1((int32_t)256, tmp130); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp523); + + uint64_t *tmp530 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp526, tmp530, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp526); + + uint64_t *tmp532 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, + (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp530, tmp134, tmp532); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp134); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp530); + + uint64_t *tmp535 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp532, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp532, + tmp135, tmp136, (int32_t)0, (int32_t)12, tmp535); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp532); + ClearMemSecret1((int32_t)256, tmp136); + ClearMemSecret1((int32_t)256, tmp135); + + uint64_t *tmp539 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp535, tmp539, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp535); + + uint64_t *tmp541 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp539, tmp139, tmp541); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp139); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp539); + + uint64_t *tmp544 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleUp4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp541, tmp515, + tmp544); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp541); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515); + + uint64_t *tmp547 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, + tmp544, tmp140, tmp141, (int32_t)0, (int32_t)12, tmp547); + ClearMemSecret1((int32_t)1024, tmp141); + ClearMemSecret1((int32_t)1024, tmp140); + + uint64_t *tmp550 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp547, tmp550, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp547); + + uint64_t *tmp552 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp550, tmp144, tmp552); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp144); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp550); + + uint64_t *tmp555 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp552, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp552, + tmp145, tmp146, (int32_t)0, (int32_t)12, tmp555); + ClearMemSecret1((int32_t)256, tmp146); + ClearMemSecret1((int32_t)256, tmp145); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp552); + + uint64_t *tmp559 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp555, tmp559, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp555); + + uint64_t *tmp561 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, + (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp559, tmp149, tmp561); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp149); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp559); + + uint64_t *tmp564 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp561, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp561, + tmp150, tmp151, (int32_t)0, (int32_t)12, tmp564); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp561); + ClearMemSecret1((int32_t)256, tmp151); + ClearMemSecret1((int32_t)256, tmp150); + + uint64_t *tmp568 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp564, tmp568, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp564); + + uint64_t *tmp570 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp568, tmp154, tmp570); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp154); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp568); + + uint64_t *tmp573 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleUp4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp570, tmp544, + tmp573); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp570); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544); + + uint64_t *tmp576 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, + tmp573, tmp155, tmp156, (int32_t)0, (int32_t)12, tmp576); + ClearMemSecret1((int32_t)1024, tmp156); + ClearMemSecret1((int32_t)1024, tmp155); + + uint64_t *tmp579 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp576, tmp579, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp576); + + uint64_t *tmp581 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp579, tmp159, tmp581); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp159); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp579); + + uint64_t *tmp584 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp581, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp581, + tmp160, tmp161, (int32_t)0, (int32_t)12, tmp584); + ClearMemSecret1((int32_t)256, tmp161); + ClearMemSecret1((int32_t)256, tmp160); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp581); + + uint64_t *tmp588 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp584, tmp588, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp584); + + uint64_t *tmp590 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, + (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp588, tmp164, tmp590); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp164); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp588); + + uint64_t *tmp593 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp590, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp590, + tmp165, tmp166, (int32_t)0, (int32_t)12, tmp593); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp590); + ClearMemSecret1((int32_t)256, tmp166); + ClearMemSecret1((int32_t)256, tmp165); + + uint64_t *tmp597 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp593, tmp597, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp593); + + uint64_t *tmp599 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp597, tmp169, tmp599); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp169); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp597); + + uint64_t *tmp602 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleUp4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp599, tmp573, + tmp602); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp599); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573); + + uint64_t *tmp605 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, + tmp602, tmp170, tmp171, (int32_t)0, (int32_t)12, tmp605); + ClearMemSecret1((int32_t)1024, tmp171); + ClearMemSecret1((int32_t)1024, tmp170); + + uint64_t *tmp608 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp605, tmp608, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp605); + + uint64_t *tmp610 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp608, tmp174, tmp610); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp608); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp174); + + uint64_t *tmp613 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp610, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp610, + tmp175, tmp176, (int32_t)0, (int32_t)12, tmp613); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp610); + ClearMemSecret1((int32_t)256, tmp176); + ClearMemSecret1((int32_t)256, tmp175); + + uint64_t *tmp617 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp613, tmp617, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp613); + + uint64_t *tmp619 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, + (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp617, tmp179, tmp619); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp179); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp617); + + uint64_t *tmp622 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp619, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp619, + tmp180, tmp181, (int32_t)0, (int32_t)12, tmp622); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp619); + ClearMemSecret1((int32_t)256, tmp181); + ClearMemSecret1((int32_t)256, tmp180); + + uint64_t *tmp626 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp622, tmp626, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp622); + + uint64_t *tmp628 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp626, tmp184, tmp628); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp626); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp184); + + uint64_t *tmp631 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleUp4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp628, tmp602, + tmp631); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp628); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602); + + uint64_t *tmp634 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, + tmp631, tmp185, tmp186, (int32_t)0, (int32_t)12, tmp634); + ClearMemSecret1((int32_t)1024, tmp186); + ClearMemSecret1((int32_t)1024, tmp185); + + uint64_t *tmp637 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp634, tmp637, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp634); + + uint64_t *tmp639 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp637, tmp189, tmp639); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp189); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp637); + + uint64_t *tmp642 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp639, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp639, + tmp190, tmp191, (int32_t)0, (int32_t)12, tmp642); + ClearMemSecret1((int32_t)256, tmp190); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp639); + ClearMemSecret1((int32_t)256, tmp191); + + uint64_t *tmp646 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp642, tmp646, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp642); + + uint64_t *tmp648 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, + (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp646, tmp194, tmp648); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp646); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp194); + + uint64_t *tmp651 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp648, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp648, + tmp195, tmp196, (int32_t)0, (int32_t)12, tmp651); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp648); + ClearMemSecret1((int32_t)256, tmp196); + ClearMemSecret1((int32_t)256, tmp195); + + uint64_t *tmp655 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp651, tmp655, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp651); + + uint64_t *tmp657 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp655, tmp199, tmp657); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp655); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp199); + + uint64_t *tmp660 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleUp4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp657, tmp631, + tmp660); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp657); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631); + + uint64_t *tmp663 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp660, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, + tmp660, tmp200, tmp201, (int32_t)0, (int32_t)12, tmp663); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp660); + ClearMemSecret1((int32_t)1024, tmp200); + ClearMemSecret1((int32_t)1024, tmp201); + + uint64_t *tmp667 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp663, tmp667, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp663); + + int64_t *tmp669 = make_array((int32_t)4, (int32_t)2); + Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = + (int32_t)0; + + uint64_t *tmp670 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); + Pad442((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)1024, tmp667, (int32_t)4, + (int32_t)2, tmp669, tmp670); + ClearMemPublic2((int32_t)4, (int32_t)2, tmp669); + + uint64_t *tmp672 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp670, tmp204, tmp672); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp670); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)2048, tmp204); + + uint64_t *tmp675 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, + (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp667, tmp205, tmp675); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp667); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512, tmp205); + + uint64_t *tmp678 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp675, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp675, + tmp206, tmp207, (int32_t)0, (int32_t)12, tmp678); + ClearMemSecret1((int32_t)512, tmp206); + ClearMemSecret1((int32_t)512, tmp207); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp675); + + uint64_t *tmp682 = + make_array((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); + Relu4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp678, tmp682, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp678); + + int64_t *tmp684 = make_array((int32_t)4, (int32_t)2); + Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = + (int32_t)0; + Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = + (int32_t)1; + Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = + (int32_t)1; + Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = + (int32_t)1; + Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = + (int32_t)1; + Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = + (int32_t)0; + Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = + (int32_t)0; + + uint64_t *tmp685 = + make_array((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512); + Pad442((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512, (int32_t)1, + (int32_t)14, (int32_t)14, (int32_t)512, tmp682, (int32_t)4, (int32_t)2, + tmp684, tmp685); + ClearMemPublic2((int32_t)4, (int32_t)2, tmp684); + ClearMemSecret4((int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp682); + + uint64_t *tmp688 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512, (int32_t)3, + (int32_t)3, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp685, tmp210, tmp688); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512, tmp210); + ClearMemSecret4((int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512, tmp685); + + uint64_t *tmp691 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp688, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp688, + tmp211, tmp212, (int32_t)0, (int32_t)12, tmp691); + ClearMemSecret1((int32_t)512, tmp211); + ClearMemSecret1((int32_t)512, tmp212); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp688); + + uint64_t *tmp695 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp691, tmp695, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp691); + + uint64_t *tmp697 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp695, tmp215, tmp697); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048, tmp215); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp695); + + uint64_t *tmp700 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + MatAdd4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp697, tmp672, + tmp700); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp672); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp697); + + uint64_t *tmp703 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700, + tmp216, tmp217, (int32_t)0, (int32_t)12, tmp703); + ClearMemSecret1((int32_t)2048, tmp217); + ClearMemSecret1((int32_t)2048, tmp216); + + uint64_t *tmp706 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp703, tmp706, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp703); + + uint64_t *tmp708 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, (int32_t)1, + (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp706, tmp220, tmp708); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512, tmp220); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp706); + + uint64_t *tmp711 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp708, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp708, + tmp221, tmp222, (int32_t)0, (int32_t)12, tmp711); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp708); + ClearMemSecret1((int32_t)512, tmp222); + ClearMemSecret1((int32_t)512, tmp221); + + uint64_t *tmp715 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp711, tmp715, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp711); + + uint64_t *tmp717 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)3, + (int32_t)3, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp715, tmp225, tmp717); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp715); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512, tmp225); + + uint64_t *tmp720 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp717, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp717, + tmp226, tmp227, (int32_t)0, (int32_t)12, tmp720); + ClearMemSecret1((int32_t)512, tmp227); + ClearMemSecret1((int32_t)512, tmp226); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp717); + + uint64_t *tmp724 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp720, tmp724, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp720); + + uint64_t *tmp726 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp724, tmp230, tmp726); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp724); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048, tmp230); + + uint64_t *tmp729 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + ScaleUp4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp726, tmp700, + tmp729); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp726); + + uint64_t *tmp732 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729, + tmp231, tmp232, (int32_t)0, (int32_t)12, tmp732); + ClearMemSecret1((int32_t)2048, tmp231); + ClearMemSecret1((int32_t)2048, tmp232); + + uint64_t *tmp735 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp732, tmp735, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp732); + + uint64_t *tmp737 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, (int32_t)1, + (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp735, tmp235, tmp737); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp735); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512, tmp235); + + uint64_t *tmp740 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp737, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp737, + tmp236, tmp237, (int32_t)0, (int32_t)12, tmp740); + ClearMemSecret1((int32_t)512, tmp237); + ClearMemSecret1((int32_t)512, tmp236); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp737); + + uint64_t *tmp744 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp740, tmp744, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp740); + + uint64_t *tmp746 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)3, + (int32_t)3, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp744, tmp240, tmp746); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512, tmp240); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp744); + + uint64_t *tmp749 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp746, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp746, + tmp241, tmp242, (int32_t)0, (int32_t)12, tmp749); + ClearMemSecret1((int32_t)512, tmp242); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp746); + ClearMemSecret1((int32_t)512, tmp241); + + uint64_t *tmp753 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp749, tmp753, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp749); + + uint64_t *tmp755 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + Conv2DWrapper((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp753, tmp245, tmp755); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp753); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048, tmp245); + + uint64_t *tmp758 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + ScaleUp4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729, + (int32_t)12); + MatAdd4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp755, tmp729, + tmp758); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp755); + + uint64_t *tmp761 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + ScaleDown4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp758, + (int32_t)12); + FusedBatchNorm4411((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp758, + tmp246, tmp247, (int32_t)0, (int32_t)12, tmp761); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp758); + ClearMemSecret1((int32_t)2048, tmp247); + ClearMemSecret1((int32_t)2048, tmp246); + + uint64_t *tmp765 = + make_array((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); + Relu4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp761, tmp765, + (int32_t)12, 1); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp761); + + uint64_t *tmp767 = + make_array((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048); + AvgPool((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)7, + (int32_t)7, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)7, (int32_t)7, + (int32_t)2048, tmp765, tmp767); + ClearMemSecret4((int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp765); + + uint64_t *tmp771 = make_array((int32_t)1, (int32_t)2048); + + int64_t tmp769 = (int32_t)1; + + int64_t tmp770 = (int32_t)2; + Squeeze24((int32_t)1, (int32_t)2048, tmp769, tmp770, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)2048, tmp767, tmp771); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048, tmp767); + + uint64_t *tmp773 = make_array((int32_t)1, (int32_t)1001); + MatMul2D((int32_t)1, (int32_t)2048, (int32_t)1001, tmp771, tmp250, tmp773, 0); + ClearMemSecret2((int32_t)2048, (int32_t)1001, tmp250); + ClearMemSecret2((int32_t)1, (int32_t)2048, tmp771); + + uint64_t *tmp776 = make_array((int32_t)1, (int32_t)1001); + ScaleUp1((int32_t)1001, tmp251, (int32_t)12); + MatAddBroadCast2((int32_t)1, (int32_t)1001, tmp773, tmp251, tmp776); + ClearMemSecret2((int32_t)1, (int32_t)1001, tmp773); + ClearMemSecret1((int32_t)1001, tmp251); + + int64_t tmp779 = (int32_t)1; + + uint64_t *tmp780 = make_array((int32_t)1); + ArgMax1((int32_t)1, (int32_t)1, (int32_t)1001, tmp776, tmp779, tmp780); + ClearMemPublic(tmp779); + ClearMemSecret2((int32_t)1, (int32_t)1001, tmp776); + EndComputation(); + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + cout << (funcReconstruct2PCCons(Arr1DIdxRowM(tmp780, (int32_t)1, i0), 2)) + << endl; + } +} diff --git a/SCI/networks/main_resnet50_field64.cpp b/SCI/networks/main_resnet50_field64.cpp deleted file mode 100644 index 62edb8c3..00000000 --- a/SCI/networks/main_resnet50_field64.cpp +++ /dev/null @@ -1,5754 +0,0 @@ -/* -This is an autogenerated file, generated using the EzPC compiler. -*/ - - -#define BITLEN_37 -#define SCI_HE - - -#include "globals.h" -#include "functionalities_wrapper.h" -#include -using namespace std; - -template -T* make_array(size_t s1){ -return new T[s1]; -} - -template -T* make_array(size_t s1, size_t s2){ -return new T[s1*s2]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3){ -return new T[s1*s2*s3]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){ -return new T[s1*s2*s3*s4]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){ -return new T[s1*s2*s3*s4*s5]; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr1DIdxRowM(B,s2,i2)); -} -} -} - -void MatAdd2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr2DIdxRowM(B,s1,s2,i1,i2)); -} -} -} - -void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr1DIdxRowM(B,s4,i4)); -} -} -} -} -} - -void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr4DIdxRowM(B,s1,s2,s3,s4,i1,i2,i3,i4)); -} -} -} -} -} - -void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr1DIdxRowM(B,s5,i5)); -} -} -} -} -} -} - -void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr5DIdxRowM(B,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5)); -} -} -} -} -} -} - -void CreateTensor1(int64_t s1, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(arr,s1,i1) = val; -} -} - -void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(arr,s1,s2,i1,i2) = val; -} -} -} - -void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = val; -} -} -} -} - -void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = val; -} -} -} -} -} - -void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(arr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = val; -} -} -} -} -} -} - -void CopyTensor1(int64_t s1, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(targetArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CopyTensor2(int64_t s1, int64_t s2, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(targetArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(targetArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(targetArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateIdentity11(int64_t s1, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(newArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CreateIdentity22(int64_t s1, int64_t s2, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(newArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(newArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(newArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,inps1,inps2,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j)); -} -} -} - -void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inArr,inps1,inps2,inps3,inps4,inps5,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)2) + k),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)3) + l),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)4) + m)); -} -} -} -} -} -} - -void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,(i1 - inp1s1),i2); -} -} else { -if ((i2 < inp1s2)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,i1,(i2 - inp1s2)); -} -} -} -} -} - -void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,(i1 - inp1s1),i2,i3,i4); -} -} else { -if ((axis == (int32_t)1)) { -if ((i2 < inp1s2)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,(i2 - inp1s2),i3,i4); -} -} else { -if ((axis == (int32_t)2)) { -if ((i3 < inp1s3)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,(i3 - inp1s3),i4); -} -} else { -if ((i4 < inp1s4)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,i3,(i4 - inp1s4)); -} -} -} -} -} -} -} -} -} - -void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, int64_t I2, int64_t I3, int64_t I4, uint64_t* inp, int64_t axis, int64_t curCount, int64_t total, uint64_t* out){ -for (uint64_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint64_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint64_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint64_t o4 = (int32_t)0; o4 < O4; o4++){ - -int64_t i1 = o1; - -int64_t i2 = o2; - -int64_t i3 = o3; - -int64_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (((I1 / total) * curCount) + o1); -} -if ((axis == (int32_t)1)) { -i2 = (((I2 / total) * curCount) + o2); -} -if ((axis == (int32_t)2)) { -i3 = (((I3 / total) * curCount) + o3); -} -if ((axis == (int32_t)3)) { -i4 = (((I4 / total) * curCount) + o4); -} -Arr4DIdxRowM(out,O1,O2,O3,O4,o1,o2,o3,o4) = Arr4DIdxRowM(inp,I1,I2,I3,I4,i1,i2,i3,i4); -} -} -} -} -} - -void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CI,CO,fh,fw,ci,co); -} -} -} -} -} - -void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int64_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t outH, int64_t outW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t GIS = (CI / G); - -int64_t GOS = (CO / G); -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint64_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint64_t g = (int32_t)0; g < G; g++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ - -uint64_t val = funcSSCons( (int64_t)0); - -int64_t ci = ((GIS * g) + cig); - -int64_t co = ((GOS * g) + cog); - -int64_t curPosH = ((strideH * h) - zPadHLeft); -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ - -int64_t curPosW = ((strideW * w) - zPadWLeft); -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && (curPosH < H)) && (curPosW < W))) { -val = SecretAdd(val, SecretMult(Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci), Arr4DIdxRowM(filterArr,FH,FW,(CI / G),CO,fh,fw,(ci / G),co))); -} -curPosW = (curPosW + (int32_t)1); -} -curPosH = (curPosH + (int32_t)1); -} -Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co) = SecretAdd(Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co), val); -} -} -} -} -} -} -} - -void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t CIG = (CI / G); - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ - -int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); -Arr2DIdxRowM(outputArr,(CO / G),((FH * FW) * (CI / G)),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,(CI / G),CO,fh,fw,ci,(co + startCO)); -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,(co + startCO)) = Arr2DIdxRowM(inputArr,(CO / G),((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t g, int64_t G, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; - -int64_t CIG = (CI / G); -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); - -int64_t startCI = (g * CIG); -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int64_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,(ci + startCI)); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CIG) + (fw * CIG)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t CIG = (CI / G); - -int64_t reshapedFilterRows = (CO / G); - -int64_t reshapedFilterCols = ((FH * FW) * CIG); - -int64_t reshapedIPRows = ((FH * FW) * CIG); - -int64_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * outH) * outW); -for (uint64_t g = (int32_t)0; g < G; g++){ - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} -} - -void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CI,CO,fd,fh,fw,ci,co); -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t d = (int32_t)0; d < finalD; d++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr5DIdxRowM(outputArr,N,finalD,finalH,finalW,CO,n,d,h,w,co) = Arr2DIdxRowM(inputArr,CO,(((N * finalD) * finalH) * finalW),co,((((((n * finalD) * finalH) * finalW) + ((d * finalH) * finalW)) + (h * finalW)) + w)); -} -} -} -} -} -} - -void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadDLeft); - -int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= D)) || ((curPosH < (int32_t)0) || (curPosH >= H))) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int64_t)0); -} else { -val = Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -leftTopCornerD = (leftTopCornerD + strideD); -} - -} -} - -void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = (((N * newD) * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = funcSSCons( (int64_t)0); -for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); fd++){ -for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); fh++){ -for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); fw++){ - -int64_t curPosD = (fd - zPadDLeft); - -int64_t curPosH = (fh - zPadHLeft); - -int64_t curPosW = (fw - zPadWLeft); -if (((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W))) { - -int64_t curFilterPosD = (fd - (d * strideD)); - -int64_t curFilterPosH = (fh - (h * strideH)); - -int64_t curFilterPosW = (fw - (w * strideW)); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CI,CO,curFilterPosD,curFilterPosH,curFilterPosW,ci,co))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CO,CI,((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} - -void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int64_t)0); -} else { -if ((((curPosH % strideH) == (int32_t)0) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr4DIdxRowM(inputArr,N,HPrime,WPrime,CI,n,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int64_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -} -} - -void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t reshapedIPCols = ((N * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CO,CI,((FD - (int32_t)1) - fd),((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadTrDLeft); - -int64_t DPrimeTilde = (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); - -int64_t extremeRightBottomCornerD = ((DPrimeTilde - (int32_t)1) + zPadTrDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int64_t)0); -} else { -if (((((curPosD % strideD) == (int32_t)0) && ((curPosH % strideH) == (int32_t)0)) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputD = (curPosD / strideD); - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr5DIdxRowM(inputArr,N,DPrime,HPrime,WPrime,CI,n,idxInputD,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int64_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -leftTopCornerD = (leftTopCornerD + (int32_t)1); -} - -} -} - -void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t reshapedIPCols = (((N * D) * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = funcSSCons( (int64_t)0); -for (uint64_t fd = d; fd < (d + FD); fd++){ -for (uint64_t fh = h; fh < (h + FH); fh++){ -for (uint64_t fw = w; fw < (w + FW); fw++){ - -int64_t curPosD = ((fd - zPadDLeft) / strideD); - -int64_t curPosH = ((fh - zPadHLeft) / strideD); - -int64_t curPosW = ((fw - zPadWLeft) / strideD); -if ((((((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W)) && (((fd - zPadDLeft) % strideD) == (int32_t)0)) && (((fh - zPadHLeft) % strideH) == (int32_t)0)) && (((fw - zPadWLeft) % strideW) == (int32_t)0))) { - -int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); - -int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); - -int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CO,CI,curFilterPosD,curFilterPosH,curFilterPosW,co,ci))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,s2,s1,j,i); -} -} -} - -void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = Arr4DIdxRowM(inpArr,inps1,inps2,inps3,inps4,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0))); -} else { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = funcSSCons( (int64_t)0); -} -} -} -} -} -} - -void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); - -int64_t lbounds5 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0); - -int64_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl)) && (m >= lbounds5)) && (m < rbounds5excl))) { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inpArr,inps1,inps2,inps3,inps4,inps5,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0)),(m - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0))); -} else { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = funcSSCons( (int64_t)0); -} -} -} -} -} -} -} - -void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, int64_t i2, int64_t i3, int64_t i4, uint64_t* inpArr, int64_t pads, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr1DIdxRowM(paddings,pads, (int32_t)0); - -int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings,pads, (int32_t)4)); - -int64_t lbounds2 = Arr1DIdxRowM(paddings,pads, (int32_t)1); - -int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings,pads, (int32_t)5)); - -int64_t lbounds3 = Arr1DIdxRowM(paddings,pads, (int32_t)2); - -int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings,pads, (int32_t)6)); - -int64_t lbounds4 = Arr1DIdxRowM(paddings,pads, (int32_t)3); - -int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings,pads, (int32_t)7)); -for (uint64_t i = (int32_t)0; i < o1; i++){ -for (uint64_t j = (int32_t)0; j < o2; j++){ -for (uint64_t k = (int32_t)0; k < o3; k++){ -for (uint64_t l = (int32_t)0; l < o4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = Arr4DIdxRowM(inpArr,i1,i2,i3,i4,(i - Arr1DIdxRowM(paddings,pads, (int32_t)0)),(j - Arr1DIdxRowM(paddings,pads, (int32_t)1)),(k - Arr1DIdxRowM(paddings,pads, (int32_t)2)),(l - Arr1DIdxRowM(paddings,pads, (int32_t)3))); -} else { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = funcSSCons( (int64_t)0); -} -} -} -} -} -} - -void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < ins1; i++){ -for (uint64_t j = (int32_t)0; j < ins2; j++){ -for (uint64_t k = (int32_t)0; k < ins3; k++){ -for (uint64_t l = (int32_t)0; l < ins4; l++){ - -int64_t linIdx = ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + (k * ins4)) + l); - -int64_t outIdx1 = (linIdx / s2); - -int64_t outIdx2 = (linIdx % s2); -Arr2DIdxRowM(outArr,s1,s2,outIdx1,outIdx2) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i,j,k,l); -} -} -} -} -} - -void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s4,i4); -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s4); -for (uint64_t ii = (int32_t)0; ii < s4; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s4,ii) = Arr1DIdxRowM(biasArr,s4,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outputArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s4,i4)); -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s5,i5); -} -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s5); -for (uint64_t ii = (int32_t)0; ii < s5; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s5,ii) = Arr1DIdxRowM(biasArr,s5,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outputArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s5,i5)); -} -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s5, biasArrScaledUp); -} - -void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (s1 * s2); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr1,s1,s2,i1,i2); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr2,s1,s2,i1,i2); -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr1,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr2,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr1,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr2,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t* axes, uint64_t* outputArr){ - -int64_t divisor = (inS2 * inS3); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = funcSSCons( (int64_t)0); -for (uint64_t i = (int32_t)0; i < inS2; i++){ -for (uint64_t j = (int32_t)0; j < inS3; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i,j,i2)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t axis1, int64_t axis2, uint64_t* outputArr){ - -int64_t divisor = (inS3 * inS4); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = funcSSCons( (int64_t)0); -for (uint64_t i = (int32_t)0; i < inS3; i++){ -for (uint64_t j = (int32_t)0; j < inS4; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i2,i,j)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, uint64_t* inArr, int64_t dim, uint64_t* outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, int64_t dim, uint64_t* outArr){ - -int64_t size = ((ins1 * ins2) * ins3); - -uint64_t* reshapedInArr = make_array(size, ins4); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr2DIdxRowM(reshapedInArr,size,ins4,linIdx,i4) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i1,i2,i3,i4); -} -} -} -} -ArgMax(size, ins4, reshapedInArr, reshapedOutArr); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr3DIdxRowM(outArr,outs1,outs2,outs3,i1,i2,i3) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -ClearMemSecret2(size, ins4, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Floor2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Floor(size, reshapedInArr, reshapedOutArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void ScaleUp1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleUp(s1, arr, sf); -} - -void ScaleUp2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleDown(s1, arr, sf); -} - -void ScaleDown2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - - -int main(int argc, char** argv) -{ -ArgMapping amap; -int port = 32000; -string serverAddr = "127.0.0.1"; - -amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); -amap.arg("p", port, "Port Number"); -amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); -amap.parse(argc, argv); - -assert(party==sci::ALICE || party==sci::BOB); - -checkIfUsingEigen(); -for(int i=0;i(ioArr[i]); -prgInstanceArr[i] = new sci::PRG128(); -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); -if (i == 0) { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength); -} -else if (i == 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength); -} -else if (i & 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[1]); -} -else { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[0]); -} -} - -io = ioArr[0]; -iknpOT = new sci::IKNP(io); -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good -kkot = new sci::KKOT(io); -prg128Instance = new sci::PRG128(); -otpack = new sci::OTPack(io, party, baseForRelu, bitlength); - -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - -#ifdef SCI_OT -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack); -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -#endif - -#ifdef SCI_HE -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -heConvImpl = new ConvField(party,io); -heFCImpl = new FCField(party,io); -heProdImpl = new ElemWiseProdField(party, io); -assertFieldRun(); -#endif -#ifdef MULTITHREADED_NONLIN -#ifdef SCI_OT -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -} -#endif -#ifdef SCI_HE -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -} -#endif -#endif - -if (party==sci::ALICE){ -iknpOT->setup_send(); -iknpOTRoleReversed->setup_recv(); -} -else if (party==sci::BOB){ -iknpOT->setup_recv(); -iknpOTRoleReversed->setup_send(); -} -cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3); -/* Variable to read the clear value corresponding to the input variable tmp0 at (1930,1-1930,46) */ -uint64_t __tmp_in_tmp0; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)224; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)224; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)3; i3++){ -if ((party == CLIENT)) { -cin >> __tmp_in_tmp0; -} -Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3,i0,i1,i2,i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; -} -} -} -} - -uint64_t* tmp1 = make_array( (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp1 at (1933,1-1933,43) */ -uint64_t __tmp_in_tmp1; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)7; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)7; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)3; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp1; -} -Arr4DIdxRowM(tmp1, (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; -} -} -} -} - -uint64_t* tmp2 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp2 at (1936,1-1936,34) */ -uint64_t __tmp_in_tmp2; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp2; -} -Arr1DIdxRowM(tmp2, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; -} - -uint64_t* tmp3 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp3 at (1939,1-1939,34) */ -uint64_t __tmp_in_tmp3; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp3; -} -Arr1DIdxRowM(tmp3, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp3 : 0; -} - -uint64_t* tmp4 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp4 at (1942,1-1942,34) */ -uint64_t __tmp_in_tmp4; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp4; -} -Arr1DIdxRowM(tmp4, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; -} - -uint64_t* tmp5 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp5 at (1945,1-1945,34) */ -uint64_t __tmp_in_tmp5; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp5; -} -Arr1DIdxRowM(tmp5, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp5 : 0; -} - -uint64_t* tmp6 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp6 at (1948,1-1948,45) */ -uint64_t __tmp_in_tmp6; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp6; -} -Arr4DIdxRowM(tmp6, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp6 : 0; -} -} -} -} - -uint64_t* tmp7 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp7 at (1951,1-1951,44) */ -uint64_t __tmp_in_tmp7; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp7; -} -Arr4DIdxRowM(tmp7, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; -} -} -} -} - -uint64_t* tmp8 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp8 at (1954,1-1954,34) */ -uint64_t __tmp_in_tmp8; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp8; -} -Arr1DIdxRowM(tmp8, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; -} - -uint64_t* tmp9 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp9 at (1957,1-1957,34) */ -uint64_t __tmp_in_tmp9; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp9; -} -Arr1DIdxRowM(tmp9, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; -} - -uint64_t* tmp10 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp10 at (1960,1-1960,35) */ -uint64_t __tmp_in_tmp10; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp10; -} -Arr1DIdxRowM(tmp10, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp10 : 0; -} - -uint64_t* tmp11 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp11 at (1963,1-1963,35) */ -uint64_t __tmp_in_tmp11; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp11; -} -Arr1DIdxRowM(tmp11, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp11 : 0; -} - -uint64_t* tmp12 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp12 at (1966,1-1966,45) */ -uint64_t __tmp_in_tmp12; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp12; -} -Arr4DIdxRowM(tmp12, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp12 : 0; -} -} -} -} - -uint64_t* tmp13 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp13 at (1969,1-1969,35) */ -uint64_t __tmp_in_tmp13; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp13; -} -Arr1DIdxRowM(tmp13, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp13 : 0; -} - -uint64_t* tmp14 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp14 at (1972,1-1972,35) */ -uint64_t __tmp_in_tmp14; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp14; -} -Arr1DIdxRowM(tmp14, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp14 : 0; -} - -uint64_t* tmp15 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp15 at (1975,1-1975,35) */ -uint64_t __tmp_in_tmp15; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp15; -} -Arr1DIdxRowM(tmp15, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp15 : 0; -} - -uint64_t* tmp16 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp16 at (1978,1-1978,35) */ -uint64_t __tmp_in_tmp16; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp16; -} -Arr1DIdxRowM(tmp16, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp16 : 0; -} - -uint64_t* tmp17 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp17 at (1981,1-1981,46) */ -uint64_t __tmp_in_tmp17; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp17; -} -Arr4DIdxRowM(tmp17, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp17 : 0; -} -} -} -} - -uint64_t* tmp18 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp18 at (1984,1-1984,36) */ -uint64_t __tmp_in_tmp18; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp18; -} -Arr1DIdxRowM(tmp18, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp18 : 0; -} - -uint64_t* tmp19 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp19 at (1987,1-1987,36) */ -uint64_t __tmp_in_tmp19; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp19; -} -Arr1DIdxRowM(tmp19, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp19 : 0; -} - -uint64_t* tmp20 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp20 at (1990,1-1990,36) */ -uint64_t __tmp_in_tmp20; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp20; -} -Arr1DIdxRowM(tmp20, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp20 : 0; -} - -uint64_t* tmp21 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp21 at (1993,1-1993,36) */ -uint64_t __tmp_in_tmp21; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp21; -} -Arr1DIdxRowM(tmp21, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp21 : 0; -} - -uint64_t* tmp22 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp22 at (1996,1-1996,46) */ -uint64_t __tmp_in_tmp22; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp22; -} -Arr4DIdxRowM(tmp22, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp22 : 0; -} -} -} -} - -uint64_t* tmp23 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp23 at (1999,1-1999,35) */ -uint64_t __tmp_in_tmp23; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp23; -} -Arr1DIdxRowM(tmp23, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp23 : 0; -} - -uint64_t* tmp24 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp24 at (2002,1-2002,35) */ -uint64_t __tmp_in_tmp24; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp24; -} -Arr1DIdxRowM(tmp24, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp24 : 0; -} - -uint64_t* tmp25 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp25 at (2005,1-2005,35) */ -uint64_t __tmp_in_tmp25; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp25; -} -Arr1DIdxRowM(tmp25, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp25 : 0; -} - -uint64_t* tmp26 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp26 at (2008,1-2008,35) */ -uint64_t __tmp_in_tmp26; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp26; -} -Arr1DIdxRowM(tmp26, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp26 : 0; -} - -uint64_t* tmp27 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp27 at (2011,1-2011,45) */ -uint64_t __tmp_in_tmp27; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp27; -} -Arr4DIdxRowM(tmp27, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp27 : 0; -} -} -} -} - -uint64_t* tmp28 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp28 at (2014,1-2014,35) */ -uint64_t __tmp_in_tmp28; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp28; -} -Arr1DIdxRowM(tmp28, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp28 : 0; -} - -uint64_t* tmp29 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp29 at (2017,1-2017,35) */ -uint64_t __tmp_in_tmp29; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp29; -} -Arr1DIdxRowM(tmp29, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp29 : 0; -} - -uint64_t* tmp30 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp30 at (2020,1-2020,35) */ -uint64_t __tmp_in_tmp30; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp30; -} -Arr1DIdxRowM(tmp30, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp30 : 0; -} - -uint64_t* tmp31 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp31 at (2023,1-2023,35) */ -uint64_t __tmp_in_tmp31; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp31; -} -Arr1DIdxRowM(tmp31, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp31 : 0; -} - -uint64_t* tmp32 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp32 at (2026,1-2026,46) */ -uint64_t __tmp_in_tmp32; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp32; -} -Arr4DIdxRowM(tmp32, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp32 : 0; -} -} -} -} - -uint64_t* tmp33 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp33 at (2029,1-2029,36) */ -uint64_t __tmp_in_tmp33; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp33; -} -Arr1DIdxRowM(tmp33, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp33 : 0; -} - -uint64_t* tmp34 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp34 at (2032,1-2032,36) */ -uint64_t __tmp_in_tmp34; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp34; -} -Arr1DIdxRowM(tmp34, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp34 : 0; -} - -uint64_t* tmp35 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp35 at (2035,1-2035,36) */ -uint64_t __tmp_in_tmp35; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp35; -} -Arr1DIdxRowM(tmp35, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp35 : 0; -} - -uint64_t* tmp36 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp36 at (2038,1-2038,36) */ -uint64_t __tmp_in_tmp36; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp36; -} -Arr1DIdxRowM(tmp36, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp36 : 0; -} - -uint64_t* tmp37 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp37 at (2041,1-2041,46) */ -uint64_t __tmp_in_tmp37; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp37; -} -Arr4DIdxRowM(tmp37, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp37 : 0; -} -} -} -} - -uint64_t* tmp38 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp38 at (2044,1-2044,35) */ -uint64_t __tmp_in_tmp38; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp38; -} -Arr1DIdxRowM(tmp38, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp38 : 0; -} - -uint64_t* tmp39 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp39 at (2047,1-2047,35) */ -uint64_t __tmp_in_tmp39; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp39; -} -Arr1DIdxRowM(tmp39, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp39 : 0; -} - -uint64_t* tmp40 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp40 at (2050,1-2050,35) */ -uint64_t __tmp_in_tmp40; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp40; -} -Arr1DIdxRowM(tmp40, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp40 : 0; -} - -uint64_t* tmp41 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp41 at (2053,1-2053,35) */ -uint64_t __tmp_in_tmp41; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp41; -} -Arr1DIdxRowM(tmp41, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp41 : 0; -} - -uint64_t* tmp42 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp42 at (2056,1-2056,45) */ -uint64_t __tmp_in_tmp42; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp42; -} -Arr4DIdxRowM(tmp42, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp42 : 0; -} -} -} -} - -uint64_t* tmp43 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp43 at (2059,1-2059,35) */ -uint64_t __tmp_in_tmp43; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp43; -} -Arr1DIdxRowM(tmp43, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp43 : 0; -} - -uint64_t* tmp44 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp44 at (2062,1-2062,35) */ -uint64_t __tmp_in_tmp44; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp44; -} -Arr1DIdxRowM(tmp44, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp44 : 0; -} - -uint64_t* tmp45 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp45 at (2065,1-2065,35) */ -uint64_t __tmp_in_tmp45; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp45; -} -Arr1DIdxRowM(tmp45, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp45 : 0; -} - -uint64_t* tmp46 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp46 at (2068,1-2068,35) */ -uint64_t __tmp_in_tmp46; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp46; -} -Arr1DIdxRowM(tmp46, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp46 : 0; -} - -uint64_t* tmp47 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp47 at (2071,1-2071,46) */ -uint64_t __tmp_in_tmp47; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp47; -} -Arr4DIdxRowM(tmp47, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp47 : 0; -} -} -} -} - -uint64_t* tmp48 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp48 at (2074,1-2074,36) */ -uint64_t __tmp_in_tmp48; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp48; -} -Arr1DIdxRowM(tmp48, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp48 : 0; -} - -uint64_t* tmp49 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp49 at (2077,1-2077,36) */ -uint64_t __tmp_in_tmp49; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp49; -} -Arr1DIdxRowM(tmp49, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp49 : 0; -} - -uint64_t* tmp50 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp50 at (2080,1-2080,36) */ -uint64_t __tmp_in_tmp50; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp50; -} -Arr1DIdxRowM(tmp50, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp50 : 0; -} - -uint64_t* tmp51 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp51 at (2083,1-2083,36) */ -uint64_t __tmp_in_tmp51; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp51; -} -Arr1DIdxRowM(tmp51, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp51 : 0; -} - -uint64_t* tmp52 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp52 at (2086,1-2086,47) */ -uint64_t __tmp_in_tmp52; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp52; -} -Arr4DIdxRowM(tmp52, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp52 : 0; -} -} -} -} - -uint64_t* tmp53 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp53 at (2089,1-2089,47) */ -uint64_t __tmp_in_tmp53; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp53; -} -Arr4DIdxRowM(tmp53, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp53 : 0; -} -} -} -} - -uint64_t* tmp54 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp54 at (2092,1-2092,36) */ -uint64_t __tmp_in_tmp54; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp54; -} -Arr1DIdxRowM(tmp54, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp54 : 0; -} - -uint64_t* tmp55 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp55 at (2095,1-2095,36) */ -uint64_t __tmp_in_tmp55; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp55; -} -Arr1DIdxRowM(tmp55, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp55 : 0; -} - -uint64_t* tmp56 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp56 at (2098,1-2098,36) */ -uint64_t __tmp_in_tmp56; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp56; -} -Arr1DIdxRowM(tmp56, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp56 : 0; -} - -uint64_t* tmp57 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp57 at (2101,1-2101,36) */ -uint64_t __tmp_in_tmp57; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp57; -} -Arr1DIdxRowM(tmp57, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp57 : 0; -} - -uint64_t* tmp58 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp58 at (2104,1-2104,47) */ -uint64_t __tmp_in_tmp58; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp58; -} -Arr4DIdxRowM(tmp58, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp58 : 0; -} -} -} -} - -uint64_t* tmp59 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp59 at (2107,1-2107,36) */ -uint64_t __tmp_in_tmp59; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp59; -} -Arr1DIdxRowM(tmp59, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp59 : 0; -} - -uint64_t* tmp60 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp60 at (2110,1-2110,36) */ -uint64_t __tmp_in_tmp60; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp60; -} -Arr1DIdxRowM(tmp60, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp60 : 0; -} - -uint64_t* tmp61 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp61 at (2113,1-2113,36) */ -uint64_t __tmp_in_tmp61; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp61; -} -Arr1DIdxRowM(tmp61, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp61 : 0; -} - -uint64_t* tmp62 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp62 at (2116,1-2116,36) */ -uint64_t __tmp_in_tmp62; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp62; -} -Arr1DIdxRowM(tmp62, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp62 : 0; -} - -uint64_t* tmp63 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp63 at (2119,1-2119,47) */ -uint64_t __tmp_in_tmp63; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp63; -} -Arr4DIdxRowM(tmp63, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp63 : 0; -} -} -} -} - -uint64_t* tmp64 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp64 at (2122,1-2122,36) */ -uint64_t __tmp_in_tmp64; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp64; -} -Arr1DIdxRowM(tmp64, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp64 : 0; -} - -uint64_t* tmp65 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp65 at (2125,1-2125,36) */ -uint64_t __tmp_in_tmp65; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp65; -} -Arr1DIdxRowM(tmp65, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp65 : 0; -} - -uint64_t* tmp66 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp66 at (2128,1-2128,36) */ -uint64_t __tmp_in_tmp66; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp66; -} -Arr1DIdxRowM(tmp66, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp66 : 0; -} - -uint64_t* tmp67 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp67 at (2131,1-2131,36) */ -uint64_t __tmp_in_tmp67; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp67; -} -Arr1DIdxRowM(tmp67, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp67 : 0; -} - -uint64_t* tmp68 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp68 at (2134,1-2134,47) */ -uint64_t __tmp_in_tmp68; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp68; -} -Arr4DIdxRowM(tmp68, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp68 : 0; -} -} -} -} - -uint64_t* tmp69 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp69 at (2137,1-2137,36) */ -uint64_t __tmp_in_tmp69; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp69; -} -Arr1DIdxRowM(tmp69, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp69 : 0; -} - -uint64_t* tmp70 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp70 at (2140,1-2140,36) */ -uint64_t __tmp_in_tmp70; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp70; -} -Arr1DIdxRowM(tmp70, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp70 : 0; -} - -uint64_t* tmp71 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp71 at (2143,1-2143,36) */ -uint64_t __tmp_in_tmp71; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp71; -} -Arr1DIdxRowM(tmp71, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp71 : 0; -} - -uint64_t* tmp72 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp72 at (2146,1-2146,36) */ -uint64_t __tmp_in_tmp72; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp72; -} -Arr1DIdxRowM(tmp72, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp72 : 0; -} - -uint64_t* tmp73 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp73 at (2149,1-2149,47) */ -uint64_t __tmp_in_tmp73; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp73; -} -Arr4DIdxRowM(tmp73, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp73 : 0; -} -} -} -} - -uint64_t* tmp74 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp74 at (2152,1-2152,36) */ -uint64_t __tmp_in_tmp74; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp74; -} -Arr1DIdxRowM(tmp74, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp74 : 0; -} - -uint64_t* tmp75 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp75 at (2155,1-2155,36) */ -uint64_t __tmp_in_tmp75; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp75; -} -Arr1DIdxRowM(tmp75, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp75 : 0; -} - -uint64_t* tmp76 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp76 at (2158,1-2158,36) */ -uint64_t __tmp_in_tmp76; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp76; -} -Arr1DIdxRowM(tmp76, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp76 : 0; -} - -uint64_t* tmp77 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp77 at (2161,1-2161,36) */ -uint64_t __tmp_in_tmp77; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp77; -} -Arr1DIdxRowM(tmp77, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp77 : 0; -} - -uint64_t* tmp78 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp78 at (2164,1-2164,47) */ -uint64_t __tmp_in_tmp78; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp78; -} -Arr4DIdxRowM(tmp78, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp78 : 0; -} -} -} -} - -uint64_t* tmp79 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp79 at (2167,1-2167,36) */ -uint64_t __tmp_in_tmp79; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp79; -} -Arr1DIdxRowM(tmp79, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp79 : 0; -} - -uint64_t* tmp80 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp80 at (2170,1-2170,36) */ -uint64_t __tmp_in_tmp80; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp80; -} -Arr1DIdxRowM(tmp80, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp80 : 0; -} - -uint64_t* tmp81 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp81 at (2173,1-2173,36) */ -uint64_t __tmp_in_tmp81; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp81; -} -Arr1DIdxRowM(tmp81, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp81 : 0; -} - -uint64_t* tmp82 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp82 at (2176,1-2176,36) */ -uint64_t __tmp_in_tmp82; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp82; -} -Arr1DIdxRowM(tmp82, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp82 : 0; -} - -uint64_t* tmp83 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp83 at (2179,1-2179,47) */ -uint64_t __tmp_in_tmp83; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp83; -} -Arr4DIdxRowM(tmp83, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp83 : 0; -} -} -} -} - -uint64_t* tmp84 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp84 at (2182,1-2182,36) */ -uint64_t __tmp_in_tmp84; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp84; -} -Arr1DIdxRowM(tmp84, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp84 : 0; -} - -uint64_t* tmp85 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp85 at (2185,1-2185,36) */ -uint64_t __tmp_in_tmp85; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp85; -} -Arr1DIdxRowM(tmp85, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp85 : 0; -} - -uint64_t* tmp86 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp86 at (2188,1-2188,36) */ -uint64_t __tmp_in_tmp86; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp86; -} -Arr1DIdxRowM(tmp86, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp86 : 0; -} - -uint64_t* tmp87 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp87 at (2191,1-2191,36) */ -uint64_t __tmp_in_tmp87; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp87; -} -Arr1DIdxRowM(tmp87, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp87 : 0; -} - -uint64_t* tmp88 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp88 at (2194,1-2194,47) */ -uint64_t __tmp_in_tmp88; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp88; -} -Arr4DIdxRowM(tmp88, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp88 : 0; -} -} -} -} - -uint64_t* tmp89 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp89 at (2197,1-2197,36) */ -uint64_t __tmp_in_tmp89; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp89; -} -Arr1DIdxRowM(tmp89, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp89 : 0; -} - -uint64_t* tmp90 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp90 at (2200,1-2200,36) */ -uint64_t __tmp_in_tmp90; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp90; -} -Arr1DIdxRowM(tmp90, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp90 : 0; -} - -uint64_t* tmp91 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp91 at (2203,1-2203,36) */ -uint64_t __tmp_in_tmp91; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp91; -} -Arr1DIdxRowM(tmp91, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp91 : 0; -} - -uint64_t* tmp92 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp92 at (2206,1-2206,36) */ -uint64_t __tmp_in_tmp92; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp92; -} -Arr1DIdxRowM(tmp92, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp92 : 0; -} - -uint64_t* tmp93 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp93 at (2209,1-2209,47) */ -uint64_t __tmp_in_tmp93; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp93; -} -Arr4DIdxRowM(tmp93, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp93 : 0; -} -} -} -} - -uint64_t* tmp94 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp94 at (2212,1-2212,36) */ -uint64_t __tmp_in_tmp94; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp94; -} -Arr1DIdxRowM(tmp94, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp94 : 0; -} - -uint64_t* tmp95 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp95 at (2215,1-2215,36) */ -uint64_t __tmp_in_tmp95; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp95; -} -Arr1DIdxRowM(tmp95, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp95 : 0; -} - -uint64_t* tmp96 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp96 at (2218,1-2218,36) */ -uint64_t __tmp_in_tmp96; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp96; -} -Arr1DIdxRowM(tmp96, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp96 : 0; -} - -uint64_t* tmp97 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp97 at (2221,1-2221,36) */ -uint64_t __tmp_in_tmp97; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp97; -} -Arr1DIdxRowM(tmp97, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp97 : 0; -} - -uint64_t* tmp98 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp98 at (2224,1-2224,47) */ -uint64_t __tmp_in_tmp98; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp98; -} -Arr4DIdxRowM(tmp98, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp98 : 0; -} -} -} -} - -uint64_t* tmp99 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp99 at (2227,1-2227,36) */ -uint64_t __tmp_in_tmp99; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp99; -} -Arr1DIdxRowM(tmp99, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp99 : 0; -} - -uint64_t* tmp100 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp100 at (2230,1-2230,37) */ -uint64_t __tmp_in_tmp100; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp100; -} -Arr1DIdxRowM(tmp100, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp100 : 0; -} - -uint64_t* tmp101 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp101 at (2233,1-2233,37) */ -uint64_t __tmp_in_tmp101; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp101; -} -Arr1DIdxRowM(tmp101, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp101 : 0; -} - -uint64_t* tmp102 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp102 at (2236,1-2236,37) */ -uint64_t __tmp_in_tmp102; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp102; -} -Arr1DIdxRowM(tmp102, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp102 : 0; -} - -uint64_t* tmp103 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp103 at (2239,1-2239,48) */ -uint64_t __tmp_in_tmp103; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp103; -} -Arr4DIdxRowM(tmp103, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp103 : 0; -} -} -} -} - -uint64_t* tmp104 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp104 at (2242,1-2242,37) */ -uint64_t __tmp_in_tmp104; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp104; -} -Arr1DIdxRowM(tmp104, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp104 : 0; -} - -uint64_t* tmp105 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp105 at (2245,1-2245,37) */ -uint64_t __tmp_in_tmp105; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp105; -} -Arr1DIdxRowM(tmp105, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp105 : 0; -} - -uint64_t* tmp106 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp106 at (2248,1-2248,37) */ -uint64_t __tmp_in_tmp106; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp106; -} -Arr1DIdxRowM(tmp106, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp106 : 0; -} - -uint64_t* tmp107 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp107 at (2251,1-2251,37) */ -uint64_t __tmp_in_tmp107; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp107; -} -Arr1DIdxRowM(tmp107, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp107 : 0; -} - -uint64_t* tmp108 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp108 at (2254,1-2254,48) */ -uint64_t __tmp_in_tmp108; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp108; -} -Arr4DIdxRowM(tmp108, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp108 : 0; -} -} -} -} - -uint64_t* tmp109 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp109 at (2257,1-2257,37) */ -uint64_t __tmp_in_tmp109; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp109; -} -Arr1DIdxRowM(tmp109, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp109 : 0; -} - -uint64_t* tmp110 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp110 at (2260,1-2260,37) */ -uint64_t __tmp_in_tmp110; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp110; -} -Arr1DIdxRowM(tmp110, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp110 : 0; -} - -uint64_t* tmp111 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp111 at (2263,1-2263,37) */ -uint64_t __tmp_in_tmp111; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp111; -} -Arr1DIdxRowM(tmp111, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp111 : 0; -} - -uint64_t* tmp112 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp112 at (2266,1-2266,37) */ -uint64_t __tmp_in_tmp112; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp112; -} -Arr1DIdxRowM(tmp112, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp112 : 0; -} - -uint64_t* tmp113 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp113 at (2269,1-2269,49) */ -uint64_t __tmp_in_tmp113; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp113; -} -Arr4DIdxRowM(tmp113, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp113 : 0; -} -} -} -} - -uint64_t* tmp114 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp114 at (2272,1-2272,48) */ -uint64_t __tmp_in_tmp114; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp114; -} -Arr4DIdxRowM(tmp114, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp114 : 0; -} -} -} -} - -uint64_t* tmp115 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp115 at (2275,1-2275,37) */ -uint64_t __tmp_in_tmp115; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp115; -} -Arr1DIdxRowM(tmp115, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp115 : 0; -} - -uint64_t* tmp116 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp116 at (2278,1-2278,37) */ -uint64_t __tmp_in_tmp116; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp116; -} -Arr1DIdxRowM(tmp116, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp116 : 0; -} - -uint64_t* tmp117 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp117 at (2281,1-2281,37) */ -uint64_t __tmp_in_tmp117; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp117; -} -Arr1DIdxRowM(tmp117, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp117 : 0; -} - -uint64_t* tmp118 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp118 at (2284,1-2284,37) */ -uint64_t __tmp_in_tmp118; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp118; -} -Arr1DIdxRowM(tmp118, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp118 : 0; -} - -uint64_t* tmp119 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp119 at (2287,1-2287,48) */ -uint64_t __tmp_in_tmp119; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp119; -} -Arr4DIdxRowM(tmp119, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp119 : 0; -} -} -} -} - -uint64_t* tmp120 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp120 at (2290,1-2290,37) */ -uint64_t __tmp_in_tmp120; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp120; -} -Arr1DIdxRowM(tmp120, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp120 : 0; -} - -uint64_t* tmp121 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp121 at (2293,1-2293,37) */ -uint64_t __tmp_in_tmp121; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp121; -} -Arr1DIdxRowM(tmp121, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp121 : 0; -} - -uint64_t* tmp122 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp122 at (2296,1-2296,37) */ -uint64_t __tmp_in_tmp122; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp122; -} -Arr1DIdxRowM(tmp122, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp122 : 0; -} - -uint64_t* tmp123 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp123 at (2299,1-2299,37) */ -uint64_t __tmp_in_tmp123; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp123; -} -Arr1DIdxRowM(tmp123, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp123 : 0; -} - -uint64_t* tmp124 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp124 at (2302,1-2302,49) */ -uint64_t __tmp_in_tmp124; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp124; -} -Arr4DIdxRowM(tmp124, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp124 : 0; -} -} -} -} - -uint64_t* tmp125 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp125 at (2305,1-2305,38) */ -uint64_t __tmp_in_tmp125; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp125; -} -Arr1DIdxRowM(tmp125, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp125 : 0; -} - -uint64_t* tmp126 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp126 at (2308,1-2308,38) */ -uint64_t __tmp_in_tmp126; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp126; -} -Arr1DIdxRowM(tmp126, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp126 : 0; -} - -uint64_t* tmp127 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp127 at (2311,1-2311,38) */ -uint64_t __tmp_in_tmp127; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp127; -} -Arr1DIdxRowM(tmp127, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp127 : 0; -} - -uint64_t* tmp128 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp128 at (2314,1-2314,38) */ -uint64_t __tmp_in_tmp128; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp128; -} -Arr1DIdxRowM(tmp128, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp128 : 0; -} - -uint64_t* tmp129 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp129 at (2317,1-2317,49) */ -uint64_t __tmp_in_tmp129; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp129; -} -Arr4DIdxRowM(tmp129, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp129 : 0; -} -} -} -} - -uint64_t* tmp130 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp130 at (2320,1-2320,37) */ -uint64_t __tmp_in_tmp130; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp130; -} -Arr1DIdxRowM(tmp130, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp130 : 0; -} - -uint64_t* tmp131 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp131 at (2323,1-2323,37) */ -uint64_t __tmp_in_tmp131; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp131; -} -Arr1DIdxRowM(tmp131, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp131 : 0; -} - -uint64_t* tmp132 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp132 at (2326,1-2326,37) */ -uint64_t __tmp_in_tmp132; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp132; -} -Arr1DIdxRowM(tmp132, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp132 : 0; -} - -uint64_t* tmp133 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp133 at (2329,1-2329,37) */ -uint64_t __tmp_in_tmp133; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp133; -} -Arr1DIdxRowM(tmp133, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp133 : 0; -} - -uint64_t* tmp134 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp134 at (2332,1-2332,48) */ -uint64_t __tmp_in_tmp134; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp134; -} -Arr4DIdxRowM(tmp134, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp134 : 0; -} -} -} -} - -uint64_t* tmp135 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp135 at (2335,1-2335,37) */ -uint64_t __tmp_in_tmp135; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp135; -} -Arr1DIdxRowM(tmp135, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp135 : 0; -} - -uint64_t* tmp136 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp136 at (2338,1-2338,37) */ -uint64_t __tmp_in_tmp136; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp136; -} -Arr1DIdxRowM(tmp136, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp136 : 0; -} - -uint64_t* tmp137 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp137 at (2341,1-2341,37) */ -uint64_t __tmp_in_tmp137; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp137; -} -Arr1DIdxRowM(tmp137, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp137 : 0; -} - -uint64_t* tmp138 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp138 at (2344,1-2344,37) */ -uint64_t __tmp_in_tmp138; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp138; -} -Arr1DIdxRowM(tmp138, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp138 : 0; -} - -uint64_t* tmp139 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp139 at (2347,1-2347,49) */ -uint64_t __tmp_in_tmp139; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp139; -} -Arr4DIdxRowM(tmp139, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp139 : 0; -} -} -} -} - -uint64_t* tmp140 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp140 at (2350,1-2350,38) */ -uint64_t __tmp_in_tmp140; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp140; -} -Arr1DIdxRowM(tmp140, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp140 : 0; -} - -uint64_t* tmp141 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp141 at (2353,1-2353,38) */ -uint64_t __tmp_in_tmp141; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp141; -} -Arr1DIdxRowM(tmp141, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp141 : 0; -} - -uint64_t* tmp142 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp142 at (2356,1-2356,38) */ -uint64_t __tmp_in_tmp142; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp142; -} -Arr1DIdxRowM(tmp142, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp142 : 0; -} - -uint64_t* tmp143 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp143 at (2359,1-2359,38) */ -uint64_t __tmp_in_tmp143; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp143; -} -Arr1DIdxRowM(tmp143, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp143 : 0; -} - -uint64_t* tmp144 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp144 at (2362,1-2362,49) */ -uint64_t __tmp_in_tmp144; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp144; -} -Arr4DIdxRowM(tmp144, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp144 : 0; -} -} -} -} - -uint64_t* tmp145 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp145 at (2365,1-2365,37) */ -uint64_t __tmp_in_tmp145; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp145; -} -Arr1DIdxRowM(tmp145, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp145 : 0; -} - -uint64_t* tmp146 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp146 at (2368,1-2368,37) */ -uint64_t __tmp_in_tmp146; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp146; -} -Arr1DIdxRowM(tmp146, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp146 : 0; -} - -uint64_t* tmp147 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp147 at (2371,1-2371,37) */ -uint64_t __tmp_in_tmp147; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp147; -} -Arr1DIdxRowM(tmp147, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp147 : 0; -} - -uint64_t* tmp148 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp148 at (2374,1-2374,37) */ -uint64_t __tmp_in_tmp148; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp148; -} -Arr1DIdxRowM(tmp148, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp148 : 0; -} - -uint64_t* tmp149 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp149 at (2377,1-2377,48) */ -uint64_t __tmp_in_tmp149; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp149; -} -Arr4DIdxRowM(tmp149, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp149 : 0; -} -} -} -} - -uint64_t* tmp150 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp150 at (2380,1-2380,37) */ -uint64_t __tmp_in_tmp150; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp150; -} -Arr1DIdxRowM(tmp150, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp150 : 0; -} - -uint64_t* tmp151 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp151 at (2383,1-2383,37) */ -uint64_t __tmp_in_tmp151; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp151; -} -Arr1DIdxRowM(tmp151, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp151 : 0; -} - -uint64_t* tmp152 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp152 at (2386,1-2386,37) */ -uint64_t __tmp_in_tmp152; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp152; -} -Arr1DIdxRowM(tmp152, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp152 : 0; -} - -uint64_t* tmp153 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp153 at (2389,1-2389,37) */ -uint64_t __tmp_in_tmp153; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp153; -} -Arr1DIdxRowM(tmp153, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp153 : 0; -} - -uint64_t* tmp154 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp154 at (2392,1-2392,49) */ -uint64_t __tmp_in_tmp154; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp154; -} -Arr4DIdxRowM(tmp154, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp154 : 0; -} -} -} -} - -uint64_t* tmp155 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp155 at (2395,1-2395,38) */ -uint64_t __tmp_in_tmp155; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp155; -} -Arr1DIdxRowM(tmp155, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp155 : 0; -} - -uint64_t* tmp156 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp156 at (2398,1-2398,38) */ -uint64_t __tmp_in_tmp156; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp156; -} -Arr1DIdxRowM(tmp156, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp156 : 0; -} - -uint64_t* tmp157 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp157 at (2401,1-2401,38) */ -uint64_t __tmp_in_tmp157; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp157; -} -Arr1DIdxRowM(tmp157, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp157 : 0; -} - -uint64_t* tmp158 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp158 at (2404,1-2404,38) */ -uint64_t __tmp_in_tmp158; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp158; -} -Arr1DIdxRowM(tmp158, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp158 : 0; -} - -uint64_t* tmp159 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp159 at (2407,1-2407,49) */ -uint64_t __tmp_in_tmp159; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp159; -} -Arr4DIdxRowM(tmp159, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp159 : 0; -} -} -} -} - -uint64_t* tmp160 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp160 at (2410,1-2410,37) */ -uint64_t __tmp_in_tmp160; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp160; -} -Arr1DIdxRowM(tmp160, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp160 : 0; -} - -uint64_t* tmp161 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp161 at (2413,1-2413,37) */ -uint64_t __tmp_in_tmp161; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp161; -} -Arr1DIdxRowM(tmp161, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp161 : 0; -} - -uint64_t* tmp162 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp162 at (2416,1-2416,37) */ -uint64_t __tmp_in_tmp162; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp162; -} -Arr1DIdxRowM(tmp162, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp162 : 0; -} - -uint64_t* tmp163 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp163 at (2419,1-2419,37) */ -uint64_t __tmp_in_tmp163; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp163; -} -Arr1DIdxRowM(tmp163, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp163 : 0; -} - -uint64_t* tmp164 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp164 at (2422,1-2422,48) */ -uint64_t __tmp_in_tmp164; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp164; -} -Arr4DIdxRowM(tmp164, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp164 : 0; -} -} -} -} - -uint64_t* tmp165 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp165 at (2425,1-2425,37) */ -uint64_t __tmp_in_tmp165; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp165; -} -Arr1DIdxRowM(tmp165, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp165 : 0; -} - -uint64_t* tmp166 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp166 at (2428,1-2428,37) */ -uint64_t __tmp_in_tmp166; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp166; -} -Arr1DIdxRowM(tmp166, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp166 : 0; -} - -uint64_t* tmp167 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp167 at (2431,1-2431,37) */ -uint64_t __tmp_in_tmp167; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp167; -} -Arr1DIdxRowM(tmp167, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp167 : 0; -} - -uint64_t* tmp168 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp168 at (2434,1-2434,37) */ -uint64_t __tmp_in_tmp168; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp168; -} -Arr1DIdxRowM(tmp168, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp168 : 0; -} - -uint64_t* tmp169 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp169 at (2437,1-2437,49) */ -uint64_t __tmp_in_tmp169; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp169; -} -Arr4DIdxRowM(tmp169, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp169 : 0; -} -} -} -} - -uint64_t* tmp170 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp170 at (2440,1-2440,38) */ -uint64_t __tmp_in_tmp170; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp170; -} -Arr1DIdxRowM(tmp170, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp170 : 0; -} - -uint64_t* tmp171 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp171 at (2443,1-2443,38) */ -uint64_t __tmp_in_tmp171; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp171; -} -Arr1DIdxRowM(tmp171, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp171 : 0; -} - -uint64_t* tmp172 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp172 at (2446,1-2446,38) */ -uint64_t __tmp_in_tmp172; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp172; -} -Arr1DIdxRowM(tmp172, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp172 : 0; -} - -uint64_t* tmp173 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp173 at (2449,1-2449,38) */ -uint64_t __tmp_in_tmp173; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp173; -} -Arr1DIdxRowM(tmp173, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp173 : 0; -} - -uint64_t* tmp174 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp174 at (2452,1-2452,49) */ -uint64_t __tmp_in_tmp174; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp174; -} -Arr4DIdxRowM(tmp174, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp174 : 0; -} -} -} -} - -uint64_t* tmp175 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp175 at (2455,1-2455,37) */ -uint64_t __tmp_in_tmp175; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp175; -} -Arr1DIdxRowM(tmp175, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp175 : 0; -} - -uint64_t* tmp176 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp176 at (2458,1-2458,37) */ -uint64_t __tmp_in_tmp176; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp176; -} -Arr1DIdxRowM(tmp176, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp176 : 0; -} - -uint64_t* tmp177 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp177 at (2461,1-2461,37) */ -uint64_t __tmp_in_tmp177; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp177; -} -Arr1DIdxRowM(tmp177, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp177 : 0; -} - -uint64_t* tmp178 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp178 at (2464,1-2464,37) */ -uint64_t __tmp_in_tmp178; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp178; -} -Arr1DIdxRowM(tmp178, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp178 : 0; -} - -uint64_t* tmp179 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp179 at (2467,1-2467,48) */ -uint64_t __tmp_in_tmp179; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp179; -} -Arr4DIdxRowM(tmp179, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp179 : 0; -} -} -} -} - -uint64_t* tmp180 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp180 at (2470,1-2470,37) */ -uint64_t __tmp_in_tmp180; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp180; -} -Arr1DIdxRowM(tmp180, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp180 : 0; -} - -uint64_t* tmp181 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp181 at (2473,1-2473,37) */ -uint64_t __tmp_in_tmp181; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp181; -} -Arr1DIdxRowM(tmp181, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp181 : 0; -} - -uint64_t* tmp182 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp182 at (2476,1-2476,37) */ -uint64_t __tmp_in_tmp182; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp182; -} -Arr1DIdxRowM(tmp182, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp182 : 0; -} - -uint64_t* tmp183 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp183 at (2479,1-2479,37) */ -uint64_t __tmp_in_tmp183; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp183; -} -Arr1DIdxRowM(tmp183, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp183 : 0; -} - -uint64_t* tmp184 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp184 at (2482,1-2482,49) */ -uint64_t __tmp_in_tmp184; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp184; -} -Arr4DIdxRowM(tmp184, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp184 : 0; -} -} -} -} - -uint64_t* tmp185 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp185 at (2485,1-2485,38) */ -uint64_t __tmp_in_tmp185; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp185; -} -Arr1DIdxRowM(tmp185, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp185 : 0; -} - -uint64_t* tmp186 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp186 at (2488,1-2488,38) */ -uint64_t __tmp_in_tmp186; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp186; -} -Arr1DIdxRowM(tmp186, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp186 : 0; -} - -uint64_t* tmp187 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp187 at (2491,1-2491,38) */ -uint64_t __tmp_in_tmp187; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp187; -} -Arr1DIdxRowM(tmp187, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp187 : 0; -} - -uint64_t* tmp188 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp188 at (2494,1-2494,38) */ -uint64_t __tmp_in_tmp188; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp188; -} -Arr1DIdxRowM(tmp188, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp188 : 0; -} - -uint64_t* tmp189 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp189 at (2497,1-2497,49) */ -uint64_t __tmp_in_tmp189; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp189; -} -Arr4DIdxRowM(tmp189, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp189 : 0; -} -} -} -} - -uint64_t* tmp190 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp190 at (2500,1-2500,37) */ -uint64_t __tmp_in_tmp190; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp190; -} -Arr1DIdxRowM(tmp190, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp190 : 0; -} - -uint64_t* tmp191 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp191 at (2503,1-2503,37) */ -uint64_t __tmp_in_tmp191; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp191; -} -Arr1DIdxRowM(tmp191, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp191 : 0; -} - -uint64_t* tmp192 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp192 at (2506,1-2506,37) */ -uint64_t __tmp_in_tmp192; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp192; -} -Arr1DIdxRowM(tmp192, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp192 : 0; -} - -uint64_t* tmp193 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp193 at (2509,1-2509,37) */ -uint64_t __tmp_in_tmp193; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp193; -} -Arr1DIdxRowM(tmp193, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp193 : 0; -} - -uint64_t* tmp194 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp194 at (2512,1-2512,48) */ -uint64_t __tmp_in_tmp194; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp194; -} -Arr4DIdxRowM(tmp194, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp194 : 0; -} -} -} -} - -uint64_t* tmp195 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp195 at (2515,1-2515,37) */ -uint64_t __tmp_in_tmp195; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp195; -} -Arr1DIdxRowM(tmp195, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp195 : 0; -} - -uint64_t* tmp196 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp196 at (2518,1-2518,37) */ -uint64_t __tmp_in_tmp196; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp196; -} -Arr1DIdxRowM(tmp196, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp196 : 0; -} - -uint64_t* tmp197 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp197 at (2521,1-2521,37) */ -uint64_t __tmp_in_tmp197; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp197; -} -Arr1DIdxRowM(tmp197, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp197 : 0; -} - -uint64_t* tmp198 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp198 at (2524,1-2524,37) */ -uint64_t __tmp_in_tmp198; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp198; -} -Arr1DIdxRowM(tmp198, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp198 : 0; -} - -uint64_t* tmp199 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp199 at (2527,1-2527,49) */ -uint64_t __tmp_in_tmp199; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp199; -} -Arr4DIdxRowM(tmp199, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp199 : 0; -} -} -} -} - -uint64_t* tmp200 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp200 at (2530,1-2530,38) */ -uint64_t __tmp_in_tmp200; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp200; -} -Arr1DIdxRowM(tmp200, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp200 : 0; -} - -uint64_t* tmp201 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp201 at (2533,1-2533,38) */ -uint64_t __tmp_in_tmp201; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp201; -} -Arr1DIdxRowM(tmp201, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp201 : 0; -} - -uint64_t* tmp202 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp202 at (2536,1-2536,38) */ -uint64_t __tmp_in_tmp202; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp202; -} -Arr1DIdxRowM(tmp202, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp202 : 0; -} - -uint64_t* tmp203 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp203 at (2539,1-2539,38) */ -uint64_t __tmp_in_tmp203; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp203; -} -Arr1DIdxRowM(tmp203, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp203 : 0; -} - -uint64_t* tmp204 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp204 at (2542,1-2542,50) */ -uint64_t __tmp_in_tmp204; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)2048; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp204; -} -Arr4DIdxRowM(tmp204, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)2048,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp204 : 0; -} -} -} -} - -uint64_t* tmp205 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp205 at (2545,1-2545,49) */ -uint64_t __tmp_in_tmp205; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1024; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp205; -} -Arr4DIdxRowM(tmp205, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp205 : 0; -} -} -} -} - -uint64_t* tmp206 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp206 at (2548,1-2548,37) */ -uint64_t __tmp_in_tmp206; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp206; -} -Arr1DIdxRowM(tmp206, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp206 : 0; -} - -uint64_t* tmp207 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp207 at (2551,1-2551,37) */ -uint64_t __tmp_in_tmp207; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp207; -} -Arr1DIdxRowM(tmp207, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp207 : 0; -} - -uint64_t* tmp208 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp208 at (2554,1-2554,37) */ -uint64_t __tmp_in_tmp208; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp208; -} -Arr1DIdxRowM(tmp208, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp208 : 0; -} - -uint64_t* tmp209 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp209 at (2557,1-2557,37) */ -uint64_t __tmp_in_tmp209; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp209; -} -Arr1DIdxRowM(tmp209, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp209 : 0; -} - -uint64_t* tmp210 = make_array( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp210 at (2560,1-2560,48) */ -uint64_t __tmp_in_tmp210; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp210; -} -Arr4DIdxRowM(tmp210, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp210 : 0; -} -} -} -} - -uint64_t* tmp211 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp211 at (2563,1-2563,37) */ -uint64_t __tmp_in_tmp211; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp211; -} -Arr1DIdxRowM(tmp211, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp211 : 0; -} - -uint64_t* tmp212 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp212 at (2566,1-2566,37) */ -uint64_t __tmp_in_tmp212; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp212; -} -Arr1DIdxRowM(tmp212, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp212 : 0; -} - -uint64_t* tmp213 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp213 at (2569,1-2569,37) */ -uint64_t __tmp_in_tmp213; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp213; -} -Arr1DIdxRowM(tmp213, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp213 : 0; -} - -uint64_t* tmp214 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp214 at (2572,1-2572,37) */ -uint64_t __tmp_in_tmp214; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp214; -} -Arr1DIdxRowM(tmp214, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp214 : 0; -} - -uint64_t* tmp215 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp215 at (2575,1-2575,49) */ -uint64_t __tmp_in_tmp215; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)2048; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp215; -} -Arr4DIdxRowM(tmp215, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp215 : 0; -} -} -} -} - -uint64_t* tmp216 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp216 at (2578,1-2578,38) */ -uint64_t __tmp_in_tmp216; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp216; -} -Arr1DIdxRowM(tmp216, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp216 : 0; -} - -uint64_t* tmp217 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp217 at (2581,1-2581,38) */ -uint64_t __tmp_in_tmp217; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp217; -} -Arr1DIdxRowM(tmp217, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp217 : 0; -} - -uint64_t* tmp218 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp218 at (2584,1-2584,38) */ -uint64_t __tmp_in_tmp218; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp218; -} -Arr1DIdxRowM(tmp218, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp218 : 0; -} - -uint64_t* tmp219 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp219 at (2587,1-2587,38) */ -uint64_t __tmp_in_tmp219; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp219; -} -Arr1DIdxRowM(tmp219, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp219 : 0; -} - -uint64_t* tmp220 = make_array( (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp220 at (2590,1-2590,49) */ -uint64_t __tmp_in_tmp220; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)2048; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp220; -} -Arr4DIdxRowM(tmp220, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp220 : 0; -} -} -} -} - -uint64_t* tmp221 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp221 at (2593,1-2593,37) */ -uint64_t __tmp_in_tmp221; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp221; -} -Arr1DIdxRowM(tmp221, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp221 : 0; -} - -uint64_t* tmp222 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp222 at (2596,1-2596,37) */ -uint64_t __tmp_in_tmp222; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp222; -} -Arr1DIdxRowM(tmp222, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp222 : 0; -} - -uint64_t* tmp223 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp223 at (2599,1-2599,37) */ -uint64_t __tmp_in_tmp223; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp223; -} -Arr1DIdxRowM(tmp223, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp223 : 0; -} - -uint64_t* tmp224 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp224 at (2602,1-2602,37) */ -uint64_t __tmp_in_tmp224; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp224; -} -Arr1DIdxRowM(tmp224, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp224 : 0; -} - -uint64_t* tmp225 = make_array( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp225 at (2605,1-2605,48) */ -uint64_t __tmp_in_tmp225; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp225; -} -Arr4DIdxRowM(tmp225, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp225 : 0; -} -} -} -} - -uint64_t* tmp226 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp226 at (2608,1-2608,37) */ -uint64_t __tmp_in_tmp226; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp226; -} -Arr1DIdxRowM(tmp226, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp226 : 0; -} - -uint64_t* tmp227 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp227 at (2611,1-2611,37) */ -uint64_t __tmp_in_tmp227; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp227; -} -Arr1DIdxRowM(tmp227, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp227 : 0; -} - -uint64_t* tmp228 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp228 at (2614,1-2614,37) */ -uint64_t __tmp_in_tmp228; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp228; -} -Arr1DIdxRowM(tmp228, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp228 : 0; -} - -uint64_t* tmp229 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp229 at (2617,1-2617,37) */ -uint64_t __tmp_in_tmp229; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp229; -} -Arr1DIdxRowM(tmp229, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp229 : 0; -} - -uint64_t* tmp230 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp230 at (2620,1-2620,49) */ -uint64_t __tmp_in_tmp230; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)2048; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp230; -} -Arr4DIdxRowM(tmp230, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp230 : 0; -} -} -} -} - -uint64_t* tmp231 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp231 at (2623,1-2623,38) */ -uint64_t __tmp_in_tmp231; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp231; -} -Arr1DIdxRowM(tmp231, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp231 : 0; -} - -uint64_t* tmp232 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp232 at (2626,1-2626,38) */ -uint64_t __tmp_in_tmp232; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp232; -} -Arr1DIdxRowM(tmp232, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp232 : 0; -} - -uint64_t* tmp233 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp233 at (2629,1-2629,38) */ -uint64_t __tmp_in_tmp233; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp233; -} -Arr1DIdxRowM(tmp233, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp233 : 0; -} - -uint64_t* tmp234 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp234 at (2632,1-2632,38) */ -uint64_t __tmp_in_tmp234; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp234; -} -Arr1DIdxRowM(tmp234, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp234 : 0; -} - -uint64_t* tmp235 = make_array( (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp235 at (2635,1-2635,49) */ -uint64_t __tmp_in_tmp235; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)2048; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp235; -} -Arr4DIdxRowM(tmp235, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp235 : 0; -} -} -} -} - -uint64_t* tmp236 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp236 at (2638,1-2638,37) */ -uint64_t __tmp_in_tmp236; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp236; -} -Arr1DIdxRowM(tmp236, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp236 : 0; -} - -uint64_t* tmp237 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp237 at (2641,1-2641,37) */ -uint64_t __tmp_in_tmp237; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp237; -} -Arr1DIdxRowM(tmp237, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp237 : 0; -} - -uint64_t* tmp238 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp238 at (2644,1-2644,37) */ -uint64_t __tmp_in_tmp238; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp238; -} -Arr1DIdxRowM(tmp238, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp238 : 0; -} - -uint64_t* tmp239 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp239 at (2647,1-2647,37) */ -uint64_t __tmp_in_tmp239; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp239; -} -Arr1DIdxRowM(tmp239, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp239 : 0; -} - -uint64_t* tmp240 = make_array( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp240 at (2650,1-2650,48) */ -uint64_t __tmp_in_tmp240; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp240; -} -Arr4DIdxRowM(tmp240, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp240 : 0; -} -} -} -} - -uint64_t* tmp241 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp241 at (2653,1-2653,37) */ -uint64_t __tmp_in_tmp241; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp241; -} -Arr1DIdxRowM(tmp241, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp241 : 0; -} - -uint64_t* tmp242 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp242 at (2656,1-2656,37) */ -uint64_t __tmp_in_tmp242; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp242; -} -Arr1DIdxRowM(tmp242, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp242 : 0; -} - -uint64_t* tmp243 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp243 at (2659,1-2659,37) */ -uint64_t __tmp_in_tmp243; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp243; -} -Arr1DIdxRowM(tmp243, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp243 : 0; -} - -uint64_t* tmp244 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp244 at (2662,1-2662,37) */ -uint64_t __tmp_in_tmp244; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp244; -} -Arr1DIdxRowM(tmp244, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp244 : 0; -} - -uint64_t* tmp245 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp245 at (2665,1-2665,49) */ -uint64_t __tmp_in_tmp245; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)2048; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp245; -} -Arr4DIdxRowM(tmp245, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp245 : 0; -} -} -} -} - -uint64_t* tmp246 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp246 at (2668,1-2668,38) */ -uint64_t __tmp_in_tmp246; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp246; -} -Arr1DIdxRowM(tmp246, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp246 : 0; -} - -uint64_t* tmp247 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp247 at (2671,1-2671,38) */ -uint64_t __tmp_in_tmp247; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp247; -} -Arr1DIdxRowM(tmp247, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp247 : 0; -} - -uint64_t* tmp248 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp248 at (2674,1-2674,38) */ -uint64_t __tmp_in_tmp248; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp248; -} -Arr1DIdxRowM(tmp248, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp248 : 0; -} - -uint64_t* tmp249 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp249 at (2677,1-2677,38) */ -uint64_t __tmp_in_tmp249; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp249; -} -Arr1DIdxRowM(tmp249, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp249 : 0; -} - -uint64_t* tmp250 = make_array( (int32_t)2048, (int32_t)1001); -/* Variable to read the clear value corresponding to the input variable tmp250 at (2680,1-2680,44) */ -uint64_t __tmp_in_tmp250; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)2048; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1001; i1++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp250; -} -Arr2DIdxRowM(tmp250, (int32_t)2048, (int32_t)1001,i0,i1) = (party == SERVER) ? __tmp_in_tmp250 : 0; -} -} - -uint64_t* tmp251 = make_array( (int32_t)1001); -/* Variable to read the clear value corresponding to the input variable tmp251 at (2683,1-2683,38) */ -uint64_t __tmp_in_tmp251; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1001; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp251; -} -Arr1DIdxRowM(tmp251, (int32_t)1001,i0) = (party == SERVER) ? __tmp_in_tmp251 : 0; -} -StartComputation(); - -int64_t* tmp252 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)3; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)3; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)3; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)3; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp253 = make_array( (int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3); -Pad442( (int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3, (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, tmp0, (int32_t)4, (int32_t)2, tmp252, tmp253); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp252); -ClearMemSecret4( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, tmp0); - -uint64_t* tmp256 = make_array( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3, (int32_t)7, (int32_t)7, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp253, tmp1, tmp256); -ClearMemSecret4( (int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3, tmp253); -ClearMemSecret4( (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64, tmp1); - -uint64_t* tmp259 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -MaxPool( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp256, tmp259); -ClearMemSecret4( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp256); - -uint64_t* tmp261 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp259, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp259, tmp2, tmp3, (int32_t)0, (int32_t)12, tmp261); -ClearMemSecret1( (int32_t)64, tmp3); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp259); -ClearMemSecret1( (int32_t)64, tmp2); - -uint64_t* tmp265 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp261, tmp265, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp261); - -uint64_t* tmp267 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp265, tmp6, tmp267); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp6); - -uint64_t* tmp269 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp265, tmp7, tmp269); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp265); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64, tmp7); - -uint64_t* tmp272 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp269, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp269, tmp8, tmp9, (int32_t)0, (int32_t)12, tmp272); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp269); -ClearMemSecret1( (int32_t)64, tmp9); -ClearMemSecret1( (int32_t)64, tmp8); - -uint64_t* tmp276 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp272, tmp276, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp272); - -uint64_t* tmp278 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp276, tmp12, tmp278); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp276); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp12); - -uint64_t* tmp281 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp278, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp278, tmp13, tmp14, (int32_t)0, (int32_t)12, tmp281); -ClearMemSecret1( (int32_t)64, tmp13); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp278); -ClearMemSecret1( (int32_t)64, tmp14); - -uint64_t* tmp285 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp281, tmp285, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp281); - -uint64_t* tmp287 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp285, tmp17, tmp287); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp285); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp17); - -uint64_t* tmp290 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -MatAdd4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp287, tmp267, tmp290); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp287); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp267); - -uint64_t* tmp293 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290, tmp18, tmp19, (int32_t)0, (int32_t)12, tmp293); -ClearMemSecret1( (int32_t)256, tmp18); -ClearMemSecret1( (int32_t)256, tmp19); - -uint64_t* tmp296 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp293, tmp296, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp293); - -uint64_t* tmp298 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp296, tmp22, tmp298); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64, tmp22); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp296); - -uint64_t* tmp301 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp298, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp298, tmp23, tmp24, (int32_t)0, (int32_t)12, tmp301); -ClearMemSecret1( (int32_t)64, tmp24); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp298); -ClearMemSecret1( (int32_t)64, tmp23); - -uint64_t* tmp305 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp301, tmp305, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp301); - -uint64_t* tmp307 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp305, tmp27, tmp307); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp305); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp27); - -uint64_t* tmp310 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp307, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp307, tmp28, tmp29, (int32_t)0, (int32_t)12, tmp310); -ClearMemSecret1( (int32_t)64, tmp29); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp307); -ClearMemSecret1( (int32_t)64, tmp28); - -uint64_t* tmp314 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp310, tmp314, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp310); - -uint64_t* tmp316 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp314, tmp32, tmp316); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp314); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp32); - -uint64_t* tmp319 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleUp4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp316, tmp290, tmp319); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp316); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290); - -uint64_t* tmp322 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319, tmp33, tmp34, (int32_t)0, (int32_t)12, tmp322); -ClearMemSecret1( (int32_t)256, tmp34); -ClearMemSecret1( (int32_t)256, tmp33); - -uint64_t* tmp325 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp322, tmp325, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp322); - -uint64_t* tmp327 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp325, tmp37, tmp327); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64, tmp37); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp325); - -uint64_t* tmp330 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp327, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp327, tmp38, tmp39, (int32_t)0, (int32_t)12, tmp330); -ClearMemSecret1( (int32_t)64, tmp38); -ClearMemSecret1( (int32_t)64, tmp39); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp327); - -uint64_t* tmp334 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp330, tmp334, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp330); - -uint64_t* tmp336 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp334, tmp42, tmp336); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp42); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp334); - -uint64_t* tmp339 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp336, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp336, tmp43, tmp44, (int32_t)0, (int32_t)12, tmp339); -ClearMemSecret1( (int32_t)64, tmp44); -ClearMemSecret1( (int32_t)64, tmp43); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp336); - -uint64_t* tmp343 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp339, tmp343, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp339); - -uint64_t* tmp345 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp343, tmp47, tmp345); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp47); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp343); - -uint64_t* tmp348 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleUp4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp345, tmp319, tmp348); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp345); - -uint64_t* tmp351 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp348, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp348, tmp48, tmp49, (int32_t)0, (int32_t)12, tmp351); -ClearMemSecret1( (int32_t)256, tmp48); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp348); -ClearMemSecret1( (int32_t)256, tmp49); - -uint64_t* tmp355 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp351, tmp355, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp351); - -int64_t* tmp357 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp358 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Pad442( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp355, (int32_t)4, (int32_t)2, tmp357, tmp358); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp357); - -uint64_t* tmp360 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp358, tmp52, tmp360); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)512, tmp52); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp358); - -uint64_t* tmp363 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp355, tmp53, tmp363); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp53); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp355); - -uint64_t* tmp366 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp363, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp363, tmp54, tmp55, (int32_t)0, (int32_t)12, tmp366); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp363); -ClearMemSecret1( (int32_t)128, tmp54); -ClearMemSecret1( (int32_t)128, tmp55); - -uint64_t* tmp370 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp366, tmp370, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp366); - -int64_t* tmp372 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp373 = make_array( (int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128); -Pad442( (int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp370, (int32_t)4, (int32_t)2, tmp372, tmp373); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp372); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp370); - -uint64_t* tmp376 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp373, tmp58, tmp376); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp58); -ClearMemSecret4( (int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128, tmp373); - -uint64_t* tmp379 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp376, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp376, tmp59, tmp60, (int32_t)0, (int32_t)12, tmp379); -ClearMemSecret1( (int32_t)128, tmp59); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp376); -ClearMemSecret1( (int32_t)128, tmp60); - -uint64_t* tmp383 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp379, tmp383, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp379); - -uint64_t* tmp385 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp383, tmp63, tmp385); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp63); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp383); - -uint64_t* tmp388 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -MatAdd4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp385, tmp360, tmp388); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp385); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp360); - -uint64_t* tmp391 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388, tmp64, tmp65, (int32_t)0, (int32_t)12, tmp391); -ClearMemSecret1( (int32_t)512, tmp64); -ClearMemSecret1( (int32_t)512, tmp65); - -uint64_t* tmp394 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp391, tmp394, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp391); - -uint64_t* tmp396 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp394, tmp68, tmp396); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp394); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp68); - -uint64_t* tmp399 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp396, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp396, tmp69, tmp70, (int32_t)0, (int32_t)12, tmp399); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp396); -ClearMemSecret1( (int32_t)128, tmp69); -ClearMemSecret1( (int32_t)128, tmp70); - -uint64_t* tmp403 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp399, tmp403, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp399); - -uint64_t* tmp405 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp403, tmp73, tmp405); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp73); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp403); - -uint64_t* tmp408 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp405, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp405, tmp74, tmp75, (int32_t)0, (int32_t)12, tmp408); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp405); -ClearMemSecret1( (int32_t)128, tmp75); -ClearMemSecret1( (int32_t)128, tmp74); - -uint64_t* tmp412 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp408, tmp412, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp408); - -uint64_t* tmp414 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp412, tmp78, tmp414); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp78); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp412); - -uint64_t* tmp417 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleUp4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp414, tmp388, tmp417); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp414); - -uint64_t* tmp420 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417, tmp79, tmp80, (int32_t)0, (int32_t)12, tmp420); -ClearMemSecret1( (int32_t)512, tmp80); -ClearMemSecret1( (int32_t)512, tmp79); - -uint64_t* tmp423 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp420, tmp423, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp420); - -uint64_t* tmp425 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp423, tmp83, tmp425); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp83); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp423); - -uint64_t* tmp428 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp425, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp425, tmp84, tmp85, (int32_t)0, (int32_t)12, tmp428); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp425); -ClearMemSecret1( (int32_t)128, tmp84); -ClearMemSecret1( (int32_t)128, tmp85); - -uint64_t* tmp432 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp428, tmp432, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp428); - -uint64_t* tmp434 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp432, tmp88, tmp434); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp88); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp432); - -uint64_t* tmp437 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp434, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp434, tmp89, tmp90, (int32_t)0, (int32_t)12, tmp437); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp434); -ClearMemSecret1( (int32_t)128, tmp89); -ClearMemSecret1( (int32_t)128, tmp90); - -uint64_t* tmp441 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp437, tmp441, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp437); - -uint64_t* tmp443 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp441, tmp93, tmp443); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp93); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp441); - -uint64_t* tmp446 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleUp4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp443, tmp417, tmp446); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp443); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417); - -uint64_t* tmp449 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446, tmp94, tmp95, (int32_t)0, (int32_t)12, tmp449); -ClearMemSecret1( (int32_t)512, tmp95); -ClearMemSecret1( (int32_t)512, tmp94); - -uint64_t* tmp452 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp449, tmp452, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp449); - -uint64_t* tmp454 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp452, tmp98, tmp454); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp98); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp452); - -uint64_t* tmp457 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp454, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp454, tmp99, tmp100, (int32_t)0, (int32_t)12, tmp457); -ClearMemSecret1( (int32_t)128, tmp99); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp454); -ClearMemSecret1( (int32_t)128, tmp100); - -uint64_t* tmp461 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp457, tmp461, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp457); - -uint64_t* tmp463 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp461, tmp103, tmp463); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp461); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp103); - -uint64_t* tmp466 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp463, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp463, tmp104, tmp105, (int32_t)0, (int32_t)12, tmp466); -ClearMemSecret1( (int32_t)128, tmp105); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp463); -ClearMemSecret1( (int32_t)128, tmp104); - -uint64_t* tmp470 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp466, tmp470, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp466); - -uint64_t* tmp472 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp470, tmp108, tmp472); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp108); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp470); - -uint64_t* tmp475 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleUp4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp472, tmp446, tmp475); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp472); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446); - -uint64_t* tmp478 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp475, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp475, tmp109, tmp110, (int32_t)0, (int32_t)12, tmp478); -ClearMemSecret1( (int32_t)512, tmp109); -ClearMemSecret1( (int32_t)512, tmp110); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp475); - -uint64_t* tmp482 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp478, tmp482, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp478); - -int64_t* tmp484 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp485 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Pad442( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp482, (int32_t)4, (int32_t)2, tmp484, tmp485); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp484); - -uint64_t* tmp487 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp485, tmp113, tmp487); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1024, tmp113); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp485); - -uint64_t* tmp490 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp482, tmp114, tmp490); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256, tmp114); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp482); - -uint64_t* tmp493 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp490, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp490, tmp115, tmp116, (int32_t)0, (int32_t)12, tmp493); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp490); -ClearMemSecret1( (int32_t)256, tmp115); -ClearMemSecret1( (int32_t)256, tmp116); - -uint64_t* tmp497 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp493, tmp497, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp493); - -int64_t* tmp499 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp500 = make_array( (int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256); -Pad442( (int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp497, (int32_t)4, (int32_t)2, tmp499, tmp500); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp499); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp497); - -uint64_t* tmp503 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp500, tmp119, tmp503); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp119); -ClearMemSecret4( (int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256, tmp500); - -uint64_t* tmp506 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp503, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp503, tmp120, tmp121, (int32_t)0, (int32_t)12, tmp506); -ClearMemSecret1( (int32_t)256, tmp120); -ClearMemSecret1( (int32_t)256, tmp121); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp503); - -uint64_t* tmp510 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp506, tmp510, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp506); - -uint64_t* tmp512 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp510, tmp124, tmp512); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp124); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp510); - -uint64_t* tmp515 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp512, tmp487, tmp515); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp512); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp487); - -uint64_t* tmp518 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515, tmp125, tmp126, (int32_t)0, (int32_t)12, tmp518); -ClearMemSecret1( (int32_t)1024, tmp126); -ClearMemSecret1( (int32_t)1024, tmp125); - -uint64_t* tmp521 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp518, tmp521, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp518); - -uint64_t* tmp523 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp521, tmp129, tmp523); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp129); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp521); - -uint64_t* tmp526 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp523, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp523, tmp130, tmp131, (int32_t)0, (int32_t)12, tmp526); -ClearMemSecret1( (int32_t)256, tmp131); -ClearMemSecret1( (int32_t)256, tmp130); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp523); - -uint64_t* tmp530 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp526, tmp530, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp526); - -uint64_t* tmp532 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp530, tmp134, tmp532); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp134); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp530); - -uint64_t* tmp535 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp532, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp532, tmp135, tmp136, (int32_t)0, (int32_t)12, tmp535); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp532); -ClearMemSecret1( (int32_t)256, tmp136); -ClearMemSecret1( (int32_t)256, tmp135); - -uint64_t* tmp539 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp535, tmp539, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp535); - -uint64_t* tmp541 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp539, tmp139, tmp541); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp139); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp539); - -uint64_t* tmp544 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp541, tmp515, tmp544); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp541); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515); - -uint64_t* tmp547 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544, tmp140, tmp141, (int32_t)0, (int32_t)12, tmp547); -ClearMemSecret1( (int32_t)1024, tmp141); -ClearMemSecret1( (int32_t)1024, tmp140); - -uint64_t* tmp550 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp547, tmp550, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp547); - -uint64_t* tmp552 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp550, tmp144, tmp552); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp144); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp550); - -uint64_t* tmp555 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp552, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp552, tmp145, tmp146, (int32_t)0, (int32_t)12, tmp555); -ClearMemSecret1( (int32_t)256, tmp146); -ClearMemSecret1( (int32_t)256, tmp145); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp552); - -uint64_t* tmp559 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp555, tmp559, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp555); - -uint64_t* tmp561 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp559, tmp149, tmp561); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp149); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp559); - -uint64_t* tmp564 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp561, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp561, tmp150, tmp151, (int32_t)0, (int32_t)12, tmp564); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp561); -ClearMemSecret1( (int32_t)256, tmp151); -ClearMemSecret1( (int32_t)256, tmp150); - -uint64_t* tmp568 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp564, tmp568, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp564); - -uint64_t* tmp570 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp568, tmp154, tmp570); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp154); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp568); - -uint64_t* tmp573 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp570, tmp544, tmp573); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp570); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544); - -uint64_t* tmp576 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573, tmp155, tmp156, (int32_t)0, (int32_t)12, tmp576); -ClearMemSecret1( (int32_t)1024, tmp156); -ClearMemSecret1( (int32_t)1024, tmp155); - -uint64_t* tmp579 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp576, tmp579, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp576); - -uint64_t* tmp581 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp579, tmp159, tmp581); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp159); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp579); - -uint64_t* tmp584 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp581, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp581, tmp160, tmp161, (int32_t)0, (int32_t)12, tmp584); -ClearMemSecret1( (int32_t)256, tmp161); -ClearMemSecret1( (int32_t)256, tmp160); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp581); - -uint64_t* tmp588 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp584, tmp588, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp584); - -uint64_t* tmp590 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp588, tmp164, tmp590); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp164); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp588); - -uint64_t* tmp593 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp590, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp590, tmp165, tmp166, (int32_t)0, (int32_t)12, tmp593); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp590); -ClearMemSecret1( (int32_t)256, tmp166); -ClearMemSecret1( (int32_t)256, tmp165); - -uint64_t* tmp597 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp593, tmp597, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp593); - -uint64_t* tmp599 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp597, tmp169, tmp599); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp169); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp597); - -uint64_t* tmp602 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp599, tmp573, tmp602); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp599); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573); - -uint64_t* tmp605 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602, tmp170, tmp171, (int32_t)0, (int32_t)12, tmp605); -ClearMemSecret1( (int32_t)1024, tmp171); -ClearMemSecret1( (int32_t)1024, tmp170); - -uint64_t* tmp608 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp605, tmp608, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp605); - -uint64_t* tmp610 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp608, tmp174, tmp610); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp608); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp174); - -uint64_t* tmp613 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp610, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp610, tmp175, tmp176, (int32_t)0, (int32_t)12, tmp613); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp610); -ClearMemSecret1( (int32_t)256, tmp176); -ClearMemSecret1( (int32_t)256, tmp175); - -uint64_t* tmp617 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp613, tmp617, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp613); - -uint64_t* tmp619 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp617, tmp179, tmp619); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp179); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp617); - -uint64_t* tmp622 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp619, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp619, tmp180, tmp181, (int32_t)0, (int32_t)12, tmp622); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp619); -ClearMemSecret1( (int32_t)256, tmp181); -ClearMemSecret1( (int32_t)256, tmp180); - -uint64_t* tmp626 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp622, tmp626, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp622); - -uint64_t* tmp628 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp626, tmp184, tmp628); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp626); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp184); - -uint64_t* tmp631 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp628, tmp602, tmp631); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp628); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602); - -uint64_t* tmp634 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631, tmp185, tmp186, (int32_t)0, (int32_t)12, tmp634); -ClearMemSecret1( (int32_t)1024, tmp186); -ClearMemSecret1( (int32_t)1024, tmp185); - -uint64_t* tmp637 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp634, tmp637, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp634); - -uint64_t* tmp639 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp637, tmp189, tmp639); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp189); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp637); - -uint64_t* tmp642 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp639, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp639, tmp190, tmp191, (int32_t)0, (int32_t)12, tmp642); -ClearMemSecret1( (int32_t)256, tmp190); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp639); -ClearMemSecret1( (int32_t)256, tmp191); - -uint64_t* tmp646 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp642, tmp646, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp642); - -uint64_t* tmp648 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp646, tmp194, tmp648); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp646); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp194); - -uint64_t* tmp651 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp648, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp648, tmp195, tmp196, (int32_t)0, (int32_t)12, tmp651); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp648); -ClearMemSecret1( (int32_t)256, tmp196); -ClearMemSecret1( (int32_t)256, tmp195); - -uint64_t* tmp655 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp651, tmp655, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp651); - -uint64_t* tmp657 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp655, tmp199, tmp657); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp655); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp199); - -uint64_t* tmp660 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp657, tmp631, tmp660); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp657); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631); - -uint64_t* tmp663 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp660, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp660, tmp200, tmp201, (int32_t)0, (int32_t)12, tmp663); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp660); -ClearMemSecret1( (int32_t)1024, tmp200); -ClearMemSecret1( (int32_t)1024, tmp201); - -uint64_t* tmp667 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp663, tmp667, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp663); - -int64_t* tmp669 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp670 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Pad442( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp667, (int32_t)4, (int32_t)2, tmp669, tmp670); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp669); - -uint64_t* tmp672 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp670, tmp204, tmp672); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp670); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)2048, tmp204); - -uint64_t* tmp675 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp667, tmp205, tmp675); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp667); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512, tmp205); - -uint64_t* tmp678 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp675, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp675, tmp206, tmp207, (int32_t)0, (int32_t)12, tmp678); -ClearMemSecret1( (int32_t)512, tmp206); -ClearMemSecret1( (int32_t)512, tmp207); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp675); - -uint64_t* tmp682 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp678, tmp682, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp678); - -int64_t* tmp684 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp685 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512); -Pad442( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp682, (int32_t)4, (int32_t)2, tmp684, tmp685); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp684); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp682); - -uint64_t* tmp688 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp685, tmp210, tmp688); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512, tmp210); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512, tmp685); - -uint64_t* tmp691 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp688, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp688, tmp211, tmp212, (int32_t)0, (int32_t)12, tmp691); -ClearMemSecret1( (int32_t)512, tmp211); -ClearMemSecret1( (int32_t)512, tmp212); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp688); - -uint64_t* tmp695 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp691, tmp695, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp691); - -uint64_t* tmp697 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp695, tmp215, tmp697); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048, tmp215); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp695); - -uint64_t* tmp700 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -MatAdd4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp697, tmp672, tmp700); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp672); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp697); - -uint64_t* tmp703 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700, tmp216, tmp217, (int32_t)0, (int32_t)12, tmp703); -ClearMemSecret1( (int32_t)2048, tmp217); -ClearMemSecret1( (int32_t)2048, tmp216); - -uint64_t* tmp706 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp703, tmp706, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp703); - -uint64_t* tmp708 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp706, tmp220, tmp708); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512, tmp220); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp706); - -uint64_t* tmp711 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp708, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp708, tmp221, tmp222, (int32_t)0, (int32_t)12, tmp711); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp708); -ClearMemSecret1( (int32_t)512, tmp222); -ClearMemSecret1( (int32_t)512, tmp221); - -uint64_t* tmp715 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp711, tmp715, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp711); - -uint64_t* tmp717 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp715, tmp225, tmp717); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp715); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512, tmp225); - -uint64_t* tmp720 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp717, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp717, tmp226, tmp227, (int32_t)0, (int32_t)12, tmp720); -ClearMemSecret1( (int32_t)512, tmp227); -ClearMemSecret1( (int32_t)512, tmp226); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp717); - -uint64_t* tmp724 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp720, tmp724, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp720); - -uint64_t* tmp726 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp724, tmp230, tmp726); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp724); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048, tmp230); - -uint64_t* tmp729 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleUp4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp726, tmp700, tmp729); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp726); - -uint64_t* tmp732 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729, tmp231, tmp232, (int32_t)0, (int32_t)12, tmp732); -ClearMemSecret1( (int32_t)2048, tmp231); -ClearMemSecret1( (int32_t)2048, tmp232); - -uint64_t* tmp735 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp732, tmp735, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp732); - -uint64_t* tmp737 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp735, tmp235, tmp737); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp735); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512, tmp235); - -uint64_t* tmp740 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp737, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp737, tmp236, tmp237, (int32_t)0, (int32_t)12, tmp740); -ClearMemSecret1( (int32_t)512, tmp237); -ClearMemSecret1( (int32_t)512, tmp236); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp737); - -uint64_t* tmp744 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp740, tmp744, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp740); - -uint64_t* tmp746 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp744, tmp240, tmp746); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512, tmp240); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp744); - -uint64_t* tmp749 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp746, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp746, tmp241, tmp242, (int32_t)0, (int32_t)12, tmp749); -ClearMemSecret1( (int32_t)512, tmp242); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp746); -ClearMemSecret1( (int32_t)512, tmp241); - -uint64_t* tmp753 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp749, tmp753, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp749); - -uint64_t* tmp755 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp753, tmp245, tmp755); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp753); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048, tmp245); - -uint64_t* tmp758 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleUp4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp755, tmp729, tmp758); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp755); - -uint64_t* tmp761 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp758, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp758, tmp246, tmp247, (int32_t)0, (int32_t)12, tmp761); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp758); -ClearMemSecret1( (int32_t)2048, tmp247); -ClearMemSecret1( (int32_t)2048, tmp246); - -uint64_t* tmp765 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp761, tmp765, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp761); - -uint64_t* tmp767 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048); -AvgPool( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)7, (int32_t)7, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp765, tmp767); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp765); - -uint64_t* tmp771 = make_array( (int32_t)1, (int32_t)2048); - -int64_t tmp769 = (int32_t)1; - -int64_t tmp770 = (int32_t)2; -Squeeze24( (int32_t)1, (int32_t)2048, tmp769, tmp770, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048, tmp767, tmp771); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048, tmp767); - -uint64_t* tmp773 = make_array( (int32_t)1, (int32_t)1001); -MatMul2D( (int32_t)1, (int32_t)2048, (int32_t)1001, tmp771, tmp250, tmp773, 0); -ClearMemSecret2( (int32_t)2048, (int32_t)1001, tmp250); -ClearMemSecret2( (int32_t)1, (int32_t)2048, tmp771); - -uint64_t* tmp776 = make_array( (int32_t)1, (int32_t)1001); -ScaleUp1( (int32_t)1001, tmp251, (int32_t)12); -MatAddBroadCast2( (int32_t)1, (int32_t)1001, tmp773, tmp251, tmp776); -ClearMemSecret2( (int32_t)1, (int32_t)1001, tmp773); -ClearMemSecret1( (int32_t)1001, tmp251); - -int64_t tmp779 = (int32_t)1; - -uint64_t* tmp780 = make_array( (int32_t)1); -ArgMax1( (int32_t)1, (int32_t)1, (int32_t)1001, tmp776, tmp779, tmp780); -ClearMemPublic(tmp779); -ClearMemSecret2( (int32_t)1, (int32_t)1001, tmp776); -EndComputation(); -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -cout << (funcReconstruct2PCCons(Arr1DIdxRowM(tmp780, (int32_t)1,i0), 2)) << endl; -} -} - diff --git a/SCI/networks/main_resnet50_ring32.cpp b/SCI/networks/main_resnet50_ring32.cpp deleted file mode 100644 index d7171343..00000000 --- a/SCI/networks/main_resnet50_ring32.cpp +++ /dev/null @@ -1,5754 +0,0 @@ -/* -This is an autogenerated file, generated using the EzPC compiler. -*/ - - -#define BITLEN_37 -#define SCI_OT - - -#include "globals.h" -#include "functionalities_wrapper.h" -#include -using namespace std; - -template -T* make_array(size_t s1){ -return new T[s1]; -} - -template -T* make_array(size_t s1, size_t s2){ -return new T[s1*s2]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3){ -return new T[s1*s2*s3]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){ -return new T[s1*s2*s3*s4]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){ -return new T[s1*s2*s3*s4*s5]; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void MatAddBroadCast2(int32_t s1, int32_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr1DIdxRowM(B,s2,i2)); -} -} -} - -void MatAdd2(int32_t s1, int32_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr2DIdxRowM(B,s1,s2,i1,i2)); -} -} -} - -void MatAddBroadCast4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr1DIdxRowM(B,s4,i4)); -} -} -} -} -} - -void MatAdd4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr4DIdxRowM(B,s1,s2,s3,s4,i1,i2,i3,i4)); -} -} -} -} -} - -void MatAddBroadCast5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr1DIdxRowM(B,s5,i5)); -} -} -} -} -} -} - -void MatAdd5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr5DIdxRowM(B,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5)); -} -} -} -} -} -} - -void CreateTensor1(int32_t s1, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(arr,s1,i1) = val; -} -} - -void CreateTensor2(int32_t s1, int32_t s2, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(arr,s1,s2,i1,i2) = val; -} -} -} - -void CreateTensor3(int32_t s1, int32_t s2, int32_t s3, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = val; -} -} -} -} - -void CreateTensor4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = val; -} -} -} -} -} - -void CreateTensor5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(arr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = val; -} -} -} -} -} -} - -void CopyTensor1(int32_t s1, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(targetArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CopyTensor2(int32_t s1, int32_t s2, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(targetArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CopyTensor3(int32_t s1, int32_t s2, int32_t s3, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(targetArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CopyTensor4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(targetArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateIdentity11(int32_t s1, uint64_t* fromArr, uint64_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(newArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CreateIdentity22(int32_t s1, int32_t s2, uint64_t* fromArr, uint64_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(newArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CreateIdentity33(int32_t s1, int32_t s2, int32_t s3, uint64_t* fromArr, uint64_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(newArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CreateIdentity44(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint64_t* fromArr, uint64_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(newArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateCopy2211(int32_t s1, int32_t s2, int32_t inps1, int32_t inps2, uint64_t* inArr, int32_t perDimSize, int32_t* beginIdx, int32_t* sizeIdx, uint64_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,inps1,inps2,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j)); -} -} -} - -void CreateCopy5511(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, int32_t inps5, uint64_t* inArr, int32_t perDimSize, int32_t* beginIdx, int32_t* sizeIdx, uint64_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -for (uint32_t m = (int32_t)0; m < s5; m++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inArr,inps1,inps2,inps3,inps4,inps5,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)2) + k),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)3) + l),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)4) + m)); -} -} -} -} -} -} - -void Concat2T222(int32_t s1, int32_t s2, int32_t inp1s1, int32_t inp1s2, uint64_t* inp1, int32_t inp2s1, int32_t inp2s2, uint64_t* inp2, int32_t axis, uint64_t* outp){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,(i1 - inp1s1),i2); -} -} else { -if ((i2 < inp1s2)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,i1,(i2 - inp1s2)); -} -} -} -} -} - -void Concat2T444(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t inp1s1, int32_t inp1s2, int32_t inp1s3, int32_t inp1s4, uint64_t* inp1, int32_t inp2s1, int32_t inp2s2, int32_t inp2s3, int32_t inp2s4, uint64_t* inp2, int32_t axis, uint64_t* outp){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,(i1 - inp1s1),i2,i3,i4); -} -} else { -if ((axis == (int32_t)1)) { -if ((i2 < inp1s2)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,(i2 - inp1s2),i3,i4); -} -} else { -if ((axis == (int32_t)2)) { -if ((i3 < inp1s3)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,(i3 - inp1s3),i4); -} -} else { -if ((i4 < inp1s4)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,i3,(i4 - inp1s4)); -} -} -} -} -} -} -} -} -} - -void Split44(int32_t O1, int32_t O2, int32_t O3, int32_t O4, int32_t I1, int32_t I2, int32_t I3, int32_t I4, uint64_t* inp, int32_t axis, int32_t curCount, int32_t total, uint64_t* out){ -for (uint32_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint32_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint32_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint32_t o4 = (int32_t)0; o4 < O4; o4++){ - -int32_t i1 = o1; - -int32_t i2 = o2; - -int32_t i3 = o3; - -int32_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (((I1 / total) * curCount) + o1); -} -if ((axis == (int32_t)1)) { -i2 = (((I2 / total) * curCount) + o2); -} -if ((axis == (int32_t)2)) { -i3 = (((I3 / total) * curCount) + o3); -} -if ((axis == (int32_t)3)) { -i4 = (((I4 / total) * curCount) + o4); -} -Arr4DIdxRowM(out,O1,O2,O3,O4,o1,o2,o3,o4) = Arr4DIdxRowM(inp,I1,I2,I3,I4,i1,i2,i3,i4); -} -} -} -} -} - -void Conv2DReshapeFilter(int32_t FH, int32_t FW, int32_t CI, int32_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CI,CO,fh,fw,ci,co); -} -} -} -} -} - -void Conv2DReshapeMatMulOP(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInput(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int64_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2D(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = ((FH * FW) * CI); - -int32_t reshapedIPRows = ((FH * FW) * CI); - -int32_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = ((N * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t outH, int32_t outW, int32_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int32_t GIS = (CI / G); - -int32_t GOS = (CO / G); -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint32_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint32_t g = (int32_t)0; g < G; g++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ - -uint64_t val = funcSSCons( (int64_t)0); - -int32_t ci = ((GIS * g) + cig); - -int32_t co = ((GOS * g) + cog); - -int32_t curPosH = ((strideH * h) - zPadHLeft); -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ - -int32_t curPosW = ((strideW * w) - zPadWLeft); -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && (curPosH < H)) && (curPosW < W))) { -val = SecretAdd(val, SecretMult(Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci), Arr4DIdxRowM(filterArr,FH,FW,(CI / G),CO,fh,fw,(ci / G),co))); -} -curPosW = (curPosW + (int32_t)1); -} -curPosH = (curPosH + (int32_t)1); -} -Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co) = SecretAdd(Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co), val); -} -} -} -} -} -} -} - -void Conv2DLoop(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int32_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int32_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup(int32_t FH, int32_t FW, int32_t CI, int32_t CO, int32_t g, int32_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int32_t CIG = (CI / G); - -int32_t COG = (CO / G); - -int32_t startCO = (g * COG); -for (uint32_t co = (int32_t)0; co < COG; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CIG; ci++){ - -int32_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); -Arr2DIdxRowM(outputArr,(CO / G),((FH * FW) * (CI / G)),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,(CI / G),CO,fh,fw,ci,(co + startCO)); -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, int32_t g, int32_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int32_t COG = (CO / G); - -int32_t startCO = (g * COG); -for (uint32_t co = (int32_t)0; co < COG; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,(co + startCO)) = Arr2DIdxRowM(inputArr,(CO / G),((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInputGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t g, int32_t G, int32_t RRows, int32_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; - -int32_t CIG = (CI / G); -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); - -int32_t startCI = (g * CIG); -for (uint32_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int64_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,(ci + startCI)); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CIG) + (fw * CIG)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2DGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int32_t CIG = (CI / G); - -int32_t reshapedFilterRows = (CO / G); - -int32_t reshapedFilterCols = ((FH * FW) * CIG); - -int32_t reshapedIPRows = ((FH * FW) * CIG); - -int32_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = ((N * outH) * outW); -for (uint32_t g = (int32_t)0; g < G; g++){ - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} -} - -void Conv3DReshapeFilter(int32_t FD, int32_t FH, int32_t FW, int32_t CI, int32_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CI,CO,fd,fh,fw,ci,co); -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP(int32_t N, int32_t finalD, int32_t finalH, int32_t finalW, int32_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t d = (int32_t)0; d < finalD; d++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr5DIdxRowM(outputArr,N,finalD,finalH,finalW,CO,n,d,h,w,co) = Arr2DIdxRowM(inputArr,CO,(((N * finalD) * finalH) * finalW),co,((((((n * finalD) * finalH) * finalW) + ((d * finalH) * finalW)) + (h * finalW)) + w)); -} -} -} -} -} -} - -void Conv3DReshapeInput(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerD = ( (int32_t)0 - zPadDLeft); - -int32_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosD = (leftTopCornerD + fd); - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= D)) || ((curPosH < (int32_t)0) || (curPosH >= H))) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int64_t)0); -} else { -val = Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -leftTopCornerD = (leftTopCornerD + strideD); -} - -} -} - -void Conv3D(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int32_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int32_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); - -int32_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = (((N * newD) * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t outD, int32_t outH, int32_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t d = (int32_t)0; d < outD; d++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = funcSSCons( (int64_t)0); -for (uint32_t fd = (d * strideD); fd < ((d * strideD) + FD); fd++){ -for (uint32_t fh = (h * strideH); fh < ((h * strideH) + FH); fh++){ -for (uint32_t fw = (w * strideW); fw < ((w * strideW) + FW); fw++){ - -int32_t curPosD = (fd - zPadDLeft); - -int32_t curPosH = (fh - zPadHLeft); - -int32_t curPosW = (fw - zPadWLeft); -if (((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W))) { - -int32_t curFilterPosD = (fd - (d * strideD)); - -int32_t curFilterPosH = (fh - (h * strideH)); - -int32_t curFilterPosW = (fw - (w * strideW)); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CI,CO,curFilterPosD,curFilterPosH,curFilterPosW,ci,co))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void Conv3DLoop(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int32_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); - -int32_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int32_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void ConvTranspose2DReshapeFilter(int32_t FH, int32_t FW, int32_t CO, int32_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CO,CI,((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} - -void ConvTranspose2DReshapeInput(int32_t N, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FH, int32_t FW, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int32_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int32_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int32_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int32_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int64_t)0); -} else { -if ((((curPosH % strideH) == (int32_t)0) && ((curPosW % strideW) == (int32_t)0))) { - -int32_t idxInputH = (curPosH / strideH); - -int32_t idxInputW = (curPosW / strideW); -val = Arr4DIdxRowM(inputArr,N,HPrime,WPrime,CI,n,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int64_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -} -} - -void ConvTranspose2D(int32_t N, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t H, int32_t W, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideH, int32_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = ((FH * FW) * CI); - -int32_t reshapedIPRows = ((FH * FW) * CI); - -int32_t reshapedIPCols = ((N * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter(int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CO,CI,((FD - (int32_t)1) - fd),((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerD = ( (int32_t)0 - zPadTrDLeft); - -int32_t DPrimeTilde = (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); - -int32_t extremeRightBottomCornerD = ((DPrimeTilde - (int32_t)1) + zPadTrDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int32_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int32_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int32_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int32_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int32_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosD = (leftTopCornerD + fd); - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int64_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int64_t)0); -} else { -if (((((curPosD % strideD) == (int32_t)0) && ((curPosH % strideH) == (int32_t)0)) && ((curPosW % strideW) == (int32_t)0))) { - -int32_t idxInputD = (curPosD / strideD); - -int32_t idxInputH = (curPosH / strideH); - -int32_t idxInputW = (curPosW / strideW); -val = Arr5DIdxRowM(inputArr,N,DPrime,HPrime,WPrime,CI,n,idxInputD,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int64_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -leftTopCornerD = (leftTopCornerD + (int32_t)1); -} - -} -} - -void ConvTranspose3D(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t D, int32_t H, int32_t W, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int32_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int32_t reshapedIPCols = (((N * D) * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t outD, int32_t outH, int32_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t d = (int32_t)0; d < outD; d++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = funcSSCons( (int64_t)0); -for (uint32_t fd = d; fd < (d + FD); fd++){ -for (uint32_t fh = h; fh < (h + FH); fh++){ -for (uint32_t fw = w; fw < (w + FW); fw++){ - -int32_t curPosD = ((fd - zPadDLeft) / strideD); - -int32_t curPosH = ((fh - zPadHLeft) / strideD); - -int32_t curPosW = ((fw - zPadWLeft) / strideD); -if ((((((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W)) && (((fd - zPadDLeft) % strideD) == (int32_t)0)) && (((fh - zPadHLeft) % strideH) == (int32_t)0)) && (((fw - zPadWLeft) % strideW) == (int32_t)0))) { - -int32_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); - -int32_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); - -int32_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CO,CI,curFilterPosD,curFilterPosH,curFilterPosW,co,ci))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t D, int32_t H, int32_t W, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2(int32_t s1, int32_t s2, uint64_t* inArr, uint64_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,s2,s1,j,i); -} -} -} - -void Pad442(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, uint64_t* inpArr, int32_t pads1, int32_t pads2, int32_t* paddings, uint64_t* outArr){ - -int32_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int32_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int32_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int32_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int32_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int32_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int32_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int32_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = Arr4DIdxRowM(inpArr,inps1,inps2,inps3,inps4,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0))); -} else { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = funcSSCons( (int64_t)0); -} -} -} -} -} -} - -void Pad552(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, int32_t inps5, uint64_t* inpArr, int32_t pads1, int32_t pads2, int32_t* paddings, uint64_t* outArr){ - -int32_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int32_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int32_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int32_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int32_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int32_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int32_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int32_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); - -int32_t lbounds5 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0); - -int32_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)1)); -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -for (uint32_t m = (int32_t)0; m < s5; m++){ -if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl)) && (m >= lbounds5)) && (m < rbounds5excl))) { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inpArr,inps1,inps2,inps3,inps4,inps5,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0)),(m - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0))); -} else { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = funcSSCons( (int64_t)0); -} -} -} -} -} -} -} - -void PadONNX441(int32_t o1, int32_t o2, int32_t o3, int32_t o4, int32_t i1, int32_t i2, int32_t i3, int32_t i4, uint64_t* inpArr, int32_t pads, int32_t* paddings, uint64_t* outArr){ - -int32_t lbounds1 = Arr1DIdxRowM(paddings,pads, (int32_t)0); - -int32_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings,pads, (int32_t)4)); - -int32_t lbounds2 = Arr1DIdxRowM(paddings,pads, (int32_t)1); - -int32_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings,pads, (int32_t)5)); - -int32_t lbounds3 = Arr1DIdxRowM(paddings,pads, (int32_t)2); - -int32_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings,pads, (int32_t)6)); - -int32_t lbounds4 = Arr1DIdxRowM(paddings,pads, (int32_t)3); - -int32_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings,pads, (int32_t)7)); -for (uint32_t i = (int32_t)0; i < o1; i++){ -for (uint32_t j = (int32_t)0; j < o2; j++){ -for (uint32_t k = (int32_t)0; k < o3; k++){ -for (uint32_t l = (int32_t)0; l < o4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = Arr4DIdxRowM(inpArr,i1,i2,i3,i4,(i - Arr1DIdxRowM(paddings,pads, (int32_t)0)),(j - Arr1DIdxRowM(paddings,pads, (int32_t)1)),(k - Arr1DIdxRowM(paddings,pads, (int32_t)2)),(l - Arr1DIdxRowM(paddings,pads, (int32_t)3))); -} else { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = funcSSCons( (int64_t)0); -} -} -} -} -} -} - -void Squeeze24(int32_t s1, int32_t s2, int32_t dim1, int32_t dim2, int32_t ins1, int32_t ins2, int32_t ins3, int32_t ins4, uint64_t* inArr, uint64_t* outArr){ -for (uint32_t i = (int32_t)0; i < ins1; i++){ -for (uint32_t j = (int32_t)0; j < ins2; j++){ -for (uint32_t k = (int32_t)0; k < ins3; k++){ -for (uint32_t l = (int32_t)0; l < ins4; l++){ - -int32_t linIdx = ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + (k * ins4)) + l); - -int32_t outIdx1 = (linIdx / s2); - -int32_t outIdx2 = (linIdx % s2); -Arr2DIdxRowM(outArr,s1,s2,outIdx1,outIdx2) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i,j,k,l); -} -} -} -} -} - -void FusedBatchNorm4411(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int32_t multExprScaleDownSf, int32_t biasExprScaleUpSf, uint64_t* outputArr){ - -int32_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s4,i4); -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s4); -for (uint32_t ii = (int32_t)0; ii < s4; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s4,ii) = Arr1DIdxRowM(biasArr,s4,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outputArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s4,i4)); -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int32_t multExprScaleDownSf, int32_t biasExprScaleUpSf, uint64_t* outputArr){ - -int32_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s5,i5); -} -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s5); -for (uint32_t ii = (int32_t)0; ii < s5; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s5,ii) = Arr1DIdxRowM(biasArr,s5,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outputArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s5,i5)); -} -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s5, biasArrScaledUp); -} - -void ElemWiseMul2(int32_t s1, int32_t s2, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int32_t inpSize = (s1 * s2); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr1,s1,s2,i1,i2); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr2,s1,s2,i1,i2); -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int32_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr1,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr2,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int32_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr1,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr2,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ReduceMean24(int32_t outS1, int32_t outS2, int32_t inS1, int32_t inS2, int32_t inS3, int32_t inS4, uint64_t* inputArr, int32_t* axes, uint64_t* outputArr){ - -int32_t divisor = (inS2 * inS3); - -int32_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = funcSSCons( (int64_t)0); -for (uint32_t i = (int32_t)0; i < inS2; i++){ -for (uint32_t j = (int32_t)0; j < inS3; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i,j,i2)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24(int32_t outS1, int32_t outS2, int32_t inS1, int32_t inS2, int32_t inS3, int32_t inS4, uint64_t* inputArr, int32_t axis1, int32_t axis2, uint64_t* outputArr){ - -int32_t divisor = (inS3 * inS4); - -int32_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = funcSSCons( (int64_t)0); -for (uint32_t i = (int32_t)0; i < inS3; i++){ -for (uint32_t j = (int32_t)0; j < inS4; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i2,i,j)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ArgMax1(int32_t outArrS1, int32_t inArrS1, int32_t inArrS2, uint64_t* inArr, int32_t dim, uint64_t* outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3(int32_t outs1, int32_t outs2, int32_t outs3, int32_t ins1, int32_t ins2, int32_t ins3, int32_t ins4, uint64_t* inArr, int32_t dim, uint64_t* outArr){ - -int32_t size = ((ins1 * ins2) * ins3); - -uint64_t* reshapedInArr = make_array(size, ins4); - -uint64_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < ins4; i4++){ - -int32_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr2DIdxRowM(reshapedInArr,size,ins4,linIdx,i4) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i1,i2,i3,i4); -} -} -} -} -ArgMax(size, ins4, reshapedInArr, reshapedOutArr); -for (uint32_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < ins3; i3++){ - -int32_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr3DIdxRowM(outArr,outs1,outs2,outs3,i1,i2,i3) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -ClearMemSecret2(size, ins4, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu2(int32_t s1, int32_t s2, uint64_t* inArr, uint64_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint64_t* inArr, uint64_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint64_t* inArr, uint64_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Floor2(int32_t s1, int32_t s2, uint64_t* inArr, uint64_t* outArr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Floor(size, reshapedInArr, reshapedOutArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void ScaleUp1(int32_t s1, uint64_t* arr, int32_t sf){ -ScaleUp(s1, arr, sf); -} - -void ScaleUp2(int32_t s1, int32_t s2, uint64_t* arr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp3(int32_t s1, int32_t s2, int32_t s3, uint64_t* arr, int32_t sf){ - -int32_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint64_t* arr, int32_t sf){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown1(int32_t s1, uint64_t* arr, int32_t sf){ -ScaleDown(s1, arr, sf); -} - -void ScaleDown2(int32_t s1, int32_t s2, uint64_t* arr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown3(int32_t s1, int32_t s2, int32_t s3, uint64_t* arr, int32_t sf){ - -int32_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint64_t* arr, int32_t sf){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - - -int main(int argc, char** argv) -{ -ArgMapping amap; -int port = 32000; -string serverAddr = "127.0.0.1"; - -amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); -amap.arg("p", port, "Port Number"); -amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); -amap.parse(argc, argv); - -assert(party==sci::ALICE || party==sci::BOB); - -checkIfUsingEigen(); -for(int i=0;i(ioArr[i]); -prgInstanceArr[i] = new sci::PRG128(); -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); -if (i == 0) { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength); -} -else if (i == 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength); -} -else if (i & 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[1]); -} -else { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[0]); -} -} - -io = ioArr[0]; -iknpOT = new sci::IKNP(io); -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good -kkot = new sci::KKOT(io); -prg128Instance = new sci::PRG128(); -otpack = new sci::OTPack(io, party, baseForRelu, bitlength); - -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - -#ifdef SCI_OT -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack); -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -#endif - -#ifdef SCI_HE -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -heConvImpl = new ConvField(party,io); -heFCImpl = new FCField(party,io); -heProdImpl = new ElemWiseProdField(party, io); -assertFieldRun(); -#endif -#ifdef MULTITHREADED_NONLIN -#ifdef SCI_OT -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -} -#endif -#ifdef SCI_HE -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -} -#endif -#endif - -if (party==sci::ALICE){ -iknpOT->setup_send(); -iknpOTRoleReversed->setup_recv(); -} -else if (party==sci::BOB){ -iknpOT->setup_recv(); -iknpOTRoleReversed->setup_send(); -} -cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3); -/* Variable to read the clear value corresponding to the input variable tmp0 at (1930,1-1930,46) */ -uint64_t __tmp_in_tmp0; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)224; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)224; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)3; i3++){ -if ((party == CLIENT)) { -cin >> __tmp_in_tmp0; -} -Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3,i0,i1,i2,i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; -} -} -} -} - -uint64_t* tmp1 = make_array( (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp1 at (1933,1-1933,43) */ -uint64_t __tmp_in_tmp1; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)7; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)7; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)3; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp1; -} -Arr4DIdxRowM(tmp1, (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; -} -} -} -} - -uint64_t* tmp2 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp2 at (1936,1-1936,34) */ -uint64_t __tmp_in_tmp2; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp2; -} -Arr1DIdxRowM(tmp2, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; -} - -uint64_t* tmp3 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp3 at (1939,1-1939,34) */ -uint64_t __tmp_in_tmp3; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp3; -} -Arr1DIdxRowM(tmp3, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp3 : 0; -} - -uint64_t* tmp4 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp4 at (1942,1-1942,34) */ -uint64_t __tmp_in_tmp4; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp4; -} -Arr1DIdxRowM(tmp4, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; -} - -uint64_t* tmp5 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp5 at (1945,1-1945,34) */ -uint64_t __tmp_in_tmp5; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp5; -} -Arr1DIdxRowM(tmp5, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp5 : 0; -} - -uint64_t* tmp6 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp6 at (1948,1-1948,45) */ -uint64_t __tmp_in_tmp6; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp6; -} -Arr4DIdxRowM(tmp6, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp6 : 0; -} -} -} -} - -uint64_t* tmp7 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp7 at (1951,1-1951,44) */ -uint64_t __tmp_in_tmp7; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp7; -} -Arr4DIdxRowM(tmp7, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; -} -} -} -} - -uint64_t* tmp8 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp8 at (1954,1-1954,34) */ -uint64_t __tmp_in_tmp8; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp8; -} -Arr1DIdxRowM(tmp8, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; -} - -uint64_t* tmp9 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp9 at (1957,1-1957,34) */ -uint64_t __tmp_in_tmp9; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp9; -} -Arr1DIdxRowM(tmp9, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp9 : 0; -} - -uint64_t* tmp10 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp10 at (1960,1-1960,35) */ -uint64_t __tmp_in_tmp10; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp10; -} -Arr1DIdxRowM(tmp10, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp10 : 0; -} - -uint64_t* tmp11 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp11 at (1963,1-1963,35) */ -uint64_t __tmp_in_tmp11; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp11; -} -Arr1DIdxRowM(tmp11, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp11 : 0; -} - -uint64_t* tmp12 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp12 at (1966,1-1966,45) */ -uint64_t __tmp_in_tmp12; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp12; -} -Arr4DIdxRowM(tmp12, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp12 : 0; -} -} -} -} - -uint64_t* tmp13 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp13 at (1969,1-1969,35) */ -uint64_t __tmp_in_tmp13; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp13; -} -Arr1DIdxRowM(tmp13, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp13 : 0; -} - -uint64_t* tmp14 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp14 at (1972,1-1972,35) */ -uint64_t __tmp_in_tmp14; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp14; -} -Arr1DIdxRowM(tmp14, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp14 : 0; -} - -uint64_t* tmp15 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp15 at (1975,1-1975,35) */ -uint64_t __tmp_in_tmp15; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp15; -} -Arr1DIdxRowM(tmp15, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp15 : 0; -} - -uint64_t* tmp16 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp16 at (1978,1-1978,35) */ -uint64_t __tmp_in_tmp16; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp16; -} -Arr1DIdxRowM(tmp16, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp16 : 0; -} - -uint64_t* tmp17 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp17 at (1981,1-1981,46) */ -uint64_t __tmp_in_tmp17; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp17; -} -Arr4DIdxRowM(tmp17, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp17 : 0; -} -} -} -} - -uint64_t* tmp18 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp18 at (1984,1-1984,36) */ -uint64_t __tmp_in_tmp18; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp18; -} -Arr1DIdxRowM(tmp18, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp18 : 0; -} - -uint64_t* tmp19 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp19 at (1987,1-1987,36) */ -uint64_t __tmp_in_tmp19; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp19; -} -Arr1DIdxRowM(tmp19, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp19 : 0; -} - -uint64_t* tmp20 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp20 at (1990,1-1990,36) */ -uint64_t __tmp_in_tmp20; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp20; -} -Arr1DIdxRowM(tmp20, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp20 : 0; -} - -uint64_t* tmp21 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp21 at (1993,1-1993,36) */ -uint64_t __tmp_in_tmp21; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp21; -} -Arr1DIdxRowM(tmp21, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp21 : 0; -} - -uint64_t* tmp22 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp22 at (1996,1-1996,46) */ -uint64_t __tmp_in_tmp22; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp22; -} -Arr4DIdxRowM(tmp22, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp22 : 0; -} -} -} -} - -uint64_t* tmp23 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp23 at (1999,1-1999,35) */ -uint64_t __tmp_in_tmp23; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp23; -} -Arr1DIdxRowM(tmp23, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp23 : 0; -} - -uint64_t* tmp24 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp24 at (2002,1-2002,35) */ -uint64_t __tmp_in_tmp24; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp24; -} -Arr1DIdxRowM(tmp24, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp24 : 0; -} - -uint64_t* tmp25 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp25 at (2005,1-2005,35) */ -uint64_t __tmp_in_tmp25; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp25; -} -Arr1DIdxRowM(tmp25, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp25 : 0; -} - -uint64_t* tmp26 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp26 at (2008,1-2008,35) */ -uint64_t __tmp_in_tmp26; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp26; -} -Arr1DIdxRowM(tmp26, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp26 : 0; -} - -uint64_t* tmp27 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp27 at (2011,1-2011,45) */ -uint64_t __tmp_in_tmp27; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp27; -} -Arr4DIdxRowM(tmp27, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp27 : 0; -} -} -} -} - -uint64_t* tmp28 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp28 at (2014,1-2014,35) */ -uint64_t __tmp_in_tmp28; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp28; -} -Arr1DIdxRowM(tmp28, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp28 : 0; -} - -uint64_t* tmp29 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp29 at (2017,1-2017,35) */ -uint64_t __tmp_in_tmp29; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp29; -} -Arr1DIdxRowM(tmp29, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp29 : 0; -} - -uint64_t* tmp30 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp30 at (2020,1-2020,35) */ -uint64_t __tmp_in_tmp30; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp30; -} -Arr1DIdxRowM(tmp30, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp30 : 0; -} - -uint64_t* tmp31 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp31 at (2023,1-2023,35) */ -uint64_t __tmp_in_tmp31; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp31; -} -Arr1DIdxRowM(tmp31, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp31 : 0; -} - -uint64_t* tmp32 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp32 at (2026,1-2026,46) */ -uint64_t __tmp_in_tmp32; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp32; -} -Arr4DIdxRowM(tmp32, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp32 : 0; -} -} -} -} - -uint64_t* tmp33 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp33 at (2029,1-2029,36) */ -uint64_t __tmp_in_tmp33; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp33; -} -Arr1DIdxRowM(tmp33, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp33 : 0; -} - -uint64_t* tmp34 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp34 at (2032,1-2032,36) */ -uint64_t __tmp_in_tmp34; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp34; -} -Arr1DIdxRowM(tmp34, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp34 : 0; -} - -uint64_t* tmp35 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp35 at (2035,1-2035,36) */ -uint64_t __tmp_in_tmp35; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp35; -} -Arr1DIdxRowM(tmp35, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp35 : 0; -} - -uint64_t* tmp36 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp36 at (2038,1-2038,36) */ -uint64_t __tmp_in_tmp36; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp36; -} -Arr1DIdxRowM(tmp36, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp36 : 0; -} - -uint64_t* tmp37 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp37 at (2041,1-2041,46) */ -uint64_t __tmp_in_tmp37; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp37; -} -Arr4DIdxRowM(tmp37, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp37 : 0; -} -} -} -} - -uint64_t* tmp38 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp38 at (2044,1-2044,35) */ -uint64_t __tmp_in_tmp38; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp38; -} -Arr1DIdxRowM(tmp38, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp38 : 0; -} - -uint64_t* tmp39 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp39 at (2047,1-2047,35) */ -uint64_t __tmp_in_tmp39; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp39; -} -Arr1DIdxRowM(tmp39, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp39 : 0; -} - -uint64_t* tmp40 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp40 at (2050,1-2050,35) */ -uint64_t __tmp_in_tmp40; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp40; -} -Arr1DIdxRowM(tmp40, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp40 : 0; -} - -uint64_t* tmp41 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp41 at (2053,1-2053,35) */ -uint64_t __tmp_in_tmp41; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp41; -} -Arr1DIdxRowM(tmp41, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp41 : 0; -} - -uint64_t* tmp42 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp42 at (2056,1-2056,45) */ -uint64_t __tmp_in_tmp42; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp42; -} -Arr4DIdxRowM(tmp42, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp42 : 0; -} -} -} -} - -uint64_t* tmp43 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp43 at (2059,1-2059,35) */ -uint64_t __tmp_in_tmp43; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp43; -} -Arr1DIdxRowM(tmp43, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp43 : 0; -} - -uint64_t* tmp44 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp44 at (2062,1-2062,35) */ -uint64_t __tmp_in_tmp44; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp44; -} -Arr1DIdxRowM(tmp44, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp44 : 0; -} - -uint64_t* tmp45 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp45 at (2065,1-2065,35) */ -uint64_t __tmp_in_tmp45; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp45; -} -Arr1DIdxRowM(tmp45, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp45 : 0; -} - -uint64_t* tmp46 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp46 at (2068,1-2068,35) */ -uint64_t __tmp_in_tmp46; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp46; -} -Arr1DIdxRowM(tmp46, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp46 : 0; -} - -uint64_t* tmp47 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp47 at (2071,1-2071,46) */ -uint64_t __tmp_in_tmp47; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp47; -} -Arr4DIdxRowM(tmp47, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp47 : 0; -} -} -} -} - -uint64_t* tmp48 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp48 at (2074,1-2074,36) */ -uint64_t __tmp_in_tmp48; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp48; -} -Arr1DIdxRowM(tmp48, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp48 : 0; -} - -uint64_t* tmp49 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp49 at (2077,1-2077,36) */ -uint64_t __tmp_in_tmp49; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp49; -} -Arr1DIdxRowM(tmp49, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp49 : 0; -} - -uint64_t* tmp50 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp50 at (2080,1-2080,36) */ -uint64_t __tmp_in_tmp50; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp50; -} -Arr1DIdxRowM(tmp50, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp50 : 0; -} - -uint64_t* tmp51 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp51 at (2083,1-2083,36) */ -uint64_t __tmp_in_tmp51; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp51; -} -Arr1DIdxRowM(tmp51, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp51 : 0; -} - -uint64_t* tmp52 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp52 at (2086,1-2086,47) */ -uint64_t __tmp_in_tmp52; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp52; -} -Arr4DIdxRowM(tmp52, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp52 : 0; -} -} -} -} - -uint64_t* tmp53 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp53 at (2089,1-2089,47) */ -uint64_t __tmp_in_tmp53; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp53; -} -Arr4DIdxRowM(tmp53, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp53 : 0; -} -} -} -} - -uint64_t* tmp54 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp54 at (2092,1-2092,36) */ -uint64_t __tmp_in_tmp54; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp54; -} -Arr1DIdxRowM(tmp54, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp54 : 0; -} - -uint64_t* tmp55 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp55 at (2095,1-2095,36) */ -uint64_t __tmp_in_tmp55; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp55; -} -Arr1DIdxRowM(tmp55, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp55 : 0; -} - -uint64_t* tmp56 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp56 at (2098,1-2098,36) */ -uint64_t __tmp_in_tmp56; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp56; -} -Arr1DIdxRowM(tmp56, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp56 : 0; -} - -uint64_t* tmp57 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp57 at (2101,1-2101,36) */ -uint64_t __tmp_in_tmp57; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp57; -} -Arr1DIdxRowM(tmp57, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp57 : 0; -} - -uint64_t* tmp58 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp58 at (2104,1-2104,47) */ -uint64_t __tmp_in_tmp58; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp58; -} -Arr4DIdxRowM(tmp58, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp58 : 0; -} -} -} -} - -uint64_t* tmp59 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp59 at (2107,1-2107,36) */ -uint64_t __tmp_in_tmp59; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp59; -} -Arr1DIdxRowM(tmp59, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp59 : 0; -} - -uint64_t* tmp60 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp60 at (2110,1-2110,36) */ -uint64_t __tmp_in_tmp60; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp60; -} -Arr1DIdxRowM(tmp60, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp60 : 0; -} - -uint64_t* tmp61 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp61 at (2113,1-2113,36) */ -uint64_t __tmp_in_tmp61; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp61; -} -Arr1DIdxRowM(tmp61, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp61 : 0; -} - -uint64_t* tmp62 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp62 at (2116,1-2116,36) */ -uint64_t __tmp_in_tmp62; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp62; -} -Arr1DIdxRowM(tmp62, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp62 : 0; -} - -uint64_t* tmp63 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp63 at (2119,1-2119,47) */ -uint64_t __tmp_in_tmp63; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp63; -} -Arr4DIdxRowM(tmp63, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp63 : 0; -} -} -} -} - -uint64_t* tmp64 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp64 at (2122,1-2122,36) */ -uint64_t __tmp_in_tmp64; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp64; -} -Arr1DIdxRowM(tmp64, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp64 : 0; -} - -uint64_t* tmp65 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp65 at (2125,1-2125,36) */ -uint64_t __tmp_in_tmp65; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp65; -} -Arr1DIdxRowM(tmp65, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp65 : 0; -} - -uint64_t* tmp66 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp66 at (2128,1-2128,36) */ -uint64_t __tmp_in_tmp66; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp66; -} -Arr1DIdxRowM(tmp66, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp66 : 0; -} - -uint64_t* tmp67 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp67 at (2131,1-2131,36) */ -uint64_t __tmp_in_tmp67; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp67; -} -Arr1DIdxRowM(tmp67, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp67 : 0; -} - -uint64_t* tmp68 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp68 at (2134,1-2134,47) */ -uint64_t __tmp_in_tmp68; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp68; -} -Arr4DIdxRowM(tmp68, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp68 : 0; -} -} -} -} - -uint64_t* tmp69 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp69 at (2137,1-2137,36) */ -uint64_t __tmp_in_tmp69; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp69; -} -Arr1DIdxRowM(tmp69, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp69 : 0; -} - -uint64_t* tmp70 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp70 at (2140,1-2140,36) */ -uint64_t __tmp_in_tmp70; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp70; -} -Arr1DIdxRowM(tmp70, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp70 : 0; -} - -uint64_t* tmp71 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp71 at (2143,1-2143,36) */ -uint64_t __tmp_in_tmp71; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp71; -} -Arr1DIdxRowM(tmp71, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp71 : 0; -} - -uint64_t* tmp72 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp72 at (2146,1-2146,36) */ -uint64_t __tmp_in_tmp72; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp72; -} -Arr1DIdxRowM(tmp72, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp72 : 0; -} - -uint64_t* tmp73 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp73 at (2149,1-2149,47) */ -uint64_t __tmp_in_tmp73; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp73; -} -Arr4DIdxRowM(tmp73, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp73 : 0; -} -} -} -} - -uint64_t* tmp74 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp74 at (2152,1-2152,36) */ -uint64_t __tmp_in_tmp74; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp74; -} -Arr1DIdxRowM(tmp74, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp74 : 0; -} - -uint64_t* tmp75 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp75 at (2155,1-2155,36) */ -uint64_t __tmp_in_tmp75; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp75; -} -Arr1DIdxRowM(tmp75, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp75 : 0; -} - -uint64_t* tmp76 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp76 at (2158,1-2158,36) */ -uint64_t __tmp_in_tmp76; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp76; -} -Arr1DIdxRowM(tmp76, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp76 : 0; -} - -uint64_t* tmp77 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp77 at (2161,1-2161,36) */ -uint64_t __tmp_in_tmp77; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp77; -} -Arr1DIdxRowM(tmp77, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp77 : 0; -} - -uint64_t* tmp78 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp78 at (2164,1-2164,47) */ -uint64_t __tmp_in_tmp78; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp78; -} -Arr4DIdxRowM(tmp78, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp78 : 0; -} -} -} -} - -uint64_t* tmp79 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp79 at (2167,1-2167,36) */ -uint64_t __tmp_in_tmp79; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp79; -} -Arr1DIdxRowM(tmp79, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp79 : 0; -} - -uint64_t* tmp80 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp80 at (2170,1-2170,36) */ -uint64_t __tmp_in_tmp80; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp80; -} -Arr1DIdxRowM(tmp80, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp80 : 0; -} - -uint64_t* tmp81 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp81 at (2173,1-2173,36) */ -uint64_t __tmp_in_tmp81; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp81; -} -Arr1DIdxRowM(tmp81, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp81 : 0; -} - -uint64_t* tmp82 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp82 at (2176,1-2176,36) */ -uint64_t __tmp_in_tmp82; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp82; -} -Arr1DIdxRowM(tmp82, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp82 : 0; -} - -uint64_t* tmp83 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp83 at (2179,1-2179,47) */ -uint64_t __tmp_in_tmp83; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp83; -} -Arr4DIdxRowM(tmp83, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp83 : 0; -} -} -} -} - -uint64_t* tmp84 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp84 at (2182,1-2182,36) */ -uint64_t __tmp_in_tmp84; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp84; -} -Arr1DIdxRowM(tmp84, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp84 : 0; -} - -uint64_t* tmp85 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp85 at (2185,1-2185,36) */ -uint64_t __tmp_in_tmp85; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp85; -} -Arr1DIdxRowM(tmp85, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp85 : 0; -} - -uint64_t* tmp86 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp86 at (2188,1-2188,36) */ -uint64_t __tmp_in_tmp86; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp86; -} -Arr1DIdxRowM(tmp86, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp86 : 0; -} - -uint64_t* tmp87 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp87 at (2191,1-2191,36) */ -uint64_t __tmp_in_tmp87; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp87; -} -Arr1DIdxRowM(tmp87, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp87 : 0; -} - -uint64_t* tmp88 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp88 at (2194,1-2194,47) */ -uint64_t __tmp_in_tmp88; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp88; -} -Arr4DIdxRowM(tmp88, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp88 : 0; -} -} -} -} - -uint64_t* tmp89 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp89 at (2197,1-2197,36) */ -uint64_t __tmp_in_tmp89; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp89; -} -Arr1DIdxRowM(tmp89, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp89 : 0; -} - -uint64_t* tmp90 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp90 at (2200,1-2200,36) */ -uint64_t __tmp_in_tmp90; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp90; -} -Arr1DIdxRowM(tmp90, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp90 : 0; -} - -uint64_t* tmp91 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp91 at (2203,1-2203,36) */ -uint64_t __tmp_in_tmp91; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp91; -} -Arr1DIdxRowM(tmp91, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp91 : 0; -} - -uint64_t* tmp92 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp92 at (2206,1-2206,36) */ -uint64_t __tmp_in_tmp92; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp92; -} -Arr1DIdxRowM(tmp92, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp92 : 0; -} - -uint64_t* tmp93 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp93 at (2209,1-2209,47) */ -uint64_t __tmp_in_tmp93; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp93; -} -Arr4DIdxRowM(tmp93, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp93 : 0; -} -} -} -} - -uint64_t* tmp94 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp94 at (2212,1-2212,36) */ -uint64_t __tmp_in_tmp94; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp94; -} -Arr1DIdxRowM(tmp94, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp94 : 0; -} - -uint64_t* tmp95 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp95 at (2215,1-2215,36) */ -uint64_t __tmp_in_tmp95; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp95; -} -Arr1DIdxRowM(tmp95, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp95 : 0; -} - -uint64_t* tmp96 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp96 at (2218,1-2218,36) */ -uint64_t __tmp_in_tmp96; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp96; -} -Arr1DIdxRowM(tmp96, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp96 : 0; -} - -uint64_t* tmp97 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp97 at (2221,1-2221,36) */ -uint64_t __tmp_in_tmp97; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp97; -} -Arr1DIdxRowM(tmp97, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp97 : 0; -} - -uint64_t* tmp98 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp98 at (2224,1-2224,47) */ -uint64_t __tmp_in_tmp98; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp98; -} -Arr4DIdxRowM(tmp98, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp98 : 0; -} -} -} -} - -uint64_t* tmp99 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp99 at (2227,1-2227,36) */ -uint64_t __tmp_in_tmp99; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp99; -} -Arr1DIdxRowM(tmp99, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp99 : 0; -} - -uint64_t* tmp100 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp100 at (2230,1-2230,37) */ -uint64_t __tmp_in_tmp100; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp100; -} -Arr1DIdxRowM(tmp100, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp100 : 0; -} - -uint64_t* tmp101 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp101 at (2233,1-2233,37) */ -uint64_t __tmp_in_tmp101; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp101; -} -Arr1DIdxRowM(tmp101, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp101 : 0; -} - -uint64_t* tmp102 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp102 at (2236,1-2236,37) */ -uint64_t __tmp_in_tmp102; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp102; -} -Arr1DIdxRowM(tmp102, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp102 : 0; -} - -uint64_t* tmp103 = make_array( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp103 at (2239,1-2239,48) */ -uint64_t __tmp_in_tmp103; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp103; -} -Arr4DIdxRowM(tmp103, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp103 : 0; -} -} -} -} - -uint64_t* tmp104 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp104 at (2242,1-2242,37) */ -uint64_t __tmp_in_tmp104; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp104; -} -Arr1DIdxRowM(tmp104, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp104 : 0; -} - -uint64_t* tmp105 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp105 at (2245,1-2245,37) */ -uint64_t __tmp_in_tmp105; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp105; -} -Arr1DIdxRowM(tmp105, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp105 : 0; -} - -uint64_t* tmp106 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp106 at (2248,1-2248,37) */ -uint64_t __tmp_in_tmp106; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp106; -} -Arr1DIdxRowM(tmp106, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp106 : 0; -} - -uint64_t* tmp107 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp107 at (2251,1-2251,37) */ -uint64_t __tmp_in_tmp107; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp107; -} -Arr1DIdxRowM(tmp107, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp107 : 0; -} - -uint64_t* tmp108 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp108 at (2254,1-2254,48) */ -uint64_t __tmp_in_tmp108; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp108; -} -Arr4DIdxRowM(tmp108, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp108 : 0; -} -} -} -} - -uint64_t* tmp109 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp109 at (2257,1-2257,37) */ -uint64_t __tmp_in_tmp109; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp109; -} -Arr1DIdxRowM(tmp109, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp109 : 0; -} - -uint64_t* tmp110 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp110 at (2260,1-2260,37) */ -uint64_t __tmp_in_tmp110; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp110; -} -Arr1DIdxRowM(tmp110, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp110 : 0; -} - -uint64_t* tmp111 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp111 at (2263,1-2263,37) */ -uint64_t __tmp_in_tmp111; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp111; -} -Arr1DIdxRowM(tmp111, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp111 : 0; -} - -uint64_t* tmp112 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp112 at (2266,1-2266,37) */ -uint64_t __tmp_in_tmp112; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp112; -} -Arr1DIdxRowM(tmp112, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp112 : 0; -} - -uint64_t* tmp113 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp113 at (2269,1-2269,49) */ -uint64_t __tmp_in_tmp113; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp113; -} -Arr4DIdxRowM(tmp113, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp113 : 0; -} -} -} -} - -uint64_t* tmp114 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp114 at (2272,1-2272,48) */ -uint64_t __tmp_in_tmp114; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp114; -} -Arr4DIdxRowM(tmp114, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp114 : 0; -} -} -} -} - -uint64_t* tmp115 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp115 at (2275,1-2275,37) */ -uint64_t __tmp_in_tmp115; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp115; -} -Arr1DIdxRowM(tmp115, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp115 : 0; -} - -uint64_t* tmp116 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp116 at (2278,1-2278,37) */ -uint64_t __tmp_in_tmp116; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp116; -} -Arr1DIdxRowM(tmp116, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp116 : 0; -} - -uint64_t* tmp117 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp117 at (2281,1-2281,37) */ -uint64_t __tmp_in_tmp117; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp117; -} -Arr1DIdxRowM(tmp117, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp117 : 0; -} - -uint64_t* tmp118 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp118 at (2284,1-2284,37) */ -uint64_t __tmp_in_tmp118; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp118; -} -Arr1DIdxRowM(tmp118, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp118 : 0; -} - -uint64_t* tmp119 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp119 at (2287,1-2287,48) */ -uint64_t __tmp_in_tmp119; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp119; -} -Arr4DIdxRowM(tmp119, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp119 : 0; -} -} -} -} - -uint64_t* tmp120 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp120 at (2290,1-2290,37) */ -uint64_t __tmp_in_tmp120; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp120; -} -Arr1DIdxRowM(tmp120, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp120 : 0; -} - -uint64_t* tmp121 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp121 at (2293,1-2293,37) */ -uint64_t __tmp_in_tmp121; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp121; -} -Arr1DIdxRowM(tmp121, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp121 : 0; -} - -uint64_t* tmp122 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp122 at (2296,1-2296,37) */ -uint64_t __tmp_in_tmp122; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp122; -} -Arr1DIdxRowM(tmp122, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp122 : 0; -} - -uint64_t* tmp123 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp123 at (2299,1-2299,37) */ -uint64_t __tmp_in_tmp123; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp123; -} -Arr1DIdxRowM(tmp123, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp123 : 0; -} - -uint64_t* tmp124 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp124 at (2302,1-2302,49) */ -uint64_t __tmp_in_tmp124; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp124; -} -Arr4DIdxRowM(tmp124, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp124 : 0; -} -} -} -} - -uint64_t* tmp125 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp125 at (2305,1-2305,38) */ -uint64_t __tmp_in_tmp125; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp125; -} -Arr1DIdxRowM(tmp125, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp125 : 0; -} - -uint64_t* tmp126 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp126 at (2308,1-2308,38) */ -uint64_t __tmp_in_tmp126; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp126; -} -Arr1DIdxRowM(tmp126, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp126 : 0; -} - -uint64_t* tmp127 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp127 at (2311,1-2311,38) */ -uint64_t __tmp_in_tmp127; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp127; -} -Arr1DIdxRowM(tmp127, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp127 : 0; -} - -uint64_t* tmp128 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp128 at (2314,1-2314,38) */ -uint64_t __tmp_in_tmp128; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp128; -} -Arr1DIdxRowM(tmp128, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp128 : 0; -} - -uint64_t* tmp129 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp129 at (2317,1-2317,49) */ -uint64_t __tmp_in_tmp129; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1024; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp129; -} -Arr4DIdxRowM(tmp129, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp129 : 0; -} -} -} -} - -uint64_t* tmp130 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp130 at (2320,1-2320,37) */ -uint64_t __tmp_in_tmp130; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp130; -} -Arr1DIdxRowM(tmp130, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp130 : 0; -} - -uint64_t* tmp131 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp131 at (2323,1-2323,37) */ -uint64_t __tmp_in_tmp131; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp131; -} -Arr1DIdxRowM(tmp131, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp131 : 0; -} - -uint64_t* tmp132 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp132 at (2326,1-2326,37) */ -uint64_t __tmp_in_tmp132; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp132; -} -Arr1DIdxRowM(tmp132, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp132 : 0; -} - -uint64_t* tmp133 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp133 at (2329,1-2329,37) */ -uint64_t __tmp_in_tmp133; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp133; -} -Arr1DIdxRowM(tmp133, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp133 : 0; -} - -uint64_t* tmp134 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp134 at (2332,1-2332,48) */ -uint64_t __tmp_in_tmp134; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp134; -} -Arr4DIdxRowM(tmp134, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp134 : 0; -} -} -} -} - -uint64_t* tmp135 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp135 at (2335,1-2335,37) */ -uint64_t __tmp_in_tmp135; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp135; -} -Arr1DIdxRowM(tmp135, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp135 : 0; -} - -uint64_t* tmp136 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp136 at (2338,1-2338,37) */ -uint64_t __tmp_in_tmp136; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp136; -} -Arr1DIdxRowM(tmp136, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp136 : 0; -} - -uint64_t* tmp137 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp137 at (2341,1-2341,37) */ -uint64_t __tmp_in_tmp137; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp137; -} -Arr1DIdxRowM(tmp137, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp137 : 0; -} - -uint64_t* tmp138 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp138 at (2344,1-2344,37) */ -uint64_t __tmp_in_tmp138; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp138; -} -Arr1DIdxRowM(tmp138, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp138 : 0; -} - -uint64_t* tmp139 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp139 at (2347,1-2347,49) */ -uint64_t __tmp_in_tmp139; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp139; -} -Arr4DIdxRowM(tmp139, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp139 : 0; -} -} -} -} - -uint64_t* tmp140 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp140 at (2350,1-2350,38) */ -uint64_t __tmp_in_tmp140; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp140; -} -Arr1DIdxRowM(tmp140, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp140 : 0; -} - -uint64_t* tmp141 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp141 at (2353,1-2353,38) */ -uint64_t __tmp_in_tmp141; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp141; -} -Arr1DIdxRowM(tmp141, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp141 : 0; -} - -uint64_t* tmp142 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp142 at (2356,1-2356,38) */ -uint64_t __tmp_in_tmp142; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp142; -} -Arr1DIdxRowM(tmp142, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp142 : 0; -} - -uint64_t* tmp143 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp143 at (2359,1-2359,38) */ -uint64_t __tmp_in_tmp143; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp143; -} -Arr1DIdxRowM(tmp143, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp143 : 0; -} - -uint64_t* tmp144 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp144 at (2362,1-2362,49) */ -uint64_t __tmp_in_tmp144; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1024; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp144; -} -Arr4DIdxRowM(tmp144, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp144 : 0; -} -} -} -} - -uint64_t* tmp145 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp145 at (2365,1-2365,37) */ -uint64_t __tmp_in_tmp145; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp145; -} -Arr1DIdxRowM(tmp145, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp145 : 0; -} - -uint64_t* tmp146 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp146 at (2368,1-2368,37) */ -uint64_t __tmp_in_tmp146; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp146; -} -Arr1DIdxRowM(tmp146, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp146 : 0; -} - -uint64_t* tmp147 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp147 at (2371,1-2371,37) */ -uint64_t __tmp_in_tmp147; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp147; -} -Arr1DIdxRowM(tmp147, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp147 : 0; -} - -uint64_t* tmp148 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp148 at (2374,1-2374,37) */ -uint64_t __tmp_in_tmp148; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp148; -} -Arr1DIdxRowM(tmp148, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp148 : 0; -} - -uint64_t* tmp149 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp149 at (2377,1-2377,48) */ -uint64_t __tmp_in_tmp149; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp149; -} -Arr4DIdxRowM(tmp149, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp149 : 0; -} -} -} -} - -uint64_t* tmp150 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp150 at (2380,1-2380,37) */ -uint64_t __tmp_in_tmp150; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp150; -} -Arr1DIdxRowM(tmp150, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp150 : 0; -} - -uint64_t* tmp151 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp151 at (2383,1-2383,37) */ -uint64_t __tmp_in_tmp151; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp151; -} -Arr1DIdxRowM(tmp151, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp151 : 0; -} - -uint64_t* tmp152 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp152 at (2386,1-2386,37) */ -uint64_t __tmp_in_tmp152; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp152; -} -Arr1DIdxRowM(tmp152, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp152 : 0; -} - -uint64_t* tmp153 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp153 at (2389,1-2389,37) */ -uint64_t __tmp_in_tmp153; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp153; -} -Arr1DIdxRowM(tmp153, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp153 : 0; -} - -uint64_t* tmp154 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp154 at (2392,1-2392,49) */ -uint64_t __tmp_in_tmp154; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp154; -} -Arr4DIdxRowM(tmp154, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp154 : 0; -} -} -} -} - -uint64_t* tmp155 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp155 at (2395,1-2395,38) */ -uint64_t __tmp_in_tmp155; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp155; -} -Arr1DIdxRowM(tmp155, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp155 : 0; -} - -uint64_t* tmp156 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp156 at (2398,1-2398,38) */ -uint64_t __tmp_in_tmp156; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp156; -} -Arr1DIdxRowM(tmp156, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp156 : 0; -} - -uint64_t* tmp157 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp157 at (2401,1-2401,38) */ -uint64_t __tmp_in_tmp157; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp157; -} -Arr1DIdxRowM(tmp157, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp157 : 0; -} - -uint64_t* tmp158 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp158 at (2404,1-2404,38) */ -uint64_t __tmp_in_tmp158; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp158; -} -Arr1DIdxRowM(tmp158, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp158 : 0; -} - -uint64_t* tmp159 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp159 at (2407,1-2407,49) */ -uint64_t __tmp_in_tmp159; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1024; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp159; -} -Arr4DIdxRowM(tmp159, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp159 : 0; -} -} -} -} - -uint64_t* tmp160 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp160 at (2410,1-2410,37) */ -uint64_t __tmp_in_tmp160; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp160; -} -Arr1DIdxRowM(tmp160, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp160 : 0; -} - -uint64_t* tmp161 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp161 at (2413,1-2413,37) */ -uint64_t __tmp_in_tmp161; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp161; -} -Arr1DIdxRowM(tmp161, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp161 : 0; -} - -uint64_t* tmp162 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp162 at (2416,1-2416,37) */ -uint64_t __tmp_in_tmp162; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp162; -} -Arr1DIdxRowM(tmp162, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp162 : 0; -} - -uint64_t* tmp163 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp163 at (2419,1-2419,37) */ -uint64_t __tmp_in_tmp163; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp163; -} -Arr1DIdxRowM(tmp163, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp163 : 0; -} - -uint64_t* tmp164 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp164 at (2422,1-2422,48) */ -uint64_t __tmp_in_tmp164; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp164; -} -Arr4DIdxRowM(tmp164, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp164 : 0; -} -} -} -} - -uint64_t* tmp165 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp165 at (2425,1-2425,37) */ -uint64_t __tmp_in_tmp165; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp165; -} -Arr1DIdxRowM(tmp165, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp165 : 0; -} - -uint64_t* tmp166 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp166 at (2428,1-2428,37) */ -uint64_t __tmp_in_tmp166; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp166; -} -Arr1DIdxRowM(tmp166, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp166 : 0; -} - -uint64_t* tmp167 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp167 at (2431,1-2431,37) */ -uint64_t __tmp_in_tmp167; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp167; -} -Arr1DIdxRowM(tmp167, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp167 : 0; -} - -uint64_t* tmp168 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp168 at (2434,1-2434,37) */ -uint64_t __tmp_in_tmp168; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp168; -} -Arr1DIdxRowM(tmp168, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp168 : 0; -} - -uint64_t* tmp169 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp169 at (2437,1-2437,49) */ -uint64_t __tmp_in_tmp169; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp169; -} -Arr4DIdxRowM(tmp169, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp169 : 0; -} -} -} -} - -uint64_t* tmp170 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp170 at (2440,1-2440,38) */ -uint64_t __tmp_in_tmp170; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp170; -} -Arr1DIdxRowM(tmp170, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp170 : 0; -} - -uint64_t* tmp171 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp171 at (2443,1-2443,38) */ -uint64_t __tmp_in_tmp171; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp171; -} -Arr1DIdxRowM(tmp171, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp171 : 0; -} - -uint64_t* tmp172 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp172 at (2446,1-2446,38) */ -uint64_t __tmp_in_tmp172; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp172; -} -Arr1DIdxRowM(tmp172, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp172 : 0; -} - -uint64_t* tmp173 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp173 at (2449,1-2449,38) */ -uint64_t __tmp_in_tmp173; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp173; -} -Arr1DIdxRowM(tmp173, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp173 : 0; -} - -uint64_t* tmp174 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp174 at (2452,1-2452,49) */ -uint64_t __tmp_in_tmp174; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1024; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp174; -} -Arr4DIdxRowM(tmp174, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp174 : 0; -} -} -} -} - -uint64_t* tmp175 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp175 at (2455,1-2455,37) */ -uint64_t __tmp_in_tmp175; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp175; -} -Arr1DIdxRowM(tmp175, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp175 : 0; -} - -uint64_t* tmp176 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp176 at (2458,1-2458,37) */ -uint64_t __tmp_in_tmp176; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp176; -} -Arr1DIdxRowM(tmp176, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp176 : 0; -} - -uint64_t* tmp177 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp177 at (2461,1-2461,37) */ -uint64_t __tmp_in_tmp177; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp177; -} -Arr1DIdxRowM(tmp177, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp177 : 0; -} - -uint64_t* tmp178 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp178 at (2464,1-2464,37) */ -uint64_t __tmp_in_tmp178; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp178; -} -Arr1DIdxRowM(tmp178, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp178 : 0; -} - -uint64_t* tmp179 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp179 at (2467,1-2467,48) */ -uint64_t __tmp_in_tmp179; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp179; -} -Arr4DIdxRowM(tmp179, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp179 : 0; -} -} -} -} - -uint64_t* tmp180 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp180 at (2470,1-2470,37) */ -uint64_t __tmp_in_tmp180; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp180; -} -Arr1DIdxRowM(tmp180, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp180 : 0; -} - -uint64_t* tmp181 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp181 at (2473,1-2473,37) */ -uint64_t __tmp_in_tmp181; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp181; -} -Arr1DIdxRowM(tmp181, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp181 : 0; -} - -uint64_t* tmp182 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp182 at (2476,1-2476,37) */ -uint64_t __tmp_in_tmp182; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp182; -} -Arr1DIdxRowM(tmp182, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp182 : 0; -} - -uint64_t* tmp183 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp183 at (2479,1-2479,37) */ -uint64_t __tmp_in_tmp183; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp183; -} -Arr1DIdxRowM(tmp183, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp183 : 0; -} - -uint64_t* tmp184 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp184 at (2482,1-2482,49) */ -uint64_t __tmp_in_tmp184; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp184; -} -Arr4DIdxRowM(tmp184, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp184 : 0; -} -} -} -} - -uint64_t* tmp185 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp185 at (2485,1-2485,38) */ -uint64_t __tmp_in_tmp185; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp185; -} -Arr1DIdxRowM(tmp185, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp185 : 0; -} - -uint64_t* tmp186 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp186 at (2488,1-2488,38) */ -uint64_t __tmp_in_tmp186; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp186; -} -Arr1DIdxRowM(tmp186, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp186 : 0; -} - -uint64_t* tmp187 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp187 at (2491,1-2491,38) */ -uint64_t __tmp_in_tmp187; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp187; -} -Arr1DIdxRowM(tmp187, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp187 : 0; -} - -uint64_t* tmp188 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp188 at (2494,1-2494,38) */ -uint64_t __tmp_in_tmp188; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp188; -} -Arr1DIdxRowM(tmp188, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp188 : 0; -} - -uint64_t* tmp189 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp189 at (2497,1-2497,49) */ -uint64_t __tmp_in_tmp189; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1024; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp189; -} -Arr4DIdxRowM(tmp189, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp189 : 0; -} -} -} -} - -uint64_t* tmp190 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp190 at (2500,1-2500,37) */ -uint64_t __tmp_in_tmp190; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp190; -} -Arr1DIdxRowM(tmp190, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp190 : 0; -} - -uint64_t* tmp191 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp191 at (2503,1-2503,37) */ -uint64_t __tmp_in_tmp191; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp191; -} -Arr1DIdxRowM(tmp191, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp191 : 0; -} - -uint64_t* tmp192 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp192 at (2506,1-2506,37) */ -uint64_t __tmp_in_tmp192; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp192; -} -Arr1DIdxRowM(tmp192, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp192 : 0; -} - -uint64_t* tmp193 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp193 at (2509,1-2509,37) */ -uint64_t __tmp_in_tmp193; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp193; -} -Arr1DIdxRowM(tmp193, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp193 : 0; -} - -uint64_t* tmp194 = make_array( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp194 at (2512,1-2512,48) */ -uint64_t __tmp_in_tmp194; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp194; -} -Arr4DIdxRowM(tmp194, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp194 : 0; -} -} -} -} - -uint64_t* tmp195 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp195 at (2515,1-2515,37) */ -uint64_t __tmp_in_tmp195; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp195; -} -Arr1DIdxRowM(tmp195, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp195 : 0; -} - -uint64_t* tmp196 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp196 at (2518,1-2518,37) */ -uint64_t __tmp_in_tmp196; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp196; -} -Arr1DIdxRowM(tmp196, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp196 : 0; -} - -uint64_t* tmp197 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp197 at (2521,1-2521,37) */ -uint64_t __tmp_in_tmp197; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp197; -} -Arr1DIdxRowM(tmp197, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp197 : 0; -} - -uint64_t* tmp198 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp198 at (2524,1-2524,37) */ -uint64_t __tmp_in_tmp198; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp198; -} -Arr1DIdxRowM(tmp198, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp198 : 0; -} - -uint64_t* tmp199 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp199 at (2527,1-2527,49) */ -uint64_t __tmp_in_tmp199; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)1024; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp199; -} -Arr4DIdxRowM(tmp199, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp199 : 0; -} -} -} -} - -uint64_t* tmp200 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp200 at (2530,1-2530,38) */ -uint64_t __tmp_in_tmp200; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp200; -} -Arr1DIdxRowM(tmp200, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp200 : 0; -} - -uint64_t* tmp201 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp201 at (2533,1-2533,38) */ -uint64_t __tmp_in_tmp201; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp201; -} -Arr1DIdxRowM(tmp201, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp201 : 0; -} - -uint64_t* tmp202 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp202 at (2536,1-2536,38) */ -uint64_t __tmp_in_tmp202; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp202; -} -Arr1DIdxRowM(tmp202, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp202 : 0; -} - -uint64_t* tmp203 = make_array( (int32_t)1024); -/* Variable to read the clear value corresponding to the input variable tmp203 at (2539,1-2539,38) */ -uint64_t __tmp_in_tmp203; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1024; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp203; -} -Arr1DIdxRowM(tmp203, (int32_t)1024,i0) = (party == SERVER) ? __tmp_in_tmp203 : 0; -} - -uint64_t* tmp204 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp204 at (2542,1-2542,50) */ -uint64_t __tmp_in_tmp204; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1024; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)2048; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp204; -} -Arr4DIdxRowM(tmp204, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)2048,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp204 : 0; -} -} -} -} - -uint64_t* tmp205 = make_array( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp205 at (2545,1-2545,49) */ -uint64_t __tmp_in_tmp205; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1024; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp205; -} -Arr4DIdxRowM(tmp205, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp205 : 0; -} -} -} -} - -uint64_t* tmp206 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp206 at (2548,1-2548,37) */ -uint64_t __tmp_in_tmp206; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp206; -} -Arr1DIdxRowM(tmp206, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp206 : 0; -} - -uint64_t* tmp207 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp207 at (2551,1-2551,37) */ -uint64_t __tmp_in_tmp207; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp207; -} -Arr1DIdxRowM(tmp207, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp207 : 0; -} - -uint64_t* tmp208 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp208 at (2554,1-2554,37) */ -uint64_t __tmp_in_tmp208; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp208; -} -Arr1DIdxRowM(tmp208, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp208 : 0; -} - -uint64_t* tmp209 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp209 at (2557,1-2557,37) */ -uint64_t __tmp_in_tmp209; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp209; -} -Arr1DIdxRowM(tmp209, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp209 : 0; -} - -uint64_t* tmp210 = make_array( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp210 at (2560,1-2560,48) */ -uint64_t __tmp_in_tmp210; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp210; -} -Arr4DIdxRowM(tmp210, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp210 : 0; -} -} -} -} - -uint64_t* tmp211 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp211 at (2563,1-2563,37) */ -uint64_t __tmp_in_tmp211; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp211; -} -Arr1DIdxRowM(tmp211, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp211 : 0; -} - -uint64_t* tmp212 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp212 at (2566,1-2566,37) */ -uint64_t __tmp_in_tmp212; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp212; -} -Arr1DIdxRowM(tmp212, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp212 : 0; -} - -uint64_t* tmp213 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp213 at (2569,1-2569,37) */ -uint64_t __tmp_in_tmp213; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp213; -} -Arr1DIdxRowM(tmp213, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp213 : 0; -} - -uint64_t* tmp214 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp214 at (2572,1-2572,37) */ -uint64_t __tmp_in_tmp214; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp214; -} -Arr1DIdxRowM(tmp214, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp214 : 0; -} - -uint64_t* tmp215 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp215 at (2575,1-2575,49) */ -uint64_t __tmp_in_tmp215; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)2048; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp215; -} -Arr4DIdxRowM(tmp215, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp215 : 0; -} -} -} -} - -uint64_t* tmp216 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp216 at (2578,1-2578,38) */ -uint64_t __tmp_in_tmp216; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp216; -} -Arr1DIdxRowM(tmp216, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp216 : 0; -} - -uint64_t* tmp217 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp217 at (2581,1-2581,38) */ -uint64_t __tmp_in_tmp217; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp217; -} -Arr1DIdxRowM(tmp217, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp217 : 0; -} - -uint64_t* tmp218 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp218 at (2584,1-2584,38) */ -uint64_t __tmp_in_tmp218; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp218; -} -Arr1DIdxRowM(tmp218, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp218 : 0; -} - -uint64_t* tmp219 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp219 at (2587,1-2587,38) */ -uint64_t __tmp_in_tmp219; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp219; -} -Arr1DIdxRowM(tmp219, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp219 : 0; -} - -uint64_t* tmp220 = make_array( (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp220 at (2590,1-2590,49) */ -uint64_t __tmp_in_tmp220; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)2048; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp220; -} -Arr4DIdxRowM(tmp220, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp220 : 0; -} -} -} -} - -uint64_t* tmp221 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp221 at (2593,1-2593,37) */ -uint64_t __tmp_in_tmp221; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp221; -} -Arr1DIdxRowM(tmp221, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp221 : 0; -} - -uint64_t* tmp222 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp222 at (2596,1-2596,37) */ -uint64_t __tmp_in_tmp222; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp222; -} -Arr1DIdxRowM(tmp222, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp222 : 0; -} - -uint64_t* tmp223 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp223 at (2599,1-2599,37) */ -uint64_t __tmp_in_tmp223; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp223; -} -Arr1DIdxRowM(tmp223, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp223 : 0; -} - -uint64_t* tmp224 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp224 at (2602,1-2602,37) */ -uint64_t __tmp_in_tmp224; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp224; -} -Arr1DIdxRowM(tmp224, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp224 : 0; -} - -uint64_t* tmp225 = make_array( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp225 at (2605,1-2605,48) */ -uint64_t __tmp_in_tmp225; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp225; -} -Arr4DIdxRowM(tmp225, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp225 : 0; -} -} -} -} - -uint64_t* tmp226 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp226 at (2608,1-2608,37) */ -uint64_t __tmp_in_tmp226; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp226; -} -Arr1DIdxRowM(tmp226, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp226 : 0; -} - -uint64_t* tmp227 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp227 at (2611,1-2611,37) */ -uint64_t __tmp_in_tmp227; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp227; -} -Arr1DIdxRowM(tmp227, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp227 : 0; -} - -uint64_t* tmp228 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp228 at (2614,1-2614,37) */ -uint64_t __tmp_in_tmp228; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp228; -} -Arr1DIdxRowM(tmp228, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp228 : 0; -} - -uint64_t* tmp229 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp229 at (2617,1-2617,37) */ -uint64_t __tmp_in_tmp229; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp229; -} -Arr1DIdxRowM(tmp229, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp229 : 0; -} - -uint64_t* tmp230 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp230 at (2620,1-2620,49) */ -uint64_t __tmp_in_tmp230; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)2048; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp230; -} -Arr4DIdxRowM(tmp230, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp230 : 0; -} -} -} -} - -uint64_t* tmp231 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp231 at (2623,1-2623,38) */ -uint64_t __tmp_in_tmp231; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp231; -} -Arr1DIdxRowM(tmp231, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp231 : 0; -} - -uint64_t* tmp232 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp232 at (2626,1-2626,38) */ -uint64_t __tmp_in_tmp232; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp232; -} -Arr1DIdxRowM(tmp232, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp232 : 0; -} - -uint64_t* tmp233 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp233 at (2629,1-2629,38) */ -uint64_t __tmp_in_tmp233; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp233; -} -Arr1DIdxRowM(tmp233, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp233 : 0; -} - -uint64_t* tmp234 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp234 at (2632,1-2632,38) */ -uint64_t __tmp_in_tmp234; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp234; -} -Arr1DIdxRowM(tmp234, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp234 : 0; -} - -uint64_t* tmp235 = make_array( (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp235 at (2635,1-2635,49) */ -uint64_t __tmp_in_tmp235; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)2048; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp235; -} -Arr4DIdxRowM(tmp235, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp235 : 0; -} -} -} -} - -uint64_t* tmp236 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp236 at (2638,1-2638,37) */ -uint64_t __tmp_in_tmp236; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp236; -} -Arr1DIdxRowM(tmp236, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp236 : 0; -} - -uint64_t* tmp237 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp237 at (2641,1-2641,37) */ -uint64_t __tmp_in_tmp237; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp237; -} -Arr1DIdxRowM(tmp237, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp237 : 0; -} - -uint64_t* tmp238 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp238 at (2644,1-2644,37) */ -uint64_t __tmp_in_tmp238; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp238; -} -Arr1DIdxRowM(tmp238, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp238 : 0; -} - -uint64_t* tmp239 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp239 at (2647,1-2647,37) */ -uint64_t __tmp_in_tmp239; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp239; -} -Arr1DIdxRowM(tmp239, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp239 : 0; -} - -uint64_t* tmp240 = make_array( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp240 at (2650,1-2650,48) */ -uint64_t __tmp_in_tmp240; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)512; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp240; -} -Arr4DIdxRowM(tmp240, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp240 : 0; -} -} -} -} - -uint64_t* tmp241 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp241 at (2653,1-2653,37) */ -uint64_t __tmp_in_tmp241; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp241; -} -Arr1DIdxRowM(tmp241, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp241 : 0; -} - -uint64_t* tmp242 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp242 at (2656,1-2656,37) */ -uint64_t __tmp_in_tmp242; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp242; -} -Arr1DIdxRowM(tmp242, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp242 : 0; -} - -uint64_t* tmp243 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp243 at (2659,1-2659,37) */ -uint64_t __tmp_in_tmp243; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp243; -} -Arr1DIdxRowM(tmp243, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp243 : 0; -} - -uint64_t* tmp244 = make_array( (int32_t)512); -/* Variable to read the clear value corresponding to the input variable tmp244 at (2662,1-2662,37) */ -uint64_t __tmp_in_tmp244; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)512; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp244; -} -Arr1DIdxRowM(tmp244, (int32_t)512,i0) = (party == SERVER) ? __tmp_in_tmp244 : 0; -} - -uint64_t* tmp245 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp245 at (2665,1-2665,49) */ -uint64_t __tmp_in_tmp245; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)2048; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp245; -} -Arr4DIdxRowM(tmp245, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp245 : 0; -} -} -} -} - -uint64_t* tmp246 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp246 at (2668,1-2668,38) */ -uint64_t __tmp_in_tmp246; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp246; -} -Arr1DIdxRowM(tmp246, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp246 : 0; -} - -uint64_t* tmp247 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp247 at (2671,1-2671,38) */ -uint64_t __tmp_in_tmp247; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp247; -} -Arr1DIdxRowM(tmp247, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp247 : 0; -} - -uint64_t* tmp248 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp248 at (2674,1-2674,38) */ -uint64_t __tmp_in_tmp248; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp248; -} -Arr1DIdxRowM(tmp248, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp248 : 0; -} - -uint64_t* tmp249 = make_array( (int32_t)2048); -/* Variable to read the clear value corresponding to the input variable tmp249 at (2677,1-2677,38) */ -uint64_t __tmp_in_tmp249; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp249; -} -Arr1DIdxRowM(tmp249, (int32_t)2048,i0) = (party == SERVER) ? __tmp_in_tmp249 : 0; -} - -uint64_t* tmp250 = make_array( (int32_t)2048, (int32_t)1001); -/* Variable to read the clear value corresponding to the input variable tmp250 at (2680,1-2680,44) */ -uint64_t __tmp_in_tmp250; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)2048; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1001; i1++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp250; -} -Arr2DIdxRowM(tmp250, (int32_t)2048, (int32_t)1001,i0,i1) = (party == SERVER) ? __tmp_in_tmp250 : 0; -} -} - -uint64_t* tmp251 = make_array( (int32_t)1001); -/* Variable to read the clear value corresponding to the input variable tmp251 at (2683,1-2683,38) */ -uint64_t __tmp_in_tmp251; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1001; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp251; -} -Arr1DIdxRowM(tmp251, (int32_t)1001,i0) = (party == SERVER) ? __tmp_in_tmp251 : 0; -} -StartComputation(); - -int32_t* tmp252 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)3; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)3; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)3; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)3; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp252, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp253 = make_array( (int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3); -Pad442( (int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3, (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, tmp0, (int32_t)4, (int32_t)2, tmp252, tmp253); -ClearMemSecret4( (int32_t)1, (int32_t)224, (int32_t)224, (int32_t)3, tmp0); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp252); - -uint64_t* tmp256 = make_array( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3, (int32_t)7, (int32_t)7, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp253, tmp1, tmp256); -ClearMemSecret4( (int32_t)7, (int32_t)7, (int32_t)3, (int32_t)64, tmp1); -ClearMemSecret4( (int32_t)1, (int32_t)230, (int32_t)230, (int32_t)3, tmp253); - -uint64_t* tmp259 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -MaxPool( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)1, (int32_t)0, (int32_t)1, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp256, tmp259); -ClearMemSecret4( (int32_t)1, (int32_t)112, (int32_t)112, (int32_t)64, tmp256); - -uint64_t* tmp261 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp259, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp259, tmp2, tmp3, (int32_t)0, (int32_t)12, tmp261); -ClearMemSecret1( (int32_t)64, tmp3); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp259); -ClearMemSecret1( (int32_t)64, tmp2); - -uint64_t* tmp265 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp261, tmp265, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp261); - -uint64_t* tmp267 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp265, tmp6, tmp267); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp6); - -uint64_t* tmp269 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp265, tmp7, tmp269); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)64, tmp7); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp265); - -uint64_t* tmp272 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp269, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp269, tmp8, tmp9, (int32_t)0, (int32_t)12, tmp272); -ClearMemSecret1( (int32_t)64, tmp8); -ClearMemSecret1( (int32_t)64, tmp9); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp269); - -uint64_t* tmp276 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp272, tmp276, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp272); - -uint64_t* tmp278 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp276, tmp12, tmp278); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp276); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp12); - -uint64_t* tmp281 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp278, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp278, tmp13, tmp14, (int32_t)0, (int32_t)12, tmp281); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp278); -ClearMemSecret1( (int32_t)64, tmp13); -ClearMemSecret1( (int32_t)64, tmp14); - -uint64_t* tmp285 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp281, tmp285, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp281); - -uint64_t* tmp287 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp285, tmp17, tmp287); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp285); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp17); - -uint64_t* tmp290 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -MatAdd4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp287, tmp267, tmp290); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp287); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp267); - -uint64_t* tmp293 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290, tmp18, tmp19, (int32_t)0, (int32_t)12, tmp293); -ClearMemSecret1( (int32_t)256, tmp19); -ClearMemSecret1( (int32_t)256, tmp18); - -uint64_t* tmp296 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp293, tmp296, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp293); - -uint64_t* tmp298 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp296, tmp22, tmp298); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64, tmp22); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp296); - -uint64_t* tmp301 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp298, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp298, tmp23, tmp24, (int32_t)0, (int32_t)12, tmp301); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp298); -ClearMemSecret1( (int32_t)64, tmp24); -ClearMemSecret1( (int32_t)64, tmp23); - -uint64_t* tmp305 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp301, tmp305, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp301); - -uint64_t* tmp307 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp305, tmp27, tmp307); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp305); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp27); - -uint64_t* tmp310 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp307, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp307, tmp28, tmp29, (int32_t)0, (int32_t)12, tmp310); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp307); -ClearMemSecret1( (int32_t)64, tmp28); -ClearMemSecret1( (int32_t)64, tmp29); - -uint64_t* tmp314 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp310, tmp314, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp310); - -uint64_t* tmp316 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp314, tmp32, tmp316); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp32); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp314); - -uint64_t* tmp319 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleUp4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp316, tmp290, tmp319); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp316); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp290); - -uint64_t* tmp322 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319, tmp33, tmp34, (int32_t)0, (int32_t)12, tmp322); -ClearMemSecret1( (int32_t)256, tmp34); -ClearMemSecret1( (int32_t)256, tmp33); - -uint64_t* tmp325 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp322, tmp325, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp322); - -uint64_t* tmp327 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp325, tmp37, tmp327); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)64, tmp37); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp325); - -uint64_t* tmp330 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp327, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp327, tmp38, tmp39, (int32_t)0, (int32_t)12, tmp330); -ClearMemSecret1( (int32_t)64, tmp39); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp327); -ClearMemSecret1( (int32_t)64, tmp38); - -uint64_t* tmp334 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp330, tmp334, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp330); - -uint64_t* tmp336 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp334, tmp42, tmp336); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp334); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)64, tmp42); - -uint64_t* tmp339 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp336, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp336, tmp43, tmp44, (int32_t)0, (int32_t)12, tmp339); -ClearMemSecret1( (int32_t)64, tmp44); -ClearMemSecret1( (int32_t)64, tmp43); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp336); - -uint64_t* tmp343 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp339, tmp343, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp339); - -uint64_t* tmp345 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp343, tmp47, tmp345); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp47); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp343); - -uint64_t* tmp348 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleUp4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp345, tmp319, tmp348); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp319); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp345); - -uint64_t* tmp351 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp348, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp348, tmp48, tmp49, (int32_t)0, (int32_t)12, tmp351); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp348); -ClearMemSecret1( (int32_t)256, tmp48); -ClearMemSecret1( (int32_t)256, tmp49); - -uint64_t* tmp355 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp351, tmp355, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp351); - -int32_t* tmp357 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp357, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp358 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256); -Pad442( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp355, (int32_t)4, (int32_t)2, tmp357, tmp358); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp357); - -uint64_t* tmp360 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp358, tmp52, tmp360); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)512, tmp52); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp358); - -uint64_t* tmp363 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp355, tmp53, tmp363); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)256, tmp355); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)128, tmp53); - -uint64_t* tmp366 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp363, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp363, tmp54, tmp55, (int32_t)0, (int32_t)12, tmp366); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp363); -ClearMemSecret1( (int32_t)128, tmp55); -ClearMemSecret1( (int32_t)128, tmp54); - -uint64_t* tmp370 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp366, tmp370, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp366); - -int32_t* tmp372 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp372, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp373 = make_array( (int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128); -Pad442( (int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp370, (int32_t)4, (int32_t)2, tmp372, tmp373); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp370); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp372); - -uint64_t* tmp376 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp373, tmp58, tmp376); -ClearMemSecret4( (int32_t)1, (int32_t)58, (int32_t)58, (int32_t)128, tmp373); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp58); - -uint64_t* tmp379 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp376, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp376, tmp59, tmp60, (int32_t)0, (int32_t)12, tmp379); -ClearMemSecret1( (int32_t)128, tmp59); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp376); -ClearMemSecret1( (int32_t)128, tmp60); - -uint64_t* tmp383 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp379, tmp383, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp379); - -uint64_t* tmp385 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp383, tmp63, tmp385); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp383); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp63); - -uint64_t* tmp388 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -MatAdd4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp385, tmp360, tmp388); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp385); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp360); - -uint64_t* tmp391 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388, tmp64, tmp65, (int32_t)0, (int32_t)12, tmp391); -ClearMemSecret1( (int32_t)512, tmp64); -ClearMemSecret1( (int32_t)512, tmp65); - -uint64_t* tmp394 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp391, tmp394, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp391); - -uint64_t* tmp396 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp394, tmp68, tmp396); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp394); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp68); - -uint64_t* tmp399 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp396, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp396, tmp69, tmp70, (int32_t)0, (int32_t)12, tmp399); -ClearMemSecret1( (int32_t)128, tmp70); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp396); -ClearMemSecret1( (int32_t)128, tmp69); - -uint64_t* tmp403 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp399, tmp403, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp399); - -uint64_t* tmp405 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp403, tmp73, tmp405); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp403); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp73); - -uint64_t* tmp408 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp405, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp405, tmp74, tmp75, (int32_t)0, (int32_t)12, tmp408); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp405); -ClearMemSecret1( (int32_t)128, tmp75); -ClearMemSecret1( (int32_t)128, tmp74); - -uint64_t* tmp412 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp408, tmp412, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp408); - -uint64_t* tmp414 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp412, tmp78, tmp414); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp78); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp412); - -uint64_t* tmp417 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleUp4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp414, tmp388, tmp417); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp388); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp414); - -uint64_t* tmp420 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417, tmp79, tmp80, (int32_t)0, (int32_t)12, tmp420); -ClearMemSecret1( (int32_t)512, tmp80); -ClearMemSecret1( (int32_t)512, tmp79); - -uint64_t* tmp423 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp420, tmp423, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp420); - -uint64_t* tmp425 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp423, tmp83, tmp425); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp423); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp83); - -uint64_t* tmp428 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp425, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp425, tmp84, tmp85, (int32_t)0, (int32_t)12, tmp428); -ClearMemSecret1( (int32_t)128, tmp85); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp425); -ClearMemSecret1( (int32_t)128, tmp84); - -uint64_t* tmp432 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp428, tmp432, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp428); - -uint64_t* tmp434 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp432, tmp88, tmp434); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp88); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp432); - -uint64_t* tmp437 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp434, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp434, tmp89, tmp90, (int32_t)0, (int32_t)12, tmp437); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp434); -ClearMemSecret1( (int32_t)128, tmp90); -ClearMemSecret1( (int32_t)128, tmp89); - -uint64_t* tmp441 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp437, tmp441, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp437); - -uint64_t* tmp443 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp441, tmp93, tmp443); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp441); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp93); - -uint64_t* tmp446 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleUp4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp443, tmp417, tmp446); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp443); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp417); - -uint64_t* tmp449 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446, tmp94, tmp95, (int32_t)0, (int32_t)12, tmp449); -ClearMemSecret1( (int32_t)512, tmp95); -ClearMemSecret1( (int32_t)512, tmp94); - -uint64_t* tmp452 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp449, tmp452, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp449); - -uint64_t* tmp454 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp452, tmp98, tmp454); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)128, tmp98); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp452); - -uint64_t* tmp457 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp454, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp454, tmp99, tmp100, (int32_t)0, (int32_t)12, tmp457); -ClearMemSecret1( (int32_t)128, tmp100); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp454); -ClearMemSecret1( (int32_t)128, tmp99); - -uint64_t* tmp461 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp457, tmp461, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp457); - -uint64_t* tmp463 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp461, tmp103, tmp463); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp461); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)128, tmp103); - -uint64_t* tmp466 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp463, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp463, tmp104, tmp105, (int32_t)0, (int32_t)12, tmp466); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp463); -ClearMemSecret1( (int32_t)128, tmp104); -ClearMemSecret1( (int32_t)128, tmp105); - -uint64_t* tmp470 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp466, tmp470, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp466); - -uint64_t* tmp472 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp470, tmp108, tmp472); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)512, tmp108); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)128, tmp470); - -uint64_t* tmp475 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleUp4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp472, tmp446, tmp475); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp446); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp472); - -uint64_t* tmp478 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp475, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp475, tmp109, tmp110, (int32_t)0, (int32_t)12, tmp478); -ClearMemSecret1( (int32_t)512, tmp110); -ClearMemSecret1( (int32_t)512, tmp109); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp475); - -uint64_t* tmp482 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp478, tmp482, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp478); - -int32_t* tmp484 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp484, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp485 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512); -Pad442( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp482, (int32_t)4, (int32_t)2, tmp484, tmp485); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp484); - -uint64_t* tmp487 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp485, tmp113, tmp487); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1024, tmp113); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp485); - -uint64_t* tmp490 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp482, tmp114, tmp490); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)256, tmp114); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)512, tmp482); - -uint64_t* tmp493 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp490, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp490, tmp115, tmp116, (int32_t)0, (int32_t)12, tmp493); -ClearMemSecret1( (int32_t)256, tmp116); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp490); -ClearMemSecret1( (int32_t)256, tmp115); - -uint64_t* tmp497 = make_array( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256); -Relu4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp493, tmp497, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp493); - -int32_t* tmp499 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp499, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp500 = make_array( (int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256); -Pad442( (int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256, (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp497, (int32_t)4, (int32_t)2, tmp499, tmp500); -ClearMemSecret4( (int32_t)1, (int32_t)28, (int32_t)28, (int32_t)256, tmp497); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp499); - -uint64_t* tmp503 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp500, tmp119, tmp503); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp119); -ClearMemSecret4( (int32_t)1, (int32_t)30, (int32_t)30, (int32_t)256, tmp500); - -uint64_t* tmp506 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp503, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp503, tmp120, tmp121, (int32_t)0, (int32_t)12, tmp506); -ClearMemSecret1( (int32_t)256, tmp121); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp503); -ClearMemSecret1( (int32_t)256, tmp120); - -uint64_t* tmp510 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp506, tmp510, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp506); - -uint64_t* tmp512 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp510, tmp124, tmp512); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp124); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp510); - -uint64_t* tmp515 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp512, tmp487, tmp515); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp487); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp512); - -uint64_t* tmp518 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515, tmp125, tmp126, (int32_t)0, (int32_t)12, tmp518); -ClearMemSecret1( (int32_t)1024, tmp126); -ClearMemSecret1( (int32_t)1024, tmp125); - -uint64_t* tmp521 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp518, tmp521, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp518); - -uint64_t* tmp523 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp521, tmp129, tmp523); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp521); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp129); - -uint64_t* tmp526 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp523, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp523, tmp130, tmp131, (int32_t)0, (int32_t)12, tmp526); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp523); -ClearMemSecret1( (int32_t)256, tmp131); -ClearMemSecret1( (int32_t)256, tmp130); - -uint64_t* tmp530 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp526, tmp530, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp526); - -uint64_t* tmp532 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp530, tmp134, tmp532); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp530); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp134); - -uint64_t* tmp535 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp532, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp532, tmp135, tmp136, (int32_t)0, (int32_t)12, tmp535); -ClearMemSecret1( (int32_t)256, tmp135); -ClearMemSecret1( (int32_t)256, tmp136); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp532); - -uint64_t* tmp539 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp535, tmp539, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp535); - -uint64_t* tmp541 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp539, tmp139, tmp541); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp139); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp539); - -uint64_t* tmp544 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp541, tmp515, tmp544); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp541); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp515); - -uint64_t* tmp547 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544, tmp140, tmp141, (int32_t)0, (int32_t)12, tmp547); -ClearMemSecret1( (int32_t)1024, tmp141); -ClearMemSecret1( (int32_t)1024, tmp140); - -uint64_t* tmp550 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp547, tmp550, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp547); - -uint64_t* tmp552 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp550, tmp144, tmp552); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp144); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp550); - -uint64_t* tmp555 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp552, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp552, tmp145, tmp146, (int32_t)0, (int32_t)12, tmp555); -ClearMemSecret1( (int32_t)256, tmp145); -ClearMemSecret1( (int32_t)256, tmp146); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp552); - -uint64_t* tmp559 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp555, tmp559, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp555); - -uint64_t* tmp561 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp559, tmp149, tmp561); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp149); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp559); - -uint64_t* tmp564 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp561, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp561, tmp150, tmp151, (int32_t)0, (int32_t)12, tmp564); -ClearMemSecret1( (int32_t)256, tmp151); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp561); -ClearMemSecret1( (int32_t)256, tmp150); - -uint64_t* tmp568 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp564, tmp568, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp564); - -uint64_t* tmp570 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp568, tmp154, tmp570); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp154); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp568); - -uint64_t* tmp573 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp570, tmp544, tmp573); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp570); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp544); - -uint64_t* tmp576 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573, tmp155, tmp156, (int32_t)0, (int32_t)12, tmp576); -ClearMemSecret1( (int32_t)1024, tmp155); -ClearMemSecret1( (int32_t)1024, tmp156); - -uint64_t* tmp579 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp576, tmp579, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp576); - -uint64_t* tmp581 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp579, tmp159, tmp581); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp579); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp159); - -uint64_t* tmp584 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp581, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp581, tmp160, tmp161, (int32_t)0, (int32_t)12, tmp584); -ClearMemSecret1( (int32_t)256, tmp160); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp581); -ClearMemSecret1( (int32_t)256, tmp161); - -uint64_t* tmp588 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp584, tmp588, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp584); - -uint64_t* tmp590 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp588, tmp164, tmp590); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp588); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp164); - -uint64_t* tmp593 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp590, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp590, tmp165, tmp166, (int32_t)0, (int32_t)12, tmp593); -ClearMemSecret1( (int32_t)256, tmp166); -ClearMemSecret1( (int32_t)256, tmp165); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp590); - -uint64_t* tmp597 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp593, tmp597, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp593); - -uint64_t* tmp599 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp597, tmp169, tmp599); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp169); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp597); - -uint64_t* tmp602 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp599, tmp573, tmp602); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp573); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp599); - -uint64_t* tmp605 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602, tmp170, tmp171, (int32_t)0, (int32_t)12, tmp605); -ClearMemSecret1( (int32_t)1024, tmp171); -ClearMemSecret1( (int32_t)1024, tmp170); - -uint64_t* tmp608 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp605, tmp608, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp605); - -uint64_t* tmp610 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp608, tmp174, tmp610); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp608); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp174); - -uint64_t* tmp613 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp610, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp610, tmp175, tmp176, (int32_t)0, (int32_t)12, tmp613); -ClearMemSecret1( (int32_t)256, tmp175); -ClearMemSecret1( (int32_t)256, tmp176); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp610); - -uint64_t* tmp617 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp613, tmp617, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp613); - -uint64_t* tmp619 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp617, tmp179, tmp619); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp617); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp179); - -uint64_t* tmp622 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp619, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp619, tmp180, tmp181, (int32_t)0, (int32_t)12, tmp622); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp619); -ClearMemSecret1( (int32_t)256, tmp180); -ClearMemSecret1( (int32_t)256, tmp181); - -uint64_t* tmp626 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp622, tmp626, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp622); - -uint64_t* tmp628 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp626, tmp184, tmp628); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp184); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp626); - -uint64_t* tmp631 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp628, tmp602, tmp631); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp628); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp602); - -uint64_t* tmp634 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631, tmp185, tmp186, (int32_t)0, (int32_t)12, tmp634); -ClearMemSecret1( (int32_t)1024, tmp186); -ClearMemSecret1( (int32_t)1024, tmp185); - -uint64_t* tmp637 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp634, tmp637, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp634); - -uint64_t* tmp639 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp637, tmp189, tmp639); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)256, tmp189); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp637); - -uint64_t* tmp642 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp639, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp639, tmp190, tmp191, (int32_t)0, (int32_t)12, tmp642); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp639); -ClearMemSecret1( (int32_t)256, tmp191); -ClearMemSecret1( (int32_t)256, tmp190); - -uint64_t* tmp646 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp642, tmp646, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp642); - -uint64_t* tmp648 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp646, tmp194, tmp648); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp646); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)256, tmp194); - -uint64_t* tmp651 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp648, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp648, tmp195, tmp196, (int32_t)0, (int32_t)12, tmp651); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp648); -ClearMemSecret1( (int32_t)256, tmp195); -ClearMemSecret1( (int32_t)256, tmp196); - -uint64_t* tmp655 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp651, tmp655, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp651); - -uint64_t* tmp657 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp655, tmp199, tmp657); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)256, tmp655); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)1024, tmp199); - -uint64_t* tmp660 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleUp4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp657, tmp631, tmp660); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp631); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp657); - -uint64_t* tmp663 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp660, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp660, tmp200, tmp201, (int32_t)0, (int32_t)12, tmp663); -ClearMemSecret1( (int32_t)1024, tmp201); -ClearMemSecret1( (int32_t)1024, tmp200); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp660); - -uint64_t* tmp667 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp663, tmp667, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp663); - -int32_t* tmp669 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp669, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp670 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024); -Pad442( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp667, (int32_t)4, (int32_t)2, tmp669, tmp670); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp669); - -uint64_t* tmp672 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp670, tmp204, tmp672); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp670); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)2048, tmp204); - -uint64_t* tmp675 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp667, tmp205, tmp675); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1024, (int32_t)512, tmp205); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)1024, tmp667); - -uint64_t* tmp678 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp675, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp675, tmp206, tmp207, (int32_t)0, (int32_t)12, tmp678); -ClearMemSecret1( (int32_t)512, tmp207); -ClearMemSecret1( (int32_t)512, tmp206); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp675); - -uint64_t* tmp682 = make_array( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512); -Relu4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp678, tmp682, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp678); - -int32_t* tmp684 = make_array( (int32_t)4, (int32_t)2); -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)0, (int64_t)1) = (int32_t)0; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)1, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)0) = (int32_t)1; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)2, (int64_t)1) = (int32_t)1; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)0) = (int32_t)0; -Arr2DIdxRowM(tmp684, (int32_t)4, (int32_t)2, (int64_t)3, (int64_t)1) = (int32_t)0; - -uint64_t* tmp685 = make_array( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512); -Pad442( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512, (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp682, (int32_t)4, (int32_t)2, tmp684, tmp685); -ClearMemPublic2( (int32_t)4, (int32_t)2, tmp684); -ClearMemSecret4( (int32_t)1, (int32_t)14, (int32_t)14, (int32_t)512, tmp682); - -uint64_t* tmp688 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp685, tmp210, tmp688); -ClearMemSecret4( (int32_t)1, (int32_t)16, (int32_t)16, (int32_t)512, tmp685); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512, tmp210); - -uint64_t* tmp691 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp688, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp688, tmp211, tmp212, (int32_t)0, (int32_t)12, tmp691); -ClearMemSecret1( (int32_t)512, tmp211); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp688); -ClearMemSecret1( (int32_t)512, tmp212); - -uint64_t* tmp695 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp691, tmp695, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp691); - -uint64_t* tmp697 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp695, tmp215, tmp697); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp695); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048, tmp215); - -uint64_t* tmp700 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -MatAdd4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp697, tmp672, tmp700); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp672); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp697); - -uint64_t* tmp703 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700, tmp216, tmp217, (int32_t)0, (int32_t)12, tmp703); -ClearMemSecret1( (int32_t)2048, tmp216); -ClearMemSecret1( (int32_t)2048, tmp217); - -uint64_t* tmp706 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp703, tmp706, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp703); - -uint64_t* tmp708 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp706, tmp220, tmp708); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp706); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512, tmp220); - -uint64_t* tmp711 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp708, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp708, tmp221, tmp222, (int32_t)0, (int32_t)12, tmp711); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp708); -ClearMemSecret1( (int32_t)512, tmp221); -ClearMemSecret1( (int32_t)512, tmp222); - -uint64_t* tmp715 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp711, tmp715, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp711); - -uint64_t* tmp717 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp715, tmp225, tmp717); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512, tmp225); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp715); - -uint64_t* tmp720 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp717, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp717, tmp226, tmp227, (int32_t)0, (int32_t)12, tmp720); -ClearMemSecret1( (int32_t)512, tmp227); -ClearMemSecret1( (int32_t)512, tmp226); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp717); - -uint64_t* tmp724 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp720, tmp724, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp720); - -uint64_t* tmp726 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp724, tmp230, tmp726); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp724); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048, tmp230); - -uint64_t* tmp729 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleUp4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp726, tmp700, tmp729); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp726); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp700); - -uint64_t* tmp732 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729, tmp231, tmp232, (int32_t)0, (int32_t)12, tmp732); -ClearMemSecret1( (int32_t)2048, tmp231); -ClearMemSecret1( (int32_t)2048, tmp232); - -uint64_t* tmp735 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp732, tmp735, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp732); - -uint64_t* tmp737 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp735, tmp235, tmp737); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp735); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)512, tmp235); - -uint64_t* tmp740 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp737, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp737, tmp236, tmp237, (int32_t)0, (int32_t)12, tmp740); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp737); -ClearMemSecret1( (int32_t)512, tmp237); -ClearMemSecret1( (int32_t)512, tmp236); - -uint64_t* tmp744 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp740, tmp744, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp740); - -uint64_t* tmp746 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp744, tmp240, tmp746); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)512, (int32_t)512, tmp240); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp744); - -uint64_t* tmp749 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp746, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp746, tmp241, tmp242, (int32_t)0, (int32_t)12, tmp749); -ClearMemSecret1( (int32_t)512, tmp242); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp746); -ClearMemSecret1( (int32_t)512, tmp241); - -uint64_t* tmp753 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp749, tmp753, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp749); - -uint64_t* tmp755 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Conv2DWrapper( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp753, tmp245, tmp755); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)2048, tmp245); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)512, tmp753); - -uint64_t* tmp758 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleUp4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729, (int32_t)12); -MatAdd4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp755, tmp729, tmp758); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp755); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp729); - -uint64_t* tmp761 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -ScaleDown4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp758, (int32_t)12); -FusedBatchNorm4411( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp758, tmp246, tmp247, (int32_t)0, (int32_t)12, tmp761); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp758); -ClearMemSecret1( (int32_t)2048, tmp246); -ClearMemSecret1( (int32_t)2048, tmp247); - -uint64_t* tmp765 = make_array( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048); -Relu4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp761, tmp765, (int32_t)12, 1); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp761); - -uint64_t* tmp767 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048); -AvgPool( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048, (int32_t)7, (int32_t)7, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp765, tmp767); -ClearMemSecret4( (int32_t)1, (int32_t)7, (int32_t)7, (int32_t)2048, tmp765); - -uint64_t* tmp771 = make_array( (int32_t)1, (int32_t)2048); - -int32_t tmp769 = (int32_t)1; - -int32_t tmp770 = (int32_t)2; -Squeeze24( (int32_t)1, (int32_t)2048, tmp769, tmp770, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048, tmp767, tmp771); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)2048, tmp767); - -uint64_t* tmp773 = make_array( (int32_t)1, (int32_t)1001); -MatMul2D( (int32_t)1, (int32_t)2048, (int32_t)1001, tmp771, tmp250, tmp773, 0); -ClearMemSecret2( (int32_t)2048, (int32_t)1001, tmp250); -ClearMemSecret2( (int32_t)1, (int32_t)2048, tmp771); - -uint64_t* tmp776 = make_array( (int32_t)1, (int32_t)1001); -ScaleUp1( (int32_t)1001, tmp251, (int32_t)12); -MatAddBroadCast2( (int32_t)1, (int32_t)1001, tmp773, tmp251, tmp776); -ClearMemSecret2( (int32_t)1, (int32_t)1001, tmp773); -ClearMemSecret1( (int32_t)1001, tmp251); - -int32_t tmp779 = (int32_t)1; - -uint64_t* tmp780 = make_array( (int32_t)1); -ArgMax1( (int32_t)1, (int32_t)1, (int32_t)1001, tmp776, tmp779, tmp780); -ClearMemPublic(tmp779); -ClearMemSecret2( (int32_t)1, (int32_t)1001, tmp776); -EndComputation(); -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -cout << (funcReconstruct2PCCons(Arr1DIdxRowM(tmp780, (int32_t)1,i0), 2)) << endl; -} -} - diff --git a/SCI/networks/main_sqnet.cpp b/SCI/networks/main_sqnet.cpp new file mode 100644 index 00000000..55ffec42 --- /dev/null +++ b/SCI/networks/main_sqnet.cpp @@ -0,0 +1,3800 @@ +/* +This is an autogenerated file, generated using the EzPC compiler. +*/ + +#include "library_fixed.h" +#include +using namespace std; + +int party = 0; +int port = 32000; +string address = "127.0.0.1"; +int num_threads = 4; +int32_t bitlength = 32; + +void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + SecretAdd(Arr2DIdxRowM(A, s1, s2, i1, i2), Arr1DIdxRowM(B, s2, i2)); + } + } +} + +void MatAdd2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B, + uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = SecretAdd( + Arr2DIdxRowM(A, s1, s2, i1, i2), Arr2DIdxRowM(B, s1, s2, i1, i2)); + } + } +} + +void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr1DIdxRowM(B, s4, i4)); + } + } + } + } +} + +void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *A, + uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4), + Arr4DIdxRowM(B, s1, s2, s3, s4, i1, i2, i3, i4)); + } + } + } + } +} + +void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr1DIdxRowM(B, s5, i5)); + } + } + } + } + } +} + +void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *A, uint64_t *B, uint64_t *outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd( + Arr5DIdxRowM(A, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5), + Arr5DIdxRowM(B, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5)); + } + } + } + } + } +} + +void CreateTensor1(int64_t s1, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(arr, s1, i1) = val; + } +} + +void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(arr, s1, s2, i1, i2) = val; + } + } +} + +void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = val; + } + } + } +} + +void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, + int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = val; + } + } + } + } +} + +void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t val, int64_t *arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + Arr5DIdxRowM(arr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = val; + } + } + } + } + } +} + +void CopyTensor1(int64_t s1, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(targetArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CopyTensor2(int64_t s1, int64_t s2, uint64_t *targetArr, uint64_t *fromArr, + uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(targetArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t *targetArr, + uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(targetArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *targetArr, uint64_t *fromArr, uint64_t *ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(targetArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateIdentity11(int64_t s1, uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + Arr1DIdxRowM(newArr, s1, i1) = Arr1DIdxRowM(fromArr, s1, i1); + } +} + +void CreateIdentity22(int64_t s1, int64_t s2, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + Arr2DIdxRowM(newArr, s1, s2, i1, i2) = + Arr2DIdxRowM(fromArr, s1, s2, i1, i2); + } + } +} + +void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t *fromArr, + uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + Arr3DIdxRowM(newArr, s1, s2, s3, i1, i2, i3) = + Arr3DIdxRowM(fromArr, s1, s2, s3, i1, i2, i3); + } + } + } +} + +void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *fromArr, uint64_t *newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + Arr4DIdxRowM(newArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(fromArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } +} + +void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, + uint64_t *inArr, int64_t perDimSize, int64_t *beginIdx, + int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = + Arr2DIdxRowM(inArr, inps1, inps2, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j)); + } + } +} + +void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inArr, int64_t perDimSize, + int64_t *beginIdx, int64_t *sizeIdx, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM( + inArr, inps1, inps2, inps3, inps4, inps5, + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)0) + i), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)1) + j), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)2) + k), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)3) + l), + (Arr1DIdxRowM(beginIdx, perDimSize, (int32_t)4) + m)); + } + } + } + } + } +} + +void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, + uint64_t *inp1, int64_t inp2s1, int64_t inp2s2, uint64_t *inp2, + int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, (i1 - inp1s1), i2); + } + } else { + if ((i2 < inp1s2)) { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp1, inp1s1, inp1s2, i1, i2); + } else { + Arr2DIdxRowM(outp, s1, s2, i1, i2) = + Arr2DIdxRowM(inp2, inp2s1, inp2s2, i1, (i2 - inp1s2)); + } + } + } + } +} + +void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, + int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t *inp1, + int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, + uint64_t *inp2, int64_t axis, uint64_t *outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + if ((axis == (int32_t)0)) { + if ((i1 < inp1s1)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = Arr4DIdxRowM( + inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, + (i1 - inp1s1), i2, i3, i4); + } + } else { + if ((axis == (int32_t)1)) { + if ((i2 < inp1s2)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, + (i2 - inp1s2), i3, i4); + } + } else { + if ((axis == (int32_t)2)) { + if ((i3 < inp1s3)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + (i3 - inp1s3), i4); + } + } else { + if ((i4 < inp1s4)) { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp1, inp1s1, inp1s2, inp1s3, inp1s4, i1, i2, + i3, i4); + } else { + Arr4DIdxRowM(outp, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr4DIdxRowM(inp2, inp2s1, inp2s2, inp2s3, inp2s4, i1, i2, + i3, (i4 - inp1s4)); + } + } + } + } + } + } + } + } +} + +void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, + int64_t I2, int64_t I3, int64_t I4, uint64_t *inp, int64_t axis, + int64_t curCount, int64_t total, uint64_t *out) { + for (uint64_t o1 = (int32_t)0; o1 < O1; o1++) { + for (uint64_t o2 = (int32_t)0; o2 < O2; o2++) { + for (uint64_t o3 = (int32_t)0; o3 < O3; o3++) { + for (uint64_t o4 = (int32_t)0; o4 < O4; o4++) { + + int64_t i1 = o1; + + int64_t i2 = o2; + + int64_t i3 = o3; + + int64_t i4 = o4; + if ((axis == (int32_t)0)) { + i1 = (((I1 / total) * curCount) + o1); + } + if ((axis == (int32_t)1)) { + i2 = (((I2 / total) * curCount) + o2); + } + if ((axis == (int32_t)2)) { + i3 = (((I3 / total) * curCount) + o3); + } + if ((axis == (int32_t)3)) { + i4 = (((I4 / total) * curCount) + o4); + } + Arr4DIdxRowM(out, O1, O2, O3, O4, o1, o2, o3, o4) = + Arr4DIdxRowM(inp, I1, I2, I3, I4, i1, i2, i3, i4); + } + } + } + } +} + +void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CI, CO, fh, fw, ci, co); + } + } + } + } +} + +void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int32_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); + Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, reshapedIPRows, + reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideH, int64_t strideW, int64_t outH, + int64_t outW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t GIS = (CI / G); + + int64_t GOS = (CO / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t cog = (int32_t)0; cog < GOS; cog++) { + for (uint64_t cig = (int32_t)0; cig < GIS; cig++) { + for (uint64_t g = (int32_t)0; g < G; g++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + + uint64_t val = funcSSCons((int32_t)0); + + int64_t ci = ((GIS * g) + cig); + + int64_t co = ((GOS * g) + cog); + + int64_t curPosH = ((strideH * h) - zPadHLeft); + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + + int64_t curPosW = ((strideW * w) - zPadWLeft); + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && + (curPosH < H)) && + (curPosW < W))) { + val = SecretAdd( + val, + SecretMult(Arr4DIdxRowM(inputArr, N, H, W, CI, n, + curPosH, curPosW, ci), + Arr4DIdxRowM(filterArr, FH, FW, (CI / G), CO, + fh, fw, (ci / G), co))); + } + curPosW = (curPosW + (int32_t)1); + } + curPosH = (curPosH + (int32_t)1); + } + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co) = SecretAdd( + Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co), val); + } + } + } + } + } + } +} + +void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, outH, outW, G, inputArr, + filterArr, outArr); +} + +void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, + int64_t g, int64_t G, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t CIG = (CI / G); + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + + int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); + Arr2DIdxRowM(outputArr, (CO / G), ((FH * FW) * (CI / G)), co, + linIdx) = Arr4DIdxRowM(inputArr, FH, FW, (CI / G), CO, + fh, fw, ci, (co + startCO)); + } + } + } + } +} + +void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, int64_t g, int64_t G, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t COG = (CO / G); + + int64_t startCO = (g * COG); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, + (co + startCO)) = + Arr2DIdxRowM(inputArr, (CO / G), ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, + int64_t FH, int64_t FW, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t g, int64_t G, + int64_t RRows, int64_t RCols, uint64_t *inputArr, + uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + + int64_t CIG = (CI / G); + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + + int64_t startCI = (g * CIG); + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int32_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + (ci + startCI)); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CIG) + (fw * CIG)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, + int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, + int64_t strideW, int64_t G, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t CIG = (CI / G); + + int64_t reshapedFilterRows = (CO / G); + + int64_t reshapedFilterCols = ((FH * FW) * CIG); + + int64_t reshapedIPRows = ((FH * FW) * CIG); + + int64_t outH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t outW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = ((N * outH) * outW); + for (uint64_t g = (int32_t)0; g < G; g++) { + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = + make_array(reshapedFilterRows, reshapedIPCols); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); + Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, + zPadWLeft, zPadWRight, strideH, strideW, g, G, + reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + } +} + +void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, + int64_t CO, uint64_t *inputArr, uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CI, CO, fd, fh, fw, ci, co); + } + } + } + } + } +} + +void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, + int64_t finalW, int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t d = (int32_t)0; d < finalD; d++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr5DIdxRowM(outputArr, N, finalD, finalH, finalW, CO, n, d, h, w, + co) = + Arr2DIdxRowM(inputArr, CO, (((N * finalD) * finalH) * finalW), + co, + ((((((n * finalD) * finalH) * finalW) + + ((d * finalH) * finalW)) + + (h * finalW)) + + w)); + } + } + } + } + } +} + +void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, + int64_t zPadWRight, int64_t strideD, int64_t strideH, + int64_t strideW, int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadDLeft); + + int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= D)) || + ((curPosH < (int32_t)0) || (curPosH >= H))) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int32_t)0); + } else { + val = Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, curPosD, + curPosH, curPosW, ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + + leftTopCornerD = (leftTopCornerD + strideD); + } + } +} + +void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, + int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, + int64_t strideH, int64_t strideW, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t newD = + ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); + + int64_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int64_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int64_t reshapedIPCols = (((N * newD) * newH) * newW); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); + Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); + fd++) { + for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); + fh++) { + for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); + fw++) { + + int64_t curPosD = (fd - zPadDLeft); + + int64_t curPosH = (fh - zPadHLeft); + + int64_t curPosW = (fw - zPadWLeft); + if (((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W))) { + + int64_t curFilterPosD = (fd - (d * strideD)); + + int64_t curFilterPosH = (fh - (h * strideH)); + + int64_t curFilterPosW = (fw - (w * strideW)); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CI, CO, + curFilterPosD, curFilterPosH, + curFilterPosW, ci, co))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, + int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, + int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, uint64_t *outArr) { + + int64_t outD = + ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); + + int64_t outH = + ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); + + int64_t outW = + ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); + Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, outD, outH, outW, inputArr, filterArr, + outArr); +} + +void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, + int64_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, + int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CO, CI, ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } +} + +void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FH, int64_t FW, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = funcSSCons((int32_t)0); + } else { + if ((((curPosH % strideH) == (int32_t)0) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = Arr4DIdxRowM(inputArr, N, HPrime, WPrime, CI, n, + idxInputH, idxInputW, ci); + } else { + val = funcSSCons((int32_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + } +} + +void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, + int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = ((FH * FW) * CI); + + int64_t reshapedIPRows = ((FH * FW) * CI); + + int64_t reshapedIPCols = ((N * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, + zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t CI, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + int64_t linIdx = + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + + ci); + Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) = + Arr5DIdxRowM(inputArr, FD, FH, FW, CO, CI, + ((FD - (int32_t)1) - fd), ((FH - (int32_t)1) - fh), + ((FW - (int32_t)1) - fw), co, ci); + } + } + } + } + } +} + +void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, + int64_t FH, int64_t FW, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, + int64_t strideH, int64_t strideW, + int64_t RRows, int64_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + int64_t leftTopCornerD = ((int32_t)0 - zPadTrDLeft); + + int64_t DPrimeTilde = + (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); + + int64_t extremeRightBottomCornerD = + ((DPrimeTilde - (int32_t)1) + zPadTrDRight); + while ( + (((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { + + int64_t leftTopCornerH = ((int32_t)0 - zPadTrHLeft); + + int64_t HPrimeTilde = + (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); + + int64_t extremeRightBottomCornerH = + ((HPrimeTilde - (int32_t)1) + zPadTrHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int64_t leftTopCornerW = ((int32_t)0 - zPadTrWLeft); + + int64_t WPrimeTilde = + (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); + + int64_t extremeRightBottomCornerW = + ((WPrimeTilde - (int32_t)1) + zPadTrWRight); + while ((((leftTopCornerW + FW) - (int32_t)1) <= + extremeRightBottomCornerW)) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + int64_t curPosD = (leftTopCornerD + fd); + + int64_t curPosH = (leftTopCornerH + fh); + + int64_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || + ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || + ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { + val = funcSSCons((int32_t)0); + } else { + if (((((curPosD % strideD) == (int32_t)0) && + ((curPosH % strideH) == (int32_t)0)) && + ((curPosW % strideW) == (int32_t)0))) { + + int64_t idxInputD = (curPosD / strideD); + + int64_t idxInputH = (curPosH / strideH); + + int64_t idxInputW = (curPosW / strideW); + val = + Arr5DIdxRowM(inputArr, N, DPrime, HPrime, WPrime, CI, + n, idxInputD, idxInputH, idxInputW, ci); + } else { + val = funcSSCons((int32_t)0); + } + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + + (fw * CI)) + + ci), + linIdxFilterMult) = val; + } + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + (int32_t)1); + } + + leftTopCornerH = (leftTopCornerH + (int32_t)1); + } + + leftTopCornerD = (leftTopCornerD + (int32_t)1); + } + } +} + +void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, + int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, + int64_t zPadTrDRight, int64_t zPadTrHLeft, + int64_t zPadTrHRight, int64_t zPadTrWLeft, + int64_t zPadTrWRight, int64_t strideD, int64_t strideH, + int64_t strideW, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int64_t reshapedFilterRows = CO; + + int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); + + int64_t reshapedIPRows = (((FD * FH) * FW) * CI); + + int64_t reshapedIPCols = (((N * D) * H) * W); + + uint64_t *filterReshaped = + make_array(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array(reshapedFilterRows, reshapedIPCols); + ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose3DReshapeInput( + N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, + zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, + int64_t CI, int64_t FD, int64_t FH, int64_t FW, + int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, + int64_t zPadHLeft, int64_t zPadHRight, + int64_t zPadWLeft, int64_t zPadWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + int64_t outD, int64_t outH, int64_t outW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = funcSSCons((int32_t)0); + for (uint64_t fd = d; fd < (d + FD); fd++) { + for (uint64_t fh = h; fh < (h + FH); fh++) { + for (uint64_t fw = w; fw < (w + FW); fw++) { + + int64_t curPosD = ((fd - zPadDLeft) / strideD); + + int64_t curPosH = ((fh - zPadHLeft) / strideD); + + int64_t curPosW = ((fw - zPadWLeft) / strideD); + if ((((((((((curPosD >= (int32_t)0) && + (curPosH >= (int32_t)0)) && + (curPosW >= (int32_t)0)) && + (curPosD < D)) && + (curPosH < H)) && + (curPosW < W)) && + (((fd - zPadDLeft) % strideD) == (int32_t)0)) && + (((fh - zPadHLeft) % strideH) == (int32_t)0)) && + (((fw - zPadWLeft) % strideW) == (int32_t)0))) { + + int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); + + int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); + + int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); + val = SecretAdd( + val, SecretMult( + Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, + curPosD, curPosH, curPosW, ci), + Arr5DIdxRowM(filterArr, FD, FH, FW, CO, CI, + curFilterPosD, curFilterPosH, + curFilterPosW, co, ci))); + } + } + } + } + Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) = + SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, + h, w, co), + val); + } + } + } + } + } + } +} + +void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, + int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, + int64_t FW, int64_t CO, int64_t D, int64_t H, + int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, + int64_t zPadTrHLeft, int64_t zPadTrHRight, + int64_t zPadTrWLeft, int64_t zPadTrWRight, + int64_t strideD, int64_t strideH, int64_t strideW, + uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, + zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, + zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, + D, H, W, inputArr, filterArr, outArr); +} + +void Transpose2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + Arr2DIdxRowM(outArr, s1, s2, i, j) = Arr2DIdxRowM(inArr, s2, s1, j, i); + } + } +} + +void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, + int64_t inps2, int64_t inps3, int64_t inps4, uint64_t *inpArr, + int64_t pads1, int64_t pads2, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = + Arr4DIdxRowM(inpArr, inps1, inps2, inps3, inps4, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0))); + } else { + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) = + funcSSCons((int32_t)0); + } + } + } + } + } +} + +void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, + int64_t inps5, uint64_t *inpArr, int64_t pads1, int64_t pads2, + int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)0); + + int64_t rbounds1excl = + (s1 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)0, (int32_t)1)); + + int64_t lbounds2 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)0); + + int64_t rbounds2excl = + (s2 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)1, (int32_t)1)); + + int64_t lbounds3 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)0); + + int64_t rbounds3excl = + (s3 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)2, (int32_t)1)); + + int64_t lbounds4 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)0); + + int64_t rbounds4excl = + (s4 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)3, (int32_t)1)); + + int64_t lbounds5 = + Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)0); + + int64_t rbounds5excl = + (s5 - Arr2DIdxRowM(paddings, pads1, pads2, (int32_t)4, (int32_t)1)); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl)) && + (m >= lbounds5)) && + (m < rbounds5excl))) { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + Arr5DIdxRowM(inpArr, inps1, inps2, inps3, inps4, inps5, + (i - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)0, (int32_t)0)), + (j - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)1, (int32_t)0)), + (k - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)2, (int32_t)0)), + (l - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)3, (int32_t)0)), + (m - Arr2DIdxRowM(paddings, pads1, pads2, + (int32_t)4, (int32_t)0))); + } else { + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) = + funcSSCons((int32_t)0); + } + } + } + } + } + } +} + +void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, + int64_t i2, int64_t i3, int64_t i4, uint64_t *inpArr, + int64_t pads, int64_t *paddings, uint64_t *outArr) { + + int64_t lbounds1 = Arr1DIdxRowM(paddings, pads, (int32_t)0); + + int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings, pads, (int32_t)4)); + + int64_t lbounds2 = Arr1DIdxRowM(paddings, pads, (int32_t)1); + + int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings, pads, (int32_t)5)); + + int64_t lbounds3 = Arr1DIdxRowM(paddings, pads, (int32_t)2); + + int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings, pads, (int32_t)6)); + + int64_t lbounds4 = Arr1DIdxRowM(paddings, pads, (int32_t)3); + + int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings, pads, (int32_t)7)); + for (uint64_t i = (int32_t)0; i < o1; i++) { + for (uint64_t j = (int32_t)0; j < o2; j++) { + for (uint64_t k = (int32_t)0; k < o3; k++) { + for (uint64_t l = (int32_t)0; l < o4; l++) { + if (((((((((i >= lbounds1) && (i < rbounds1excl)) && + (j >= lbounds2)) && + (j < rbounds2excl)) && + (k >= lbounds3)) && + (k < rbounds3excl)) && + (l >= lbounds4)) && + (l < rbounds4excl))) { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = + Arr4DIdxRowM(inpArr, i1, i2, i3, i4, + (i - Arr1DIdxRowM(paddings, pads, (int32_t)0)), + (j - Arr1DIdxRowM(paddings, pads, (int32_t)1)), + (k - Arr1DIdxRowM(paddings, pads, (int32_t)2)), + (l - Arr1DIdxRowM(paddings, pads, (int32_t)3))); + } else { + Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = + funcSSCons((int32_t)0); + } + } + } + } + } +} + +void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + uint64_t *outArr) { + for (uint64_t i = (int32_t)0; i < ins1; i++) { + for (uint64_t j = (int32_t)0; j < ins2; j++) { + for (uint64_t k = (int32_t)0; k < ins3; k++) { + for (uint64_t l = (int32_t)0; l < ins4; l++) { + + int64_t linIdx = + ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + + (k * ins4)) + + l); + + int64_t outIdx1 = (linIdx / s2); + + int64_t outIdx2 = (linIdx % s2); + Arr2DIdxRowM(outArr, s1, s2, outIdx1, outIdx2) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i, j, k, l); + } + } + } + } +} + +void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *inArr, uint64_t *multArr, uint64_t *biasArr, + int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, + uint64_t *outputArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s4, i4); + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s4); + for (uint64_t ii = (int32_t)0; ii < s4; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s4, ii) = Arr1DIdxRowM(biasArr, s4, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outputArr, s1, s2, s3, s4, i1, i2, i3, i4) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s4, i4)); + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s4, biasArrScaledUp); +} + +void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + int64_t s5, uint64_t *inArr, uint64_t *multArr, + uint64_t *biasArr, int64_t multExprScaleDownSf, + int64_t biasExprScaleUpSf, uint64_t *outputArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *inArrReshaped = make_array(inpSize); + + uint64_t *multArrReshaped = make_array(inpSize); + + uint64_t *multExprAns = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) = + Arr1DIdxRowM(multArr, s5, i5); + } + } + } + } + } + ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((multExprScaleDownSf > (int32_t)0)) { + ScaleDown(inpSize, multExprAns, multExprScaleDownSf); + } + + uint64_t *biasArrScaledUp = make_array(s5); + for (uint64_t ii = (int32_t)0; ii < s5; ii++) { + Arr1DIdxRowM(biasArrScaledUp, s5, ii) = Arr1DIdxRowM(biasArr, s5, ii); + } + if ((biasExprScaleUpSf > (int32_t)0)) { + ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outputArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx), + Arr1DIdxRowM(biasArrScaledUp, s5, i5)); + } + } + } + } + } + ClearMemSecret1(inpSize, inArrReshaped); + ClearMemSecret1(inpSize, multArrReshaped); + ClearMemSecret1(inpSize, multExprAns); + ClearMemSecret1(s5, biasArrScaledUp); +} + +void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t *arr1, uint64_t *arr2, + uint64_t *outArr) { + + int64_t inpSize = (s1 * s2); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr1, s1, s2, i1, i2); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr2DIdxRowM(arr2, s1, s2, i1, i2); + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = (((s1 * s2) * s3) * s4); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr1, s1, s2, s3, s4, i1, i2, i3, i4); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr4DIdxRowM(arr2, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) { + + int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *arr1Reshaped = make_array(inpSize); + + uint64_t *arr2Reshaped = make_array(inpSize); + + uint64_t *outArrReshaped = make_array(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr1, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) = + Arr5DIdxRowM(arr2, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(outArrReshaped, inpSize, linIdx); + } + } + } + } + } + ClearMemSecret1(inpSize, arr1Reshaped); + ClearMemSecret1(inpSize, arr2Reshaped); + ClearMemSecret1(inpSize, outArrReshaped); +} + +void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, int64_t *axes, + uint64_t *outputArr) { + + int64_t divisor = (inS2 * inS3); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = funcSSCons((int32_t)0); + for (uint64_t i = (int32_t)0; i < inS2; i++) { + for (uint64_t j = (int32_t)0; j < inS3; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i, j, i2)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, + int64_t inS3, int64_t inS4, uint64_t *inputArr, + int64_t axis1, int64_t axis2, uint64_t *outputArr) { + + int64_t divisor = (inS3 * inS4); + + int64_t outputSize = (outS1 * outS2); + + uint64_t *sumArr = make_array(outputSize); + + uint64_t *outputArrReshaped = make_array(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = funcSSCons((int32_t)0); + for (uint64_t i = (int32_t)0; i < inS3; i++) { + for (uint64_t j = (int32_t)0; j < inS4; j++) { + summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4, + i1, i2, i, j)); + } + } + Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ; + } + } + ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) = + Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2)); + } + } + ClearMemSecret1(outputSize, sumArr); + ClearMemSecret1(outputSize, outputArrReshaped); +} + +void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, + uint64_t *inArr, int64_t dim, uint64_t *outArr) { + ArgMax(inArrS1, inArrS2, inArr, outArr); +} + +void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, + int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr, + int64_t dim, uint64_t *outArr) { + + int64_t size = ((ins1 * ins2) * ins3); + + uint64_t *reshapedInArr = make_array(size, ins4); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr2DIdxRowM(reshapedInArr, size, ins4, linIdx, i4) = + Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i1, i2, i3, i4); + } + } + } + } + ArgMax(size, ins4, reshapedInArr, reshapedOutArr); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + + int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); + Arr3DIdxRowM(outArr, outs1, outs2, outs3, i1, i2, i3) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + ClearMemSecret2(size, ins4, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf, uint64_t doTruncation) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *inArr, + uint64_t *outArr, int64_t sf, uint64_t doTruncation) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, + uint64_t *inArr, uint64_t *outArr, int64_t sf, + uint64_t doTruncation) { + + int64_t size = ((((s1 * s2) * s3) * s4) * s5); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5); + } + } + } + } + } + Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + int64_t linIdx = + ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + + ((i3 * s4) * s5)) + + (i4 * s5)) + + i5); + Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + } + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void Floor2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr, + int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedInArr = make_array(size); + + uint64_t *reshapedOutArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedInArr, size, linIdx) = + Arr2DIdxRowM(inArr, s1, s2, i1, i2); + } + } + Floor(size, reshapedInArr, reshapedOutArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(outArr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedOutArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedInArr); + ClearMemSecret1(size, reshapedOutArr); +} + +void ScaleUp1(int64_t s1, uint64_t *arr, int64_t sf) { ScaleUp(s1, arr, sf); } + +void ScaleUp2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleUp(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown1(int64_t s1, uint64_t *arr, int64_t sf) { + ScaleDown(s1, arr, sf); +} + +void ScaleDown2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) { + + int64_t size = (s1 * s2); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr2DIdxRowM(arr, s1, s2, i1, i2); + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + int64_t linIdx = ((i1 * s2) + i2); + Arr2DIdxRowM(arr, s1, s2, i1, i2) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) { + + int64_t size = ((s1 * s2) * s3); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3); + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); + Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr, + int64_t sf) { + + int64_t size = (((s1 * s2) * s3) * s4); + + uint64_t *reshapedArr = make_array(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr1DIdxRowM(reshapedArr, size, linIdx) = + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4); + } + } + } + } + ScaleDown(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + int64_t linIdx = + ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); + Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) = + Arr1DIdxRowM(reshapedArr, size, linIdx); + } + } + } + } + ClearMemSecret1(size, reshapedArr); +} + +int main(int argc, char **argv) { + ArgMapping amap; + + amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + amap.arg("nt", num_threads, "Number of Threads"); + amap.arg("ell", bitlength, "Uniform Bitwidth"); + amap.parse(argc, argv); + + assert(party == SERVER || party == CLIENT); + + uint64_t *tmp0 = + make_array((int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3); + /* Variable to read the clear value corresponding to the input variable tmp0 + * at (1930,1-1930,46) */ + uint64_t __tmp_in_tmp0; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)227; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)227; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)3; i3++) { + if ((party == CLIENT)) { + cin >> __tmp_in_tmp0; + } + Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3, + i0, i1, i2, i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; + } + } + } + } + + uint64_t *tmp1 = + make_array((int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp1 + * at (1933,1-1933,43) */ + uint64_t __tmp_in_tmp1; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)3; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp1; + } + Arr4DIdxRowM(tmp1, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; + } + } + } + } + + uint64_t *tmp2 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp2 + * at (1936,1-1936,34) */ + uint64_t __tmp_in_tmp2; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp2; + } + Arr1DIdxRowM(tmp2, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; + } + + uint64_t *tmp3 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp3 + * at (1939,1-1939,44) */ + uint64_t __tmp_in_tmp3; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp3; + } + Arr4DIdxRowM(tmp3, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp3 : 0; + } + } + } + } + + uint64_t *tmp4 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp4 + * at (1942,1-1942,34) */ + uint64_t __tmp_in_tmp4; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp4; + } + Arr1DIdxRowM(tmp4, (int32_t)16, i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; + } + + uint64_t *tmp5 = + make_array((int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp5 + * at (1945,1-1945,44) */ + uint64_t __tmp_in_tmp5; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)16; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp5; + } + Arr4DIdxRowM(tmp5, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp5 : 0; + } + } + } + } + + uint64_t *tmp6 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp6 + * at (1948,1-1948,34) */ + uint64_t __tmp_in_tmp6; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp6; + } + Arr1DIdxRowM(tmp6, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp6 : 0; + } + + uint64_t *tmp7 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp7 + * at (1951,1-1951,44) */ + uint64_t __tmp_in_tmp7; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)16; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp7; + } + Arr4DIdxRowM(tmp7, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; + } + } + } + } + + uint64_t *tmp8 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp8 + * at (1954,1-1954,34) */ + uint64_t __tmp_in_tmp8; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp8; + } + Arr1DIdxRowM(tmp8, (int32_t)64, i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; + } + + uint64_t *tmp9 = + make_array((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp9 + * at (1957,1-1957,45) */ + uint64_t __tmp_in_tmp9; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)16; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp9; + } + Arr4DIdxRowM(tmp9, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)16, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp9 : 0; + } + } + } + } + + uint64_t *tmp10 = make_array((int32_t)16); + /* Variable to read the clear value corresponding to the input variable tmp10 + * at (1960,1-1960,35) */ + uint64_t __tmp_in_tmp10; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)16; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp10; + } + Arr1DIdxRowM(tmp10, (int32_t)16, i0) = + (party == SERVER) ? __tmp_in_tmp10 : 0; + } + + uint64_t *tmp11 = + make_array((int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp11 + * at (1963,1-1963,45) */ + uint64_t __tmp_in_tmp11; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)16; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp11; + } + Arr4DIdxRowM(tmp11, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp11 : 0; + } + } + } + } + + uint64_t *tmp12 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp12 + * at (1966,1-1966,35) */ + uint64_t __tmp_in_tmp12; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp12; + } + Arr1DIdxRowM(tmp12, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp12 : 0; + } + + uint64_t *tmp13 = + make_array((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp13 + * at (1969,1-1969,45) */ + uint64_t __tmp_in_tmp13; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)16; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp13; + } + Arr4DIdxRowM(tmp13, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp13 : 0; + } + } + } + } + + uint64_t *tmp14 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp14 + * at (1972,1-1972,35) */ + uint64_t __tmp_in_tmp14; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp14; + } + Arr1DIdxRowM(tmp14, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp14 : 0; + } + + uint64_t *tmp15 = + make_array((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp15 + * at (1975,1-1975,46) */ + uint64_t __tmp_in_tmp15; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp15; + } + Arr4DIdxRowM(tmp15, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp15 : 0; + } + } + } + } + + uint64_t *tmp16 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp16 + * at (1978,1-1978,35) */ + uint64_t __tmp_in_tmp16; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp16; + } + Arr1DIdxRowM(tmp16, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp16 : 0; + } + + uint64_t *tmp17 = + make_array((int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp17 + * at (1981,1-1981,46) */ + uint64_t __tmp_in_tmp17; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp17; + } + Arr4DIdxRowM(tmp17, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp17 : 0; + } + } + } + } + + uint64_t *tmp18 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp18 + * at (1984,1-1984,36) */ + uint64_t __tmp_in_tmp18; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp18; + } + Arr1DIdxRowM(tmp18, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp18 : 0; + } + + uint64_t *tmp19 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp19 + * at (1987,1-1987,46) */ + uint64_t __tmp_in_tmp19; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp19; + } + Arr4DIdxRowM(tmp19, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp19 : 0; + } + } + } + } + + uint64_t *tmp20 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp20 + * at (1990,1-1990,36) */ + uint64_t __tmp_in_tmp20; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp20; + } + Arr1DIdxRowM(tmp20, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp20 : 0; + } + + uint64_t *tmp21 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp21 + * at (1993,1-1993,46) */ + uint64_t __tmp_in_tmp21; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp21; + } + Arr4DIdxRowM(tmp21, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)32, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp21 : 0; + } + } + } + } + + uint64_t *tmp22 = make_array((int32_t)32); + /* Variable to read the clear value corresponding to the input variable tmp22 + * at (1996,1-1996,35) */ + uint64_t __tmp_in_tmp22; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)32; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp22; + } + Arr1DIdxRowM(tmp22, (int32_t)32, i0) = + (party == SERVER) ? __tmp_in_tmp22 : 0; + } + + uint64_t *tmp23 = + make_array((int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp23 + * at (1999,1-1999,46) */ + uint64_t __tmp_in_tmp23; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp23; + } + Arr4DIdxRowM(tmp23, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp23 : 0; + } + } + } + } + + uint64_t *tmp24 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp24 + * at (2002,1-2002,36) */ + uint64_t __tmp_in_tmp24; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp24; + } + Arr1DIdxRowM(tmp24, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp24 : 0; + } + + uint64_t *tmp25 = + make_array((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp25 + * at (2005,1-2005,46) */ + uint64_t __tmp_in_tmp25; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp25; + } + Arr4DIdxRowM(tmp25, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp25 : 0; + } + } + } + } + + uint64_t *tmp26 = make_array((int32_t)128); + /* Variable to read the clear value corresponding to the input variable tmp26 + * at (2008,1-2008,36) */ + uint64_t __tmp_in_tmp26; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp26; + } + Arr1DIdxRowM(tmp26, (int32_t)128, i0) = + (party == SERVER) ? __tmp_in_tmp26 : 0; + } + + uint64_t *tmp27 = + make_array((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)48); + /* Variable to read the clear value corresponding to the input variable tmp27 + * at (2011,1-2011,46) */ + uint64_t __tmp_in_tmp27; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)48; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp27; + } + Arr4DIdxRowM(tmp27, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)48, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp27 : 0; + } + } + } + } + + uint64_t *tmp28 = make_array((int32_t)48); + /* Variable to read the clear value corresponding to the input variable tmp28 + * at (2014,1-2014,35) */ + uint64_t __tmp_in_tmp28; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)48; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp28; + } + Arr1DIdxRowM(tmp28, (int32_t)48, i0) = + (party == SERVER) ? __tmp_in_tmp28 : 0; + } + + uint64_t *tmp29 = + make_array((int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp29 + * at (2017,1-2017,46) */ + uint64_t __tmp_in_tmp29; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)48; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)192; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp29; + } + Arr4DIdxRowM(tmp29, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp29 : 0; + } + } + } + } + + uint64_t *tmp30 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp30 + * at (2020,1-2020,36) */ + uint64_t __tmp_in_tmp30; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp30; + } + Arr1DIdxRowM(tmp30, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp30 : 0; + } + + uint64_t *tmp31 = + make_array((int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp31 + * at (2023,1-2023,46) */ + uint64_t __tmp_in_tmp31; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)48; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)192; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp31; + } + Arr4DIdxRowM(tmp31, (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp31 : 0; + } + } + } + } + + uint64_t *tmp32 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp32 + * at (2026,1-2026,36) */ + uint64_t __tmp_in_tmp32; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp32; + } + Arr1DIdxRowM(tmp32, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp32 : 0; + } + + uint64_t *tmp33 = + make_array((int32_t)1, (int32_t)1, (int32_t)384, (int32_t)48); + /* Variable to read the clear value corresponding to the input variable tmp33 + * at (2029,1-2029,46) */ + uint64_t __tmp_in_tmp33; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)384; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)48; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp33; + } + Arr4DIdxRowM(tmp33, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)48, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp33 : 0; + } + } + } + } + + uint64_t *tmp34 = make_array((int32_t)48); + /* Variable to read the clear value corresponding to the input variable tmp34 + * at (2032,1-2032,35) */ + uint64_t __tmp_in_tmp34; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)48; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp34; + } + Arr1DIdxRowM(tmp34, (int32_t)48, i0) = + (party == SERVER) ? __tmp_in_tmp34 : 0; + } + + uint64_t *tmp35 = + make_array((int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp35 + * at (2035,1-2035,46) */ + uint64_t __tmp_in_tmp35; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)48; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)192; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp35; + } + Arr4DIdxRowM(tmp35, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp35 : 0; + } + } + } + } + + uint64_t *tmp36 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp36 + * at (2038,1-2038,36) */ + uint64_t __tmp_in_tmp36; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp36; + } + Arr1DIdxRowM(tmp36, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp36 : 0; + } + + uint64_t *tmp37 = + make_array((int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp37 + * at (2041,1-2041,46) */ + uint64_t __tmp_in_tmp37; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)48; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)192; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp37; + } + Arr4DIdxRowM(tmp37, (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp37 : 0; + } + } + } + } + + uint64_t *tmp38 = make_array((int32_t)192); + /* Variable to read the clear value corresponding to the input variable tmp38 + * at (2044,1-2044,36) */ + uint64_t __tmp_in_tmp38; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp38; + } + Arr1DIdxRowM(tmp38, (int32_t)192, i0) = + (party == SERVER) ? __tmp_in_tmp38 : 0; + } + + uint64_t *tmp39 = + make_array((int32_t)1, (int32_t)1, (int32_t)384, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp39 + * at (2047,1-2047,46) */ + uint64_t __tmp_in_tmp39; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)384; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp39; + } + Arr4DIdxRowM(tmp39, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp39 : 0; + } + } + } + } + + uint64_t *tmp40 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp40 + * at (2050,1-2050,35) */ + uint64_t __tmp_in_tmp40; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp40; + } + Arr1DIdxRowM(tmp40, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp40 : 0; + } + + uint64_t *tmp41 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp41 + * at (2053,1-2053,46) */ + uint64_t __tmp_in_tmp41; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp41; + } + Arr4DIdxRowM(tmp41, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp41 : 0; + } + } + } + } + + uint64_t *tmp42 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp42 + * at (2056,1-2056,36) */ + uint64_t __tmp_in_tmp42; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp42; + } + Arr1DIdxRowM(tmp42, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp42 : 0; + } + + uint64_t *tmp43 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp43 + * at (2059,1-2059,46) */ + uint64_t __tmp_in_tmp43; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp43; + } + Arr4DIdxRowM(tmp43, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp43 : 0; + } + } + } + } + + uint64_t *tmp44 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp44 + * at (2062,1-2062,36) */ + uint64_t __tmp_in_tmp44; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp44; + } + Arr1DIdxRowM(tmp44, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp44 : 0; + } + + uint64_t *tmp45 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp45 + * at (2065,1-2065,46) */ + uint64_t __tmp_in_tmp45; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp45; + } + Arr4DIdxRowM(tmp45, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)64, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp45 : 0; + } + } + } + } + + uint64_t *tmp46 = make_array((int32_t)64); + /* Variable to read the clear value corresponding to the input variable tmp46 + * at (2068,1-2068,35) */ + uint64_t __tmp_in_tmp46; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp46; + } + Arr1DIdxRowM(tmp46, (int32_t)64, i0) = + (party == SERVER) ? __tmp_in_tmp46 : 0; + } + + uint64_t *tmp47 = + make_array((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp47 + * at (2071,1-2071,46) */ + uint64_t __tmp_in_tmp47; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp47; + } + Arr4DIdxRowM(tmp47, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp47 : 0; + } + } + } + } + + uint64_t *tmp48 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp48 + * at (2074,1-2074,36) */ + uint64_t __tmp_in_tmp48; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp48; + } + Arr1DIdxRowM(tmp48, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp48 : 0; + } + + uint64_t *tmp49 = + make_array((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp49 + * at (2077,1-2077,46) */ + uint64_t __tmp_in_tmp49; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp49; + } + Arr4DIdxRowM(tmp49, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256, + i0, i1, i2, i3) = (party == SERVER) ? __tmp_in_tmp49 : 0; + } + } + } + } + + uint64_t *tmp50 = make_array((int32_t)256); + /* Variable to read the clear value corresponding to the input variable tmp50 + * at (2080,1-2080,36) */ + uint64_t __tmp_in_tmp50; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp50; + } + Arr1DIdxRowM(tmp50, (int32_t)256, i0) = + (party == SERVER) ? __tmp_in_tmp50 : 0; + } + + uint64_t *tmp51 = + make_array((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1000); + /* Variable to read the clear value corresponding to the input variable tmp51 + * at (2083,1-2083,48) */ + uint64_t __tmp_in_tmp51; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++) { + for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1000; i3++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp51; + } + Arr4DIdxRowM(tmp51, (int32_t)1, (int32_t)1, (int32_t)512, + (int32_t)1000, i0, i1, i2, i3) = + (party == SERVER) ? __tmp_in_tmp51 : 0; + } + } + } + } + + uint64_t *tmp52 = make_array((int32_t)1000); + /* Variable to read the clear value corresponding to the input variable tmp52 + * at (2086,1-2086,37) */ + uint64_t __tmp_in_tmp52; + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1000; i0++) { + if ((party == SERVER)) { + cin >> __tmp_in_tmp52; + } + Arr1DIdxRowM(tmp52, (int32_t)1000, i0) = + (party == SERVER) ? __tmp_in_tmp52 : 0; + } + StartComputation(); + + uint64_t *tmp53 = + make_array((int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)2, (int32_t)2, tmp0, tmp1, tmp53); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, tmp1); + ClearMemSecret4((int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3, tmp0); + + uint64_t *tmp56 = + make_array((int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64); + ScaleUp1((int32_t)64, tmp2, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp53, + tmp2, tmp56); + ClearMemSecret1((int32_t)64, tmp2); + ClearMemSecret4((int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp53); + + uint64_t *tmp59 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + MaxPool((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)113, (int32_t)113, + (int32_t)64, tmp56, tmp59); + ClearMemSecret4((int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp56); + + uint64_t *tmp61 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp59, tmp61, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp59); + + uint64_t *tmp63 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp61, tmp3, tmp63); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp61); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16, tmp3); + + uint64_t *tmp66 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); + ScaleUp1((int32_t)16, tmp4, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp63, + tmp4, tmp66); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp63); + ClearMemSecret1((int32_t)16, tmp4); + + uint64_t *tmp69 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp66, tmp69, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp66); + + uint64_t *tmp71 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)1, + (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp69, tmp5, tmp71); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64, tmp5); + + uint64_t *tmp73 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleUp1((int32_t)64, tmp6, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp71, + tmp6, tmp73); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp71); + ClearMemSecret1((int32_t)64, tmp6); + + uint64_t *tmp76 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp73, tmp76, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp73); + + uint64_t *tmp78 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp69, tmp7, tmp78); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp69); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64, tmp7); + + uint64_t *tmp81 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleUp1((int32_t)64, tmp8, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp78, + tmp8, tmp81); + ClearMemSecret1((int32_t)64, tmp8); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp78); + + uint64_t *tmp84 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp81, tmp84, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp81); + + int64_t tmp86 = (int32_t)3; + + uint64_t *tmp87 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Concat2T444((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)64, tmp76, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)64, tmp84, tmp86, tmp87); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp84); + ClearMemPublic(tmp86); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp76); + + uint64_t *tmp91 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, + (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp87, tmp9, tmp91); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp87); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)16, tmp9); + + uint64_t *tmp94 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); + ScaleUp1((int32_t)16, tmp10, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp91, + tmp10, tmp94); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp91); + ClearMemSecret1((int32_t)16, tmp10); + + uint64_t *tmp97 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp94, tmp97, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp94); + + uint64_t *tmp99 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)1, + (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp97, tmp11, tmp99); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64, tmp11); + + uint64_t *tmp101 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleUp1((int32_t)64, tmp12, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp99, + tmp12, tmp101); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp99); + ClearMemSecret1((int32_t)64, tmp12); + + uint64_t *tmp104 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp101, tmp104, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp101); + + uint64_t *tmp106 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)3, + (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp97, tmp13, tmp106); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64, tmp13); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp97); + + uint64_t *tmp109 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + ScaleUp1((int32_t)64, tmp14, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp106, + tmp14, tmp109); + ClearMemSecret1((int32_t)64, tmp14); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp106); + + uint64_t *tmp112 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); + Relu4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp109, tmp112, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp109); + + int64_t tmp114 = (int32_t)3; + + uint64_t *tmp115 = + make_array((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); + Concat2T444((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)64, tmp104, (int32_t)1, + (int32_t)56, (int32_t)56, (int32_t)64, tmp112, tmp114, tmp115); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp104); + ClearMemPublic(tmp114); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp112); + + uint64_t *tmp119 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + MaxPool((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, (int32_t)3, + (int32_t)3, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)56, (int32_t)56, + (int32_t)128, tmp115, tmp119); + ClearMemSecret4((int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp115); + + uint64_t *tmp121 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, (int32_t)1, + (int32_t)1, (int32_t)32, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp119, tmp15, tmp121); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp119); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)128, (int32_t)32, tmp15); + + uint64_t *tmp124 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); + ScaleUp1((int32_t)32, tmp16, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp121, + tmp16, tmp124); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp121); + ClearMemSecret1((int32_t)32, tmp16); + + uint64_t *tmp127 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); + Relu4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp124, tmp127, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp124); + + uint64_t *tmp129 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp127, tmp17, tmp129); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128, tmp17); + + uint64_t *tmp131 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + ScaleUp1((int32_t)128, tmp18, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp129, + tmp18, tmp131); + ClearMemSecret1((int32_t)128, tmp18); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp129); + + uint64_t *tmp134 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + Relu4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp131, tmp134, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp131); + + uint64_t *tmp136 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp127, tmp19, tmp136); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128, tmp19); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp127); + + uint64_t *tmp139 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + ScaleUp1((int32_t)128, tmp20, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp136, + tmp20, tmp139); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp136); + ClearMemSecret1((int32_t)128, tmp20); + + uint64_t *tmp142 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + Relu4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp139, tmp142, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp139); + + int64_t tmp144 = (int32_t)3; + + uint64_t *tmp145 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256); + Concat2T444((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, (int32_t)1, + (int32_t)27, (int32_t)27, (int32_t)128, tmp134, (int32_t)1, + (int32_t)27, (int32_t)27, (int32_t)128, tmp142, tmp144, tmp145); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp134); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp142); + ClearMemPublic(tmp144); + + uint64_t *tmp149 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); + Conv2DWrapper((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)32, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp145, tmp21, tmp149); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)32, tmp21); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, tmp145); + + uint64_t *tmp152 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); + ScaleUp1((int32_t)32, tmp22, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp149, + tmp22, tmp152); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp149); + ClearMemSecret1((int32_t)32, tmp22); + + uint64_t *tmp155 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); + Relu4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp152, tmp155, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp152); + + uint64_t *tmp157 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)1, + (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp155, tmp23, tmp157); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128, tmp23); + + uint64_t *tmp159 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + ScaleUp1((int32_t)128, tmp24, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp157, + tmp24, tmp159); + ClearMemSecret1((int32_t)128, tmp24); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp157); + + uint64_t *tmp162 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + Relu4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp159, tmp162, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp159); + + uint64_t *tmp164 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + Conv2DWrapper((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)3, + (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp155, tmp25, tmp164); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128, tmp25); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp155); + + uint64_t *tmp167 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + ScaleUp1((int32_t)128, tmp26, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp164, + tmp26, tmp167); + ClearMemSecret1((int32_t)128, tmp26); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp164); + + uint64_t *tmp170 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); + Relu4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp167, tmp170, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp167); + + int64_t tmp172 = (int32_t)3; + + uint64_t *tmp173 = + make_array((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256); + Concat2T444((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, (int32_t)1, + (int32_t)27, (int32_t)27, (int32_t)128, tmp162, (int32_t)1, + (int32_t)27, (int32_t)27, (int32_t)128, tmp170, tmp172, tmp173); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp170); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp162); + ClearMemPublic(tmp172); + + uint64_t *tmp177 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + MaxPool((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, (int32_t)3, + (int32_t)3, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)27, (int32_t)27, + (int32_t)256, tmp173, tmp177); + ClearMemSecret4((int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, tmp173); + + uint64_t *tmp179 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, (int32_t)1, + (int32_t)1, (int32_t)48, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp177, tmp27, tmp179); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp177); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)256, (int32_t)48, tmp27); + + uint64_t *tmp182 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); + ScaleUp1((int32_t)48, tmp28, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp179, + tmp28, tmp182); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp179); + ClearMemSecret1((int32_t)48, tmp28); + + uint64_t *tmp185 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp182, tmp185, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp182); + + uint64_t *tmp187 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)1, + (int32_t)1, (int32_t)192, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp185, tmp29, tmp187); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192, tmp29); + + uint64_t *tmp189 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + ScaleUp1((int32_t)192, tmp30, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp187, + tmp30, tmp189); + ClearMemSecret1((int32_t)192, tmp30); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp187); + + uint64_t *tmp192 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp189, tmp192, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp189); + + uint64_t *tmp194 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)3, + (int32_t)3, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp185, tmp31, tmp194); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp185); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192, tmp31); + + uint64_t *tmp197 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + ScaleUp1((int32_t)192, tmp32, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp194, + tmp32, tmp197); + ClearMemSecret1((int32_t)192, tmp32); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp194); + + uint64_t *tmp200 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp197, tmp200, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp197); + + int64_t tmp202 = (int32_t)3; + + uint64_t *tmp203 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384); + Concat2T444((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, + (int32_t)13, (int32_t)13, (int32_t)192, tmp192, (int32_t)1, + (int32_t)13, (int32_t)13, (int32_t)192, tmp200, tmp202, tmp203); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp200); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp192); + ClearMemPublic(tmp202); + + uint64_t *tmp207 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, + (int32_t)1, (int32_t)48, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp203, tmp33, tmp207); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, tmp203); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)384, (int32_t)48, tmp33); + + uint64_t *tmp210 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); + ScaleUp1((int32_t)48, tmp34, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp207, + tmp34, tmp210); + ClearMemSecret1((int32_t)48, tmp34); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp207); + + uint64_t *tmp213 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp210, tmp213, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp210); + + uint64_t *tmp215 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)1, + (int32_t)1, (int32_t)192, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp213, tmp35, tmp215); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192, tmp35); + + uint64_t *tmp217 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + ScaleUp1((int32_t)192, tmp36, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp215, + tmp36, tmp217); + ClearMemSecret1((int32_t)192, tmp36); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp215); + + uint64_t *tmp220 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp217, tmp220, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp217); + + uint64_t *tmp222 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)3, + (int32_t)3, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp213, tmp37, tmp222); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp213); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192, tmp37); + + uint64_t *tmp225 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + ScaleUp1((int32_t)192, tmp38, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp222, + tmp38, tmp225); + ClearMemSecret1((int32_t)192, tmp38); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp222); + + uint64_t *tmp228 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp225, tmp228, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp225); + + int64_t tmp230 = (int32_t)3; + + uint64_t *tmp231 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384); + Concat2T444((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, + (int32_t)13, (int32_t)13, (int32_t)192, tmp220, (int32_t)1, + (int32_t)13, (int32_t)13, (int32_t)192, tmp228, tmp230, tmp231); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp220); + ClearMemPublic(tmp230); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp228); + + uint64_t *tmp235 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, + (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp231, tmp39, tmp235); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, tmp231); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)384, (int32_t)64, tmp39); + + uint64_t *tmp238 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); + ScaleUp1((int32_t)64, tmp40, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp235, + tmp40, tmp238); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp235); + ClearMemSecret1((int32_t)64, tmp40); + + uint64_t *tmp241 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp238, tmp241, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp238); + + uint64_t *tmp243 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp241, tmp41, tmp243); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp41); + + uint64_t *tmp245 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + ScaleUp1((int32_t)256, tmp42, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp243, + tmp42, tmp245); + ClearMemSecret1((int32_t)256, tmp42); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp243); + + uint64_t *tmp248 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp245, tmp248, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp245); + + uint64_t *tmp250 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp241, tmp43, tmp250); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256, tmp43); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp241); + + uint64_t *tmp253 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + ScaleUp1((int32_t)256, tmp44, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp250, + tmp44, tmp253); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp250); + ClearMemSecret1((int32_t)256, tmp44); + + uint64_t *tmp256 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp253, tmp256, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp253); + + int64_t tmp258 = (int32_t)3; + + uint64_t *tmp259 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512); + Concat2T444((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, + (int32_t)13, (int32_t)13, (int32_t)256, tmp248, (int32_t)1, + (int32_t)13, (int32_t)13, (int32_t)256, tmp256, tmp258, tmp259); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp256); + ClearMemPublic(tmp258); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp248); + + uint64_t *tmp263 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp259, tmp45, tmp263); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, tmp259); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)64, tmp45); + + uint64_t *tmp266 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); + ScaleUp1((int32_t)64, tmp46, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp263, + tmp46, tmp266); + ClearMemSecret1((int32_t)64, tmp46); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp263); + + uint64_t *tmp269 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp266, tmp269, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp266); + + uint64_t *tmp271 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)1, + (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp269, tmp47, tmp271); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp47); + + uint64_t *tmp273 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + ScaleUp1((int32_t)256, tmp48, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp271, + tmp48, tmp273); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp271); + ClearMemSecret1((int32_t)256, tmp48); + + uint64_t *tmp276 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp273, tmp276, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp273); + + uint64_t *tmp278 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)3, + (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1, (int32_t)1, tmp269, tmp49, tmp278); + ClearMemSecret4((int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256, tmp49); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp269); + + uint64_t *tmp281 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + ScaleUp1((int32_t)256, tmp50, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp278, + tmp50, tmp281); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp278); + ClearMemSecret1((int32_t)256, tmp50); + + uint64_t *tmp284 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp281, tmp284, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp281); + + int64_t tmp286 = (int32_t)3; + + uint64_t *tmp287 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512); + Concat2T444((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, + (int32_t)13, (int32_t)13, (int32_t)256, tmp276, (int32_t)1, + (int32_t)13, (int32_t)13, (int32_t)256, tmp284, tmp286, tmp287); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp276); + ClearMemPublic(tmp286); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp284); + + uint64_t *tmp291 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000); + Conv2DWrapper((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, + (int32_t)1, (int32_t)1000, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)0, (int32_t)1, (int32_t)1, tmp287, tmp51, tmp291); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1000, tmp51); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, tmp287); + + uint64_t *tmp294 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000); + ScaleUp1((int32_t)1000, tmp52, (int32_t)9); + MatAddBroadCast4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp291, + tmp52, tmp294); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp291); + ClearMemSecret1((int32_t)1000, tmp52); + + uint64_t *tmp297 = + make_array((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000); + Relu4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp294, tmp297, + (int32_t)9, 1); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp294); + + uint64_t *tmp299 = + make_array((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000); + AvgPool((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, (int32_t)13, + (int32_t)13, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, + (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)13, (int32_t)13, + (int32_t)1000, tmp297, tmp299); + ClearMemSecret4((int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp297); + + int64_t tmp301 = (int32_t)3; + + uint64_t *tmp302 = make_array((int32_t)1, (int32_t)1, (int32_t)1); + ArgMax3((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, + (int32_t)1, (int32_t)1000, tmp299, tmp301, tmp302); + ClearMemPublic(tmp301); + ClearMemSecret4((int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp299); + EndComputation(); + for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++) { + for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++) { + for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1; i2++) { + cout << (funcReconstruct2PCCons(Arr3DIdxRowM(tmp302, (int32_t)1, + (int32_t)1, (int32_t)1, i0, + i1, i2), + 2)) + << endl; + } + } + } +} diff --git a/SCI/networks/main_sqnet_field64.cpp b/SCI/networks/main_sqnet_field64.cpp deleted file mode 100644 index 7e0ae87d..00000000 --- a/SCI/networks/main_sqnet_field64.cpp +++ /dev/null @@ -1,3054 +0,0 @@ -/* -This is an autogenerated file, generated using the EzPC compiler. -*/ - - -#define BITLEN_32 -#define SCI_HE - - -#include "globals.h" -#include "functionalities_wrapper.h" -#include -using namespace std; - -template -T* make_array(size_t s1){ -return new T[s1]; -} - -template -T* make_array(size_t s1, size_t s2){ -return new T[s1*s2]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3){ -return new T[s1*s2*s3]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){ -return new T[s1*s2*s3*s4]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){ -return new T[s1*s2*s3*s4*s5]; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr1DIdxRowM(B,s2,i2)); -} -} -} - -void MatAdd2(int64_t s1, int64_t s2, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr2DIdxRowM(B,s1,s2,i1,i2)); -} -} -} - -void MatAddBroadCast4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr1DIdxRowM(B,s4,i4)); -} -} -} -} -} - -void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr4DIdxRowM(B,s1,s2,s3,s4,i1,i2,i3,i4)); -} -} -} -} -} - -void MatAddBroadCast5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr1DIdxRowM(B,s5,i5)); -} -} -} -} -} -} - -void MatAdd5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* A, uint64_t* B, uint64_t* outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr5DIdxRowM(B,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5)); -} -} -} -} -} -} - -void CreateTensor1(int64_t s1, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(arr,s1,i1) = val; -} -} - -void CreateTensor2(int64_t s1, int64_t s2, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(arr,s1,s2,i1,i2) = val; -} -} -} - -void CreateTensor3(int64_t s1, int64_t s2, int64_t s3, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = val; -} -} -} -} - -void CreateTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = val; -} -} -} -} -} - -void CreateTensor5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t val, int64_t* arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(arr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = val; -} -} -} -} -} -} - -void CopyTensor1(int64_t s1, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(targetArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CopyTensor2(int64_t s1, int64_t s2, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(targetArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CopyTensor3(int64_t s1, int64_t s2, int64_t s3, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(targetArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CopyTensor4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* targetArr, uint64_t* fromArr, uint64_t* ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(targetArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateIdentity11(int64_t s1, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(newArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CreateIdentity22(int64_t s1, int64_t s2, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(newArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CreateIdentity33(int64_t s1, int64_t s2, int64_t s3, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(newArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CreateIdentity44(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* fromArr, uint64_t* newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(newArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateCopy2211(int64_t s1, int64_t s2, int64_t inps1, int64_t inps2, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,inps1,inps2,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j)); -} -} -} - -void CreateCopy5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inArr, int64_t perDimSize, int64_t* beginIdx, int64_t* sizeIdx, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inArr,inps1,inps2,inps3,inps4,inps5,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)2) + k),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)3) + l),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)4) + m)); -} -} -} -} -} -} - -void Concat2T222(int64_t s1, int64_t s2, int64_t inp1s1, int64_t inp1s2, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,(i1 - inp1s1),i2); -} -} else { -if ((i2 < inp1s2)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,i1,(i2 - inp1s2)); -} -} -} -} -} - -void Concat2T444(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inp1s1, int64_t inp1s2, int64_t inp1s3, int64_t inp1s4, uint64_t* inp1, int64_t inp2s1, int64_t inp2s2, int64_t inp2s3, int64_t inp2s4, uint64_t* inp2, int64_t axis, uint64_t* outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,(i1 - inp1s1),i2,i3,i4); -} -} else { -if ((axis == (int32_t)1)) { -if ((i2 < inp1s2)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,(i2 - inp1s2),i3,i4); -} -} else { -if ((axis == (int32_t)2)) { -if ((i3 < inp1s3)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,(i3 - inp1s3),i4); -} -} else { -if ((i4 < inp1s4)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,i3,(i4 - inp1s4)); -} -} -} -} -} -} -} -} -} - -void Split44(int64_t O1, int64_t O2, int64_t O3, int64_t O4, int64_t I1, int64_t I2, int64_t I3, int64_t I4, uint64_t* inp, int64_t axis, int64_t curCount, int64_t total, uint64_t* out){ -for (uint64_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint64_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint64_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint64_t o4 = (int32_t)0; o4 < O4; o4++){ - -int64_t i1 = o1; - -int64_t i2 = o2; - -int64_t i3 = o3; - -int64_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (((I1 / total) * curCount) + o1); -} -if ((axis == (int32_t)1)) { -i2 = (((I2 / total) * curCount) + o2); -} -if ((axis == (int32_t)2)) { -i3 = (((I3 / total) * curCount) + o3); -} -if ((axis == (int32_t)3)) { -i4 = (((I4 / total) * curCount) + o4); -} -Arr4DIdxRowM(out,O1,O2,O3,O4,o1,o2,o3,o4) = Arr4DIdxRowM(inp,I1,I2,I3,I4,i1,i2,i3,i4); -} -} -} -} -} - -void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CI,CO,fh,fw,ci,co); -} -} -} -} -} - -void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2D(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t outH, int64_t outW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t GIS = (CI / G); - -int64_t GOS = (CO / G); -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint64_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint64_t g = (int32_t)0; g < G; g++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ - -uint64_t val = funcSSCons( (int32_t)0); - -int64_t ci = ((GIS * g) + cig); - -int64_t co = ((GOS * g) + cog); - -int64_t curPosH = ((strideH * h) - zPadHLeft); -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ - -int64_t curPosW = ((strideW * w) - zPadWLeft); -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && (curPosH < H)) && (curPosW < W))) { -val = SecretAdd(val, SecretMult(Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci), Arr4DIdxRowM(filterArr,FH,FW,(CI / G),CO,fh,fw,(ci / G),co))); -} -curPosW = (curPosW + (int32_t)1); -} -curPosH = (curPosH + (int32_t)1); -} -Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co) = SecretAdd(Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co), val); -} -} -} -} -} -} -} - -void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t CIG = (CI / G); - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ - -int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); -Arr2DIdxRowM(outputArr,(CO / G),((FH * FW) * (CI / G)),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,(CI / G),CO,fh,fw,ci,(co + startCO)); -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, int64_t g, int64_t G, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t COG = (CO / G); - -int64_t startCO = (g * COG); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,(co + startCO)) = Arr2DIdxRowM(inputArr,(CO / G),((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t g, int64_t G, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; - -int64_t CIG = (CI / G); -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); - -int64_t startCI = (g * CIG); -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,(ci + startCI)); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CIG) + (fw * CIG)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH, int64_t strideW, int64_t G, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t CIG = (CI / G); - -int64_t reshapedFilterRows = (CO / G); - -int64_t reshapedFilterCols = ((FH * FW) * CIG); - -int64_t reshapedIPRows = ((FH * FW) * CIG); - -int64_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = ((N * outH) * outW); -for (uint64_t g = (int32_t)0; g < G; g++){ - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -} -} - -void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CI,CO,fd,fh,fw,ci,co); -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t d = (int32_t)0; d < finalD; d++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr5DIdxRowM(outputArr,N,finalD,finalH,finalW,CO,n,d,h,w,co) = Arr2DIdxRowM(inputArr,CO,(((N * finalD) * finalH) * finalW),co,((((((n * finalD) * finalH) * finalW) + ((d * finalH) * finalW)) + (h * finalW)) + w)); -} -} -} -} -} -} - -void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadDLeft); - -int64_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int64_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int64_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= D)) || ((curPosH < (int32_t)0) || (curPosH >= H))) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -leftTopCornerD = (leftTopCornerD + strideD); -} - -} -} - -void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); - -int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int64_t reshapedIPCols = (((N * newD) * newH) * newW); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD); fd++){ -for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH); fh++){ -for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW); fw++){ - -int64_t curPosD = (fd - zPadDLeft); - -int64_t curPosH = (fh - zPadHLeft); - -int64_t curPosW = (fw - zPadWLeft); -if (((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W))) { - -int64_t curFilterPosD = (fd - (d * strideD)); - -int64_t curFilterPosH = (fh - (h * strideH)); - -int64_t curFilterPosW = (fw - (w * strideW)); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CI,CO,curFilterPosD,curFilterPosH,curFilterPosW,ci,co))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); - -int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW, int64_t CO, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CO,CI,((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} - -void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int32_t)0); -} else { -if ((((curPosH % strideH) == (int32_t)0) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr4DIdxRowM(inputArr,N,HPrime,WPrime,CI,n,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -} -} - -void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = ((FH * FW) * CI); - -int64_t reshapedIPRows = ((FH * FW) * CI); - -int64_t reshapedIPCols = ((N * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t CI, uint64_t* inputArr, uint64_t* outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -int64_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CO,CI,((FD - (int32_t)1) - fd),((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t RRows, int64_t RCols, uint64_t* inputArr, uint64_t* outputArr){ - -int64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -int64_t leftTopCornerD = ( (int32_t)0 - zPadTrDLeft); - -int64_t DPrimeTilde = (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); - -int64_t extremeRightBottomCornerD = ((DPrimeTilde - (int32_t)1) + zPadTrDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int64_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int64_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int64_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int64_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int64_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int64_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -int64_t curPosD = (leftTopCornerD + fd); - -int64_t curPosH = (leftTopCornerH + fh); - -int64_t curPosW = (leftTopCornerW + fw); - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int32_t)0); -} else { -if (((((curPosD % strideD) == (int32_t)0) && ((curPosH % strideH) == (int32_t)0)) && ((curPosW % strideW) == (int32_t)0))) { - -int64_t idxInputD = (curPosD / strideD); - -int64_t idxInputH = (curPosH / strideH); - -int64_t idxInputW = (curPosW / strideW); -val = Arr5DIdxRowM(inputArr,N,DPrime,HPrime,WPrime,CI,n,idxInputD,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -leftTopCornerD = (leftTopCornerD + (int32_t)1); -} - -} -} - -void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ - -int64_t reshapedFilterRows = CO; - -int64_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int64_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int64_t reshapedIPCols = (((N * D) * H) * W); - -uint64_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint64_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint64_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD, int64_t strideH, int64_t strideW, int64_t outD, int64_t outH, int64_t outW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = funcSSCons( (int32_t)0); -for (uint64_t fd = d; fd < (d + FD); fd++){ -for (uint64_t fh = h; fh < (h + FH); fh++){ -for (uint64_t fw = w; fw < (w + FW); fw++){ - -int64_t curPosD = ((fd - zPadDLeft) / strideD); - -int64_t curPosH = ((fh - zPadHLeft) / strideD); - -int64_t curPosW = ((fw - zPadWLeft) / strideD); -if ((((((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W)) && (((fd - zPadDLeft) % strideD) == (int32_t)0)) && (((fh - zPadHLeft) % strideH) == (int32_t)0)) && (((fw - zPadWLeft) % strideW) == (int32_t)0))) { - -int64_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); - -int64_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); - -int64_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CO,CI,curFilterPosD,curFilterPosH,curFilterPosW,co,ci))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime, int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO, int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight, int64_t zPadTrHLeft, int64_t zPadTrHRight, int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideD, int64_t strideH, int64_t strideW, uint64_t* inputArr, uint64_t* filterArr, uint64_t* outArr){ -ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,s2,s1,j,i); -} -} -} - -void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = Arr4DIdxRowM(inpArr,inps1,inps2,inps3,inps4,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0))); -} else { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = funcSSCons( (int32_t)0); -} -} -} -} -} -} - -void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4, int64_t inps5, uint64_t* inpArr, int64_t pads1, int64_t pads2, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int64_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int64_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int64_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); - -int64_t lbounds5 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0); - -int64_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)1)); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl)) && (m >= lbounds5)) && (m < rbounds5excl))) { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inpArr,inps1,inps2,inps3,inps4,inps5,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0)),(m - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0))); -} else { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = funcSSCons( (int32_t)0); -} -} -} -} -} -} -} - -void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1, int64_t i2, int64_t i3, int64_t i4, uint64_t* inpArr, int64_t pads, int64_t* paddings, uint64_t* outArr){ - -int64_t lbounds1 = Arr1DIdxRowM(paddings,pads, (int32_t)0); - -int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings,pads, (int32_t)4)); - -int64_t lbounds2 = Arr1DIdxRowM(paddings,pads, (int32_t)1); - -int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings,pads, (int32_t)5)); - -int64_t lbounds3 = Arr1DIdxRowM(paddings,pads, (int32_t)2); - -int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings,pads, (int32_t)6)); - -int64_t lbounds4 = Arr1DIdxRowM(paddings,pads, (int32_t)3); - -int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings,pads, (int32_t)7)); -for (uint64_t i = (int32_t)0; i < o1; i++){ -for (uint64_t j = (int32_t)0; j < o2; j++){ -for (uint64_t k = (int32_t)0; k < o3; k++){ -for (uint64_t l = (int32_t)0; l < o4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = Arr4DIdxRowM(inpArr,i1,i2,i3,i4,(i - Arr1DIdxRowM(paddings,pads, (int32_t)0)),(j - Arr1DIdxRowM(paddings,pads, (int32_t)1)),(k - Arr1DIdxRowM(paddings,pads, (int32_t)2)),(l - Arr1DIdxRowM(paddings,pads, (int32_t)3))); -} else { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = funcSSCons( (int32_t)0); -} -} -} -} -} -} - -void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, uint64_t* outArr){ -for (uint64_t i = (int32_t)0; i < ins1; i++){ -for (uint64_t j = (int32_t)0; j < ins2; j++){ -for (uint64_t k = (int32_t)0; k < ins3; k++){ -for (uint64_t l = (int32_t)0; l < ins4; l++){ - -int64_t linIdx = ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + (k * ins4)) + l); - -int64_t outIdx1 = (linIdx / s2); - -int64_t outIdx2 = (linIdx % s2); -Arr2DIdxRowM(outArr,s1,s2,outIdx1,outIdx2) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i,j,k,l); -} -} -} -} -} - -void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s4,i4); -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s4); -for (uint64_t ii = (int32_t)0; ii < s4; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s4,ii) = Arr1DIdxRowM(biasArr,s4,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outputArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s4,i4)); -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* multArr, uint64_t* biasArr, int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf, uint64_t* outputArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* inArrReshaped = make_array(inpSize); - -uint64_t* multArrReshaped = make_array(inpSize); - -uint64_t* multExprAns = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s5,i5); -} -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint64_t* biasArrScaledUp = make_array(s5); -for (uint64_t ii = (int32_t)0; ii < s5; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s5,ii) = Arr1DIdxRowM(biasArr,s5,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outputArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s5,i5)); -} -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s5, biasArrScaledUp); -} - -void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (s1 * s2); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr1,s1,s2,i1,i2); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr2,s1,s2,i1,i2); -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = (((s1 * s2) * s3) * s4); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr1,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr2,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* arr1, uint64_t* arr2, uint64_t* outArr){ - -int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* arr1Reshaped = make_array(inpSize); - -uint64_t* arr2Reshaped = make_array(inpSize); - -uint64_t* outArrReshaped = make_array(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr1,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr2,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t* axes, uint64_t* outputArr){ - -int64_t divisor = (inS2 * inS3); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = funcSSCons( (int32_t)0); -for (uint64_t i = (int32_t)0; i < inS2; i++){ -for (uint64_t j = (int32_t)0; j < inS3; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i,j,i2)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2, int64_t inS3, int64_t inS4, uint64_t* inputArr, int64_t axis1, int64_t axis2, uint64_t* outputArr){ - -int64_t divisor = (inS3 * inS4); - -int64_t outputSize = (outS1 * outS2); - -uint64_t* sumArr = make_array(outputSize); - -uint64_t* outputArrReshaped = make_array(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = funcSSCons( (int32_t)0); -for (uint64_t i = (int32_t)0; i < inS3; i++){ -for (uint64_t j = (int32_t)0; j < inS4; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i2,i,j)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2, uint64_t* inArr, int64_t dim, uint64_t* outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1, int64_t ins2, int64_t ins3, int64_t ins4, uint64_t* inArr, int64_t dim, uint64_t* outArr){ - -int64_t size = ((ins1 * ins2) * ins3); - -uint64_t* reshapedInArr = make_array(size, ins4); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr2DIdxRowM(reshapedInArr,size,ins4,linIdx,i4) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i1,i2,i3,i4); -} -} -} -} -ArgMax(size, ins4, reshapedInArr, reshapedOutArr); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ - -int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr3DIdxRowM(outArr,outs1,outs2,outs3,i1,i2,i3) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -ClearMemSecret2(size, ins4, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5, uint64_t* inArr, uint64_t* outArr, int64_t sf, uint64_t doTruncation){ - -int64_t size = ((((s1 * s2) * s3) * s4) * s5); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -int64_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Floor2(int64_t s1, int64_t s2, uint64_t* inArr, uint64_t* outArr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedInArr = make_array(size); - -uint64_t* reshapedOutArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Floor(size, reshapedInArr, reshapedOutArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void ScaleUp1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleUp(s1, arr, sf); -} - -void ScaleUp2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown1(int64_t s1, uint64_t* arr, int64_t sf){ -ScaleDown(s1, arr, sf); -} - -void ScaleDown2(int64_t s1, int64_t s2, uint64_t* arr, int64_t sf){ - -int64_t size = (s1 * s2); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -int64_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t* arr, int64_t sf){ - -int64_t size = ((s1 * s2) * s3); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t* arr, int64_t sf){ - -int64_t size = (((s1 * s2) * s3) * s4); - -uint64_t* reshapedArr = make_array(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -int64_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - - -int main(int argc, char** argv) -{ -ArgMapping amap; -int port = 32000; -string serverAddr = "127.0.0.1"; - -amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); -amap.arg("p", port, "Port Number"); -amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); -amap.parse(argc, argv); - -assert(party==sci::ALICE || party==sci::BOB); - -checkIfUsingEigen(); -for(int i=0;i(ioArr[i]); -prgInstanceArr[i] = new sci::PRG128(); -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); -if (i == 0) { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength); -} -else if (i == 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength); -} -else if (i & 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[1]); -} -else { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[0]); -} -} - -io = ioArr[0]; -iknpOT = new sci::IKNP(io); -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good -kkot = new sci::KKOT(io); -prg128Instance = new sci::PRG128(); -otpack = new sci::OTPack(io, party, baseForRelu, bitlength); - -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - -#ifdef SCI_OT -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack); -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -#endif - -#ifdef SCI_HE -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -heConvImpl = new ConvField(party,io); -heFCImpl = new FCField(party,io); -heProdImpl = new ElemWiseProdField(party, io); -assertFieldRun(); -#endif -#ifdef MULTITHREADED_NONLIN -#ifdef SCI_OT -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -} -#endif -#ifdef SCI_HE -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -} -#endif -#endif - -if (party==sci::ALICE){ -iknpOT->setup_send(); -iknpOTRoleReversed->setup_recv(); -} -else if (party==sci::BOB){ -iknpOT->setup_recv(); -iknpOTRoleReversed->setup_send(); -} -cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<( (int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3); -/* Variable to read the clear value corresponding to the input variable tmp0 at (1930,1-1930,46) */ -uint64_t __tmp_in_tmp0; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)227; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)227; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)3; i3++){ -if ((party == CLIENT)) { -cin >> __tmp_in_tmp0; -} -Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3,i0,i1,i2,i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; -} -} -} -} - -uint64_t* tmp1 = make_array( (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp1 at (1933,1-1933,43) */ -uint64_t __tmp_in_tmp1; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)3; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp1; -} -Arr4DIdxRowM(tmp1, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; -} -} -} -} - -uint64_t* tmp2 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp2 at (1936,1-1936,34) */ -uint64_t __tmp_in_tmp2; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp2; -} -Arr1DIdxRowM(tmp2, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; -} - -uint64_t* tmp3 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp3 at (1939,1-1939,44) */ -uint64_t __tmp_in_tmp3; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp3; -} -Arr4DIdxRowM(tmp3, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp3 : 0; -} -} -} -} - -uint64_t* tmp4 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp4 at (1942,1-1942,34) */ -uint64_t __tmp_in_tmp4; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp4; -} -Arr1DIdxRowM(tmp4, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; -} - -uint64_t* tmp5 = make_array( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp5 at (1945,1-1945,44) */ -uint64_t __tmp_in_tmp5; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)16; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp5; -} -Arr4DIdxRowM(tmp5, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp5 : 0; -} -} -} -} - -uint64_t* tmp6 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp6 at (1948,1-1948,34) */ -uint64_t __tmp_in_tmp6; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp6; -} -Arr1DIdxRowM(tmp6, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp6 : 0; -} - -uint64_t* tmp7 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp7 at (1951,1-1951,44) */ -uint64_t __tmp_in_tmp7; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)16; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp7; -} -Arr4DIdxRowM(tmp7, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; -} -} -} -} - -uint64_t* tmp8 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp8 at (1954,1-1954,34) */ -uint64_t __tmp_in_tmp8; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp8; -} -Arr1DIdxRowM(tmp8, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; -} - -uint64_t* tmp9 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp9 at (1957,1-1957,45) */ -uint64_t __tmp_in_tmp9; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp9; -} -Arr4DIdxRowM(tmp9, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp9 : 0; -} -} -} -} - -uint64_t* tmp10 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp10 at (1960,1-1960,35) */ -uint64_t __tmp_in_tmp10; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp10; -} -Arr1DIdxRowM(tmp10, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp10 : 0; -} - -uint64_t* tmp11 = make_array( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp11 at (1963,1-1963,45) */ -uint64_t __tmp_in_tmp11; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)16; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp11; -} -Arr4DIdxRowM(tmp11, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp11 : 0; -} -} -} -} - -uint64_t* tmp12 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp12 at (1966,1-1966,35) */ -uint64_t __tmp_in_tmp12; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp12; -} -Arr1DIdxRowM(tmp12, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp12 : 0; -} - -uint64_t* tmp13 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp13 at (1969,1-1969,45) */ -uint64_t __tmp_in_tmp13; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)16; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp13; -} -Arr4DIdxRowM(tmp13, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp13 : 0; -} -} -} -} - -uint64_t* tmp14 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp14 at (1972,1-1972,35) */ -uint64_t __tmp_in_tmp14; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp14; -} -Arr1DIdxRowM(tmp14, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp14 : 0; -} - -uint64_t* tmp15 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp15 at (1975,1-1975,46) */ -uint64_t __tmp_in_tmp15; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)128; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp15; -} -Arr4DIdxRowM(tmp15, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp15 : 0; -} -} -} -} - -uint64_t* tmp16 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp16 at (1978,1-1978,35) */ -uint64_t __tmp_in_tmp16; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp16; -} -Arr1DIdxRowM(tmp16, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp16 : 0; -} - -uint64_t* tmp17 = make_array( (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp17 at (1981,1-1981,46) */ -uint64_t __tmp_in_tmp17; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp17; -} -Arr4DIdxRowM(tmp17, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp17 : 0; -} -} -} -} - -uint64_t* tmp18 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp18 at (1984,1-1984,36) */ -uint64_t __tmp_in_tmp18; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp18; -} -Arr1DIdxRowM(tmp18, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp18 : 0; -} - -uint64_t* tmp19 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp19 at (1987,1-1987,46) */ -uint64_t __tmp_in_tmp19; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp19; -} -Arr4DIdxRowM(tmp19, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp19 : 0; -} -} -} -} - -uint64_t* tmp20 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp20 at (1990,1-1990,36) */ -uint64_t __tmp_in_tmp20; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp20; -} -Arr1DIdxRowM(tmp20, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp20 : 0; -} - -uint64_t* tmp21 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp21 at (1993,1-1993,46) */ -uint64_t __tmp_in_tmp21; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp21; -} -Arr4DIdxRowM(tmp21, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp21 : 0; -} -} -} -} - -uint64_t* tmp22 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp22 at (1996,1-1996,35) */ -uint64_t __tmp_in_tmp22; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp22; -} -Arr1DIdxRowM(tmp22, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp22 : 0; -} - -uint64_t* tmp23 = make_array( (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp23 at (1999,1-1999,46) */ -uint64_t __tmp_in_tmp23; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp23; -} -Arr4DIdxRowM(tmp23, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp23 : 0; -} -} -} -} - -uint64_t* tmp24 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp24 at (2002,1-2002,36) */ -uint64_t __tmp_in_tmp24; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp24; -} -Arr1DIdxRowM(tmp24, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp24 : 0; -} - -uint64_t* tmp25 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp25 at (2005,1-2005,46) */ -uint64_t __tmp_in_tmp25; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)32; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp25; -} -Arr4DIdxRowM(tmp25, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp25 : 0; -} -} -} -} - -uint64_t* tmp26 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp26 at (2008,1-2008,36) */ -uint64_t __tmp_in_tmp26; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp26; -} -Arr1DIdxRowM(tmp26, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp26 : 0; -} - -uint64_t* tmp27 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)48); -/* Variable to read the clear value corresponding to the input variable tmp27 at (2011,1-2011,46) */ -uint64_t __tmp_in_tmp27; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)256; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)48; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp27; -} -Arr4DIdxRowM(tmp27, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)48,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp27 : 0; -} -} -} -} - -uint64_t* tmp28 = make_array( (int32_t)48); -/* Variable to read the clear value corresponding to the input variable tmp28 at (2014,1-2014,35) */ -uint64_t __tmp_in_tmp28; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)48; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp28; -} -Arr1DIdxRowM(tmp28, (int32_t)48,i0) = (party == SERVER) ? __tmp_in_tmp28 : 0; -} - -uint64_t* tmp29 = make_array( (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp29 at (2017,1-2017,46) */ -uint64_t __tmp_in_tmp29; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)48; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)192; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp29; -} -Arr4DIdxRowM(tmp29, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp29 : 0; -} -} -} -} - -uint64_t* tmp30 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp30 at (2020,1-2020,36) */ -uint64_t __tmp_in_tmp30; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp30; -} -Arr1DIdxRowM(tmp30, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp30 : 0; -} - -uint64_t* tmp31 = make_array( (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp31 at (2023,1-2023,46) */ -uint64_t __tmp_in_tmp31; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)48; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)192; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp31; -} -Arr4DIdxRowM(tmp31, (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp31 : 0; -} -} -} -} - -uint64_t* tmp32 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp32 at (2026,1-2026,36) */ -uint64_t __tmp_in_tmp32; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp32; -} -Arr1DIdxRowM(tmp32, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp32 : 0; -} - -uint64_t* tmp33 = make_array( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)48); -/* Variable to read the clear value corresponding to the input variable tmp33 at (2029,1-2029,46) */ -uint64_t __tmp_in_tmp33; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)384; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)48; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp33; -} -Arr4DIdxRowM(tmp33, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)48,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp33 : 0; -} -} -} -} - -uint64_t* tmp34 = make_array( (int32_t)48); -/* Variable to read the clear value corresponding to the input variable tmp34 at (2032,1-2032,35) */ -uint64_t __tmp_in_tmp34; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)48; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp34; -} -Arr1DIdxRowM(tmp34, (int32_t)48,i0) = (party == SERVER) ? __tmp_in_tmp34 : 0; -} - -uint64_t* tmp35 = make_array( (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp35 at (2035,1-2035,46) */ -uint64_t __tmp_in_tmp35; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)48; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)192; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp35; -} -Arr4DIdxRowM(tmp35, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp35 : 0; -} -} -} -} - -uint64_t* tmp36 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp36 at (2038,1-2038,36) */ -uint64_t __tmp_in_tmp36; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp36; -} -Arr1DIdxRowM(tmp36, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp36 : 0; -} - -uint64_t* tmp37 = make_array( (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp37 at (2041,1-2041,46) */ -uint64_t __tmp_in_tmp37; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)48; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)192; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp37; -} -Arr4DIdxRowM(tmp37, (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp37 : 0; -} -} -} -} - -uint64_t* tmp38 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp38 at (2044,1-2044,36) */ -uint64_t __tmp_in_tmp38; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp38; -} -Arr1DIdxRowM(tmp38, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp38 : 0; -} - -uint64_t* tmp39 = make_array( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp39 at (2047,1-2047,46) */ -uint64_t __tmp_in_tmp39; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)384; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp39; -} -Arr4DIdxRowM(tmp39, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp39 : 0; -} -} -} -} - -uint64_t* tmp40 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp40 at (2050,1-2050,35) */ -uint64_t __tmp_in_tmp40; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp40; -} -Arr1DIdxRowM(tmp40, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp40 : 0; -} - -uint64_t* tmp41 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp41 at (2053,1-2053,46) */ -uint64_t __tmp_in_tmp41; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp41; -} -Arr4DIdxRowM(tmp41, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp41 : 0; -} -} -} -} - -uint64_t* tmp42 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp42 at (2056,1-2056,36) */ -uint64_t __tmp_in_tmp42; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp42; -} -Arr1DIdxRowM(tmp42, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp42 : 0; -} - -uint64_t* tmp43 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp43 at (2059,1-2059,46) */ -uint64_t __tmp_in_tmp43; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp43; -} -Arr4DIdxRowM(tmp43, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp43 : 0; -} -} -} -} - -uint64_t* tmp44 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp44 at (2062,1-2062,36) */ -uint64_t __tmp_in_tmp44; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp44; -} -Arr1DIdxRowM(tmp44, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp44 : 0; -} - -uint64_t* tmp45 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp45 at (2065,1-2065,46) */ -uint64_t __tmp_in_tmp45; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp45; -} -Arr4DIdxRowM(tmp45, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp45 : 0; -} -} -} -} - -uint64_t* tmp46 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp46 at (2068,1-2068,35) */ -uint64_t __tmp_in_tmp46; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp46; -} -Arr1DIdxRowM(tmp46, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp46 : 0; -} - -uint64_t* tmp47 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp47 at (2071,1-2071,46) */ -uint64_t __tmp_in_tmp47; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp47; -} -Arr4DIdxRowM(tmp47, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp47 : 0; -} -} -} -} - -uint64_t* tmp48 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp48 at (2074,1-2074,36) */ -uint64_t __tmp_in_tmp48; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp48; -} -Arr1DIdxRowM(tmp48, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp48 : 0; -} - -uint64_t* tmp49 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp49 at (2077,1-2077,46) */ -uint64_t __tmp_in_tmp49; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)3; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)3; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)64; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp49; -} -Arr4DIdxRowM(tmp49, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp49 : 0; -} -} -} -} - -uint64_t* tmp50 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp50 at (2080,1-2080,36) */ -uint64_t __tmp_in_tmp50; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp50; -} -Arr1DIdxRowM(tmp50, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp50 : 0; -} - -uint64_t* tmp51 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1000); -/* Variable to read the clear value corresponding to the input variable tmp51 at (2083,1-2083,48) */ -uint64_t __tmp_in_tmp51; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)512; i2++){ -for (uint64_t i3 = (uint64_t)0; i3 < (int32_t)1000; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp51; -} -Arr4DIdxRowM(tmp51, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1000,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp51 : 0; -} -} -} -} - -uint64_t* tmp52 = make_array( (int32_t)1000); -/* Variable to read the clear value corresponding to the input variable tmp52 at (2086,1-2086,37) */ -uint64_t __tmp_in_tmp52; -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1000; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp52; -} -Arr1DIdxRowM(tmp52, (int32_t)1000,i0) = (party == SERVER) ? __tmp_in_tmp52 : 0; -} -StartComputation(); - -uint64_t* tmp53 = make_array( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp0, tmp1, tmp53); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, tmp1); -ClearMemSecret4( (int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3, tmp0); - -uint64_t* tmp56 = make_array( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64); -ScaleUp1( (int32_t)64, tmp2, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp53, tmp2, tmp56); -ClearMemSecret1( (int32_t)64, tmp2); -ClearMemSecret4( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp53); - -uint64_t* tmp59 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -MaxPool( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp56, tmp59); -ClearMemSecret4( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp56); - -uint64_t* tmp61 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp59, tmp61, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp59); - -uint64_t* tmp63 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp61, tmp3, tmp63); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp61); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16, tmp3); - -uint64_t* tmp66 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -ScaleUp1( (int32_t)16, tmp4, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp63, tmp4, tmp66); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp63); -ClearMemSecret1( (int32_t)16, tmp4); - -uint64_t* tmp69 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp66, tmp69, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp66); - -uint64_t* tmp71 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp69, tmp5, tmp71); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64, tmp5); - -uint64_t* tmp73 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleUp1( (int32_t)64, tmp6, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp71, tmp6, tmp73); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp71); -ClearMemSecret1( (int32_t)64, tmp6); - -uint64_t* tmp76 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp73, tmp76, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp73); - -uint64_t* tmp78 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp69, tmp7, tmp78); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp69); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64, tmp7); - -uint64_t* tmp81 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleUp1( (int32_t)64, tmp8, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp78, tmp8, tmp81); -ClearMemSecret1( (int32_t)64, tmp8); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp78); - -uint64_t* tmp84 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp81, tmp84, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp81); - -int64_t tmp86 = (int32_t)3; - -uint64_t* tmp87 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp76, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp84, tmp86, tmp87); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp84); -ClearMemPublic(tmp86); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp76); - -uint64_t* tmp91 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp87, tmp9, tmp91); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp87); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)16, tmp9); - -uint64_t* tmp94 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -ScaleUp1( (int32_t)16, tmp10, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp91, tmp10, tmp94); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp91); -ClearMemSecret1( (int32_t)16, tmp10); - -uint64_t* tmp97 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp94, tmp97, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp94); - -uint64_t* tmp99 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp97, tmp11, tmp99); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64, tmp11); - -uint64_t* tmp101 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleUp1( (int32_t)64, tmp12, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp99, tmp12, tmp101); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp99); -ClearMemSecret1( (int32_t)64, tmp12); - -uint64_t* tmp104 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp101, tmp104, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp101); - -uint64_t* tmp106 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp97, tmp13, tmp106); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64, tmp13); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp97); - -uint64_t* tmp109 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleUp1( (int32_t)64, tmp14, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp106, tmp14, tmp109); -ClearMemSecret1( (int32_t)64, tmp14); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp106); - -uint64_t* tmp112 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp109, tmp112, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp109); - -int64_t tmp114 = (int32_t)3; - -uint64_t* tmp115 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp104, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp112, tmp114, tmp115); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp104); -ClearMemPublic(tmp114); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp112); - -uint64_t* tmp119 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -MaxPool( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp115, tmp119); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp115); - -uint64_t* tmp121 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp119, tmp15, tmp121); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp119); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)32, tmp15); - -uint64_t* tmp124 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -ScaleUp1( (int32_t)32, tmp16, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp121, tmp16, tmp124); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp121); -ClearMemSecret1( (int32_t)32, tmp16); - -uint64_t* tmp127 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp124, tmp127, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp124); - -uint64_t* tmp129 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp127, tmp17, tmp129); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128, tmp17); - -uint64_t* tmp131 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -ScaleUp1( (int32_t)128, tmp18, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp129, tmp18, tmp131); -ClearMemSecret1( (int32_t)128, tmp18); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp129); - -uint64_t* tmp134 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp131, tmp134, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp131); - -uint64_t* tmp136 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp127, tmp19, tmp136); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128, tmp19); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp127); - -uint64_t* tmp139 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -ScaleUp1( (int32_t)128, tmp20, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp136, tmp20, tmp139); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp136); -ClearMemSecret1( (int32_t)128, tmp20); - -uint64_t* tmp142 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp139, tmp142, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp139); - -int64_t tmp144 = (int32_t)3; - -uint64_t* tmp145 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256); -Concat2T444( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp134, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp142, tmp144, tmp145); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp134); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp142); -ClearMemPublic(tmp144); - -uint64_t* tmp149 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp145, tmp21, tmp149); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)32, tmp21); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, tmp145); - -uint64_t* tmp152 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -ScaleUp1( (int32_t)32, tmp22, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp149, tmp22, tmp152); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp149); -ClearMemSecret1( (int32_t)32, tmp22); - -uint64_t* tmp155 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp152, tmp155, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp152); - -uint64_t* tmp157 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp155, tmp23, tmp157); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128, tmp23); - -uint64_t* tmp159 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -ScaleUp1( (int32_t)128, tmp24, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp157, tmp24, tmp159); -ClearMemSecret1( (int32_t)128, tmp24); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp157); - -uint64_t* tmp162 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp159, tmp162, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp159); - -uint64_t* tmp164 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp155, tmp25, tmp164); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128, tmp25); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp155); - -uint64_t* tmp167 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -ScaleUp1( (int32_t)128, tmp26, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp164, tmp26, tmp167); -ClearMemSecret1( (int32_t)128, tmp26); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp164); - -uint64_t* tmp170 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp167, tmp170, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp167); - -int64_t tmp172 = (int32_t)3; - -uint64_t* tmp173 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256); -Concat2T444( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp162, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp170, tmp172, tmp173); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp170); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp162); -ClearMemPublic(tmp172); - -uint64_t* tmp177 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -MaxPool( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, tmp173, tmp177); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, tmp173); - -uint64_t* tmp179 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp177, tmp27, tmp179); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp177); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)48, tmp27); - -uint64_t* tmp182 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -ScaleUp1( (int32_t)48, tmp28, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp179, tmp28, tmp182); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp179); -ClearMemSecret1( (int32_t)48, tmp28); - -uint64_t* tmp185 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp182, tmp185, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp182); - -uint64_t* tmp187 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp185, tmp29, tmp187); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192, tmp29); - -uint64_t* tmp189 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -ScaleUp1( (int32_t)192, tmp30, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp187, tmp30, tmp189); -ClearMemSecret1( (int32_t)192, tmp30); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp187); - -uint64_t* tmp192 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp189, tmp192, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp189); - -uint64_t* tmp194 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)3, (int32_t)3, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp185, tmp31, tmp194); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp185); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192, tmp31); - -uint64_t* tmp197 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -ScaleUp1( (int32_t)192, tmp32, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp194, tmp32, tmp197); -ClearMemSecret1( (int32_t)192, tmp32); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp194); - -uint64_t* tmp200 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp197, tmp200, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp197); - -int64_t tmp202 = (int32_t)3; - -uint64_t* tmp203 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384); -Concat2T444( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp192, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp200, tmp202, tmp203); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp200); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp192); -ClearMemPublic(tmp202); - -uint64_t* tmp207 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp203, tmp33, tmp207); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, tmp203); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)48, tmp33); - -uint64_t* tmp210 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -ScaleUp1( (int32_t)48, tmp34, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp207, tmp34, tmp210); -ClearMemSecret1( (int32_t)48, tmp34); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp207); - -uint64_t* tmp213 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp210, tmp213, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp210); - -uint64_t* tmp215 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp213, tmp35, tmp215); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192, tmp35); - -uint64_t* tmp217 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -ScaleUp1( (int32_t)192, tmp36, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp215, tmp36, tmp217); -ClearMemSecret1( (int32_t)192, tmp36); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp215); - -uint64_t* tmp220 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp217, tmp220, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp217); - -uint64_t* tmp222 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)3, (int32_t)3, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp213, tmp37, tmp222); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp213); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192, tmp37); - -uint64_t* tmp225 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -ScaleUp1( (int32_t)192, tmp38, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp222, tmp38, tmp225); -ClearMemSecret1( (int32_t)192, tmp38); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp222); - -uint64_t* tmp228 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp225, tmp228, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp225); - -int64_t tmp230 = (int32_t)3; - -uint64_t* tmp231 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384); -Concat2T444( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp220, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp228, tmp230, tmp231); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp220); -ClearMemPublic(tmp230); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp228); - -uint64_t* tmp235 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp231, tmp39, tmp235); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, tmp231); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)64, tmp39); - -uint64_t* tmp238 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -ScaleUp1( (int32_t)64, tmp40, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp235, tmp40, tmp238); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp235); -ClearMemSecret1( (int32_t)64, tmp40); - -uint64_t* tmp241 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp238, tmp241, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp238); - -uint64_t* tmp243 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp241, tmp41, tmp243); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp41); - -uint64_t* tmp245 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -ScaleUp1( (int32_t)256, tmp42, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp243, tmp42, tmp245); -ClearMemSecret1( (int32_t)256, tmp42); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp243); - -uint64_t* tmp248 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp245, tmp248, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp245); - -uint64_t* tmp250 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp241, tmp43, tmp250); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256, tmp43); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp241); - -uint64_t* tmp253 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -ScaleUp1( (int32_t)256, tmp44, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp250, tmp44, tmp253); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp250); -ClearMemSecret1( (int32_t)256, tmp44); - -uint64_t* tmp256 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp253, tmp256, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp253); - -int64_t tmp258 = (int32_t)3; - -uint64_t* tmp259 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512); -Concat2T444( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp248, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp256, tmp258, tmp259); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp256); -ClearMemPublic(tmp258); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp248); - -uint64_t* tmp263 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp259, tmp45, tmp263); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, tmp259); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)64, tmp45); - -uint64_t* tmp266 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -ScaleUp1( (int32_t)64, tmp46, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp263, tmp46, tmp266); -ClearMemSecret1( (int32_t)64, tmp46); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp263); - -uint64_t* tmp269 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp266, tmp269, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp266); - -uint64_t* tmp271 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp269, tmp47, tmp271); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp47); - -uint64_t* tmp273 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -ScaleUp1( (int32_t)256, tmp48, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp271, tmp48, tmp273); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp271); -ClearMemSecret1( (int32_t)256, tmp48); - -uint64_t* tmp276 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp273, tmp276, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp273); - -uint64_t* tmp278 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp269, tmp49, tmp278); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256, tmp49); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp269); - -uint64_t* tmp281 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -ScaleUp1( (int32_t)256, tmp50, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp278, tmp50, tmp281); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp278); -ClearMemSecret1( (int32_t)256, tmp50); - -uint64_t* tmp284 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp281, tmp284, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp281); - -int64_t tmp286 = (int32_t)3; - -uint64_t* tmp287 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512); -Concat2T444( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp276, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp284, tmp286, tmp287); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp276); -ClearMemPublic(tmp286); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp284); - -uint64_t* tmp291 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1000, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp287, tmp51, tmp291); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1000, tmp51); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, tmp287); - -uint64_t* tmp294 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000); -ScaleUp1( (int32_t)1000, tmp52, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp291, tmp52, tmp294); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp291); -ClearMemSecret1( (int32_t)1000, tmp52); - -uint64_t* tmp297 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp294, tmp297, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp294); - -uint64_t* tmp299 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000); -AvgPool( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, (int32_t)13, (int32_t)13, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp297, tmp299); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp297); - -int64_t tmp301 = (int32_t)3; - -uint64_t* tmp302 = make_array( (int32_t)1, (int32_t)1, (int32_t)1); -ArgMax3( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp299, tmp301, tmp302); -ClearMemPublic(tmp301); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp299); -EndComputation(); -for (uint64_t i0 = (uint64_t)0; i0 < (int32_t)1; i0++){ -for (uint64_t i1 = (uint64_t)0; i1 < (int32_t)1; i1++){ -for (uint64_t i2 = (uint64_t)0; i2 < (int32_t)1; i2++){ -cout << (funcReconstruct2PCCons(Arr3DIdxRowM(tmp302, (int32_t)1, (int32_t)1, (int32_t)1,i0,i1,i2), 2)) << endl; -} -} -} -} - diff --git a/SCI/networks/main_sqnet_ring32.cpp b/SCI/networks/main_sqnet_ring32.cpp deleted file mode 100644 index 9f0ca919..00000000 --- a/SCI/networks/main_sqnet_ring32.cpp +++ /dev/null @@ -1,3054 +0,0 @@ -/* -This is an autogenerated file, generated using the EzPC compiler. -*/ - - -#define BITLEN_32 -#define SCI_OT - - -#include "globals.h" -#include "functionalities_wrapper.h" -#include -using namespace std; - -template -T* make_array(size_t s1){ -return new T[s1]; -} - -template -T* make_array(size_t s1, size_t s2){ -return new T[s1*s2]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3){ -return new T[s1*s2*s3]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4){ -return new T[s1*s2*s3*s4]; -} - -template -T* make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5){ -return new T[s1*s2*s3*s4*s5]; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void MatAddBroadCast2(int32_t s1, int32_t s2, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr1DIdxRowM(B,s2,i2)); -} -} -} - -void MatAdd2(int32_t s1, int32_t s2, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = SecretAdd(Arr2DIdxRowM(A,s1,s2,i1,i2), Arr2DIdxRowM(B,s1,s2,i1,i2)); -} -} -} - -void MatAddBroadCast4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr1DIdxRowM(B,s4,i4)); -} -} -} -} -} - -void MatAdd4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr4DIdxRowM(A,s1,s2,s3,s4,i1,i2,i3,i4), Arr4DIdxRowM(B,s1,s2,s3,s4,i1,i2,i3,i4)); -} -} -} -} -} - -void MatAddBroadCast5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr1DIdxRowM(B,s5,i5)); -} -} -} -} -} -} - -void MatAdd5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* A, uint32_t* B, uint32_t* outArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr5DIdxRowM(A,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5), Arr5DIdxRowM(B,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5)); -} -} -} -} -} -} - -void CreateTensor1(int32_t s1, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(arr,s1,i1) = val; -} -} - -void CreateTensor2(int32_t s1, int32_t s2, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(arr,s1,s2,i1,i2) = val; -} -} -} - -void CreateTensor3(int32_t s1, int32_t s2, int32_t s3, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = val; -} -} -} -} - -void CreateTensor4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = val; -} -} -} -} -} - -void CreateTensor5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t val, int32_t* arr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ -Arr5DIdxRowM(arr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = val; -} -} -} -} -} -} - -void CopyTensor1(int32_t s1, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(targetArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CopyTensor2(int32_t s1, int32_t s2, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(targetArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CopyTensor3(int32_t s1, int32_t s2, int32_t s3, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(targetArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CopyTensor4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* targetArr, uint32_t* fromArr, uint32_t* ignore){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(targetArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateIdentity11(int32_t s1, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -Arr1DIdxRowM(newArr,s1,i1) = Arr1DIdxRowM(fromArr,s1,i1); -} -} - -void CreateIdentity22(int32_t s1, int32_t s2, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -Arr2DIdxRowM(newArr,s1,s2,i1,i2) = Arr2DIdxRowM(fromArr,s1,s2,i1,i2); -} -} -} - -void CreateIdentity33(int32_t s1, int32_t s2, int32_t s3, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -Arr3DIdxRowM(newArr,s1,s2,s3,i1,i2,i3) = Arr3DIdxRowM(fromArr,s1,s2,s3,i1,i2,i3); -} -} -} -} - -void CreateIdentity44(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* fromArr, uint32_t* newArr){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -Arr4DIdxRowM(newArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(fromArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -} - -void CreateCopy2211(int32_t s1, int32_t s2, int32_t inps1, int32_t inps2, uint32_t* inArr, int32_t perDimSize, int32_t* beginIdx, int32_t* sizeIdx, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,inps1,inps2,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j)); -} -} -} - -void CreateCopy5511(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, int32_t inps5, uint32_t* inArr, int32_t perDimSize, int32_t* beginIdx, int32_t* sizeIdx, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -for (uint32_t m = (int32_t)0; m < s5; m++){ -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inArr,inps1,inps2,inps3,inps4,inps5,(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)0) + i),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)1) + j),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)2) + k),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)3) + l),(Arr1DIdxRowM(beginIdx,perDimSize, (int32_t)4) + m)); -} -} -} -} -} -} - -void Concat2T222(int32_t s1, int32_t s2, int32_t inp1s1, int32_t inp1s2, uint32_t* inp1, int32_t inp2s1, int32_t inp2s2, uint32_t* inp2, int32_t axis, uint32_t* outp){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,(i1 - inp1s1),i2); -} -} else { -if ((i2 < inp1s2)) { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp1,inp1s1,inp1s2,i1,i2); -} else { -Arr2DIdxRowM(outp,s1,s2,i1,i2) = Arr2DIdxRowM(inp2,inp2s1,inp2s2,i1,(i2 - inp1s2)); -} -} -} -} -} - -void Concat2T444(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t inp1s1, int32_t inp1s2, int32_t inp1s3, int32_t inp1s4, uint32_t* inp1, int32_t inp2s1, int32_t inp2s2, int32_t inp2s3, int32_t inp2s4, uint32_t* inp2, int32_t axis, uint32_t* outp){ -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((i1 < inp1s1)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,(i1 - inp1s1),i2,i3,i4); -} -} else { -if ((axis == (int32_t)1)) { -if ((i2 < inp1s2)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,(i2 - inp1s2),i3,i4); -} -} else { -if ((axis == (int32_t)2)) { -if ((i3 < inp1s3)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,(i3 - inp1s3),i4); -} -} else { -if ((i4 < inp1s4)) { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp1,inp1s1,inp1s2,inp1s3,inp1s4,i1,i2,i3,i4); -} else { -Arr4DIdxRowM(outp,s1,s2,s3,s4,i1,i2,i3,i4) = Arr4DIdxRowM(inp2,inp2s1,inp2s2,inp2s3,inp2s4,i1,i2,i3,(i4 - inp1s4)); -} -} -} -} -} -} -} -} -} - -void Split44(int32_t O1, int32_t O2, int32_t O3, int32_t O4, int32_t I1, int32_t I2, int32_t I3, int32_t I4, uint32_t* inp, int32_t axis, int32_t curCount, int32_t total, uint32_t* out){ -for (uint32_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint32_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint32_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint32_t o4 = (int32_t)0; o4 < O4; o4++){ - -int32_t i1 = o1; - -int32_t i2 = o2; - -int32_t i3 = o3; - -int32_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (((I1 / total) * curCount) + o1); -} -if ((axis == (int32_t)1)) { -i2 = (((I2 / total) * curCount) + o2); -} -if ((axis == (int32_t)2)) { -i3 = (((I3 / total) * curCount) + o3); -} -if ((axis == (int32_t)3)) { -i4 = (((I4 / total) * curCount) + o4); -} -Arr4DIdxRowM(out,O1,O2,O3,O4,o1,o2,o3,o4) = Arr4DIdxRowM(inp,I1,I2,I3,I4,i1,i2,i3,i4); -} -} -} -} -} - -void Conv2DReshapeFilter(int32_t FH, int32_t FW, int32_t CI, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CI,CO,fh,fw,ci,co); -} -} -} -} -} - -void Conv2DReshapeMatMulOP(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInput(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2D(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = ((FH * FW) * CI); - -int32_t reshapedIPRows = ((FH * FW) * CI); - -int32_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = ((N * newH) * newW); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t outH, int32_t outW, int32_t G, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t GIS = (CI / G); - -int32_t GOS = (CO / G); -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint32_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint32_t g = (int32_t)0; g < G; g++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ - -uint32_t val = funcSSCons( (int32_t)0); - -int32_t ci = ((GIS * g) + cig); - -int32_t co = ((GOS * g) + cog); - -int32_t curPosH = ((strideH * h) - zPadHLeft); -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ - -int32_t curPosW = ((strideW * w) - zPadWLeft); -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -if (((((curPosH >= (int32_t)0) && (curPosW >= (int32_t)0)) && (curPosH < H)) && (curPosW < W))) { -val = SecretAdd(val, SecretMult(Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,ci), Arr4DIdxRowM(filterArr,FH,FW,(CI / G),CO,fh,fw,(ci / G),co))); -} -curPosW = (curPosW + (int32_t)1); -} -curPosH = (curPosH + (int32_t)1); -} -Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co) = SecretAdd(Arr4DIdxRowM(outArr,N,outH,outW,CO,n,h,w,co), val); -} -} -} -} -} -} -} - -void Conv2DLoop(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t G, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int32_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup(int32_t FH, int32_t FW, int32_t CI, int32_t CO, int32_t g, int32_t G, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t CIG = (CI / G); - -int32_t COG = (CO / G); - -int32_t startCO = (g * COG); -for (uint32_t co = (int32_t)0; co < COG; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CIG; ci++){ - -int32_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); -Arr2DIdxRowM(outputArr,(CO / G),((FH * FW) * (CI / G)),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,(CI / G),CO,fh,fw,ci,(co + startCO)); -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, int32_t g, int32_t G, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t COG = (CO / G); - -int32_t startCO = (g * COG); -for (uint32_t co = (int32_t)0; co < COG; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,(co + startCO)) = Arr2DIdxRowM(inputArr,(CO / G),((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void Conv2DReshapeInputGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t g, int32_t G, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; - -int32_t CIG = (CI / G); -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); - -int32_t startCI = (g * CIG); -for (uint32_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= H)) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr4DIdxRowM(inputArr,N,H,W,CI,n,curPosH,curPosW,(ci + startCI)); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CIG) + (fw * CIG)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -} -} - -void Conv2DGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, int32_t strideW, int32_t G, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t CIG = (CI / G); - -int32_t reshapedFilterRows = (CO / G); - -int32_t reshapedFilterCols = ((FH * FW) * CIG); - -int32_t reshapedIPRows = ((FH * FW) * CIG); - -int32_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = ((N * outH) * outW); -for (uint32_t g = (int32_t)0; g < G; g++){ - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -} -} - -void Conv3DReshapeFilter(int32_t FD, int32_t FH, int32_t FW, int32_t CI, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CI,CO,fd,fh,fw,ci,co); -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP(int32_t N, int32_t finalD, int32_t finalH, int32_t finalW, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t d = (int32_t)0; d < finalD; d++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr5DIdxRowM(outputArr,N,finalD,finalH,finalW,CO,n,d,h,w,co) = Arr2DIdxRowM(inputArr,CO,(((N * finalD) * finalH) * finalW),co,((((((n * finalD) * finalH) * finalW) + ((d * finalH) * finalW)) + (h * finalW)) + w)); -} -} -} -} -} -} - -void Conv3DReshapeInput(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerD = ( (int32_t)0 - zPadDLeft); - -int32_t extremeRightBottomCornerD = ((D - (int32_t)1) + zPadDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int32_t leftTopCornerH = ( (int32_t)0 - zPadHLeft); - -int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadWLeft); - -int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosD = (leftTopCornerD + fd); - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= D)) || ((curPosH < (int32_t)0) || (curPosH >= H))) || ((curPosW < (int32_t)0) || (curPosW >= W)))) { -val = funcSSCons( (int32_t)0); -} else { -val = Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci); -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + strideW); -} - -leftTopCornerH = (leftTopCornerH + strideH); -} - -leftTopCornerD = (leftTopCornerD + strideD); -} - -} -} - -void Conv3D(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int32_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int32_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + (int32_t)1); - -int32_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); - -int32_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); - -int32_t reshapedIPCols = (((N * newD) * newH) * newW); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t outD, int32_t outH, int32_t outW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t d = (int32_t)0; d < outD; d++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t fd = (d * strideD); fd < ((d * strideD) + FD); fd++){ -for (uint32_t fh = (h * strideH); fh < ((h * strideH) + FH); fh++){ -for (uint32_t fw = (w * strideW); fw < ((w * strideW) + FW); fw++){ - -int32_t curPosD = (fd - zPadDLeft); - -int32_t curPosH = (fh - zPadHLeft); - -int32_t curPosW = (fw - zPadWLeft); -if (((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W))) { - -int32_t curFilterPosD = (fd - (d * strideD)); - -int32_t curFilterPosH = (fh - (h * strideH)); - -int32_t curFilterPosW = (fw - (w * strideW)); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CI,CO,curFilterPosD,curFilterPosH,curFilterPosW,ci,co))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void Conv3DLoop(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + (int32_t)1); - -int32_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + (int32_t)1); - -int32_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + (int32_t)1); -Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP(int32_t N, int32_t finalH, int32_t finalW, int32_t CO, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t h = (int32_t)0; h < finalH; h++){ -for (uint32_t w = (int32_t)0; w < finalW; w++){ -Arr4DIdxRowM(outputArr,N,finalH,finalW,CO,n,h,w,co) = Arr2DIdxRowM(inputArr,CO,((N * finalH) * finalW),co,((((n * finalH) * finalW) + (h * finalW)) + w)); -} -} -} -} -} - -void ConvTranspose2DReshapeFilter(int32_t FH, int32_t FW, int32_t CO, int32_t CI, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,((FH * FW) * CI),co,linIdx) = Arr4DIdxRowM(inputArr,FH,FW,CO,CI,((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} - -void ConvTranspose2DReshapeInput(int32_t N, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FH, int32_t FW, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int32_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int32_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int32_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int32_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if ((((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde)) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int32_t)0); -} else { -if ((((curPosH % strideH) == (int32_t)0) && ((curPosW % strideW) == (int32_t)0))) { - -int32_t idxInputH = (curPosH / strideH); - -int32_t idxInputW = (curPosW / strideW); -val = Arr4DIdxRowM(inputArr,N,HPrime,WPrime,CI,n,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((fh * FW) * CI) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -} -} - -void ConvTranspose2D(int32_t N, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FH, int32_t FW, int32_t CO, int32_t H, int32_t W, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = ((FH * FW) * CI); - -int32_t reshapedIPRows = ((FH * FW) * CI); - -int32_t reshapedIPCols = ((N * H) * W); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter(int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t CI, uint32_t* inputArr, uint32_t* outputArr){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -int32_t linIdx = ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci); -Arr2DIdxRowM(outputArr,CO,(((FD * FH) * FW) * CI),co,linIdx) = Arr5DIdxRowM(inputArr,FD,FH,FW,CO,CI,((FD - (int32_t)1) - fd),((FH - (int32_t)1) - fh),((FW - (int32_t)1) - fw),co,ci); -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t RRows, int32_t RCols, uint32_t* inputArr, uint32_t* outputArr){ - -int32_t linIdxFilterMult = (int32_t)0; -for (uint32_t n = (int32_t)0; n < N; n++){ - -int32_t leftTopCornerD = ( (int32_t)0 - zPadTrDLeft); - -int32_t DPrimeTilde = (DPrime + ((DPrime - (int32_t)1) * (strideD - (int32_t)1))); - -int32_t extremeRightBottomCornerD = ((DPrimeTilde - (int32_t)1) + zPadTrDRight); -while ((((leftTopCornerD + FD) - (int32_t)1) <= extremeRightBottomCornerD)) { - -int32_t leftTopCornerH = ( (int32_t)0 - zPadTrHLeft); - -int32_t HPrimeTilde = (HPrime + ((HPrime - (int32_t)1) * (strideH - (int32_t)1))); - -int32_t extremeRightBottomCornerH = ((HPrimeTilde - (int32_t)1) + zPadTrHRight); -while ((((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { - -int32_t leftTopCornerW = ( (int32_t)0 - zPadTrWLeft); - -int32_t WPrimeTilde = (WPrime + ((WPrime - (int32_t)1) * (strideW - (int32_t)1))); - -int32_t extremeRightBottomCornerW = ((WPrimeTilde - (int32_t)1) + zPadTrWRight); -while ((((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { -for (uint32_t fd = (int32_t)0; fd < FD; fd++){ -for (uint32_t fh = (int32_t)0; fh < FH; fh++){ -for (uint32_t fw = (int32_t)0; fw < FW; fw++){ - -int32_t curPosD = (leftTopCornerD + fd); - -int32_t curPosH = (leftTopCornerH + fh); - -int32_t curPosW = (leftTopCornerW + fw); - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ -if (((((curPosD < (int32_t)0) || (curPosD >= DPrimeTilde)) || ((curPosH < (int32_t)0) || (curPosH >= HPrimeTilde))) || ((curPosW < (int32_t)0) || (curPosW >= WPrimeTilde)))) { -val = funcSSCons( (int32_t)0); -} else { -if (((((curPosD % strideD) == (int32_t)0) && ((curPosH % strideH) == (int32_t)0)) && ((curPosW % strideW) == (int32_t)0))) { - -int32_t idxInputD = (curPosD / strideD); - -int32_t idxInputH = (curPosH / strideH); - -int32_t idxInputW = (curPosW / strideW); -val = Arr5DIdxRowM(inputArr,N,DPrime,HPrime,WPrime,CI,n,idxInputD,idxInputH,idxInputW,ci); -} else { -val = funcSSCons( (int32_t)0); -} -} -Arr2DIdxRowM(outputArr,RRows,RCols,((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) + ci),linIdxFilterMult) = val; -} -} -} -} -linIdxFilterMult = (linIdxFilterMult + (int32_t)1); -leftTopCornerW = (leftTopCornerW + (int32_t)1); -} - -leftTopCornerH = (leftTopCornerH + (int32_t)1); -} - -leftTopCornerD = (leftTopCornerD + (int32_t)1); -} - -} -} - -void ConvTranspose3D(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t D, int32_t H, int32_t W, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ - -int32_t reshapedFilterRows = CO; - -int32_t reshapedFilterCols = (((FD * FH) * FW) * CI); - -int32_t reshapedIPRows = (((FD * FH) * FW) * CI); - -int32_t reshapedIPCols = (((N * D) * H) * W); - -uint32_t* filterReshaped = make_array(reshapedFilterRows, reshapedFilterCols); - -uint32_t* inputReshaped = make_array(reshapedIPRows, reshapedIPCols); - -uint32_t* matmulOP = make_array(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner(int32_t N, int32_t D, int32_t H, int32_t W, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t zPadDLeft, int32_t zPadDRight, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, int32_t strideD, int32_t strideH, int32_t strideW, int32_t outD, int32_t outH, int32_t outW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ -for (uint32_t n = (int32_t)0; n < N; n++){ -for (uint32_t co = (int32_t)0; co < CO; co++){ -for (uint32_t d = (int32_t)0; d < outD; d++){ -for (uint32_t h = (int32_t)0; h < outH; h++){ -for (uint32_t w = (int32_t)0; w < outW; w++){ -for (uint32_t ci = (int32_t)0; ci < CI; ci++){ - -uint32_t val = funcSSCons( (int32_t)0); -for (uint32_t fd = d; fd < (d + FD); fd++){ -for (uint32_t fh = h; fh < (h + FH); fh++){ -for (uint32_t fw = w; fw < (w + FW); fw++){ - -int32_t curPosD = ((fd - zPadDLeft) / strideD); - -int32_t curPosH = ((fh - zPadHLeft) / strideD); - -int32_t curPosW = ((fw - zPadWLeft) / strideD); -if ((((((((((curPosD >= (int32_t)0) && (curPosH >= (int32_t)0)) && (curPosW >= (int32_t)0)) && (curPosD < D)) && (curPosH < H)) && (curPosW < W)) && (((fd - zPadDLeft) % strideD) == (int32_t)0)) && (((fh - zPadHLeft) % strideH) == (int32_t)0)) && (((fw - zPadWLeft) % strideW) == (int32_t)0))) { - -int32_t curFilterPosD = (((FD + d) - fd) - (int32_t)1); - -int32_t curFilterPosH = (((FH + h) - fh) - (int32_t)1); - -int32_t curFilterPosW = (((FW + w) - fw) - (int32_t)1); -val = SecretAdd(val, SecretMult(Arr5DIdxRowM(inputArr,N,D,H,W,CI,n,curPosD,curPosH,curPosW,ci), Arr5DIdxRowM(filterArr,FD,FH,FW,CO,CI,curFilterPosD,curFilterPosH,curFilterPosW,co,ci))); -} -} -} -} -Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co) = SecretAdd(Arr5DIdxRowM(outArr,N,outD,outH,outW,CO,n,d,h,w,co), val); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop(int32_t N, int32_t DPrime, int32_t HPrime, int32_t WPrime, int32_t CI, int32_t FD, int32_t FH, int32_t FW, int32_t CO, int32_t D, int32_t H, int32_t W, int32_t zPadTrDLeft, int32_t zPadTrDRight, int32_t zPadTrHLeft, int32_t zPadTrHRight, int32_t zPadTrWLeft, int32_t zPadTrWRight, int32_t strideD, int32_t strideH, int32_t strideW, uint32_t* inputArr, uint32_t* filterArr, uint32_t* outArr){ -ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2(int32_t s1, int32_t s2, uint32_t* inArr, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -Arr2DIdxRowM(outArr,s1,s2,i,j) = Arr2DIdxRowM(inArr,s2,s1,j,i); -} -} -} - -void Pad442(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, uint32_t* inpArr, int32_t pads1, int32_t pads2, int32_t* paddings, uint32_t* outArr){ - -int32_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int32_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int32_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int32_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int32_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int32_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int32_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int32_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = Arr4DIdxRowM(inpArr,inps1,inps2,inps3,inps4,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0))); -} else { -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i,j,k,l) = funcSSCons( (int32_t)0); -} -} -} -} -} -} - -void Pad552(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t inps1, int32_t inps2, int32_t inps3, int32_t inps4, int32_t inps5, uint32_t* inpArr, int32_t pads1, int32_t pads2, int32_t* paddings, uint32_t* outArr){ - -int32_t lbounds1 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0); - -int32_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)1)); - -int32_t lbounds2 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0); - -int32_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)1)); - -int32_t lbounds3 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0); - -int32_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)1)); - -int32_t lbounds4 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0); - -int32_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)1)); - -int32_t lbounds5 = Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0); - -int32_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)1)); -for (uint32_t i = (int32_t)0; i < s1; i++){ -for (uint32_t j = (int32_t)0; j < s2; j++){ -for (uint32_t k = (int32_t)0; k < s3; k++){ -for (uint32_t l = (int32_t)0; l < s4; l++){ -for (uint32_t m = (int32_t)0; m < s5; m++){ -if (((((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl)) && (m >= lbounds5)) && (m < rbounds5excl))) { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = Arr5DIdxRowM(inpArr,inps1,inps2,inps3,inps4,inps5,(i - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)0, (int32_t)0)),(j - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)1, (int32_t)0)),(k - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)2, (int32_t)0)),(l - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)3, (int32_t)0)),(m - Arr2DIdxRowM(paddings,pads1,pads2, (int32_t)4, (int32_t)0))); -} else { -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i,j,k,l,m) = funcSSCons( (int32_t)0); -} -} -} -} -} -} -} - -void PadONNX441(int32_t o1, int32_t o2, int32_t o3, int32_t o4, int32_t i1, int32_t i2, int32_t i3, int32_t i4, uint32_t* inpArr, int32_t pads, int32_t* paddings, uint32_t* outArr){ - -int32_t lbounds1 = Arr1DIdxRowM(paddings,pads, (int32_t)0); - -int32_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings,pads, (int32_t)4)); - -int32_t lbounds2 = Arr1DIdxRowM(paddings,pads, (int32_t)1); - -int32_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings,pads, (int32_t)5)); - -int32_t lbounds3 = Arr1DIdxRowM(paddings,pads, (int32_t)2); - -int32_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings,pads, (int32_t)6)); - -int32_t lbounds4 = Arr1DIdxRowM(paddings,pads, (int32_t)3); - -int32_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings,pads, (int32_t)7)); -for (uint32_t i = (int32_t)0; i < o1; i++){ -for (uint32_t j = (int32_t)0; j < o2; j++){ -for (uint32_t k = (int32_t)0; k < o3; k++){ -for (uint32_t l = (int32_t)0; l < o4; l++){ -if (((((((((i >= lbounds1) && (i < rbounds1excl)) && (j >= lbounds2)) && (j < rbounds2excl)) && (k >= lbounds3)) && (k < rbounds3excl)) && (l >= lbounds4)) && (l < rbounds4excl))) { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = Arr4DIdxRowM(inpArr,i1,i2,i3,i4,(i - Arr1DIdxRowM(paddings,pads, (int32_t)0)),(j - Arr1DIdxRowM(paddings,pads, (int32_t)1)),(k - Arr1DIdxRowM(paddings,pads, (int32_t)2)),(l - Arr1DIdxRowM(paddings,pads, (int32_t)3))); -} else { -Arr4DIdxRowM(outArr,o1,o2,o3,o4,i,j,k,l) = funcSSCons( (int32_t)0); -} -} -} -} -} -} - -void Squeeze24(int32_t s1, int32_t s2, int32_t dim1, int32_t dim2, int32_t ins1, int32_t ins2, int32_t ins3, int32_t ins4, uint32_t* inArr, uint32_t* outArr){ -for (uint32_t i = (int32_t)0; i < ins1; i++){ -for (uint32_t j = (int32_t)0; j < ins2; j++){ -for (uint32_t k = (int32_t)0; k < ins3; k++){ -for (uint32_t l = (int32_t)0; l < ins4; l++){ - -int32_t linIdx = ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) + (k * ins4)) + l); - -int32_t outIdx1 = (linIdx / s2); - -int32_t outIdx2 = (linIdx % s2); -Arr2DIdxRowM(outArr,s1,s2,outIdx1,outIdx2) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i,j,k,l); -} -} -} -} -} - -void FusedBatchNorm4411(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* inArr, uint32_t* multArr, uint32_t* biasArr, int32_t multExprScaleDownSf, int32_t biasExprScaleUpSf, uint32_t* outputArr){ - -int32_t inpSize = (((s1 * s2) * s3) * s4); - -uint32_t* inArrReshaped = make_array(inpSize); - -uint32_t* multArrReshaped = make_array(inpSize); - -uint32_t* multExprAns = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s4,i4); -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint32_t* biasArrScaledUp = make_array(s4); -for (uint32_t ii = (int32_t)0; ii < s4; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s4,ii) = Arr1DIdxRowM(biasArr,s4,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outputArr,s1,s2,s3,s4,i1,i2,i3,i4) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s4,i4)); -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* inArr, uint32_t* multArr, uint32_t* biasArr, int32_t multExprScaleDownSf, int32_t biasExprScaleUpSf, uint32_t* outputArr){ - -int32_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint32_t* inArrReshaped = make_array(inpSize); - -uint32_t* multArrReshaped = make_array(inpSize); - -uint32_t* multExprAns = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(inArrReshaped,inpSize,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(multArrReshaped,inpSize,linIdx) = Arr1DIdxRowM(multArr,s5,i5); -} -} -} -} -} -ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((multExprScaleDownSf > (int32_t)0)) { -ScaleDown(inpSize, multExprAns, multExprScaleDownSf); -} - -uint32_t* biasArrScaledUp = make_array(s5); -for (uint32_t ii = (int32_t)0; ii < s5; ii++){ -Arr1DIdxRowM(biasArrScaledUp,s5,ii) = Arr1DIdxRowM(biasArr,s5,ii); -} -if ((biasExprScaleUpSf > (int32_t)0)) { -ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outputArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = SecretAdd(Arr1DIdxRowM(multExprAns,inpSize,linIdx), Arr1DIdxRowM(biasArrScaledUp,s5,i5)); -} -} -} -} -} -ClearMemSecret1(inpSize, inArrReshaped); -ClearMemSecret1(inpSize, multArrReshaped); -ClearMemSecret1(inpSize, multExprAns); -ClearMemSecret1(s5, biasArrScaledUp); -} - -void ElemWiseMul2(int32_t s1, int32_t s2, uint32_t* arr1, uint32_t* arr2, uint32_t* outArr){ - -int32_t inpSize = (s1 * s2); - -uint32_t* arr1Reshaped = make_array(inpSize); - -uint32_t* arr2Reshaped = make_array(inpSize); - -uint32_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr1,s1,s2,i1,i2); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr2DIdxRowM(arr2,s1,s2,i1,i2); -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* arr1, uint32_t* arr2, uint32_t* outArr){ - -int32_t inpSize = (((s1 * s2) * s3) * s4); - -uint32_t* arr1Reshaped = make_array(inpSize); - -uint32_t* arr2Reshaped = make_array(inpSize); - -uint32_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr1,s1,s2,s3,s4,i1,i2,i3,i4); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr4DIdxRowM(arr2,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ElemWiseMul5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* arr1, uint32_t* arr2, uint32_t* outArr){ - -int32_t inpSize = ((((s1 * s2) * s3) * s4) * s5); - -uint32_t* arr1Reshaped = make_array(inpSize); - -uint32_t* arr2Reshaped = make_array(inpSize); - -uint32_t* outArrReshaped = make_array(inpSize); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(arr1Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr1,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -Arr1DIdxRowM(arr2Reshaped,inpSize,linIdx) = Arr5DIdxRowM(arr2,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(outArrReshaped,inpSize,linIdx); -} -} -} -} -} -ClearMemSecret1(inpSize, arr1Reshaped); -ClearMemSecret1(inpSize, arr2Reshaped); -ClearMemSecret1(inpSize, outArrReshaped); -} - -void ReduceMean24(int32_t outS1, int32_t outS2, int32_t inS1, int32_t inS2, int32_t inS3, int32_t inS4, uint32_t* inputArr, int32_t* axes, uint32_t* outputArr){ - -int32_t divisor = (inS2 * inS3); - -int32_t outputSize = (outS1 * outS2); - -uint32_t* sumArr = make_array(outputSize); - -uint32_t* outputArrReshaped = make_array(outputSize); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint32_t summ = funcSSCons( (int32_t)0); -for (uint32_t i = (int32_t)0; i < inS2; i++){ -for (uint32_t j = (int32_t)0; j < inS3; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i,j,i2)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24(int32_t outS1, int32_t outS2, int32_t inS1, int32_t inS2, int32_t inS3, int32_t inS4, uint32_t* inputArr, int32_t axis1, int32_t axis2, uint32_t* outputArr){ - -int32_t divisor = (inS3 * inS4); - -int32_t outputSize = (outS1 * outS2); - -uint32_t* sumArr = make_array(outputSize); - -uint32_t* outputArrReshaped = make_array(outputSize); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint32_t summ = funcSSCons( (int32_t)0); -for (uint32_t i = (int32_t)0; i < inS3; i++){ -for (uint32_t j = (int32_t)0; j < inS4; j++){ -summ = SecretAdd(summ, Arr4DIdxRowM(inputArr,inS1,inS2,inS3,inS4,i1,i2,i,j)); -} -} -Arr1DIdxRowM(sumArr,outputSize,((i1 * outS2) + i2)) = summ; -} -} -ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped); -for (uint32_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < outS2; i2++){ -Arr2DIdxRowM(outputArr,outS1,outS2,i1,i2) = Arr1DIdxRowM(outputArrReshaped,outputSize,((i1 * outS2) + i2)); -} -} -ClearMemSecret1(outputSize, sumArr); -ClearMemSecret1(outputSize, outputArrReshaped); -} - -void ArgMax1(int32_t outArrS1, int32_t inArrS1, int32_t inArrS2, uint32_t* inArr, int32_t dim, uint32_t* outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3(int32_t outs1, int32_t outs2, int32_t outs3, int32_t ins1, int32_t ins2, int32_t ins3, int32_t ins4, uint32_t* inArr, int32_t dim, uint32_t* outArr){ - -int32_t size = ((ins1 * ins2) * ins3); - -uint32_t* reshapedInArr = make_array(size, ins4); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < ins4; i4++){ - -int32_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr2DIdxRowM(reshapedInArr,size,ins4,linIdx,i4) = Arr4DIdxRowM(inArr,ins1,ins2,ins3,ins4,i1,i2,i3,i4); -} -} -} -} -ArgMax(size, ins4, reshapedInArr, reshapedOutArr); -for (uint32_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < ins3; i3++){ - -int32_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3); -Arr3DIdxRowM(outArr,outs1,outs2,outs3,i1,i2,i3) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -ClearMemSecret2(size, ins4, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu2(int32_t s1, int32_t s2, uint32_t* inArr, uint32_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* inArr, uint32_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr4DIdxRowM(inArr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(outArr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Relu5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, uint32_t* inArr, uint32_t* outArr, int32_t sf, uint32_t doTruncation){ - -int32_t size = ((((s1 * s2) * s3) * s4) * s5); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr5DIdxRowM(inArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5); -} -} -} -} -} -Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint32_t i5 = (int32_t)0; i5 < s5; i5++){ - -int32_t linIdx = ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) + ((i3 * s4) * s5)) + (i4 * s5)) + i5); -Arr5DIdxRowM(outArr,s1,s2,s3,s4,s5,i1,i2,i3,i4,i5) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -} -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void Floor2(int32_t s1, int32_t s2, uint32_t* inArr, uint32_t* outArr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedInArr = make_array(size); - -uint32_t* reshapedOutArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedInArr,size,linIdx) = Arr2DIdxRowM(inArr,s1,s2,i1,i2); -} -} -Floor(size, reshapedInArr, reshapedOutArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(outArr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedOutArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedInArr); -ClearMemSecret1(size, reshapedOutArr); -} - -void ScaleUp1(int32_t s1, uint32_t* arr, int32_t sf){ -ScaleUp(s1, arr, sf); -} - -void ScaleUp2(int32_t s1, int32_t s2, uint32_t* arr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp3(int32_t s1, int32_t s2, int32_t s3, uint32_t* arr, int32_t sf){ - -int32_t size = ((s1 * s2) * s3); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleUp4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* arr, int32_t sf){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleUp(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown1(int32_t s1, uint32_t* arr, int32_t sf){ -ScaleDown(s1, arr, sf); -} - -void ScaleDown2(int32_t s1, int32_t s2, uint32_t* arr, int32_t sf){ - -int32_t size = (s1 * s2); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr2DIdxRowM(arr,s1,s2,i1,i2); -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ - -int32_t linIdx = ((i1 * s2) + i2); -Arr2DIdxRowM(arr,s1,s2,i1,i2) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown3(int32_t s1, int32_t s2, int32_t s3, uint32_t* arr, int32_t sf){ - -int32_t size = ((s1 * s2) * s3); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3); -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ - -int32_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3); -Arr3DIdxRowM(arr,s1,s2,s3,i1,i2,i3) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -ClearMemSecret1(size, reshapedArr); -} - -void ScaleDown4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, uint32_t* arr, int32_t sf){ - -int32_t size = (((s1 * s2) * s3) * s4); - -uint32_t* reshapedArr = make_array(size); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr1DIdxRowM(reshapedArr,size,linIdx) = Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4); -} -} -} -} -ScaleDown(size, reshapedArr, sf); -for (uint32_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint32_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint32_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint32_t i4 = (int32_t)0; i4 < s4; i4++){ - -int32_t linIdx = ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4); -Arr4DIdxRowM(arr,s1,s2,s3,s4,i1,i2,i3,i4) = Arr1DIdxRowM(reshapedArr,size,linIdx); -} -} -} -} -ClearMemSecret1(size, reshapedArr); -} - - -int main(int argc, char** argv) -{ -ArgMapping amap; -int port = 32000; -string serverAddr = "127.0.0.1"; - -amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); -amap.arg("p", port, "Port Number"); -amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); -amap.parse(argc, argv); - -assert(party==sci::ALICE || party==sci::BOB); - -checkIfUsingEigen(); -for(int i=0;i(ioArr[i]); -prgInstanceArr[i] = new sci::PRG128(); -kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); -matmulInstanceArr[i] = new Matmul>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); -if (i == 0) { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength); -} -else if (i == 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength); -} -else if (i & 1) { -otpackArr[i] = new sci::OTPack(ioArr[i], 3-party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[1]); -} -else { -otpackArr[i] = new sci::OTPack(ioArr[i], party, baseForRelu, bitlength, false); -otpackArr[i]->copy(otpackArr[0]); -} -} - -io = ioArr[0]; -iknpOT = new sci::IKNP(io); -iknpOTRoleReversed = new sci::IKNP(io); //TCP is full duplex -- so both side OT on same TCP should be good -kkot = new sci::KKOT(io); -prg128Instance = new sci::PRG128(); -otpack = new sci::OTPack(io, party, baseForRelu, bitlength); - -matmulImpl = new Matmul>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - -#ifdef SCI_OT -reluImpl = new ReLURingProtocol(party,RING,io,bitlength,baseForRelu,otpack); -maxpoolImpl = new MaxPoolProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); -#endif - -#ifdef SCI_HE -reluImpl = new ReLUFieldProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); -maxpoolImpl = new MaxPoolProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -argmaxImpl = new ArgMaxProtocol(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); -heConvImpl = new ConvField(party,io); -heFCImpl = new FCField(party,io); -heProdImpl = new ElemWiseProdField(party, io); -assertFieldRun(); -#endif -#ifdef MULTITHREADED_NONLIN -#ifdef SCI_OT -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLURingProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLURingProtocol(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); -} -} -#endif -#ifdef SCI_HE -for(int i = 0; i < numThreads; i++) { -if (i & 1) { -reluImplArr[i] = new ReLUFieldProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -else { -reluImplArr[i] = new ReLUFieldProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); -maxpoolImplArr[i] = new MaxPoolProtocol(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); -} -} -#endif -#endif - -if (party==sci::ALICE){ -iknpOT->setup_send(); -iknpOTRoleReversed->setup_recv(); -} -else if (party==sci::BOB){ -iknpOT->setup_recv(); -iknpOTRoleReversed->setup_send(); -} -cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<( (int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3); -/* Variable to read the clear value corresponding to the input variable tmp0 at (1930,1-1930,46) */ -uint32_t __tmp_in_tmp0; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)227; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)227; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)3; i3++){ -if ((party == CLIENT)) { -cin >> __tmp_in_tmp0; -} -Arr4DIdxRowM(tmp0, (int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3,i0,i1,i2,i3) = (party == CLIENT) ? __tmp_in_tmp0 : 0; -} -} -} -} - -uint32_t* tmp1 = make_array( (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp1 at (1933,1-1933,43) */ -uint32_t __tmp_in_tmp1; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)3; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp1; -} -Arr4DIdxRowM(tmp1, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp1 : 0; -} -} -} -} - -uint32_t* tmp2 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp2 at (1936,1-1936,34) */ -uint32_t __tmp_in_tmp2; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp2; -} -Arr1DIdxRowM(tmp2, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp2 : 0; -} - -uint32_t* tmp3 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp3 at (1939,1-1939,44) */ -uint32_t __tmp_in_tmp3; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp3; -} -Arr4DIdxRowM(tmp3, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp3 : 0; -} -} -} -} - -uint32_t* tmp4 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp4 at (1942,1-1942,34) */ -uint32_t __tmp_in_tmp4; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp4; -} -Arr1DIdxRowM(tmp4, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp4 : 0; -} - -uint32_t* tmp5 = make_array( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp5 at (1945,1-1945,44) */ -uint32_t __tmp_in_tmp5; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp5; -} -Arr4DIdxRowM(tmp5, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp5 : 0; -} -} -} -} - -uint32_t* tmp6 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp6 at (1948,1-1948,34) */ -uint32_t __tmp_in_tmp6; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp6; -} -Arr1DIdxRowM(tmp6, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp6 : 0; -} - -uint32_t* tmp7 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp7 at (1951,1-1951,44) */ -uint32_t __tmp_in_tmp7; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp7; -} -Arr4DIdxRowM(tmp7, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp7 : 0; -} -} -} -} - -uint32_t* tmp8 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp8 at (1954,1-1954,34) */ -uint32_t __tmp_in_tmp8; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp8; -} -Arr1DIdxRowM(tmp8, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp8 : 0; -} - -uint32_t* tmp9 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp9 at (1957,1-1957,45) */ -uint32_t __tmp_in_tmp9; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)16; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp9; -} -Arr4DIdxRowM(tmp9, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)16,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp9 : 0; -} -} -} -} - -uint32_t* tmp10 = make_array( (int32_t)16); -/* Variable to read the clear value corresponding to the input variable tmp10 at (1960,1-1960,35) */ -uint32_t __tmp_in_tmp10; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)16; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp10; -} -Arr1DIdxRowM(tmp10, (int32_t)16,i0) = (party == SERVER) ? __tmp_in_tmp10 : 0; -} - -uint32_t* tmp11 = make_array( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp11 at (1963,1-1963,45) */ -uint32_t __tmp_in_tmp11; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp11; -} -Arr4DIdxRowM(tmp11, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp11 : 0; -} -} -} -} - -uint32_t* tmp12 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp12 at (1966,1-1966,35) */ -uint32_t __tmp_in_tmp12; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp12; -} -Arr1DIdxRowM(tmp12, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp12 : 0; -} - -uint32_t* tmp13 = make_array( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp13 at (1969,1-1969,45) */ -uint32_t __tmp_in_tmp13; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)16; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp13; -} -Arr4DIdxRowM(tmp13, (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp13 : 0; -} -} -} -} - -uint32_t* tmp14 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp14 at (1972,1-1972,35) */ -uint32_t __tmp_in_tmp14; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp14; -} -Arr1DIdxRowM(tmp14, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp14 : 0; -} - -uint32_t* tmp15 = make_array( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp15 at (1975,1-1975,46) */ -uint32_t __tmp_in_tmp15; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)128; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp15; -} -Arr4DIdxRowM(tmp15, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp15 : 0; -} -} -} -} - -uint32_t* tmp16 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp16 at (1978,1-1978,35) */ -uint32_t __tmp_in_tmp16; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp16; -} -Arr1DIdxRowM(tmp16, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp16 : 0; -} - -uint32_t* tmp17 = make_array( (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp17 at (1981,1-1981,46) */ -uint32_t __tmp_in_tmp17; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp17; -} -Arr4DIdxRowM(tmp17, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp17 : 0; -} -} -} -} - -uint32_t* tmp18 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp18 at (1984,1-1984,36) */ -uint32_t __tmp_in_tmp18; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp18; -} -Arr1DIdxRowM(tmp18, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp18 : 0; -} - -uint32_t* tmp19 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp19 at (1987,1-1987,46) */ -uint32_t __tmp_in_tmp19; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp19; -} -Arr4DIdxRowM(tmp19, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp19 : 0; -} -} -} -} - -uint32_t* tmp20 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp20 at (1990,1-1990,36) */ -uint32_t __tmp_in_tmp20; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp20; -} -Arr1DIdxRowM(tmp20, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp20 : 0; -} - -uint32_t* tmp21 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp21 at (1993,1-1993,46) */ -uint32_t __tmp_in_tmp21; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)32; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp21; -} -Arr4DIdxRowM(tmp21, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)32,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp21 : 0; -} -} -} -} - -uint32_t* tmp22 = make_array( (int32_t)32); -/* Variable to read the clear value corresponding to the input variable tmp22 at (1996,1-1996,35) */ -uint32_t __tmp_in_tmp22; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)32; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp22; -} -Arr1DIdxRowM(tmp22, (int32_t)32,i0) = (party == SERVER) ? __tmp_in_tmp22 : 0; -} - -uint32_t* tmp23 = make_array( (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp23 at (1999,1-1999,46) */ -uint32_t __tmp_in_tmp23; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp23; -} -Arr4DIdxRowM(tmp23, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp23 : 0; -} -} -} -} - -uint32_t* tmp24 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp24 at (2002,1-2002,36) */ -uint32_t __tmp_in_tmp24; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp24; -} -Arr1DIdxRowM(tmp24, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp24 : 0; -} - -uint32_t* tmp25 = make_array( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp25 at (2005,1-2005,46) */ -uint32_t __tmp_in_tmp25; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)32; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)128; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp25; -} -Arr4DIdxRowM(tmp25, (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp25 : 0; -} -} -} -} - -uint32_t* tmp26 = make_array( (int32_t)128); -/* Variable to read the clear value corresponding to the input variable tmp26 at (2008,1-2008,36) */ -uint32_t __tmp_in_tmp26; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)128; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp26; -} -Arr1DIdxRowM(tmp26, (int32_t)128,i0) = (party == SERVER) ? __tmp_in_tmp26 : 0; -} - -uint32_t* tmp27 = make_array( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)48); -/* Variable to read the clear value corresponding to the input variable tmp27 at (2011,1-2011,46) */ -uint32_t __tmp_in_tmp27; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)256; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)48; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp27; -} -Arr4DIdxRowM(tmp27, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)48,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp27 : 0; -} -} -} -} - -uint32_t* tmp28 = make_array( (int32_t)48); -/* Variable to read the clear value corresponding to the input variable tmp28 at (2014,1-2014,35) */ -uint32_t __tmp_in_tmp28; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)48; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp28; -} -Arr1DIdxRowM(tmp28, (int32_t)48,i0) = (party == SERVER) ? __tmp_in_tmp28 : 0; -} - -uint32_t* tmp29 = make_array( (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp29 at (2017,1-2017,46) */ -uint32_t __tmp_in_tmp29; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)48; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)192; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp29; -} -Arr4DIdxRowM(tmp29, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp29 : 0; -} -} -} -} - -uint32_t* tmp30 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp30 at (2020,1-2020,36) */ -uint32_t __tmp_in_tmp30; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp30; -} -Arr1DIdxRowM(tmp30, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp30 : 0; -} - -uint32_t* tmp31 = make_array( (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp31 at (2023,1-2023,46) */ -uint32_t __tmp_in_tmp31; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)48; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)192; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp31; -} -Arr4DIdxRowM(tmp31, (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp31 : 0; -} -} -} -} - -uint32_t* tmp32 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp32 at (2026,1-2026,36) */ -uint32_t __tmp_in_tmp32; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp32; -} -Arr1DIdxRowM(tmp32, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp32 : 0; -} - -uint32_t* tmp33 = make_array( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)48); -/* Variable to read the clear value corresponding to the input variable tmp33 at (2029,1-2029,46) */ -uint32_t __tmp_in_tmp33; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)384; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)48; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp33; -} -Arr4DIdxRowM(tmp33, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)48,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp33 : 0; -} -} -} -} - -uint32_t* tmp34 = make_array( (int32_t)48); -/* Variable to read the clear value corresponding to the input variable tmp34 at (2032,1-2032,35) */ -uint32_t __tmp_in_tmp34; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)48; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp34; -} -Arr1DIdxRowM(tmp34, (int32_t)48,i0) = (party == SERVER) ? __tmp_in_tmp34 : 0; -} - -uint32_t* tmp35 = make_array( (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp35 at (2035,1-2035,46) */ -uint32_t __tmp_in_tmp35; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)48; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)192; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp35; -} -Arr4DIdxRowM(tmp35, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp35 : 0; -} -} -} -} - -uint32_t* tmp36 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp36 at (2038,1-2038,36) */ -uint32_t __tmp_in_tmp36; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp36; -} -Arr1DIdxRowM(tmp36, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp36 : 0; -} - -uint32_t* tmp37 = make_array( (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp37 at (2041,1-2041,46) */ -uint32_t __tmp_in_tmp37; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)48; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)192; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp37; -} -Arr4DIdxRowM(tmp37, (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp37 : 0; -} -} -} -} - -uint32_t* tmp38 = make_array( (int32_t)192); -/* Variable to read the clear value corresponding to the input variable tmp38 at (2044,1-2044,36) */ -uint32_t __tmp_in_tmp38; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)192; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp38; -} -Arr1DIdxRowM(tmp38, (int32_t)192,i0) = (party == SERVER) ? __tmp_in_tmp38 : 0; -} - -uint32_t* tmp39 = make_array( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp39 at (2047,1-2047,46) */ -uint32_t __tmp_in_tmp39; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)384; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp39; -} -Arr4DIdxRowM(tmp39, (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp39 : 0; -} -} -} -} - -uint32_t* tmp40 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp40 at (2050,1-2050,35) */ -uint32_t __tmp_in_tmp40; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp40; -} -Arr1DIdxRowM(tmp40, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp40 : 0; -} - -uint32_t* tmp41 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp41 at (2053,1-2053,46) */ -uint32_t __tmp_in_tmp41; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp41; -} -Arr4DIdxRowM(tmp41, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp41 : 0; -} -} -} -} - -uint32_t* tmp42 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp42 at (2056,1-2056,36) */ -uint32_t __tmp_in_tmp42; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp42; -} -Arr1DIdxRowM(tmp42, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp42 : 0; -} - -uint32_t* tmp43 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp43 at (2059,1-2059,46) */ -uint32_t __tmp_in_tmp43; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp43; -} -Arr4DIdxRowM(tmp43, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp43 : 0; -} -} -} -} - -uint32_t* tmp44 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp44 at (2062,1-2062,36) */ -uint32_t __tmp_in_tmp44; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp44; -} -Arr1DIdxRowM(tmp44, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp44 : 0; -} - -uint32_t* tmp45 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp45 at (2065,1-2065,46) */ -uint32_t __tmp_in_tmp45; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)64; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp45; -} -Arr4DIdxRowM(tmp45, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)64,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp45 : 0; -} -} -} -} - -uint32_t* tmp46 = make_array( (int32_t)64); -/* Variable to read the clear value corresponding to the input variable tmp46 at (2068,1-2068,35) */ -uint32_t __tmp_in_tmp46; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)64; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp46; -} -Arr1DIdxRowM(tmp46, (int32_t)64,i0) = (party == SERVER) ? __tmp_in_tmp46 : 0; -} - -uint32_t* tmp47 = make_array( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp47 at (2071,1-2071,46) */ -uint32_t __tmp_in_tmp47; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp47; -} -Arr4DIdxRowM(tmp47, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp47 : 0; -} -} -} -} - -uint32_t* tmp48 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp48 at (2074,1-2074,36) */ -uint32_t __tmp_in_tmp48; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp48; -} -Arr1DIdxRowM(tmp48, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp48 : 0; -} - -uint32_t* tmp49 = make_array( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp49 at (2077,1-2077,46) */ -uint32_t __tmp_in_tmp49; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)3; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)3; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)64; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)256; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp49; -} -Arr4DIdxRowM(tmp49, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp49 : 0; -} -} -} -} - -uint32_t* tmp50 = make_array( (int32_t)256); -/* Variable to read the clear value corresponding to the input variable tmp50 at (2080,1-2080,36) */ -uint32_t __tmp_in_tmp50; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)256; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp50; -} -Arr1DIdxRowM(tmp50, (int32_t)256,i0) = (party == SERVER) ? __tmp_in_tmp50 : 0; -} - -uint32_t* tmp51 = make_array( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1000); -/* Variable to read the clear value corresponding to the input variable tmp51 at (2083,1-2083,48) */ -uint32_t __tmp_in_tmp51; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)512; i2++){ -for (uint32_t i3 = (uint32_t)0; i3 < (int32_t)1000; i3++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp51; -} -Arr4DIdxRowM(tmp51, (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1000,i0,i1,i2,i3) = (party == SERVER) ? __tmp_in_tmp51 : 0; -} -} -} -} - -uint32_t* tmp52 = make_array( (int32_t)1000); -/* Variable to read the clear value corresponding to the input variable tmp52 at (2086,1-2086,37) */ -uint32_t __tmp_in_tmp52; -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1000; i0++){ -if ((party == SERVER)) { -cin >> __tmp_in_tmp52; -} -Arr1DIdxRowM(tmp52, (int32_t)1000,i0) = (party == SERVER) ? __tmp_in_tmp52 : 0; -} -StartComputation(); - -uint32_t* tmp53 = make_array( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, tmp0, tmp1, tmp53); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)3, (int32_t)64, tmp1); -ClearMemSecret4( (int32_t)1, (int32_t)227, (int32_t)227, (int32_t)3, tmp0); - -uint32_t* tmp56 = make_array( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64); -ScaleUp1( (int32_t)64, tmp2, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp53, tmp2, tmp56); -ClearMemSecret1( (int32_t)64, tmp2); -ClearMemSecret4( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp53); - -uint32_t* tmp59 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -MaxPool( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp56, tmp59); -ClearMemSecret4( (int32_t)1, (int32_t)113, (int32_t)113, (int32_t)64, tmp56); - -uint32_t* tmp61 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp59, tmp61, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp59); - -uint32_t* tmp63 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp61, tmp3, tmp63); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp61); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)16, tmp3); - -uint32_t* tmp66 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -ScaleUp1( (int32_t)16, tmp4, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp63, tmp4, tmp66); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp63); -ClearMemSecret1( (int32_t)16, tmp4); - -uint32_t* tmp69 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp66, tmp69, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp66); - -uint32_t* tmp71 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp69, tmp5, tmp71); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64, tmp5); - -uint32_t* tmp73 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleUp1( (int32_t)64, tmp6, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp71, tmp6, tmp73); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp71); -ClearMemSecret1( (int32_t)64, tmp6); - -uint32_t* tmp76 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp73, tmp76, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp73); - -uint32_t* tmp78 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp69, tmp7, tmp78); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64, tmp7); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp69); - -uint32_t* tmp81 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleUp1( (int32_t)64, tmp8, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp78, tmp8, tmp81); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp78); -ClearMemSecret1( (int32_t)64, tmp8); - -uint32_t* tmp84 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp81, tmp84, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp81); - -int32_t tmp86 = (int32_t)3; - -uint32_t* tmp87 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp76, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp84, tmp86, tmp87); -ClearMemPublic(tmp86); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp76); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp84); - -uint32_t* tmp91 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp87, tmp9, tmp91); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp87); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)16, tmp9); - -uint32_t* tmp94 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -ScaleUp1( (int32_t)16, tmp10, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp91, tmp10, tmp94); -ClearMemSecret1( (int32_t)16, tmp10); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp91); - -uint32_t* tmp97 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp94, tmp97, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp94); - -uint32_t* tmp99 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp97, tmp11, tmp99); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)16, (int32_t)64, tmp11); - -uint32_t* tmp101 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleUp1( (int32_t)64, tmp12, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp99, tmp12, tmp101); -ClearMemSecret1( (int32_t)64, tmp12); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp99); - -uint32_t* tmp104 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp101, tmp104, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp101); - -uint32_t* tmp106 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp97, tmp13, tmp106); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)16, (int32_t)64, tmp13); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)16, tmp97); - -uint32_t* tmp109 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -ScaleUp1( (int32_t)64, tmp14, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp106, tmp14, tmp109); -ClearMemSecret1( (int32_t)64, tmp14); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp106); - -uint32_t* tmp112 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64); -Relu4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp109, tmp112, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp109); - -int32_t tmp114 = (int32_t)3; - -uint32_t* tmp115 = make_array( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128); -Concat2T444( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp104, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp112, tmp114, tmp115); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp112); -ClearMemPublic(tmp114); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)64, tmp104); - -uint32_t* tmp119 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -MaxPool( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp115, tmp119); -ClearMemSecret4( (int32_t)1, (int32_t)56, (int32_t)56, (int32_t)128, tmp115); - -uint32_t* tmp121 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp119, tmp15, tmp121); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp119); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)32, tmp15); - -uint32_t* tmp124 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -ScaleUp1( (int32_t)32, tmp16, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp121, tmp16, tmp124); -ClearMemSecret1( (int32_t)32, tmp16); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp121); - -uint32_t* tmp127 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp124, tmp127, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp124); - -uint32_t* tmp129 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp127, tmp17, tmp129); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128, tmp17); - -uint32_t* tmp131 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -ScaleUp1( (int32_t)128, tmp18, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp129, tmp18, tmp131); -ClearMemSecret1( (int32_t)128, tmp18); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp129); - -uint32_t* tmp134 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp131, tmp134, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp131); - -uint32_t* tmp136 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp127, tmp19, tmp136); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128, tmp19); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp127); - -uint32_t* tmp139 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -ScaleUp1( (int32_t)128, tmp20, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp136, tmp20, tmp139); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp136); -ClearMemSecret1( (int32_t)128, tmp20); - -uint32_t* tmp142 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp139, tmp142, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp139); - -int32_t tmp144 = (int32_t)3; - -uint32_t* tmp145 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256); -Concat2T444( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp134, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp142, tmp144, tmp145); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp134); -ClearMemPublic(tmp144); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp142); - -uint32_t* tmp149 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp145, tmp21, tmp149); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)32, tmp21); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, tmp145); - -uint32_t* tmp152 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -ScaleUp1( (int32_t)32, tmp22, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp149, tmp22, tmp152); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp149); -ClearMemSecret1( (int32_t)32, tmp22); - -uint32_t* tmp155 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp152, tmp155, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp152); - -uint32_t* tmp157 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)1, (int32_t)1, (int32_t)128, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp155, tmp23, tmp157); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)32, (int32_t)128, tmp23); - -uint32_t* tmp159 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -ScaleUp1( (int32_t)128, tmp24, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp157, tmp24, tmp159); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp157); -ClearMemSecret1( (int32_t)128, tmp24); - -uint32_t* tmp162 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp159, tmp162, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp159); - -uint32_t* tmp164 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Conv2DWrapper( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, (int32_t)3, (int32_t)3, (int32_t)128, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp155, tmp25, tmp164); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)32, tmp155); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)32, (int32_t)128, tmp25); - -uint32_t* tmp167 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -ScaleUp1( (int32_t)128, tmp26, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp164, tmp26, tmp167); -ClearMemSecret1( (int32_t)128, tmp26); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp164); - -uint32_t* tmp170 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128); -Relu4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp167, tmp170, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp167); - -int32_t tmp172 = (int32_t)3; - -uint32_t* tmp173 = make_array( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256); -Concat2T444( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp162, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp170, tmp172, tmp173); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp170); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)128, tmp162); -ClearMemPublic(tmp172); - -uint32_t* tmp177 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -MaxPool( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, (int32_t)3, (int32_t)3, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)2, (int32_t)2, (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, tmp173, tmp177); -ClearMemSecret4( (int32_t)1, (int32_t)27, (int32_t)27, (int32_t)256, tmp173); - -uint32_t* tmp179 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp177, tmp27, tmp179); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)48, tmp27); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp177); - -uint32_t* tmp182 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -ScaleUp1( (int32_t)48, tmp28, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp179, tmp28, tmp182); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp179); -ClearMemSecret1( (int32_t)48, tmp28); - -uint32_t* tmp185 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp182, tmp185, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp182); - -uint32_t* tmp187 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp185, tmp29, tmp187); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192, tmp29); - -uint32_t* tmp189 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -ScaleUp1( (int32_t)192, tmp30, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp187, tmp30, tmp189); -ClearMemSecret1( (int32_t)192, tmp30); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp187); - -uint32_t* tmp192 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp189, tmp192, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp189); - -uint32_t* tmp194 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)3, (int32_t)3, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp185, tmp31, tmp194); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp185); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192, tmp31); - -uint32_t* tmp197 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -ScaleUp1( (int32_t)192, tmp32, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp194, tmp32, tmp197); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp194); -ClearMemSecret1( (int32_t)192, tmp32); - -uint32_t* tmp200 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp197, tmp200, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp197); - -int32_t tmp202 = (int32_t)3; - -uint32_t* tmp203 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384); -Concat2T444( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp192, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp200, tmp202, tmp203); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp200); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp192); -ClearMemPublic(tmp202); - -uint32_t* tmp207 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp203, tmp33, tmp207); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, tmp203); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)48, tmp33); - -uint32_t* tmp210 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -ScaleUp1( (int32_t)48, tmp34, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp207, tmp34, tmp210); -ClearMemSecret1( (int32_t)48, tmp34); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp207); - -uint32_t* tmp213 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp210, tmp213, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp210); - -uint32_t* tmp215 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)1, (int32_t)1, (int32_t)192, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp213, tmp35, tmp215); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)48, (int32_t)192, tmp35); - -uint32_t* tmp217 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -ScaleUp1( (int32_t)192, tmp36, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp215, tmp36, tmp217); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp215); -ClearMemSecret1( (int32_t)192, tmp36); - -uint32_t* tmp220 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp217, tmp220, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp217); - -uint32_t* tmp222 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, (int32_t)3, (int32_t)3, (int32_t)192, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp213, tmp37, tmp222); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)48, tmp213); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)48, (int32_t)192, tmp37); - -uint32_t* tmp225 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -ScaleUp1( (int32_t)192, tmp38, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp222, tmp38, tmp225); -ClearMemSecret1( (int32_t)192, tmp38); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp222); - -uint32_t* tmp228 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp225, tmp228, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp225); - -int32_t tmp230 = (int32_t)3; - -uint32_t* tmp231 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384); -Concat2T444( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp220, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp228, tmp230, tmp231); -ClearMemPublic(tmp230); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp220); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)192, tmp228); - -uint32_t* tmp235 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp231, tmp39, tmp235); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)384, tmp231); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)384, (int32_t)64, tmp39); - -uint32_t* tmp238 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -ScaleUp1( (int32_t)64, tmp40, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp235, tmp40, tmp238); -ClearMemSecret1( (int32_t)64, tmp40); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp235); - -uint32_t* tmp241 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp238, tmp241, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp238); - -uint32_t* tmp243 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp241, tmp41, tmp243); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp41); - -uint32_t* tmp245 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -ScaleUp1( (int32_t)256, tmp42, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp243, tmp42, tmp245); -ClearMemSecret1( (int32_t)256, tmp42); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp243); - -uint32_t* tmp248 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp245, tmp248, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp245); - -uint32_t* tmp250 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp241, tmp43, tmp250); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256, tmp43); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp241); - -uint32_t* tmp253 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -ScaleUp1( (int32_t)256, tmp44, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp250, tmp44, tmp253); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp250); -ClearMemSecret1( (int32_t)256, tmp44); - -uint32_t* tmp256 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp253, tmp256, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp253); - -int32_t tmp258 = (int32_t)3; - -uint32_t* tmp259 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512); -Concat2T444( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp248, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp256, tmp258, tmp259); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp248); -ClearMemPublic(tmp258); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp256); - -uint32_t* tmp263 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp259, tmp45, tmp263); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)64, tmp45); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, tmp259); - -uint32_t* tmp266 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -ScaleUp1( (int32_t)64, tmp46, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp263, tmp46, tmp266); -ClearMemSecret1( (int32_t)64, tmp46); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp263); - -uint32_t* tmp269 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp266, tmp269, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp266); - -uint32_t* tmp271 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)1, (int32_t)1, (int32_t)256, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp269, tmp47, tmp271); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)64, (int32_t)256, tmp47); - -uint32_t* tmp273 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -ScaleUp1( (int32_t)256, tmp48, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp271, tmp48, tmp273); -ClearMemSecret1( (int32_t)256, tmp48); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp271); - -uint32_t* tmp276 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp273, tmp276, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp273); - -uint32_t* tmp278 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, (int32_t)3, (int32_t)3, (int32_t)256, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, tmp269, tmp49, tmp278); -ClearMemSecret4( (int32_t)3, (int32_t)3, (int32_t)64, (int32_t)256, tmp49); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)64, tmp269); - -uint32_t* tmp281 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -ScaleUp1( (int32_t)256, tmp50, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp278, tmp50, tmp281); -ClearMemSecret1( (int32_t)256, tmp50); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp278); - -uint32_t* tmp284 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp281, tmp284, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp281); - -int32_t tmp286 = (int32_t)3; - -uint32_t* tmp287 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512); -Concat2T444( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp276, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp284, tmp286, tmp287); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp276); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)256, tmp284); -ClearMemPublic(tmp286); - -uint32_t* tmp291 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000); -Conv2DWrapper( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, (int32_t)1, (int32_t)1, (int32_t)1000, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, tmp287, tmp51, tmp291); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)512, (int32_t)1000, tmp51); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)512, tmp287); - -uint32_t* tmp294 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000); -ScaleUp1( (int32_t)1000, tmp52, (int32_t)9); -MatAddBroadCast4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp291, tmp52, tmp294); -ClearMemSecret1( (int32_t)1000, tmp52); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp291); - -uint32_t* tmp297 = make_array( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000); -Relu4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp294, tmp297, (int32_t)9, 1); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp294); - -uint32_t* tmp299 = make_array( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000); -AvgPool( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, (int32_t)13, (int32_t)13, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)0, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp297, tmp299); -ClearMemSecret4( (int32_t)1, (int32_t)13, (int32_t)13, (int32_t)1000, tmp297); - -int32_t tmp301 = (int32_t)3; - -uint32_t* tmp302 = make_array( (int32_t)1, (int32_t)1, (int32_t)1); -ArgMax3( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp299, tmp301, tmp302); -ClearMemPublic(tmp301); -ClearMemSecret4( (int32_t)1, (int32_t)1, (int32_t)1, (int32_t)1000, tmp299); -EndComputation(); -for (uint32_t i0 = (uint32_t)0; i0 < (int32_t)1; i0++){ -for (uint32_t i1 = (uint32_t)0; i1 < (int32_t)1; i1++){ -for (uint32_t i2 = (uint32_t)0; i2 < (int32_t)1; i2++){ -cout << (funcReconstruct2PCCons(Arr3DIdxRowM(tmp302, (int32_t)1, (int32_t)1, (int32_t)1,i0,i1,i2), 2)) << endl; -} -} -} -} - diff --git a/SCI/src/BuildingBlocks/CMakeLists.txt b/SCI/src/BuildingBlocks/CMakeLists.txt new file mode 100644 index 00000000..4ad87975 --- /dev/null +++ b/SCI/src/BuildingBlocks/CMakeLists.txt @@ -0,0 +1,8 @@ +add_library(SCI-BuildingBlocks + value-extension.cpp + aux-protocols.cpp + truncation.cpp) + +target_link_libraries(SCI-BuildingBlocks + PUBLIC SCI-OTPrimitive SCI-Millionaire +) diff --git a/SCI/src/BuildingBlocks/aux-protocols.cpp b/SCI/src/BuildingBlocks/aux-protocols.cpp new file mode 100644 index 00000000..a0b765b7 --- /dev/null +++ b/SCI/src/BuildingBlocks/aux-protocols.cpp @@ -0,0 +1,665 @@ +/* +Authors: Deevashwer Rathee, Mayank Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "BuildingBlocks/aux-protocols.h" +#include "BuildingBlocks/truncation.h" +#include "BuildingBlocks/value-extension.h" + +using namespace std; +using namespace sci; + +AuxProtocols::AuxProtocols(int party, sci::NetIO *io, + OTPack *otpack) { + this->party = party; + this->io = io; + this->otpack = otpack; + this->mill = new MillionaireProtocol(party, io, otpack); + this->mill_and_eq = + new MillionaireWithEquality(party, io, otpack); +} + +AuxProtocols::~AuxProtocols() { + delete mill; + delete mill_and_eq; +} + +void AuxProtocols::wrap_computation(uint64_t *x, uint8_t *y, int32_t size, + int32_t bw_x) { + assert(bw_x <= 64); + uint64_t mask = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + + uint64_t *tmp_x = new uint64_t[size]; + for (int i = 0; i < size; i++) { + if (party == sci::ALICE) + tmp_x[i] = x[i] & mask; + else + tmp_x[i] = (mask - x[i]) & mask; // 2^{bw_x} - 1 - x[i] + } + mill->compare(y, tmp_x, size, bw_x, true); // computing greater_than + + delete[] tmp_x; +} + +void AuxProtocols::multiplexer(uint8_t *sel, uint64_t *x, uint64_t *y, + int32_t size, int32_t bw_x, int32_t bw_y) { + assert(bw_x <= 64 && bw_y <= 64 && bw_y <= bw_x); + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + + uint64_t *corr_data = new uint64_t[size]; + uint64_t *data_S = new uint64_t[size]; + uint64_t *data_R = new uint64_t[size]; + + // y = (sel_0 \xor sel_1) * (x_0 + x_1) + // y = (sel_0 + sel_1 - 2*sel_0*sel_1)*x_0 + (sel_0 + sel_1 - + // 2*sel_0*sel_1)*x_1 y = [sel_0*x_0 + sel_1*(x_0 - 2*sel_0*x_0)] + // + [sel_1*x_1 + sel_0*(x_1 - 2*sel_1*x_1)] + for (int i = 0; i < size; i++) { + corr_data[i] = (x[i] * (1 - 2 * uint64_t(sel[i]))) & mask_y; + } + if (party == sci::ALICE) { + otpack->iknp_straight->send_cot(data_S, corr_data, size, bw_y); + otpack->iknp_reversed->recv_cot(data_R, (bool *)sel, size, bw_y); + } else { // party == sci::BOB + otpack->iknp_straight->recv_cot(data_R, (bool *)sel, size, bw_y); + otpack->iknp_reversed->send_cot(data_S, corr_data, size, bw_y); + } + for (int i = 0; i < size; i++) { + y[i] = ((x[i] * uint64_t(sel[i]) + data_R[i] - data_S[i]) & mask_y); + } + + delete[] corr_data; + delete[] data_S; + delete[] data_R; +} + +void AuxProtocols::B2A(uint8_t *x, uint64_t *y, int32_t size, int32_t bw_y) { + assert(bw_y <= 64 && bw_y >= 1); + if (bw_y == 1) { + for (int i = 0; i < size; i++) { + y[i] = uint64_t(x[i]) & 1; + } + return; + } + uint64_t mask = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + + if (party == sci::ALICE) { + uint64_t *corr_data = new uint64_t[size]; + for (int i = 0; i < size; i++) { + corr_data[i] = (-2 * uint64_t(x[i])) & mask; + } + otpack->iknp_straight->send_cot(y, corr_data, size, bw_y); + + for (int i = 0; i < size; i++) { + y[i] = (uint64_t(x[i]) - y[i]) & mask; + } + delete[] corr_data; + } else { // party == sci::BOB + otpack->iknp_straight->recv_cot(y, (bool *)x, size, bw_y); + + for (int i = 0; i < size; i++) { + y[i] = (uint64_t(x[i]) + y[i]) & mask; + } + } +} + +template +void AuxProtocols::lookup_table(T **spec, T *x, T *y, int32_t size, + int32_t bw_x, int32_t bw_y) { + if (party == sci::ALICE) { + assert(x == nullptr); + assert(y == nullptr); + } else { // party == sci::BOB + assert(spec == nullptr); + } + assert(bw_x <= 8 && bw_x >= 2); + int32_t T_size = sizeof(T) * 8; + assert(bw_y <= T_size); + + T mask_x = (bw_x == T_size ? -1 : ((1ULL << bw_x) - 1)); + T mask_y = (bw_y == T_size ? -1 : ((1ULL << bw_y) - 1)); + uint64_t N = 1 << bw_x; + + if (party == sci::ALICE) { + PRG128 prg; + T **data = new T *[size]; + for (int i = 0; i < size; i++) { + data[i] = new T[N]; + for (uint64_t j = 0; j < N; j++) { + data[i][j] = spec[i][j]; + } + } + + otpack->kkot[bw_x - 1]->send(data, size, bw_y); + + for (int i = 0; i < size; i++) + delete[] data[i]; + delete[] data; + } else { // party == sci::BOB + uint8_t *choice = new uint8_t[size]; + for (int i = 0; i < size; i++) { + choice[i] = x[i] & mask_x; + } + otpack->kkot[bw_x - 1]->recv(y, choice, size, bw_y); + + delete[] choice; + } +} + +void AuxProtocols::MSB(uint64_t *x, uint8_t *msb_x, int32_t size, + int32_t bw_x) { + assert(bw_x <= 64); + int32_t shift = bw_x - 1; + uint64_t shift_mask = (shift == 64 ? -1 : ((1ULL << shift) - 1)); + + uint64_t *tmp_x = new uint64_t[size]; + uint8_t *msb_xb = new uint8_t[size]; + for (int i = 0; i < size; i++) { + tmp_x[i] = x[i] & shift_mask; + msb_xb[i] = (x[i] >> shift) & 1; + if (party == sci::BOB) + tmp_x[i] = (shift_mask - tmp_x[i]) & shift_mask; + } + + mill->compare(msb_x, tmp_x, size, bw_x - 1, true); // computing greater_than + + for (int i = 0; i < size; i++) { + msb_x[i] = msb_x[i] ^ msb_xb[i]; + } + + delete[] tmp_x; + delete[] msb_xb; +} + +void AuxProtocols::MSB_to_Wrap(uint64_t *x, uint8_t *msb_x, uint8_t *wrap_x, + int32_t size, int32_t bw_x) { + assert(bw_x <= 64); + if (party == sci::ALICE) { + PRG128 prg; + prg.random_bool((bool *)wrap_x, size); + uint8_t **spec = new uint8_t *[size]; + for (int i = 0; i < size; i++) { + spec[i] = new uint8_t[4]; + uint8_t msb_xb = (x[i] >> (bw_x - 1)) & 1; + for (int j = 0; j < 4; j++) { + uint8_t bits_j[2]; // j0 || j1 (LSB to MSB) + uint8_to_bool(bits_j, j, 2); + spec[i][j] = (((1 ^ msb_x[i] ^ bits_j[0]) * (msb_xb ^ bits_j[1])) ^ + (msb_xb * bits_j[1]) ^ wrap_x[i]) & + 1; + } + } + lookup_table(spec, nullptr, nullptr, size, 2, 1); + + for (int i = 0; i < size; i++) + delete[] spec[i]; + delete[] spec; + } else { // party == sci::BOB + uint8_t *lut_in = new uint8_t[size]; + for (int i = 0; i < size; i++) { + lut_in[i] = (((x[i] >> (bw_x - 1)) & 1) << 1) | msb_x[i]; + } + lookup_table(nullptr, lut_in, wrap_x, size, 2, 1); + + delete[] lut_in; + } +} + +void AuxProtocols::AND(uint8_t *x, uint8_t *y, uint8_t *z, int32_t size) { + int old_size = size; + size = ceil(size / 8.0) * 8; + uint8_t *tmp_x = new uint8_t[size]; + uint8_t *tmp_y = new uint8_t[size]; + uint8_t *tmp_z = new uint8_t[size]; + memcpy(tmp_x, x, old_size * sizeof(uint8_t)); + memcpy(tmp_y, y, old_size * sizeof(uint8_t)); + + // assert((size % 8) == 0); + Triple triples_std(size, true); + this->mill->triple_gen->generate(party, &triples_std, _16KKOT_to_4OT); + + uint8_t *ei = new uint8_t[(size) / 8]; + uint8_t *fi = new uint8_t[(size) / 8]; + uint8_t *e = new uint8_t[(size) / 8]; + uint8_t *f = new uint8_t[(size) / 8]; + + // this->mill->AND_step_1(ei, fi, x, y, triples_std.ai, triples_std.bi, size); + this->mill->AND_step_1(ei, fi, tmp_x, tmp_y, triples_std.ai, triples_std.bi, + size); + + int size_used = size / 8; + if (party == sci::ALICE) { + // Send share of e and f + io->send_data(ei, size_used); + io->send_data(ei, size_used); + io->send_data(fi, size_used); + io->send_data(fi, size_used); + // Receive share of e and f + io->recv_data(e, size_used); + io->recv_data(e, size_used); + io->recv_data(f, size_used); + io->recv_data(f, size_used); + } else // party = sci::sci::BOB + { + // Receive share of e and f + io->recv_data(e, size_used); + io->recv_data(e, size_used); + io->recv_data(f, size_used); + io->recv_data(f, size_used); + // Send share of e and f + io->send_data(ei, size_used); + io->send_data(ei, size_used); + io->send_data(fi, size_used); + io->send_data(fi, size_used); + } + + // Reconstruct e and f + for (int i = 0; i < size_used; i++) { + e[i] ^= ei[i]; + f[i] ^= fi[i]; + } + + // this->mill->AND_step_2(z, e, f, nullptr, nullptr, triples_std.ai, + // triples_std.bi, triples_std.ci, size); + this->mill->AND_step_2(tmp_z, e, f, nullptr, nullptr, triples_std.ai, + triples_std.bi, triples_std.ci, size); + memcpy(z, tmp_z, old_size * sizeof(uint8_t)); + + // cleanup + delete[] tmp_x; + delete[] tmp_y; + delete[] tmp_z; + delete[] ei; + delete[] fi; + delete[] e; + delete[] f; + + return; +} + +void AuxProtocols::reduce(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + int32_t bw_y) { + assert(bw_y <= bw_x); + uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + + for (int i = 0; i < dim; i++) { + y[i] = x[i] & mask_y; + } +} + +void AuxProtocols::digit_decomposition(int32_t dim, uint64_t *x, + uint64_t *x_digits, int32_t bw_x, + int32_t digit_size) { + assert(false && "Inefficient version of digit decomposition called"); + int num_digits = ceil(double(bw_x) / digit_size); + int last_digit_size = bw_x - (num_digits - 1) * digit_size; + uint64_t digit_mask = (digit_size == 64 ? -1 : (1ULL << digit_size) - 1); + uint64_t last_digit_mask = + (last_digit_size == 64 ? -1 : (1ULL << last_digit_size) - 1); + + Truncation trunc(this->party, this->io, this->otpack); + for (int i = 0; i < num_digits; i++) { + trunc.truncate_and_reduce(dim, x, x_digits + i * dim, i * digit_size, bw_x); + uint64_t mask = (i == (num_digits - 1) ? last_digit_mask : digit_mask); + for (int j = 0; j < dim; j++) { + x_digits[i * dim + j] &= mask; + } + } +} + +void AuxProtocols::digit_decomposition_sci(int32_t dim, uint64_t *x, + uint64_t *x_digits, int32_t bw_x, + int32_t digit_size, + bool all_digit_size) { + int num_digits = ceil(double(bw_x) / digit_size); + int last_digit_size = bw_x - (num_digits - 1) * digit_size; + uint64_t digit_mask = (digit_size == 64 ? -1 : (1ULL << digit_size) - 1); + uint64_t last_digit_mask = + (last_digit_size == 64 ? -1 : (1ULL << last_digit_size) - 1); + for (int i = 0; i < num_digits; i++) { + for (int j = 0; j < dim; j++) { + x_digits[i * dim + j] = (x[j] >> (i * digit_size)); + x_digits[i * dim + j] &= + (i == (num_digits - 1)) ? last_digit_mask : digit_mask; + } + } + uint8_t *wrap_ = new uint8_t[dim * (num_digits - 1)]; + uint8_t *ones_ = new uint8_t[dim * (num_digits - 1)]; + uint8_t *dp_wrap_entering = new uint8_t[dim * num_digits]; + uint8_t *dp_temp = new uint8_t[dim * num_digits]; + uint64_t *dp_wrap_arith = new uint64_t[dim * num_digits]; + // Fill wrap_ and ones_ + uint64_t *temp_x_digits = new uint64_t[dim * (num_digits - 1)]; + + for (int i = 0; i < (num_digits - 1); i++) { + for (int j = 0; j < dim; j++) { + if (party == sci::ALICE) + temp_x_digits[i * dim + j] = x_digits[i * dim + j] & digit_mask; + else + temp_x_digits[i * dim + j] = + (digit_mask - x_digits[i * dim + j]) & digit_mask; + } + } + this->mill_and_eq->compare_with_eq(wrap_, ones_, temp_x_digits, + (dim * (num_digits - 1)), digit_size); + + // DP steps proceed + for (int i = 0; i < num_digits; i++) { + if (i > 0) { + this->AND(ones_ + (i - 1) * dim, dp_wrap_entering + (i - 1) * dim, + dp_temp + (i - 1) * dim, dim); + } + for (int j = 0; j < dim; j++) { + if (i == 0) { + dp_wrap_entering[i * dim + j] = 0; + } else { + dp_wrap_entering[i * dim + j] = + wrap_[(i - 1) * dim + j] ^ dp_temp[(i - 1) * dim + j]; + } + } + } + this->B2A(dp_wrap_entering, dp_wrap_arith, num_digits * dim, digit_size); + for (int i = 0; i < num_digits; i++) { + for (int j = 0; j < dim; j++) { + x_digits[i * dim + j] += dp_wrap_arith[i * dim + j]; + uint64_t temp_mask = + (i == (num_digits - 1)) ? last_digit_mask : digit_mask; + x_digits[i * dim + j] &= temp_mask; + } + if (all_digit_size) { + if (i == (num_digits - 1)) { + XTProtocol *xt = new XTProtocol(this->party, this->io, this->otpack); + uint64_t *temp_last_digs = new uint64_t[dim]; + xt->z_extend(dim, x_digits + (num_digits - 1) * dim, temp_last_digs, + last_digit_size, digit_size); + for (int j = 0; j < dim; j++) { + x_digits[i * dim + j] = temp_last_digs[j]; + x_digits[i * dim + j] &= digit_mask; + } + delete xt; + delete[] temp_last_digs; + } + } + } + + delete[] wrap_; + delete[] ones_; + delete[] dp_wrap_entering; + delete[] dp_temp; + delete[] dp_wrap_arith; + delete[] temp_x_digits; +} + +uint64_t lookup_msnzb(uint64_t index) { + uint64_t ret = 0ULL; + ret = floor(log2(index)); + if (index == 0) { + ret = 0ULL; + } + // In the above step only at max log(64) = 6 bits are filled. + ret <<= 1; + // Last bit stores 1 if index is 0, else 0. + if (index == 0) { + ret ^= 1ULL; + } + return ret; +} + +void AuxProtocols::msnzb_sci(uint64_t *x, uint64_t *msnzb_index, int32_t bw_x, + int32_t size, int32_t digit_size) { + // The protocol only works when digit_size divides bw_x. + int32_t last_digit_size = bw_x % digit_size; + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + uint64_t digit_mask = (digit_size == 64 ? -1 : ((1ULL << digit_size) - 1)); + uint64_t last_digit_mask = + (last_digit_size == 64 ? -1 : ((1ULL << last_digit_size) - 1)); + if (last_digit_size == 0) { + last_digit_mask = digit_mask; + last_digit_size = digit_size; + } + int32_t num_digits = ceil((bw_x * 1.0) / digit_size); + uint64_t *x_digits = new uint64_t[num_digits * size]; + + XTProtocol *xt = new XTProtocol(this->party, this->io, this->otpack); + + // Extract digits + this->digit_decomposition_sci(size, x, x_digits, bw_x, digit_size); + + // Use LUTs for MSNZB on digits + int D = (1 << digit_size); + int DLast = (1 << last_digit_size); + uint8_t *z_ = new uint8_t[num_digits * size]; + uint64_t *msnzb_ = new uint64_t[num_digits * size]; + uint64_t *msnzb_extended = new uint64_t[num_digits * size]; + int lookup_output_bits = (ceil(log2(digit_size))) + 1; + int mux_bits = ceil(log2(bw_x)); + uint64_t msnzb_mask = (1ULL << (lookup_output_bits - 1)) - 1; + uint64_t mux_mask = (1ULL << mux_bits) - 1; + if (party == ALICE) { + uint64_t **spec; + spec = new uint64_t *[num_digits * size]; + PRG128 prg; + prg.random_data(z_, size * sizeof(uint8_t)); + prg.random_data(msnzb_, size * sizeof(uint64_t)); + for (int i = 0; i < (num_digits - 1) * size; i++) { + spec[i] = new uint64_t[D]; + z_[i] &= 1; + msnzb_[i] &= msnzb_mask; + for (int j = 0; j < D; j++) { + int idx = (x_digits[i] + j) & digit_mask; + uint64_t lookup_val = lookup_msnzb(idx); + spec[i][j] = ((lookup_val >> 1) - msnzb_[i]) & msnzb_mask; + spec[i][j] <<= 1; + spec[i][j] |= + ((uint64_t)(((uint8_t)(lookup_val & 1ULL)) ^ z_[i]) & 1ULL); + } + } + for (int i = (num_digits - 1) * size; i < num_digits * size; i++) { + spec[i] = new uint64_t[DLast]; + z_[i] &= 1; + msnzb_[i] &= msnzb_mask; + for (int j = 0; j < DLast; j++) { + int idx = (x_digits[i] + j) & last_digit_mask; + uint64_t lookup_val = lookup_msnzb(idx); + spec[i][j] = ((lookup_val >> 1) - msnzb_[i]) & msnzb_mask; + spec[i][j] <<= 1; + spec[i][j] |= + ((uint64_t)(((uint8_t)(lookup_val & 1ULL)) ^ z_[i]) & 1ULL); + } + } + if (last_digit_size == digit_size) { + this->lookup_table(spec, nullptr, nullptr, num_digits * size, + digit_size, lookup_output_bits); + } else { + this->lookup_table(spec, nullptr, nullptr, + (num_digits - 1) * size, digit_size, + lookup_output_bits); + this->lookup_table(spec + (num_digits - 1) * size, nullptr, + nullptr, size, last_digit_size, + lookup_output_bits); + } + + // Zero extend to mux_bits + xt->z_extend(num_digits * size, msnzb_, msnzb_extended, + lookup_output_bits - 1, mux_bits); + + for (int i = 0; i < num_digits * size; i++) { + delete[] spec[i]; + } + delete[] spec; + } else { // BOB + if (last_digit_size == digit_size) { + this->lookup_table(nullptr, x_digits, msnzb_, num_digits * size, + digit_size, lookup_output_bits); + } else { + this->lookup_table(nullptr, x_digits, msnzb_, + (num_digits - 1) * size, digit_size, + lookup_output_bits); + this->lookup_table(nullptr, x_digits + (num_digits - 1) * size, + msnzb_ + (num_digits - 1) * size, size, + last_digit_size, lookup_output_bits); + } + + for (int i = 0; i < (num_digits * size); i++) { + z_[i] = (uint8_t)(msnzb_[i] & 1ULL); + msnzb_[i] >>= 1; + } + + // Zero extend to mux_bits + xt->z_extend(num_digits * size, msnzb_, msnzb_extended, + lookup_output_bits - 1, mux_bits); + + for (int i = 0; i < num_digits; i++) { + for (int j = 0; j < size; j++) { + msnzb_extended[i * size + j] += (i * digit_size); + msnzb_extended[i * size + j] &= mux_mask; + } + } + } + + // Combine MSNZB of digits + uint8_t *dp_zeros_ = new uint8_t[(num_digits - 1) * size]; + uint8_t *one_xor_zeros_ = new uint8_t[(num_digits - 1) * size]; + uint8_t *dp_zeros_final = new uint8_t[num_digits * size]; + + if (party == ALICE) { + for (int i = 0; i < size; i++) { + dp_zeros_final[(num_digits - 1) * size + i] = + z_[(num_digits - 1) * size + i]; + } + for (int i = 0; i < (num_digits - 1); i++) { + for (int j = 0; j < size; j++) { + one_xor_zeros_[i * size + j] = z_[i * size + j]; + } + } + } else { + for (int i = 0; i < size; i++) { + dp_zeros_final[(num_digits - 1) * size + i] = + (1 ^ z_[(num_digits - 1) * size + i]); + } + for (int i = 0; i < (num_digits - 1); i++) { + for (int j = 0; j < size; j++) { + one_xor_zeros_[i * size + j] = (1 ^ z_[i * size + j]); + } + } + } + for (int i = (num_digits - 2); i >= 0; i--) { + if (i == (num_digits - 2)) { + for (int j = 0; j < size; j++) { + dp_zeros_[i * size + j] = z_[(i + 1) * size + j]; + } + } else { + this->AND(dp_zeros_ + (i + 1) * size, z_ + (i + 1) * size, + dp_zeros_ + i * size, size); + } + } + this->AND(dp_zeros_, one_xor_zeros_, dp_zeros_final, (num_digits - 1) * size); + + uint64_t *msnzb_muxed = new uint64_t[num_digits * size]; + this->multiplexer(dp_zeros_final, msnzb_extended, msnzb_muxed, + num_digits * size, mux_bits, mux_bits); + + for (int i = 0; i < size; i++) { + msnzb_index[i] = 0ULL; + for (int j = 0; j < num_digits; j++) { + msnzb_index[i] += msnzb_muxed[j * size + i]; + msnzb_index[i] &= mux_mask; + } + } + + delete xt; + delete[] x_digits; + delete[] z_; + delete[] msnzb_; + delete[] msnzb_extended; + delete[] dp_zeros_; + delete[] one_xor_zeros_; + delete[] dp_zeros_final; + delete[] msnzb_muxed; + return; +} + +void AuxProtocols::msnzb_one_hot(uint64_t *x, uint8_t *one_hot_vector, + int32_t bw_x, int32_t size, + int32_t digit_size) { + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + int msnzb_index_bits = ceil(log2(bw_x)); + uint64_t msnzb_index_mask = (1ULL << msnzb_index_bits) - 1; + + uint64_t *msnzb_index = new uint64_t[size]; + + this->msnzb_sci(x, msnzb_index, bw_x, size, digit_size); + + // use LUT to get the one-hot representation + int D = 1 << msnzb_index_bits; + uint64_t *xor_mask = new uint64_t[size]; + if (party == ALICE) { + uint64_t **spec; + spec = new uint64_t *[size]; + PRG128 prg; + prg.random_data(one_hot_vector, size * bw_x * sizeof(uint8_t)); + for (int i = 0; i < size; i++) { + for (int j = 0; j < bw_x; j++) { + one_hot_vector[i * bw_x + j] &= 1; + } + xor_mask[i] = 0ULL; + for (int j = (bw_x - 1); j >= 0; j--) { + xor_mask[i] <<= 1; + xor_mask[i] ^= (uint64_t)one_hot_vector[i * bw_x + j]; + } + } + for (int i = 0; i < size; i++) { + spec[i] = new uint64_t[D]; + for (int j = 0; j < D; j++) { + int idx = (msnzb_index[i] + j) & msnzb_index_mask; + uint64_t lookup_val = (1ULL << idx); + lookup_val ^= xor_mask[i]; + spec[i][j] = lookup_val; + } + } + this->lookup_table(spec, nullptr, nullptr, size, msnzb_index_bits, + bw_x); + + for (int i = 0; i < size; i++) { + delete[] spec[i]; + } + delete[] spec; + } else { // BOB + uint64_t *temp = new uint64_t[size]; + this->lookup_table(nullptr, msnzb_index, temp, size, + msnzb_index_bits, bw_x); + for (int i = 0; i < size; i++) { + for (int j = 0; j < bw_x; j++) { + one_hot_vector[i * bw_x + j] = (uint8_t)(temp[i] & 1ULL); + temp[i] >>= 1; + } + } + delete[] temp; + } + delete[] msnzb_index; +} + +template void AuxProtocols::lookup_table(uint64_t **spec, uint64_t *x, + uint64_t *y, int32_t size, + int32_t bw_x, int32_t bw_y); +template void AuxProtocols::lookup_table(uint8_t **spec, uint8_t *x, uint8_t *y, + int32_t size, int32_t bw_x, + int32_t bw_y); diff --git a/SCI/src/BuildingBlocks/aux-protocols.h b/SCI/src/BuildingBlocks/aux-protocols.h new file mode 100644 index 00000000..8b87ca93 --- /dev/null +++ b/SCI/src/BuildingBlocks/aux-protocols.h @@ -0,0 +1,162 @@ +/* +Authors: Deevashwer Rathee, Mayank Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef AUX_PROTOCOLS_H__ +#define AUX_PROTOCOLS_H__ + +#include "Millionaire/millionaire.h" +#include "Millionaire/millionaire_with_equality.h" +#include "OT/emp-ot.h" + +class AuxProtocols { +public: + int party; + sci::NetIO *io; + sci::OTPack *otpack; + MillionaireProtocol *mill; + MillionaireWithEquality *mill_and_eq; + + AuxProtocols(int party, sci::NetIO *io, sci::OTPack *otpack); + + ~AuxProtocols(); + + void wrap_computation( + // input vector + uint64_t *x, + // wrap-bit of shares of x + uint8_t *y, + // size of input vector + int32_t size, + // bitwidth of x + int32_t bw_x); + + // y = sel * x + void multiplexer( + // selection bits + uint8_t *sel, + // input vector + uint64_t *x, + // output vector + uint64_t *y, + // size of vectors + int32_t size, + // bitwidth of x + int32_t bw_x, + // bitwidth of y + int32_t bw_y); + + // Boolean to Arithmetic Shares + void B2A( + // input (boolean) vector + uint8_t *x, + // output vector + uint64_t *y, + // size of vector + int32_t size, + // bitwidth of y + int32_t bw_y); + + template + void lookup_table( + // table specification + T **spec, + // input vector + T *x, + // output vector + T *y, + // size of vector + int32_t size, + // bitwidth of input to LUT + int32_t bw_x, + // bitwidth of output of LUT + int32_t bw_y); + + // MSB computation + void MSB( + // input vector + uint64_t *x, + // shares of MSB(x) + uint8_t *msb_x, + // size of input vector + int32_t size, + // bitwidth of x + int32_t bw_x); + + // MSB to Wrap computation + void MSB_to_Wrap( + // input vector + uint64_t *x, + // shares of MSB(x) + uint8_t *msb_x, + // output shares of Wrap(x) + uint8_t *wrap_x, + // size of input vector + int32_t size, + // bitwidth of x + int32_t bw_x); + + // Bitwise AND + void AND( + // input A (boolean) vector + uint8_t *x, + // input B (boolean) vector + uint8_t *y, + // output vector + uint8_t *z, + // size of vector + int32_t size); + + void digit_decomposition(int32_t dim, uint64_t *x, uint64_t *x_digits, + int32_t bw_x, int32_t digit_size); + + void digit_decomposition_sci( + int32_t dim, uint64_t *x, uint64_t *x_digits, int32_t bw_x, + int32_t digit_size, + // set true if the bitlength of all output digits is digit_size + // leave false, if the last digit is output over <= digit_size bits + bool all_digit_size = false); + + void reduce(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + int32_t bw_y); + + // Make x positive: pos_x = x * (1 - 2*MSB(x)) + void make_positive( + // input vector + uint64_t *x, + // input (boolean) vector containing MSB(x) + uint8_t *msb_x, + // output vector + uint64_t *pos_x, + // size of vector + int32_t size); + + // Outputs index and not one-hot vector + void msnzb_sci(uint64_t *x, uint64_t *msnzb_index, int32_t bw_x, int32_t size, + int32_t digit_size = 8); + + // Wrapper over msnzb_sci. Outputs one-hot vector + void msnzb_one_hot(uint64_t *x, + // size: bw_x * size + uint8_t *one_hot_vector, int32_t bw_x, int32_t size, + int32_t digit_size = 8); +}; + +#endif diff --git a/SCI/src/BuildingBlocks/truncation.cpp b/SCI/src/BuildingBlocks/truncation.cpp new file mode 100644 index 00000000..395a00b0 --- /dev/null +++ b/SCI/src/BuildingBlocks/truncation.cpp @@ -0,0 +1,311 @@ +/* +Authors: Mayank Rathee, Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "BuildingBlocks/truncation.h" +#include "BuildingBlocks/value-extension.h" + +using namespace std; +using namespace sci; + +Truncation::Truncation(int party, NetIO *io, OTPack *otpack, + AuxProtocols *auxp, + MillionaireWithEquality *mill_eq_in) { + this->party = party; + this->io = io; + this->otpack = otpack; + if (auxp == nullptr) { + del_aux = true; + this->aux = new AuxProtocols(party, io, otpack); + } else { + this->aux = auxp; + } + if (mill_eq_in == nullptr) { + del_milleq = true; + this->mill_eq = + new MillionaireWithEquality(party, io, otpack, this->aux->mill); + } else { + this->mill_eq = mill_eq_in; + } + this->mill = this->aux->mill; + this->eq = new Equality(party, io, otpack, this->mill); + this->triple_gen = this->mill->triple_gen; +} + +Truncation::~Truncation() { + if (del_aux) { + delete this->aux; + } + if (del_milleq) { + delete this->mill_eq; + } + delete this->eq; +} + +void Truncation::div_pow2(int32_t dim, uint64_t *inA, uint64_t *outB, + int32_t shift, int32_t bw, bool signed_arithmetic, + uint8_t *msb_x) { + if (signed_arithmetic == false) { + truncate(dim, inA, outB, shift, bw, false, msb_x); + return; + } + if (shift == 0) { + memcpy(outB, inA, sizeof(uint64_t) * dim); + return; + } + assert((bw - shift) > 0 && "Division shouldn't truncate the full bitwidth"); + assert(signed_arithmetic && (bw - shift - 1 >= 0)); + assert((msb_x == nullptr) && "Not yet implemented"); + assert(inA != outB); + + uint64_t mask_bw = (bw == 64 ? -1 : ((1ULL << bw) - 1)); + uint64_t mask_shift = (shift == 64 ? -1 : ((1ULL << shift) - 1)); + // mask_upper extracts the upper bw-shift-1 bits after the MSB + uint64_t mask_upper = + ((bw - shift - 1) == 64 ? -1 : ((1ULL << (bw - shift - 1)) - 1)); + + uint64_t *inA_orig = new uint64_t[dim]; + + if (party == ALICE) { + for (int i = 0; i < dim; i++) { + inA_orig[i] = inA[i]; + inA[i] = ((inA[i] + (1ULL << (bw - 1))) & mask_bw); + } + } + + uint64_t *inA_lower = new uint64_t[dim]; + uint64_t *inA_upper = new uint64_t[dim]; + uint8_t *wrap_lower = new uint8_t[dim]; + uint8_t *wrap_upper = new uint8_t[dim]; + uint8_t *msb_upper = new uint8_t[dim]; + uint8_t *zero_test_lower = new uint8_t[dim]; + uint8_t *eq_upper = new uint8_t[dim]; + uint8_t *and_upper = new uint8_t[dim]; + uint8_t *div_correction = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + inA_lower[i] = inA[i] & mask_shift; + inA_upper[i] = (inA[i] >> shift) & mask_upper; + if (party == BOB) { + inA_upper[i] = (mask_upper - inA_upper[i]) & mask_upper; + } + } + + this->aux->wrap_computation(inA_lower, wrap_lower, dim, shift); + for (int i = 0; i < dim; i++) { + if (party == BOB) { + inA_lower[i] = (-1 * inA_lower[i]) & mask_shift; + } + } + this->eq->check_equality(zero_test_lower, inA_lower, dim, shift); + this->mill_eq->compare_with_eq(msb_upper, eq_upper, inA_upper, dim, + (bw - shift - 1)); + this->aux->AND(wrap_lower, eq_upper, and_upper, dim); + for (int i = 0; i < dim; i++) { + msb_upper[i] = (msb_upper[i] ^ and_upper[i] ^ (inA[i] >> (bw - 1))) & 1; + } + this->aux->MSB_to_Wrap(inA, msb_upper, wrap_upper, dim, bw); + // negate zero_test_lower and msb_upper + // if signed_arithmetic == true, MSB of inA is flipped in the beginning + // if MSB was 1, and the lower shift bits were not all 0, add 1 as + // div_correction + for (int i = 0; i < dim; i++) { + if (party == ALICE) { + zero_test_lower[i] ^= 1; + msb_upper[i] ^= 1; + } + } + this->aux->AND(zero_test_lower, msb_upper, div_correction, dim); + + uint64_t *arith_wrap_upper = new uint64_t[dim]; + uint64_t *arith_wrap_lower = new uint64_t[dim]; + uint64_t *arith_div_correction = new uint64_t[dim]; + this->aux->B2A(wrap_upper, arith_wrap_upper, dim, shift); + this->aux->B2A(wrap_lower, arith_wrap_lower, dim, bw); + this->aux->B2A(div_correction, arith_div_correction, dim, bw); + + for (int i = 0; i < dim; i++) { + outB[i] = + ((inA[i] >> shift) + arith_div_correction[i] + arith_wrap_lower[i] - + (1ULL << (bw - shift)) * arith_wrap_upper[i]) & + mask_bw; + } + + if (signed_arithmetic && (party == ALICE)) { + for (int i = 0; i < dim; i++) { + outB[i] = ((outB[i] - (1ULL << (bw - shift - 1))) & mask_bw); + inA[i] = inA_orig[i]; + } + } + delete[] inA_orig; + delete[] inA_lower; + delete[] inA_upper; + delete[] wrap_lower; + delete[] wrap_upper; + delete[] msb_upper; + delete[] zero_test_lower; + delete[] eq_upper; + delete[] and_upper; + delete[] div_correction; + delete[] arith_wrap_lower; + delete[] arith_wrap_upper; + delete[] arith_div_correction; + + return; +} + +void Truncation::truncate(int32_t dim, uint64_t *inA, uint64_t *outB, + int32_t shift, int32_t bw, bool signed_arithmetic, + uint8_t *msb_x) { + if (shift == 0) { + memcpy(outB, inA, sizeof(uint64_t) * dim); + return; + } + assert((bw - shift) > 0 && "Truncation shouldn't truncate the full bitwidth"); + assert((signed_arithmetic && (bw - shift - 1 >= 0)) || !signed_arithmetic); + assert(inA != outB); + + uint64_t mask_bw = (bw == 64 ? -1 : ((1ULL << bw) - 1)); + uint64_t mask_shift = (shift == 64 ? -1 : ((1ULL << shift) - 1)); + uint64_t mask_upper = + ((bw - shift) == 64 ? -1 : ((1ULL << (bw - shift)) - 1)); + + uint64_t *inA_orig = new uint64_t[dim]; + + if (signed_arithmetic && (party == ALICE)) { + for (int i = 0; i < dim; i++) { + inA_orig[i] = inA[i]; + inA[i] = ((inA[i] + (1ULL << (bw - 1))) & mask_bw); + } + } + + uint64_t *inA_lower = new uint64_t[dim]; + uint64_t *inA_upper = new uint64_t[dim]; + uint8_t *wrap_lower = new uint8_t[dim]; + uint8_t *wrap_upper = new uint8_t[dim]; + uint8_t *eq_upper = new uint8_t[dim]; + uint8_t *and_upper = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + inA_lower[i] = inA[i] & mask_shift; + inA_upper[i] = (inA[i] >> shift) & mask_upper; + if (party == BOB) { + inA_upper[i] = (mask_upper - inA_upper[i]) & mask_upper; + } + } + + this->aux->wrap_computation(inA_lower, wrap_lower, dim, shift); + if (msb_x == nullptr) { + this->mill_eq->compare_with_eq(wrap_upper, eq_upper, inA_upper, dim, + (bw - shift)); + this->aux->AND(wrap_lower, eq_upper, and_upper, dim); + for (int i = 0; i < dim; i++) { + wrap_upper[i] ^= and_upper[i]; + } + } else { + if (signed_arithmetic) { + uint8_t *inv_msb_x = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + inv_msb_x[i] = msb_x[i] ^ (party == ALICE ? 1 : 0); + } + this->aux->MSB_to_Wrap(inA, inv_msb_x, wrap_upper, dim, bw); + delete[] inv_msb_x; + } else { + this->aux->MSB_to_Wrap(inA, msb_x, wrap_upper, dim, bw); + } + } + + uint64_t *arith_wrap_upper = new uint64_t[dim]; + uint64_t *arith_wrap_lower = new uint64_t[dim]; + this->aux->B2A(wrap_upper, arith_wrap_upper, dim, shift); + this->aux->B2A(wrap_lower, arith_wrap_lower, dim, bw); + + for (int i = 0; i < dim; i++) { + outB[i] = (((inA[i] >> shift) & mask_upper) + arith_wrap_lower[i] - + (1ULL << (bw - shift)) * arith_wrap_upper[i]) & + mask_bw; + } + + if (signed_arithmetic && (party == ALICE)) { + for (int i = 0; i < dim; i++) { + outB[i] = ((outB[i] - (1ULL << (bw - shift - 1))) & mask_bw); + inA[i] = inA_orig[i]; + } + } + delete[] inA_orig; + delete[] inA_lower; + delete[] inA_upper; + delete[] wrap_lower; + delete[] wrap_upper; + delete[] eq_upper; + delete[] and_upper; + delete[] arith_wrap_lower; + delete[] arith_wrap_upper; + + return; +} + +void Truncation::truncate_red_then_ext(int32_t dim, uint64_t *inA, + uint64_t *outB, int32_t shift, + int32_t bw, bool signed_arithmetic, + uint8_t *msb_x) { + if (shift == 0) { + memcpy(outB, inA, dim * sizeof(uint64_t)); + return; + } + uint64_t *tmpB = new uint64_t[dim]; + truncate_and_reduce(dim, inA, tmpB, shift, bw); + XTProtocol xt(this->party, this->io, this->otpack, this->aux); + if (signed_arithmetic) + xt.s_extend(dim, tmpB, outB, bw - shift, bw); + else + xt.z_extend(dim, tmpB, outB, bw - shift, bw); + + delete[] tmpB; + return; +} + +void Truncation::truncate_and_reduce(int32_t dim, uint64_t *inA, uint64_t *outB, + int32_t shift, int32_t bw) { + if (shift == 0) { + memcpy(outB, inA, sizeof(uint64_t) * dim); + return; + } + assert((bw - shift) > 0 && "Truncation shouldn't truncate the full bitwidth"); + + uint64_t mask_bw = (bw == 64 ? -1 : ((1ULL << bw) - 1)); + uint64_t mask_shift = (shift == 64 ? -1 : ((1ULL << shift) - 1)); + uint64_t mask_out = ((bw - shift) == 64 ? -1 : ((1ULL << (bw - shift)) - 1)); + + uint64_t *inA_lower = new uint64_t[dim]; + uint8_t *wrap = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + inA_lower[i] = inA[i] & mask_shift; + } + + this->aux->wrap_computation(inA_lower, wrap, dim, shift); + + uint64_t *arith_wrap = new uint64_t[dim]; + this->aux->B2A(wrap, arith_wrap, dim, (bw - shift)); + + for (int i = 0; i < dim; i++) { + outB[i] = ((inA[i] >> shift) + arith_wrap[i]) & mask_out; + } + + return; +} diff --git a/SCI/src/BuildingBlocks/truncation.h b/SCI/src/BuildingBlocks/truncation.h new file mode 100644 index 00000000..42133006 --- /dev/null +++ b/SCI/src/BuildingBlocks/truncation.h @@ -0,0 +1,115 @@ +/* +Authors: Mayank Rathee, Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef TRUNCATION_H__ +#define TRUNCATION_H__ + +#include "BuildingBlocks/aux-protocols.h" +#include "Millionaire/equality.h" +#include "Millionaire/millionaire_with_equality.h" + +class Truncation { +public: + sci::NetIO *io = nullptr; + sci::OTPack *otpack; + TripleGenerator *triple_gen = nullptr; + MillionaireProtocol *mill = nullptr; + MillionaireWithEquality *mill_eq = nullptr; + Equality *eq = nullptr; + AuxProtocols *aux = nullptr; + bool del_aux = false; + bool del_milleq = false; + int party; + + // Constructor + Truncation(int party, sci::NetIO *io, sci::OTPack *otpack, + AuxProtocols *auxp = nullptr, + MillionaireWithEquality *mill_eq_in = nullptr); + + // Destructor + ~Truncation(); + + // Truncate (right-shift) by shift in the same ring (round towards -inf) + void truncate( + // Size of vector + int32_t dim, + // input vector + uint64_t *inA, + // output vector + uint64_t *outB, + // right shift amount + int32_t shift, + // Input and output bitwidth + int32_t bw, + // signed truncation? + bool signed_arithmetic = true, + // msb of input vector elements + uint8_t *msb_x = nullptr); + + // Divide by 2^shift in the same ring (round towards 0) + void div_pow2( + // Size of vector + int32_t dim, + // input vector + uint64_t *inA, + // output vector + uint64_t *outB, + // right shift amount + int32_t shift, + // Input and output bitwidth + int32_t bw, + // signed truncation? + bool signed_arithmetic = true, + // msb of input vector elements + uint8_t *msb_x = nullptr); + + // Truncate (right-shift) by shift in the same ring + void truncate_red_then_ext( + // Size of vector + int32_t dim, + // input vector + uint64_t *inA, + // output vector + uint64_t *outB, + // right shift amount + int32_t shift, + // Input and output bitwidth + int32_t bw, + // signed truncation? + bool signed_arithmetic = true, + // msb of input vector elements + uint8_t *msb_x = nullptr); + + // Truncate (right-shift) by shift and go to a smaller ring + void truncate_and_reduce( + // Size of vector + int32_t dim, + // input vector + uint64_t *inA, + // output vector + uint64_t *outB, + // right shift amount + int32_t shift, + // Input bitwidth + int32_t bw); +}; + +#endif // TRUNCATION_H__ diff --git a/SCI/src/BuildingBlocks/value-extension.cpp b/SCI/src/BuildingBlocks/value-extension.cpp new file mode 100644 index 00000000..b4a7e984 --- /dev/null +++ b/SCI/src/BuildingBlocks/value-extension.cpp @@ -0,0 +1,121 @@ +/* +Authors: Mayank Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "BuildingBlocks/value-extension.h" + +using namespace std; +using namespace sci; + +XTProtocol::XTProtocol(int party, NetIO *io, OTPack *otpack, + AuxProtocols *auxp) { + this->party = party; + this->io = io; + this->otpack = otpack; + if (auxp == nullptr) { + del_aux = true; + this->aux = new AuxProtocols(party, io, otpack); + } else { + this->aux = auxp; + } + this->millionaire = this->aux->mill; + this->triple_gen = this->millionaire->triple_gen; +} + +XTProtocol::~XTProtocol() { + if (del_aux) { + delete this->aux; + } +} + +void XTProtocol::z_extend(int32_t dim, uint64_t *inA, uint64_t *outB, + int32_t bwA, int32_t bwB, uint8_t *msbA) { + if (bwA == bwB) { + memcpy(outB, inA, sizeof(uint64_t) * dim); + return; + } + assert(bwB > bwA && "Extended bitwidth should be > original"); + uint64_t mask_bwA = (bwA == 64 ? -1 : ((1ULL << bwA) - 1)); + uint64_t mask_bwB = (bwB == 64 ? -1 : ((1ULL << bwB) - 1)); + uint8_t *wrap = new uint8_t[dim]; + + if (msbA != nullptr) { + this->aux->MSB_to_Wrap(inA, msbA, wrap, dim, bwA); + } else { + this->aux->wrap_computation(inA, wrap, dim, bwA); + } + + uint64_t *arith_wrap = new uint64_t[dim]; + this->aux->B2A(wrap, arith_wrap, dim, (bwB - bwA)); + + for (int i = 0; i < dim; i++) { + outB[i] = ((inA[i] & mask_bwA) - (1ULL << bwA) * arith_wrap[i]) & mask_bwB; + } + + delete[] wrap; + delete[] arith_wrap; +} + +void XTProtocol::s_extend(int32_t dim, uint64_t *inA, uint64_t *outB, + int32_t bwA, int32_t bwB, uint8_t *msbA) { + if (bwA == bwB) { + memcpy(outB, inA, sizeof(uint64_t) * dim); + return; + } + assert(bwB > bwA && "Extended bitwidth should be > original"); + uint64_t mask_bwA = (bwA == 64 ? -1 : ((1ULL << bwA) - 1)); + uint64_t mask_bwB = (bwB == 64 ? -1 : ((1ULL << bwB) - 1)); + + uint64_t *mapped_inA = new uint64_t[dim]; + uint64_t *mapped_outB = new uint64_t[dim]; + if (party == ALICE) { + for (int i = 0; i < dim; i++) { + mapped_inA[i] = (inA[i] + (1ULL << (bwA - 1))) & mask_bwA; + } + } else { // BOB + for (int i = 0; i < dim; i++) { + mapped_inA[i] = inA[i]; + } + } + + uint8_t *tmp_msbA = nullptr; + if (msbA != nullptr) { + tmp_msbA = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + tmp_msbA[i] = (party == ALICE ? msbA[i] ^ 1 : msbA[i]); + } + } + this->z_extend(dim, mapped_inA, mapped_outB, bwA, bwB, tmp_msbA); + if (msbA != nullptr) { + delete[] tmp_msbA; + } + + if (party == ALICE) { + for (int i = 0; i < dim; i++) { + outB[i] = (mapped_outB[i] - (1ULL << (bwA - 1))) & mask_bwB; + } + } else { // BOB + for (int i = 0; i < dim; i++) { + outB[i] = (mapped_outB[i]) & mask_bwB; + } + } + delete[] mapped_inA; + delete[] mapped_outB; +} diff --git a/SCI/src/BuildingBlocks/value-extension.h b/SCI/src/BuildingBlocks/value-extension.h new file mode 100644 index 00000000..661d031b --- /dev/null +++ b/SCI/src/BuildingBlocks/value-extension.h @@ -0,0 +1,52 @@ +/* +Authors: Mayank Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef ZERO_EXT_H__ +#define ZERO_EXT_H__ + +#include "BuildingBlocks/aux-protocols.h" +#include "Millionaire/millionaire.h" + +class XTProtocol { +public: + sci::NetIO *io = nullptr; + sci::OTPack *otpack; + TripleGenerator *triple_gen = nullptr; + MillionaireProtocol *millionaire = nullptr; + AuxProtocols *aux = nullptr; + bool del_aux = false; + int party; + + // Constructor + XTProtocol(int party, sci::NetIO *io, sci::OTPack *otpack, + AuxProtocols *auxp = nullptr); + + // Destructor + ~XTProtocol(); + + void z_extend(int32_t dim, uint64_t *inA, uint64_t *outB, int32_t bwA, + int32_t bwB, uint8_t *msbA = nullptr); + + void s_extend(int32_t dim, uint64_t *inA, uint64_t *outB, int32_t bwA, + int32_t bwB, uint8_t *msbA = nullptr); +}; + +#endif // ZERO_EXT_H__ diff --git a/SCI/src/CMakeLists.txt b/SCI/src/CMakeLists.txt index 274dc1d7..be88c28b 100644 --- a/SCI/src/CMakeLists.txt +++ b/SCI/src/CMakeLists.txt @@ -1,14 +1,109 @@ +include_directories(${CMAKE_CURRENT_LIST_DIR}) + +find_package(Eigen3 3.3 NO_MODULE QUIET) +if (NOT Eigen3_FOUND) + message(STATUS "Eigen 3.3 was not found: clone and install Eigen3 locally") + if (NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/eigen/CMakeLists.txt") + find_package(Git REQUIRED) + message(STATUS "initialize Git submodule: extern/eigen") + execute_process(COMMAND git submodule update --init --recursive extern/eigen + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}") + endif () + execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory build + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/eigen/") + execute_process(COMMAND ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX} .. + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/eigen/build") + execute_process(COMMAND ${CMAKE_COMMAND} --build .. --target install + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/eigen/build") + message(STATUS "${PROJECT_SOURCE_DIR}") + find_package(Eigen3 3.3 REQUIRED NO_MODULE PATHS "${CMAKE_INSTALL_PREFIX}") +endif () + add_subdirectory(utils) add_subdirectory(OT) add_subdirectory(Millionaire) -add_subdirectory(NonLinear) +add_subdirectory(BuildingBlocks) +add_subdirectory(LinearOT) add_subdirectory(LinearHE) +add_subdirectory(NonLinear) +add_subdirectory(Math) -add_library(SCI-Protocols INTERFACE) +add_library(SCI-common INTERFACE) -target_link_libraries(SCI-Protocols +find_package(Threads REQUIRED) +find_package(Eigen3 REQUIRED) + +target_link_libraries(SCI-common INTERFACE - SCI-OT SCI-NonLinear - SCI-LinearHE + Threads::Threads +) + +target_include_directories(SCI-common + INTERFACE + $ + $ ) + +add_library(SCI-OT library_fixed_uniform.cpp library_fixed.cpp + globals.cpp cleartext_library_fixed.cpp) +add_library(SCI-HE library_fixed_uniform.cpp globals.cpp) + +target_link_libraries(SCI-OT PUBLIC SCI-common SCI-LinearOT + SCI-BuildingBlocks SCI-Math Eigen3::Eigen) +target_link_libraries(SCI-HE PUBLIC SCI-common SCI-LinearHE) + +target_compile_definitions(SCI-OT PUBLIC SCI_OT=1) +target_compile_definitions(SCI-HE PUBLIC SCI_HE=1) + +install(TARGETS + SCI-OT + SCI-HE + SCI-common + SCI-BuildingBlocks + SCI-LinearOT + SCI-LinearHE + SCI-NonLinear + SCI-Math + SCI-Millionaire + SCI-OTPrimitive + SCI-utils + EXPORT SCITargets + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib + RUNTIME DESTINATION bin + INCLUDES DESTINATION include) + +install(EXPORT SCITargets + FILE SCITargets.cmake + NAMESPACE SCI:: + DESTINATION lib/cmake/SCI) + +install(DIRECTORY + utils + OT + Millionaire + NonLinear + BuildingBlocks + LinearOT + LinearHE + Math + DESTINATION include + FILES_MATCHING + PATTERN "*.h" + PATTERN "*.hpp") + +install(FILES + "defines.h" + "defines_uniform.h" + "globals.h" + "library_fixed.h" + "library_fixed_uniform.h" + "cleartext_library_fixed.h" + "cleartext_library_fixed_uniform.h" + DESTINATION include) + +install(FILES + "${CMAKE_CURRENT_SOURCE_DIR}/utils/cmake/FindGMP.cmake" + "${CMAKE_CURRENT_SOURCE_DIR}/utils/cmake/source_of_randomness.cmake" + DESTINATION lib/cmake/SCI) diff --git a/SCI/src/LinearHE/CMakeLists.txt b/SCI/src/LinearHE/CMakeLists.txt index 775b7c1a..72a60574 100644 --- a/SCI/src/LinearHE/CMakeLists.txt +++ b/SCI/src/LinearHE/CMakeLists.txt @@ -1,41 +1,21 @@ find_package(OpenMP REQUIRED) # set(CMAKE_FIND_DEBUG_MODE 1) -message(STATUS "SEAL 3.3.2 was not found: clone and install SEAL locally") -if (NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/SEAL/native/src/CMakeLists.txt") - find_package(Git REQUIRED) - message(STATUS "initialize Git submodule: extern/SEAL") - execute_process(COMMAND git submodule update --init --recursive extern/SEAL - WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}") -endif () -if(APPLE) - execute_process(COMMAND ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=${PROJECT_SOURCE_DIR}/build . - -DCMAKE_C_COMPILER=${MAC_GCC} -DCMAKE_CXX_COMPILER=${MAC_GPP} +find_package(SEAL 3.3.2 EXACT QUIET) +if (NOT SEAL_FOUND) + message(STATUS "SEAL 3.3.2 was not found: clone and install SEAL locally") + if (NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/SEAL/native/src/CMakeLists.txt") + find_package(Git REQUIRED) + message(STATUS "initialize Git submodule: extern/SEAL") + execute_process(COMMAND git submodule update --init --recursive extern/SEAL + WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}") + endif () + execute_process(COMMAND ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX} . WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/SEAL/native/src") -else () - execute_process(COMMAND ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=${PROJECT_SOURCE_DIR}/build . + execute_process(COMMAND ${CMAKE_COMMAND} --build . --target install WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/SEAL/native/src") -endif() -execute_process(COMMAND ${CMAKE_COMMAND} --build . --target install - WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/SEAL/native/src") -find_package(SEAL 3.3.2 EXACT REQUIRED PATHS "${PROJECT_SOURCE_DIR}/build/") - -message(STATUS "Eigen 3.3 was not found: clone and install Eigen3 locally") -if (NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/eigen/CMakeLists.txt") - find_package(Git REQUIRED) - message(STATUS "initialize Git submodule: extern/eigen") - execute_process(COMMAND git submodule update --init --recursive extern/eigen - WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}") + find_package(SEAL 3.3.2 EXACT REQUIRED PATHS "${CMAKE_INSTALL_PREFIX}") endif () -execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory build - WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/eigen/") -execute_process(COMMAND ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=${PROJECT_SOURCE_DIR}/build .. - WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/eigen/build") -execute_process(COMMAND ${CMAKE_COMMAND} --build .. --target install - WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/extern/eigen/build") -message(STATUS "${PROJECT_SOURCE_DIR}") -find_package(Eigen3 3.3 REQUIRED NO_MODULE PATHS "${PROJECT_SOURCE_DIR}/build/") - add_library(SCI-LinearHE conv-field.cpp @@ -51,8 +31,3 @@ target_link_libraries(SCI-LinearHE OpenMP::OpenMP_CXX Eigen3::Eigen ) - -if(!APPLE) - target_compile_options(SCI-LinearHE PRIVATE "-fopenmp") -endif() -target_compile_options(SCI-LinearHE PUBLIC "-fpermissive") diff --git a/SCI/src/LinearHE/conv-field.cpp b/SCI/src/LinearHE/conv-field.cpp index 1a70be38..d5e6b847 100644 --- a/SCI/src/LinearHE/conv-field.cpp +++ b/SCI/src/LinearHE/conv-field.cpp @@ -30,943 +30,914 @@ using namespace sci; using namespace seal; using namespace Eigen; -Image pad_image( - ConvMetadata data, - Image &image) -{ - int image_h = data.image_h; - int image_w = data.image_w; - Image p_image; - - int pad_h = data.pad_t + data.pad_b; - int pad_w = data.pad_l + data.pad_r; - int pad_top = data.pad_t; - int pad_left = data.pad_l; - - for (Channel &channel: image) { - Channel p_channel = Channel::Zero(image_h + pad_h, image_w + pad_w); - p_channel.block(pad_top, pad_left, image_h, image_w) = channel; - p_image.push_back(p_channel); - } - return p_image; +Image pad_image(ConvMetadata data, Image &image) { + int image_h = data.image_h; + int image_w = data.image_w; + Image p_image; + + int pad_h = data.pad_t + data.pad_b; + int pad_w = data.pad_l + data.pad_r; + int pad_top = data.pad_t; + int pad_left = data.pad_l; + + for (Channel &channel : image) { + Channel p_channel = Channel::Zero(image_h + pad_h, image_w + pad_w); + p_channel.block(pad_top, pad_left, image_h, image_w) = channel; + p_image.push_back(p_channel); + } + return p_image; } /* Adapted im2col algorithm from Caffe framework */ -void i2c( - Image &image, - Channel &column, - const int filter_h, - const int filter_w, - const int stride_h, - const int stride_w, - const int output_h, - const int output_w) -{ - int height = image[0].rows(); - int width = image[0].cols(); - int channels = image.size(); - - int col_width = column.cols(); - - // Index counters for images - int column_i = 0; - const int channel_size = height * width; - for (auto &channel: image) { - for (int filter_row = 0; filter_row < filter_h; filter_row++) { - for (int filter_col = 0; filter_col < filter_w; filter_col++) { - int input_row = filter_row; - for (int output_rows = output_h; output_rows; output_rows--) { - if (!condition_check(input_row, height)) { - for (int output_cols = output_w; output_cols; output_cols--) { - int row_i = column_i / col_width; - int col_i = column_i % col_width; - column(row_i, col_i) = 0; - column_i++; - } - } else { - int input_col = filter_col; - for (int output_col = output_w; output_col; output_col--) { - if (condition_check(input_col, width)) { - int row_i = column_i / col_width; - int col_i = column_i % col_width; - column(row_i, col_i) = channel(input_row, input_col); - column_i++; - } else { - int row_i = column_i / col_width; - int col_i = column_i % col_width; - column(row_i, col_i) = 0; - column_i++; - } - input_col += stride_w; - } - } - input_row += stride_h; - } +void i2c(Image &image, Channel &column, const int filter_h, const int filter_w, + const int stride_h, const int stride_w, const int output_h, + const int output_w) { + int height = image[0].rows(); + int width = image[0].cols(); + int channels = image.size(); + + int col_width = column.cols(); + + // Index counters for images + int column_i = 0; + const int channel_size = height * width; + for (auto &channel : image) { + for (int filter_row = 0; filter_row < filter_h; filter_row++) { + for (int filter_col = 0; filter_col < filter_w; filter_col++) { + int input_row = filter_row; + for (int output_rows = output_h; output_rows; output_rows--) { + if (!condition_check(input_row, height)) { + for (int output_cols = output_w; output_cols; output_cols--) { + int row_i = column_i / col_width; + int col_i = column_i % col_width; + column(row_i, col_i) = 0; + column_i++; } + } else { + int input_col = filter_col; + for (int output_col = output_w; output_col; output_col--) { + if (condition_check(input_col, width)) { + int row_i = column_i / col_width; + int col_i = column_i % col_width; + column(row_i, col_i) = channel(input_row, input_col); + column_i++; + } else { + int row_i = column_i / col_width; + int col_i = column_i % col_width; + column(row_i, col_i) = 0; + column_i++; + } + input_col += stride_w; + } + } + input_row += stride_h; } + } } + } } -// Generates a masking vector of random noise that will be applied to parts of the ciphertext -// that contain leakage from the convolution -vector HE_preprocess_noise( - const uint64_t* const* secret_share, - const ConvMetadata &data, - Encryptor &encryptor, - BatchEncoder &batch_encoder, - Evaluator &evaluator) -{ - vector> noise(data.out_ct, vector(data.slot_count, 0ULL)); - // Sample randomness into vector - PRG128 prg; - for(int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { - prg.random_mod_p(noise[ct_idx].data(), data.slot_count, prime_mod); - } - vector enc_noise(data.out_ct); - - // Puncture the vector with 0s where an actual convolution result value lives -#pragma omp parallel for num_threads(numThreads) schedule(static) - for (int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { - int out_base = 2 * ct_idx * data.chans_per_half; - for (int out_c = 0; out_c < 2*data.chans_per_half - && out_c + out_base < data.out_chans; out_c++) { - int half_idx = out_c / data.chans_per_half; - int half_off = out_c % data.chans_per_half; - for (int col = 0; col < data.output_h; col++) { - for (int row = 0; row < data.output_w; row++) { - int noise_idx = half_idx * data.pack_num - + half_off * data.image_size - + col * data.stride_w * data.image_w - + row * data.stride_h; - int share_idx = col * data.output_w + row ; - noise[ct_idx][noise_idx] = secret_share[out_base+out_c][share_idx]; - } - } +// Generates a masking vector of random noise that will be applied to parts of +// the ciphertext that contain leakage from the convolution +vector HE_preprocess_noise(const uint64_t *const *secret_share, + const ConvMetadata &data, + Encryptor &encryptor, + BatchEncoder &batch_encoder, + Evaluator &evaluator) { + vector> noise(data.out_ct, + vector(data.slot_count, 0ULL)); + // Sample randomness into vector + PRG128 prg; + for (int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { + prg.random_mod_p(noise[ct_idx].data(), data.slot_count, + prime_mod); + } + vector enc_noise(data.out_ct); + + // Puncture the vector with 0s where an actual convolution result value lives +#pragma omp parallel for num_threads(num_threads) schedule(static) + for (int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { + int out_base = 2 * ct_idx * data.chans_per_half; + for (int out_c = 0; + out_c < 2 * data.chans_per_half && out_c + out_base < data.out_chans; + out_c++) { + int half_idx = out_c / data.chans_per_half; + int half_off = out_c % data.chans_per_half; + for (int col = 0; col < data.output_h; col++) { + for (int row = 0; row < data.output_w; row++) { + int noise_idx = + half_idx * data.pack_num + half_off * data.image_size + + col * data.stride_w * data.image_w + row * data.stride_h; + int share_idx = col * data.output_w + row; + noise[ct_idx][noise_idx] = secret_share[out_base + out_c][share_idx]; } - Plaintext tmp; - batch_encoder.encode(noise[ct_idx], tmp); - encryptor.encrypt(tmp, enc_noise[ct_idx]); - evaluator.mod_switch_to_next_inplace(enc_noise[ct_idx]); + } } - return enc_noise; + Plaintext tmp; + batch_encoder.encode(noise[ct_idx], tmp); + encryptor.encrypt(tmp, enc_noise[ct_idx]); + evaluator.mod_switch_to_next_inplace(enc_noise[ct_idx]); + } + return enc_noise; } -// Preprocesses the input image for output packing. Ciphertext is packed in RowMajor -// order. In this mode simply pack all the input channels as tightly as possible -// where each channel is padded to the nearest of two -vector> preprocess_image_OP( - Image &image, - ConvMetadata data) -{ - vector> ct(data.inp_ct, vector(data.slot_count, 0)); - int inp_c = 0; - for (int ct_idx = 0; ct_idx < data.inp_ct; ct_idx++) { - int inp_c_limit = (ct_idx+1) * 2 * data.chans_per_half; - for (;inp_c < data.inp_chans && inp_c < inp_c_limit; inp_c++) { - // Calculate which half of ciphertext the output channel - // falls in and the offest from that half, - int half_idx = (inp_c % (2*data.chans_per_half)) / data.chans_per_half; - int half_off = inp_c % data.chans_per_half; - for (int row = 0; row < data.image_h; row++) { - for (int col = 0; col < data.image_w; col++) { - int idx = half_idx * data.pack_num - + half_off * data.image_size - + row * data.image_w - + col; - ct[ct_idx][idx] = image[inp_c](row,col); - } - } +// Preprocesses the input image for output packing. Ciphertext is packed in +// RowMajor order. In this mode simply pack all the input channels as tightly as +// possible where each channel is padded to the nearest of two +vector> preprocess_image_OP(Image &image, ConvMetadata data) { + vector> ct(data.inp_ct, + vector(data.slot_count, 0)); + int inp_c = 0; + for (int ct_idx = 0; ct_idx < data.inp_ct; ct_idx++) { + int inp_c_limit = (ct_idx + 1) * 2 * data.chans_per_half; + for (; inp_c < data.inp_chans && inp_c < inp_c_limit; inp_c++) { + // Calculate which half of ciphertext the output channel + // falls in and the offest from that half, + int half_idx = (inp_c % (2 * data.chans_per_half)) / data.chans_per_half; + int half_off = inp_c % data.chans_per_half; + for (int row = 0; row < data.image_h; row++) { + for (int col = 0; col < data.image_w; col++) { + int idx = half_idx * data.pack_num + half_off * data.image_size + + row * data.image_w + col; + ct[ct_idx][idx] = image[inp_c](row, col); } + } } - return ct; + } + return ct; } -// Evaluates the filter rotations necessary to convole an input. Essentially, think -// about placing the filter in the top left corner of the padded image and sliding the -// image over the filter in such a way that we capture which elements of filter -// multiply with which elements of the image. We account for the zero padding by -// zero-puncturing the masks. This function can evaluate plaintexts and -// ciphertexts. -vector> filter_rotations( - vector &input, - const ConvMetadata &data, - Evaluator *evaluator, - GaloisKeys *gal_keys) -{ - vector> rotations(input.size(), vector(data.filter_size)); - int pad_h = data.pad_t + data.pad_b; - int pad_w = data.pad_l + data.pad_r; - - // This tells us how many filters fit on a single row of the padded image - int f_per_row = data.image_w + pad_w - data.filter_w + 1; - - // This offset calculates rotations needed to bring filter from top left - // corner of image to the top left corner of padded image - int offset = f_per_row * data.pad_t + data.pad_l; - - // For each element of the filter, rotate the padded image s.t. the top - // left position always contains the first element of the image it touches -#pragma omp parallel for num_threads(numThreads) schedule(static) collapse(2) - for (int f = 0; f < data.filter_size; f++) { - for (int ct_idx = 0; ct_idx < input.size(); ct_idx++) { - int f_row = f / data.filter_w; - int f_col = f % data.filter_w; - int row_offset = f_row * data.image_w - offset; - int rot_amt = row_offset + f_col; - int idx = f_row*data.filter_w+f_col; - evaluator->rotate_rows(input[ct_idx], rot_amt, - *gal_keys, rotations[ct_idx][idx]); - } +// Evaluates the filter rotations necessary to convole an input. Essentially, +// think about placing the filter in the top left corner of the padded image and +// sliding the image over the filter in such a way that we capture which +// elements of filter multiply with which elements of the image. We account for +// the zero padding by zero-puncturing the masks. This function can evaluate +// plaintexts and ciphertexts. +vector> filter_rotations(vector &input, + const ConvMetadata &data, + Evaluator *evaluator, + GaloisKeys *gal_keys) { + vector> rotations(input.size(), + vector(data.filter_size)); + int pad_h = data.pad_t + data.pad_b; + int pad_w = data.pad_l + data.pad_r; + + // This tells us how many filters fit on a single row of the padded image + int f_per_row = data.image_w + pad_w - data.filter_w + 1; + + // This offset calculates rotations needed to bring filter from top left + // corner of image to the top left corner of padded image + int offset = f_per_row * data.pad_t + data.pad_l; + + // For each element of the filter, rotate the padded image s.t. the top + // left position always contains the first element of the image it touches +#pragma omp parallel for num_threads(num_threads) schedule(static) collapse(2) + for (int f = 0; f < data.filter_size; f++) { + for (size_t ct_idx = 0; ct_idx < input.size(); ct_idx++) { + int f_row = f / data.filter_w; + int f_col = f % data.filter_w; + int row_offset = f_row * data.image_w - offset; + int rot_amt = row_offset + f_col; + int idx = f_row * data.filter_w + f_col; + evaluator->rotate_rows(input[ct_idx], rot_amt, *gal_keys, + rotations[ct_idx][idx]); } - return rotations; + } + return rotations; } // Encrypts the given input image -vector HE_encrypt( - vector> &pt, - const ConvMetadata &data, - Encryptor &encryptor, - BatchEncoder &batch_encoder) -{ - vector ct(pt.size()); -#pragma omp parallel for num_threads(numThreads) schedule(static) - for (int ct_idx = 0; ct_idx < pt.size(); ct_idx++) { - Plaintext tmp; - batch_encoder.encode(pt[ct_idx], tmp); - encryptor.encrypt(tmp, ct[ct_idx]); - } - return ct; +vector HE_encrypt(vector> &pt, + const ConvMetadata &data, Encryptor &encryptor, + BatchEncoder &batch_encoder) { + vector ct(pt.size()); +#pragma omp parallel for num_threads(num_threads) schedule(static) + for (size_t ct_idx = 0; ct_idx < pt.size(); ct_idx++) { + Plaintext tmp; + batch_encoder.encode(pt[ct_idx], tmp); + encryptor.encrypt(tmp, ct[ct_idx]); + } + return ct; } // Creates filter masks for an image input that has been output packed. -vector>> HE_preprocess_filters_OP( - Filters &filters, - const ConvMetadata &data, - BatchEncoder &batch_encoder) -{ - // Mask is convolutions x cts per convolution x mask size - vector>> encoded_masks(data.convs, - vector>(data.inp_ct, - vector(data.filter_size))); - // Since a half in a permutation may have a variable number of rotations we - // use this index to track where we are at in the masks tensor - // Build each half permutation as well as it's inward rotations -#pragma omp parallel for num_threads(numThreads) schedule(static) collapse(2) - for (int perm = 0; perm < data.half_perms; perm += 2) { - for (int rot = 0; rot < data.half_rots; rot++) { - int conv_idx = perm * data.half_rots; - for (int ct_idx = 0; ct_idx < data.inp_ct; ct_idx++) { - // The output channel the current ct starts from - // int out_base = (((perm/2) + ct_idx)*2*data.chans_per_half) % data.out_mod; - int out_base = (perm*data.chans_per_half) % data.out_mod; - // Generate all inward rotations of each half -- half_rots loop - for (int f = 0; f < data.filter_size; f++) { - vector<vector<uint64_t>> masks(2, vector<uint64_t>(data.slot_count, 0)); - for (int half_idx = 0; half_idx < 2; half_idx++) { - int inp_base = (2*ct_idx + half_idx) * data.chans_per_half; - for (int chan = 0; chan < data.chans_per_half - && (chan + inp_base) < data.inp_chans; chan++) { - // Pull the value of this mask - int f_w = f % data.filter_w; - int f_h = f / data.filter_w; - // Set the coefficients of this channel for both - // permutations - uint64_t val, val2; - int out_idx, out_idx2; - - int offset = neg_mod(chan-rot, (int64_t)data.chans_per_half); - if (half_idx) { - // If out_halves < 1 we may repeat within a - // ciphertext - // TODO: Add the log optimization for this case - if (data.out_halves > 1) - out_idx = offset + out_base + data.chans_per_half; - else - out_idx = offset + out_base; - out_idx2 = offset + out_base; - } else { - out_idx = offset + out_base; - out_idx2 = offset + out_base + data.chans_per_half; - } - val = (out_idx < data.out_chans) - ? filters[out_idx][inp_base+chan](f_h,f_w) : 0; - val2 = (out_idx2 < data.out_chans) - ? filters[out_idx2][inp_base+chan](f_h,f_w) : 0; - // Iterate through the whole image and figure out which - // values the filter value touches - this is the same - // as for input packing - for(int curr_h = 0; curr_h < data.image_h; curr_h += data.stride_h) { - for(int curr_w = 0; curr_w < data.image_w; curr_w += data.stride_w) { - // curr_h and curr_w simulate the current top-left position of - // the filter. This detects whether the filter would fit over - // this section. If it's out-of-bounds we set the mask index to 0 - bool zero = ((curr_w+f_w) < data.pad_l) || - ((curr_w+f_w) >= (data.image_w+data.pad_l)) || - ((curr_h+f_h) < data.pad_t) || - ((curr_h+f_h) >= (data.image_h+data.pad_l)); - // Calculate which half of ciphertext the output channel - // falls in and the offest from that half, - int idx = half_idx * data.pack_num - + chan * data.image_size - + curr_h * data.image_w - + curr_w; - // Add both values to appropiate permutations - masks[0][idx] = zero? 0: val; - if (data.half_perms > 1) { - masks[1][idx] = zero? 0: val2; - } - } - } - } - } - batch_encoder.encode(masks[0], encoded_masks[conv_idx+rot][ct_idx][f]); - if (data.half_perms > 1) { - batch_encoder.encode(masks[1], - encoded_masks[conv_idx+data.half_rots+rot][ct_idx][f]); - } +vector<vector<vector<Plaintext>>> +HE_preprocess_filters_OP(Filters &filters, const ConvMetadata &data, + BatchEncoder &batch_encoder) { + // Mask is convolutions x cts per convolution x mask size + vector<vector<vector<Plaintext>>> encoded_masks( + data.convs, vector<vector<Plaintext>>( + data.inp_ct, vector<Plaintext>(data.filter_size))); + // Since a half in a permutation may have a variable number of rotations we + // use this index to track where we are at in the masks tensor + // Build each half permutation as well as it's inward rotations +#pragma omp parallel for num_threads(num_threads) schedule(static) collapse(2) + for (int perm = 0; perm < data.half_perms; perm += 2) { + for (int rot = 0; rot < data.half_rots; rot++) { + int conv_idx = perm * data.half_rots; + for (int ct_idx = 0; ct_idx < data.inp_ct; ct_idx++) { + // The output channel the current ct starts from + // int out_base = (((perm/2) + ct_idx)*2*data.chans_per_half) % + // data.out_mod; + int out_base = (perm * data.chans_per_half) % data.out_mod; + // Generate all inward rotations of each half -- half_rots loop + for (int f = 0; f < data.filter_size; f++) { + vector<vector<uint64_t>> masks(2, + vector<uint64_t>(data.slot_count, 0)); + for (int half_idx = 0; half_idx < 2; half_idx++) { + int inp_base = (2 * ct_idx + half_idx) * data.chans_per_half; + for (int chan = 0; chan < data.chans_per_half && + (chan + inp_base) < data.inp_chans; + chan++) { + // Pull the value of this mask + int f_w = f % data.filter_w; + int f_h = f / data.filter_w; + // Set the coefficients of this channel for both + // permutations + uint64_t val, val2; + int out_idx, out_idx2; + + int offset = neg_mod(chan - rot, (int64_t)data.chans_per_half); + if (half_idx) { + // If out_halves < 1 we may repeat within a + // ciphertext + // TODO: Add the log optimization for this case + if (data.out_halves > 1) + out_idx = offset + out_base + data.chans_per_half; + else + out_idx = offset + out_base; + out_idx2 = offset + out_base; + } else { + out_idx = offset + out_base; + out_idx2 = offset + out_base + data.chans_per_half; + } + val = (out_idx < data.out_chans) + ? filters[out_idx][inp_base + chan](f_h, f_w) + : 0; + val2 = (out_idx2 < data.out_chans) + ? filters[out_idx2][inp_base + chan](f_h, f_w) + : 0; + // Iterate through the whole image and figure out which + // values the filter value touches - this is the same + // as for input packing + for (int curr_h = 0; curr_h < data.image_h; + curr_h += data.stride_h) { + for (int curr_w = 0; curr_w < data.image_w; + curr_w += data.stride_w) { + // curr_h and curr_w simulate the current top-left position of + // the filter. This detects whether the filter would fit over + // this section. If it's out-of-bounds we set the mask index + // to 0 + bool zero = ((curr_w + f_w) < data.pad_l) || + ((curr_w + f_w) >= (data.image_w + data.pad_l)) || + ((curr_h + f_h) < data.pad_t) || + ((curr_h + f_h) >= (data.image_h + data.pad_l)); + // Calculate which half of ciphertext the output channel + // falls in and the offest from that half, + int idx = half_idx * data.pack_num + chan * data.image_size + + curr_h * data.image_w + curr_w; + // Add both values to appropiate permutations + masks[0][idx] = zero ? 0 : val; + if (data.half_perms > 1) { + masks[1][idx] = zero ? 0 : val2; + } } + } } + } + batch_encoder.encode(masks[0], + encoded_masks[conv_idx + rot][ct_idx][f]); + if (data.half_perms > 1) { + batch_encoder.encode( + masks[1], + encoded_masks[conv_idx + data.half_rots + rot][ct_idx][f]); + } } + } } - return encoded_masks; + } + return encoded_masks; } // Performs convolution for an output packed image. Returns the intermediate // rotation sets -vector<Ciphertext> HE_conv_OP( - vector<vector<vector<Plaintext>>> &masks, - vector<vector<Ciphertext>> &rotations, - const ConvMetadata &data, - Evaluator &evaluator, - Ciphertext &zero) -{ - vector<Ciphertext> result(data.convs); - - // Multiply masks and add for each convolution -#pragma omp parallel for num_threads(numThreads) schedule(static) - for (int conv_idx = 0; conv_idx < data.convs; conv_idx++) { - result[conv_idx] = zero; - for (int ct_idx = 0; ct_idx < data.inp_ct; ct_idx++) { - for (int f = 0; f < data.filter_size; f++) { - Ciphertext tmp; - if(!masks[conv_idx][ct_idx][f].is_zero()) { - evaluator.multiply_plain(rotations[ct_idx][f], - masks[conv_idx][ct_idx][f], tmp); - - evaluator.add_inplace(result[conv_idx], tmp); - } - } +vector<Ciphertext> HE_conv_OP(vector<vector<vector<Plaintext>>> &masks, + vector<vector<Ciphertext>> &rotations, + const ConvMetadata &data, Evaluator &evaluator, + Ciphertext &zero) { + vector<Ciphertext> result(data.convs); + + // Multiply masks and add for each convolution +#pragma omp parallel for num_threads(num_threads) schedule(static) + for (int conv_idx = 0; conv_idx < data.convs; conv_idx++) { + result[conv_idx] = zero; + for (int ct_idx = 0; ct_idx < data.inp_ct; ct_idx++) { + for (int f = 0; f < data.filter_size; f++) { + Ciphertext tmp; + if (!masks[conv_idx][ct_idx][f].is_zero()) { + evaluator.multiply_plain(rotations[ct_idx][f], + masks[conv_idx][ct_idx][f], tmp); + + evaluator.add_inplace(result[conv_idx], tmp); } - evaluator.mod_switch_to_next_inplace(result[conv_idx]); + } } - return result; + evaluator.mod_switch_to_next_inplace(result[conv_idx]); + } + return result; } // Takes the result of an output-packed convolution, and rotates + adds all the // ciphertexts to get a tightly packed output -vector<Ciphertext> HE_output_rotations( - vector<Ciphertext> &convs, - const ConvMetadata &data, - Evaluator &evaluator, - GaloisKeys &gal_keys, - Ciphertext &zero, - vector<Ciphertext> &enc_noise) -{ - vector<Ciphertext> partials(data.half_perms); - Ciphertext zero_next_level = zero; - evaluator.mod_switch_to_next_inplace(zero_next_level); - // Init the result vector to all 0 - vector<Ciphertext> result(data.out_ct); - for (int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { - result[ct_idx] = zero_next_level; - } - - // For each half perm, add up all the inside channels of each half -#pragma omp parallel for num_threads(numThreads) schedule(static) - for (int perm = 0; perm < data.half_perms; perm+=2) { - partials[perm] = zero_next_level; - if (data.half_perms > 1) - partials[perm+1] = zero_next_level; - // The output channel the current ct starts from - int total_rots = data.half_rots; - for (int in_rot = 0; in_rot < total_rots; in_rot++) { - int conv_idx = perm * data.half_rots + in_rot; - int rot_amt; - rot_amt = -neg_mod(-in_rot, (int64_t)data.chans_per_half) * data.image_size; - - evaluator.rotate_rows_inplace(convs[conv_idx], rot_amt, gal_keys); - evaluator.add_inplace(partials[perm], convs[conv_idx]); - // Do the same for the column swap if it exists - if (data.half_perms > 1) { - evaluator.rotate_rows_inplace(convs[conv_idx+data.half_rots], - rot_amt, gal_keys); - evaluator.add_inplace(partials[perm+1], convs[conv_idx+data.half_rots]); - } - } - // The correct index for the correct ciphertext in the final output - int out_idx = (perm/2) % data.out_ct; - if (perm == 0) { - // The first set of convolutions is aligned correctly - evaluator.add_inplace(result[out_idx], partials[perm]); - ///* - if (data.out_halves == 1 && data.inp_halves > 1) { - // If the output fits in a single half but the input - // doesn't, add the two columns - evaluator.rotate_columns_inplace(partials[perm], gal_keys); - evaluator.add_inplace(result[out_idx], partials[perm]); - } - //*/ - // Do the same for column swap if exists and we aren't on a repeat - if (data.half_perms > 1) { - evaluator.rotate_columns_inplace(partials[perm+1], gal_keys); - evaluator.add_inplace(result[out_idx], partials[perm+1]); - } - } else { - // Rotate the output ciphertexts by one and add - evaluator.add_inplace(result[out_idx], partials[perm]); - // If we're on a tight half we add both halves together and - // don't look at the column flip - if (data.half_perms > 1) { - evaluator.rotate_columns_inplace(partials[perm+1], gal_keys); - evaluator.add_inplace(result[out_idx], partials[perm+1]); - } - } +vector<Ciphertext> HE_output_rotations(vector<Ciphertext> &convs, + const ConvMetadata &data, + Evaluator &evaluator, + GaloisKeys &gal_keys, Ciphertext &zero, + vector<Ciphertext> &enc_noise) { + vector<Ciphertext> partials(data.half_perms); + Ciphertext zero_next_level = zero; + evaluator.mod_switch_to_next_inplace(zero_next_level); + // Init the result vector to all 0 + vector<Ciphertext> result(data.out_ct); + for (int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { + result[ct_idx] = zero_next_level; + } + + // For each half perm, add up all the inside channels of each half +#pragma omp parallel for num_threads(num_threads) schedule(static) + for (int perm = 0; perm < data.half_perms; perm += 2) { + partials[perm] = zero_next_level; + if (data.half_perms > 1) + partials[perm + 1] = zero_next_level; + // The output channel the current ct starts from + int total_rots = data.half_rots; + for (int in_rot = 0; in_rot < total_rots; in_rot++) { + int conv_idx = perm * data.half_rots + in_rot; + int rot_amt; + rot_amt = + -neg_mod(-in_rot, (int64_t)data.chans_per_half) * data.image_size; + + evaluator.rotate_rows_inplace(convs[conv_idx], rot_amt, gal_keys); + evaluator.add_inplace(partials[perm], convs[conv_idx]); + // Do the same for the column swap if it exists + if (data.half_perms > 1) { + evaluator.rotate_rows_inplace(convs[conv_idx + data.half_rots], rot_amt, + gal_keys); + evaluator.add_inplace(partials[perm + 1], + convs[conv_idx + data.half_rots]); + } } - //// Add the noise vector to remove any leakage - for (int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { - evaluator.add_inplace(result[ct_idx], enc_noise[ct_idx]); - // evaluator.mod_switch_to_next_inplace(result[ct_idx]); + // The correct index for the correct ciphertext in the final output + int out_idx = (perm / 2) % data.out_ct; + if (perm == 0) { + // The first set of convolutions is aligned correctly + evaluator.add_inplace(result[out_idx], partials[perm]); + ///* + if (data.out_halves == 1 && data.inp_halves > 1) { + // If the output fits in a single half but the input + // doesn't, add the two columns + evaluator.rotate_columns_inplace(partials[perm], gal_keys); + evaluator.add_inplace(result[out_idx], partials[perm]); + } + //*/ + // Do the same for column swap if exists and we aren't on a repeat + if (data.half_perms > 1) { + evaluator.rotate_columns_inplace(partials[perm + 1], gal_keys); + evaluator.add_inplace(result[out_idx], partials[perm + 1]); + } + } else { + // Rotate the output ciphertexts by one and add + evaluator.add_inplace(result[out_idx], partials[perm]); + // If we're on a tight half we add both halves together and + // don't look at the column flip + if (data.half_perms > 1) { + evaluator.rotate_columns_inplace(partials[perm + 1], gal_keys); + evaluator.add_inplace(result[out_idx], partials[perm + 1]); + } } - return result; + } + //// Add the noise vector to remove any leakage + for (int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { + evaluator.add_inplace(result[ct_idx], enc_noise[ct_idx]); + // evaluator.mod_switch_to_next_inplace(result[ct_idx]); + } + return result; } // Decrypts and reshapes convolution result -uint64_t** HE_decrypt( - vector<Ciphertext> &enc_result, - const ConvMetadata &data, - Decryptor &decryptor, - BatchEncoder &batch_encoder) -{ - // Decrypt ciphertext - vector<vector<uint64_t>> result(data.out_ct); - -#pragma omp parallel for num_threads(numThreads) schedule(static) - for (int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { - Plaintext tmp; - decryptor.decrypt(enc_result[ct_idx], tmp); - batch_encoder.decode(tmp, result[ct_idx]); +uint64_t **HE_decrypt(vector<Ciphertext> &enc_result, const ConvMetadata &data, + Decryptor &decryptor, BatchEncoder &batch_encoder) { + // Decrypt ciphertext + vector<vector<uint64_t>> result(data.out_ct); + +#pragma omp parallel for num_threads(num_threads) schedule(static) + for (int ct_idx = 0; ct_idx < data.out_ct; ct_idx++) { + Plaintext tmp; + decryptor.decrypt(enc_result[ct_idx], tmp); + batch_encoder.decode(tmp, result[ct_idx]); + } + + uint64_t **final_result = new uint64_t *[data.out_chans]; + // Extract correct values to reshape + for (int out_c = 0; out_c < data.out_chans; out_c++) { + int ct_idx = out_c / (2 * data.chans_per_half); + int half_idx = (out_c % (2 * data.chans_per_half)) / data.chans_per_half; + int half_off = out_c % data.chans_per_half; + // Depending on the padding type and stride the output values won't be + // lined up so extract them into a temporary channel before placing + // them in resultant Image + final_result[out_c] = new uint64_t[data.output_h * data.output_w]; + for (int col = 0; col < data.output_h; col++) { + for (int row = 0; row < data.output_w; row++) { + int idx = half_idx * data.pack_num + half_off * data.image_size + + col * data.stride_w * data.image_w + row * data.stride_h; + final_result[out_c][col * data.output_w + row] = result[ct_idx][idx]; + } } - - uint64_t** final_result = new uint64_t*[data.out_chans]; - // Extract correct values to reshape - for (int out_c = 0; out_c < data.out_chans; out_c++) { - int ct_idx = out_c / (2*data.chans_per_half); - int half_idx = (out_c % (2*data.chans_per_half)) / data.chans_per_half; - int half_off = out_c % data.chans_per_half; - // Depending on the padding type and stride the output values won't be - // lined up so extract them into a temporary channel before placing - // them in resultant Image - final_result[out_c] = new uint64_t[data.output_h*data.output_w]; - for (int col = 0; col < data.output_h; col++) { - for (int row = 0; row < data.output_w; row++) { - int idx = half_idx * data.pack_num - + half_off * data.image_size - + col * data.stride_w * data.image_w - + row * data.stride_h; - final_result[out_c][col*data.output_w + row] = result[ct_idx][idx]; - } - } - } - return final_result; + } + return final_result; } -ConvField::ConvField(int party, NetIO* io) -{ - this->party = party; - this->io = io; - this->slot_count = POLY_MOD_DEGREE_LARGE; - generate_new_keys(party, io, slot_count, context[1], encryptor[1], decryptor[1], - evaluator[1], encoder[1], gal_keys[1], zero[1]); - this->slot_count = POLY_MOD_DEGREE; - generate_new_keys(party, io, slot_count, context[0], encryptor[0], decryptor[0], - evaluator[0], encoder[0], gal_keys[0], zero[0]); +ConvField::ConvField(int party, NetIO *io) { + this->party = party; + this->io = io; + this->slot_count = POLY_MOD_DEGREE_LARGE; + generate_new_keys(party, io, slot_count, context[1], encryptor[1], + decryptor[1], evaluator[1], encoder[1], gal_keys[1], + zero[1]); + this->slot_count = POLY_MOD_DEGREE; + generate_new_keys(party, io, slot_count, context[0], encryptor[0], + decryptor[0], evaluator[0], encoder[0], gal_keys[0], + zero[0]); } -ConvField::~ConvField() -{ - for(int i = 0; i < 2; i++) { - free_keys(party, encryptor[i], decryptor[i], evaluator[i], - encoder[i], gal_keys[i], zero[i]); - } +ConvField::~ConvField() { + for (int i = 0; i < 2; i++) { + free_keys(party, encryptor[i], decryptor[i], evaluator[i], encoder[i], + gal_keys[i], zero[i]); + } } -void ConvField::configure() -{ - data.slot_count = this->slot_count; - // If using Output packing we pad image_size to the nearest power of 2 - data.image_size = next_pow2(data.image_h*data.image_w); - data.filter_size = data.filter_h * data.filter_w; - - assert(data.out_chans > 0 && data.inp_chans > 0); - // Doesn't currently support a channel being larger than a half ciphertext - assert(data.image_size <= (slot_count/2)); - - data.pack_num = slot_count / 2; - data.chans_per_half = data.pack_num / data.image_size; - data.out_ct = ceil((float) data.out_chans / (2*data.chans_per_half)); - data.inp_ct = ceil((float) data.inp_chans / (2*data.chans_per_half)); - - data.inp_halves = ceil((float) data.inp_chans / data.chans_per_half); - data.out_halves = ceil((float) data.out_chans / data.chans_per_half); - - // The modulo is calculated per ciphertext instead of per half since we - // should never have the last out_half wrap around to the first in the - // same ciphertext - data.out_mod = data.out_ct*2*data.chans_per_half; - - data.half_perms = (data.out_halves % 2 != 0 && data.out_halves > 1) ? - data.out_halves + 1 : data.out_halves; - data.half_rots = (data.inp_halves > 1 || data.out_halves > 1) ? - data.chans_per_half : max(data.chans_per_half, - max(data.out_chans, data.inp_chans)); - data.convs = data.half_perms * data.half_rots; - - data.output_h = 1 + (data.image_h+data.pad_t+data.pad_b-data.filter_h)/data.stride_h; - data.output_w = 1 + (data.image_w+data.pad_l+data.pad_r-data.filter_w)/data.stride_w; +void ConvField::configure() { + data.slot_count = this->slot_count; + // If using Output packing we pad image_size to the nearest power of 2 + data.image_size = next_pow2(data.image_h * data.image_w); + data.filter_size = data.filter_h * data.filter_w; + + assert(data.out_chans > 0 && data.inp_chans > 0); + // Doesn't currently support a channel being larger than a half ciphertext + assert(data.image_size <= (slot_count / 2)); + + data.pack_num = slot_count / 2; + data.chans_per_half = data.pack_num / data.image_size; + data.out_ct = ceil((float)data.out_chans / (2 * data.chans_per_half)); + data.inp_ct = ceil((float)data.inp_chans / (2 * data.chans_per_half)); + + data.inp_halves = ceil((float)data.inp_chans / data.chans_per_half); + data.out_halves = ceil((float)data.out_chans / data.chans_per_half); + + // The modulo is calculated per ciphertext instead of per half since we + // should never have the last out_half wrap around to the first in the + // same ciphertext + data.out_mod = data.out_ct * 2 * data.chans_per_half; + + data.half_perms = (data.out_halves % 2 != 0 && data.out_halves > 1) + ? data.out_halves + 1 + : data.out_halves; + data.half_rots = + (data.inp_halves > 1 || data.out_halves > 1) + ? data.chans_per_half + : max(data.chans_per_half, max(data.out_chans, data.inp_chans)); + data.convs = data.half_perms * data.half_rots; + + data.output_h = 1 + (data.image_h + data.pad_t + data.pad_b - data.filter_h) / + data.stride_h; + data.output_w = 1 + (data.image_w + data.pad_l + data.pad_r - data.filter_w) / + data.stride_w; } -Image ConvField::ideal_functionality( - Image &image, - Filters &filters) -{ - int channels = data.inp_chans; - int filter_h = data.filter_h; - int filter_w = data.filter_w; - int output_h = data.output_h; - int output_w = data.output_w; - - auto p_image = pad_image(data, image); - const int col_height = filter_h * filter_w * channels; - const int col_width = output_h * output_w; - Channel image_col(col_height, col_width); - i2c(p_image, image_col, data.filter_h, data.filter_w, data.stride_h, - data.stride_w, data.output_h, data.output_w); - - // For each filter, flatten it into and multiply with image_col - Image result; - for (auto &filter: filters) { - Channel filter_col(1, col_height); - // Use im2col with a filter size 1x1 to translate - i2c(filter, filter_col, 1, 1, 1, 1, filter_h, filter_w); - Channel tmp = filter_col * image_col; - - // Reshape result of multiplication to the right size - // SEAL stores matrices in RowMajor form - result.push_back(Eigen::Map<Eigen::Matrix<uint64_t, Eigen::Dynamic, Eigen::Dynamic, - Eigen::RowMajor>>(tmp.data(), output_h, output_w)); - } - return result; +Image ConvField::ideal_functionality(Image &image, Filters &filters) { + int channels = data.inp_chans; + int filter_h = data.filter_h; + int filter_w = data.filter_w; + int output_h = data.output_h; + int output_w = data.output_w; + + auto p_image = pad_image(data, image); + const int col_height = filter_h * filter_w * channels; + const int col_width = output_h * output_w; + Channel image_col(col_height, col_width); + i2c(p_image, image_col, data.filter_h, data.filter_w, data.stride_h, + data.stride_w, data.output_h, data.output_w); + + // For each filter, flatten it into and multiply with image_col + Image result; + for (auto &filter : filters) { + Channel filter_col(1, col_height); + // Use im2col with a filter size 1x1 to translate + i2c(filter, filter_col, 1, 1, 1, 1, filter_h, filter_w); + Channel tmp = filter_col * image_col; + + // Reshape result of multiplication to the right size + // SEAL stores matrices in RowMajor form + result.push_back(Eigen::Map<Eigen::Matrix<uint64_t, Eigen::Dynamic, + Eigen::Dynamic, Eigen::RowMajor>>( + tmp.data(), output_h, output_w)); + } + return result; } -void ConvField::non_strided_conv( - int32_t H, - int32_t W, - int32_t CI, - int32_t FH, - int32_t FW, - int32_t CO, - Image* image, - Filters* filters, - vector<vector<vector<uint64_t>>>& outArr, - bool verbose = false) -{ - data.image_h = H; - data.image_w = W; - data.inp_chans = CI; - data.out_chans = CO; - data.filter_h = FH; - data.filter_w = FW; - data.pad_t = 0; - data.pad_b = 0; - data.pad_l = 0; - data.pad_r = 0; - data.stride_h = 1; - data.stride_w = 1; - this->slot_count = min(SEAL_POLY_MOD_DEGREE_MAX, max(8192, 2*next_pow2(H*W))); - configure(); - - shared_ptr<SEALContext> context_; - Encryptor* encryptor_; - Decryptor* decryptor_; - Evaluator* evaluator_; - BatchEncoder* encoder_; - GaloisKeys* gal_keys_; - Ciphertext* zero_; - if (slot_count == POLY_MOD_DEGREE) { - context_ = this->context[0]; - encryptor_ = this->encryptor[0]; - decryptor_ = this->decryptor[0]; - evaluator_ = this->evaluator[0]; - encoder_ = this->encoder[0]; - gal_keys_ = this->gal_keys[0]; - zero_ = this->zero[0]; - } else if (slot_count == POLY_MOD_DEGREE_LARGE) { - context_ = this->context[1]; - encryptor_ = this->encryptor[1]; - decryptor_ = this->decryptor[1]; - evaluator_ = this->evaluator[1]; - encoder_ = this->encoder[1]; - gal_keys_ = this->gal_keys[1]; - zero_ = this->zero[1]; - } else { - generate_new_keys(party, io, slot_count, context_, encryptor_, decryptor_, - evaluator_, encoder_, gal_keys_, zero_, verbose); +void ConvField::non_strided_conv(int32_t H, int32_t W, int32_t CI, int32_t FH, + int32_t FW, int32_t CO, Image *image, + Filters *filters, + vector<vector<vector<uint64_t>>> &outArr, + bool verbose) { + data.image_h = H; + data.image_w = W; + data.inp_chans = CI; + data.out_chans = CO; + data.filter_h = FH; + data.filter_w = FW; + data.pad_t = 0; + data.pad_b = 0; + data.pad_l = 0; + data.pad_r = 0; + data.stride_h = 1; + data.stride_w = 1; + this->slot_count = + min(SEAL_POLY_MOD_DEGREE_MAX, max(8192, 2 * next_pow2(H * W))); + configure(); + + shared_ptr<SEALContext> context_; + Encryptor *encryptor_; + Decryptor *decryptor_; + Evaluator *evaluator_; + BatchEncoder *encoder_; + GaloisKeys *gal_keys_; + Ciphertext *zero_; + if (slot_count == POLY_MOD_DEGREE) { + context_ = this->context[0]; + encryptor_ = this->encryptor[0]; + decryptor_ = this->decryptor[0]; + evaluator_ = this->evaluator[0]; + encoder_ = this->encoder[0]; + gal_keys_ = this->gal_keys[0]; + zero_ = this->zero[0]; + } else if (slot_count == POLY_MOD_DEGREE_LARGE) { + context_ = this->context[1]; + encryptor_ = this->encryptor[1]; + decryptor_ = this->decryptor[1]; + evaluator_ = this->evaluator[1]; + encoder_ = this->encoder[1]; + gal_keys_ = this->gal_keys[1]; + zero_ = this->zero[1]; + } else { + generate_new_keys(party, io, slot_count, context_, encryptor_, decryptor_, + evaluator_, encoder_, gal_keys_, zero_, verbose); + } + + if (party == BOB) { + auto pt = preprocess_image_OP(*image, data); + if (verbose) + cout << "[Client] Image preprocessed" << endl; + + auto ct = HE_encrypt(pt, data, *encryptor_, *encoder_); + send_encrypted_vector(io, ct); + if (verbose) + cout << "[Client] Image encrypted and sent" << endl; + + vector<Ciphertext> enc_result(data.out_ct); + recv_encrypted_vector(io, enc_result); + auto HE_result = HE_decrypt(enc_result, data, *decryptor_, *encoder_); + + if (verbose) + cout << "[Client] Result received and decrypted" << endl; + + for (int idx = 0; idx < data.output_h * data.output_w; idx++) { + for (int chan = 0; chan < CO; chan++) { + outArr[idx / data.output_w][idx % data.output_w][chan] += + HE_result[chan][idx]; + } } - - if (party == BOB) - { - auto pt = preprocess_image_OP(*image, data); - if (verbose) cout << "[Client] Image preprocessed" << endl; - - auto ct = HE_encrypt(pt, data, *encryptor_, *encoder_); - send_encrypted_vector(io, ct); - if (verbose) cout << "[Client] Image encrypted and sent" << endl; - - vector<Ciphertext> enc_result(data.out_ct); - recv_encrypted_vector(io, enc_result); - auto HE_result = HE_decrypt(enc_result, data, *decryptor_, *encoder_); - - if (verbose) cout << "[Client] Result received and decrypted" << endl; - - for (int idx = 0; idx < data.output_h*data.output_w; idx++) { - for (int chan = 0; chan < CO; chan++) { - outArr[idx / data.output_w][idx % data.output_w][chan] - += HE_result[chan][idx]; - } - } + } else // party == ALICE + { + PRG128 prg; + uint64_t **secret_share = new uint64_t *[CO]; + for (int chan = 0; chan < CO; chan++) { + secret_share[chan] = new uint64_t[data.output_h * data.output_w]; + prg.random_mod_p<uint64_t>(secret_share[chan], + data.output_h * data.output_w, prime_mod); } - else // party == ALICE - { - PRG128 prg; - uint64_t** secret_share = new uint64_t*[CO]; - for (int chan = 0; chan < CO; chan++) { - secret_share[chan] = new uint64_t[data.output_h*data.output_w]; - prg.random_mod_p<uint64_t>(secret_share[chan], - data.output_h*data.output_w, prime_mod); - } - vector<Ciphertext> noise_ct = HE_preprocess_noise(secret_share, data, - *encryptor_, *encoder_, *evaluator_); + vector<Ciphertext> noise_ct = HE_preprocess_noise( + secret_share, data, *encryptor_, *encoder_, *evaluator_); - if (verbose) cout << "[Server] Noise processed" << endl; + if (verbose) + cout << "[Server] Noise processed" << endl; - vector<vector<vector<Plaintext>>> masks_OP; - masks_OP = HE_preprocess_filters_OP(*filters, data, *encoder_); + vector<vector<vector<Plaintext>>> masks_OP; + masks_OP = HE_preprocess_filters_OP(*filters, data, *encoder_); - if (verbose) cout << "[Server] Filters processed" << endl; + if (verbose) + cout << "[Server] Filters processed" << endl; - vector<Ciphertext> result; - vector<Ciphertext> ct(data.inp_ct); - vector<vector<Ciphertext>> rotations(data.inp_ct); - for(int i = 0; i < data.inp_ct; i++){ - rotations[i].resize(data.filter_size); - } - recv_encrypted_vector(io, ct); - rotations = filter_rotations(ct, data, evaluator_, gal_keys_); - if (verbose) cout << "[Server] Filter Rotations done" << endl; + vector<Ciphertext> result; + vector<Ciphertext> ct(data.inp_ct); + vector<vector<Ciphertext>> rotations(data.inp_ct); + for (int i = 0; i < data.inp_ct; i++) { + rotations[i].resize(data.filter_size); + } + recv_encrypted_vector(io, ct); + rotations = filter_rotations(ct, data, evaluator_, gal_keys_); + if (verbose) + cout << "[Server] Filter Rotations done" << endl; #ifdef HE_DEBUG - PRINT_NOISE_BUDGET(decryptor_, rotations[0][0], "before homomorphic convolution"); + PRINT_NOISE_BUDGET(decryptor_, rotations[0][0], + "before homomorphic convolution"); #endif - auto conv_result = HE_conv_OP(masks_OP, rotations, data, *evaluator_, *zero_); - if (verbose) cout << "[Server] Convolution done" << endl; + auto conv_result = + HE_conv_OP(masks_OP, rotations, data, *evaluator_, *zero_); + if (verbose) + cout << "[Server] Convolution done" << endl; #ifdef HE_DEBUG - PRINT_NOISE_BUDGET(decryptor_, conv_result[0], "after homomorphic convolution"); + PRINT_NOISE_BUDGET(decryptor_, conv_result[0], + "after homomorphic convolution"); #endif - result = HE_output_rotations(conv_result, data, *evaluator_, - *gal_keys_, *zero_, noise_ct); - if (verbose) cout << "[Server] Output Rotations done" << endl; + result = HE_output_rotations(conv_result, data, *evaluator_, *gal_keys_, + *zero_, noise_ct); + if (verbose) + cout << "[Server] Output Rotations done" << endl; #ifdef HE_DEBUG - PRINT_NOISE_BUDGET(decryptor_, result[0], "after output rotations"); + PRINT_NOISE_BUDGET(decryptor_, result[0], "after output rotations"); #endif - parms_id_type parms_id = result[0].parms_id(); - shared_ptr<const SEALContext::ContextData> context_data - = context_->get_context_data(parms_id); - for(int ct_idx = 0; ct_idx < result.size(); ct_idx++) { - flood_ciphertext(result[ct_idx], context_data, SMUDGING_BITLEN); - } + parms_id_type parms_id = result[0].parms_id(); + shared_ptr<const SEALContext::ContextData> context_data = + context_->get_context_data(parms_id); + for (size_t ct_idx = 0; ct_idx < result.size(); ct_idx++) { + flood_ciphertext(result[ct_idx], context_data, SMUDGING_BITLEN); + } #ifdef HE_DEBUG - PRINT_NOISE_BUDGET(decryptor_, result[0], "after noise flooding"); + PRINT_NOISE_BUDGET(decryptor_, result[0], "after noise flooding"); #endif - for(int ct_idx = 0; ct_idx < result.size(); ct_idx++) { - evaluator_->mod_switch_to_next_inplace(result[ct_idx]); - } + for (size_t ct_idx = 0; ct_idx < result.size(); ct_idx++) { + evaluator_->mod_switch_to_next_inplace(result[ct_idx]); + } #ifdef HE_DEBUG - PRINT_NOISE_BUDGET(decryptor_, result[0], "after mod-switch"); + PRINT_NOISE_BUDGET(decryptor_, result[0], "after mod-switch"); #endif - send_encrypted_vector(io, result); - if (verbose) cout << "[Server] Result computed and sent" << endl; + send_encrypted_vector(io, result); + if (verbose) + cout << "[Server] Result computed and sent" << endl; - for (int idx = 0; idx < data.output_h*data.output_w; idx++) { - for (int chan = 0; chan < CO; chan++) { - outArr[idx/data.output_w][idx%data.output_w][chan] - += (prime_mod - secret_share[chan][idx]); - } - } - for(int i = 0; i < data.out_chans; i++) - delete[] secret_share[i]; - delete[] secret_share; - } - if (slot_count > POLY_MOD_DEGREE && slot_count < POLY_MOD_DEGREE_LARGE) { - free_keys(party, encryptor_, decryptor_, evaluator_, - encoder_, gal_keys_, zero_); + for (int idx = 0; idx < data.output_h * data.output_w; idx++) { + for (int chan = 0; chan < CO; chan++) { + outArr[idx / data.output_w][idx % data.output_w][chan] += + (prime_mod - secret_share[chan][idx]); + } } + for (int i = 0; i < data.out_chans; i++) + delete[] secret_share[i]; + delete[] secret_share; + } + if (slot_count > POLY_MOD_DEGREE && slot_count < POLY_MOD_DEGREE_LARGE) { + free_keys(party, encryptor_, decryptor_, evaluator_, encoder_, gal_keys_, + zero_); + } } -void ConvField::convolution( - int32_t N, - int32_t H, - int32_t W, - int32_t CI, - int32_t FH, - int32_t FW, - int32_t CO, - int32_t zPadHLeft, - int32_t zPadHRight, - int32_t zPadWLeft, - int32_t zPadWRight, - int32_t strideH, - int32_t strideW, - vector<vector<vector<vector<uint64_t>>>>& inputArr, - vector<vector<vector<vector<uint64_t>>>>& filterArr, - vector<vector<vector<vector<uint64_t>>>>& outArr, - bool verify_output = false, - bool verbose = false) -{ - int paddedH = H+zPadHLeft+zPadHRight; - int paddedW = W+zPadWLeft+zPadWRight; - int newH = 1 + (paddedH-FH)/strideH; - int newW = 1 + (paddedW-FW)/strideW; - int limitH = FH + ((paddedH-FH)/strideH)*strideH; - int limitW = FW + ((paddedW-FW)/strideW)*strideW; - - for(int i = 0; i < newH; i++) { - for(int j = 0; j < newW; j++) { - for(int k = 0; k < CO; k++) { - outArr[0][i][j][k] = 0; - } - } +void ConvField::convolution(int32_t N, int32_t H, int32_t W, int32_t CI, + int32_t FH, int32_t FW, int32_t CO, + int32_t zPadHLeft, int32_t zPadHRight, + int32_t zPadWLeft, int32_t zPadWRight, + int32_t strideH, int32_t strideW, + vector<vector<vector<vector<uint64_t>>>> &inputArr, + vector<vector<vector<vector<uint64_t>>>> &filterArr, + vector<vector<vector<vector<uint64_t>>>> &outArr, + bool verify_output, bool verbose) { + int paddedH = H + zPadHLeft + zPadHRight; + int paddedW = W + zPadWLeft + zPadWRight; + int newH = 1 + (paddedH - FH) / strideH; + int newW = 1 + (paddedW - FW) / strideW; + int limitH = FH + ((paddedH - FH) / strideH) * strideH; + int limitW = FW + ((paddedW - FW) / strideW) * strideW; + + for (int i = 0; i < newH; i++) { + for (int j = 0; j < newW; j++) { + for (int k = 0; k < CO; k++) { + outArr[0][i][j][k] = 0; + } } - - Image image; - Filters filters; - - image.resize(CI); - for (int chan = 0; chan < CI; chan++) { - Channel tmp_chan(H, W); - for (int h = 0; h < H; h++) { - for (int w = 0; w < W; w++) { - tmp_chan(h, w) = neg_mod((int64_t)inputArr[0][h][w][chan], - (int64_t) prime_mod); - } - } - image[chan] = tmp_chan; + } + + Image image; + Filters filters; + + image.resize(CI); + for (int chan = 0; chan < CI; chan++) { + Channel tmp_chan(H, W); + for (int h = 0; h < H; h++) { + for (int w = 0; w < W; w++) { + tmp_chan(h, w) = + neg_mod((int64_t)inputArr[0][h][w][chan], (int64_t)prime_mod); + } } - if (party == BOB) - { - for (int s_row = 0; s_row < strideH; s_row++) { - for (int s_col = 0; s_col < strideW; s_col++) { - int lH = ((limitH-s_row+strideH-1)/strideH); - int lW = ((limitW-s_col+strideW-1)/strideW); - int lFH = ((FH-s_row+strideH-1)/strideH); - int lFW = ((FW-s_col+strideW-1)/strideW); - Image lImage(CI); - for (int chan = 0; chan < CI; chan++) { - Channel tmp_chan(lH, lW); - // lImage[chan] = new uint64_t[lH*lW]; - for (int row = 0; row < lH; row++) { - for (int col = 0; col < lW; col++) { - int idxH = row*strideH + s_row - zPadHLeft; - int idxW = col*strideW + s_col - zPadWLeft; - if ((idxH < 0 || idxH >= H) || (idxW < 0 || idxW >= W)) { - tmp_chan(row, col) = 0; - } else { - tmp_chan(row, col) = neg_mod(inputArr[0][idxH][idxW][chan], - (int64_t) prime_mod); - } - } - } - lImage[chan] = tmp_chan; - } - if (lFH > 0 && lFW > 0) { - non_strided_conv(lH, lW, CI, lFH, lFW, CO, &lImage, nullptr, - outArr[0], verbose); - } + image[chan] = tmp_chan; + } + if (party == BOB) { + for (int s_row = 0; s_row < strideH; s_row++) { + for (int s_col = 0; s_col < strideW; s_col++) { + int lH = ((limitH - s_row + strideH - 1) / strideH); + int lW = ((limitW - s_col + strideW - 1) / strideW); + int lFH = ((FH - s_row + strideH - 1) / strideH); + int lFW = ((FW - s_col + strideW - 1) / strideW); + Image lImage(CI); + for (int chan = 0; chan < CI; chan++) { + Channel tmp_chan(lH, lW); + // lImage[chan] = new uint64_t[lH*lW]; + for (int row = 0; row < lH; row++) { + for (int col = 0; col < lW; col++) { + int idxH = row * strideH + s_row - zPadHLeft; + int idxW = col * strideW + s_col - zPadWLeft; + if ((idxH < 0 || idxH >= H) || (idxW < 0 || idxW >= W)) { + tmp_chan(row, col) = 0; + } else { + tmp_chan(row, col) = + neg_mod(inputArr[0][idxH][idxW][chan], (int64_t)prime_mod); + } } + } + lImage[chan] = tmp_chan; } - for (int idx = 0; idx < newH*newW; idx++) { - for (int chan = 0; chan < CO; chan++) { - outArr[0][idx/newW][idx%newW][chan] - = neg_mod((int64_t) outArr[0][idx/newW][idx%newW][chan], prime_mod); - } + if (lFH > 0 && lFW > 0) { + non_strided_conv(lH, lW, CI, lFH, lFW, CO, &lImage, nullptr, + outArr[0], verbose); } - if (verify_output) verify(H, W, CI, CO, image, nullptr, outArr); + } } - else // party == ALICE - { - filters.resize(CO); - for (int out_c = 0; out_c < CO; out_c++) { - Image tmp_img(CI); - for (int inp_c = 0; inp_c < CI; inp_c++) { - Channel tmp_chan(FH, FW); - for (int idx = 0; idx < FH*FW; idx++) { - tmp_chan(idx/FW, idx%FW) - = (int64_t) filterArr[idx/FW][idx%FW][inp_c][out_c]; - } - tmp_img[inp_c] = tmp_chan; - } - filters[out_c] = tmp_img; + for (int idx = 0; idx < newH * newW; idx++) { + for (int chan = 0; chan < CO; chan++) { + outArr[0][idx / newW][idx % newW][chan] = neg_mod( + (int64_t)outArr[0][idx / newW][idx % newW][chan], prime_mod); + } + } + if (verify_output) + verify(H, W, CI, CO, image, nullptr, outArr); + } else // party == ALICE + { + filters.resize(CO); + for (int out_c = 0; out_c < CO; out_c++) { + Image tmp_img(CI); + for (int inp_c = 0; inp_c < CI; inp_c++) { + Channel tmp_chan(FH, FW); + for (int idx = 0; idx < FH * FW; idx++) { + tmp_chan(idx / FW, idx % FW) = + (int64_t)filterArr[idx / FW][idx % FW][inp_c][out_c]; } + tmp_img[inp_c] = tmp_chan; + } + filters[out_c] = tmp_img; + } - for (int s_row = 0; s_row < strideH; s_row++) { - for (int s_col = 0; s_col < strideW; s_col++) { - int lH = ((limitH-s_row+strideH-1)/strideH); - int lW = ((limitW-s_col+strideW-1)/strideW); - int lFH = ((FH-s_row+strideH-1)/strideH); - int lFW = ((FW-s_col+strideW-1)/strideW); - Filters lFilters(CO); - for (int out_c = 0; out_c < CO; out_c++) { - Image tmp_img(CI); - for (int inp_c = 0; inp_c < CI; inp_c++) { - Channel tmp_chan(lFH, lFW); - for (int row = 0; row < lFH; row++) { - for (int col = 0; col < lFW; col++) { - int idxFH = row*strideH + s_row; - int idxFW = col*strideW + s_col; - tmp_chan(row, col) - = neg_mod(filterArr[idxFH][idxFW][inp_c][out_c], - (int64_t) prime_mod); - } - } - tmp_img[inp_c] = tmp_chan; - } - lFilters[out_c] = tmp_img; - } - if (lFH > 0 && lFW > 0) { - non_strided_conv(lH, lW, CI, lFH, lFW, CO, nullptr, &lFilters, - outArr[0], verbose); - } + for (int s_row = 0; s_row < strideH; s_row++) { + for (int s_col = 0; s_col < strideW; s_col++) { + int lH = ((limitH - s_row + strideH - 1) / strideH); + int lW = ((limitW - s_col + strideW - 1) / strideW); + int lFH = ((FH - s_row + strideH - 1) / strideH); + int lFW = ((FW - s_col + strideW - 1) / strideW); + Filters lFilters(CO); + for (int out_c = 0; out_c < CO; out_c++) { + Image tmp_img(CI); + for (int inp_c = 0; inp_c < CI; inp_c++) { + Channel tmp_chan(lFH, lFW); + for (int row = 0; row < lFH; row++) { + for (int col = 0; col < lFW; col++) { + int idxFH = row * strideH + s_row; + int idxFW = col * strideW + s_col; + tmp_chan(row, col) = neg_mod( + filterArr[idxFH][idxFW][inp_c][out_c], (int64_t)prime_mod); + } } + tmp_img[inp_c] = tmp_chan; + } + lFilters[out_c] = tmp_img; } - data.image_h = H; - data.image_w = W; - data.inp_chans = CI; - data.out_chans = CO; - data.filter_h = FH; - data.filter_w = FW; - data.pad_t = zPadHLeft; - data.pad_b = zPadHRight; - data.pad_l = zPadWLeft; - data.pad_r = zPadWRight; - data.stride_h = strideH; - data.stride_w = strideW; - - // The filter values should be small enough to not overflow uint64_t - Image local_result = ideal_functionality(image, filters); - - for (int idx = 0; idx < newH*newW; idx++) { - for (int chan = 0; chan < CO; chan++) { - outArr[0][idx/newW][idx%newW][chan] = neg_mod( - (int64_t) local_result[chan](idx/newW, idx%newW) - + (int64_t) outArr[0][idx/newW][idx%newW][chan], prime_mod); - } + if (lFH > 0 && lFW > 0) { + non_strided_conv(lH, lW, CI, lFH, lFW, CO, nullptr, &lFilters, + outArr[0], verbose); } - if (verify_output) verify(H, W, CI, CO, image, &filters, outArr); + } } + data.image_h = H; + data.image_w = W; + data.inp_chans = CI; + data.out_chans = CO; + data.filter_h = FH; + data.filter_w = FW; + data.pad_t = zPadHLeft; + data.pad_b = zPadHRight; + data.pad_l = zPadWLeft; + data.pad_r = zPadWRight; + data.stride_h = strideH; + data.stride_w = strideW; + + // The filter values should be small enough to not overflow uint64_t + Image local_result = ideal_functionality(image, filters); + + for (int idx = 0; idx < newH * newW; idx++) { + for (int chan = 0; chan < CO; chan++) { + outArr[0][idx / newW][idx % newW][chan] = + neg_mod((int64_t)local_result[chan](idx / newW, idx % newW) + + (int64_t)outArr[0][idx / newW][idx % newW][chan], + prime_mod); + } + } + if (verify_output) + verify(H, W, CI, CO, image, &filters, outArr); + } } -void ConvField::verify( - int H, - int W, - int CI, - int CO, - Image &image, - Filters* filters, - vector<vector<vector<vector<uint64_t>>>>& outArr) -{ - int newH = outArr[0].size(); - int newW = outArr[0][0].size(); - if (party == BOB) - { - for(int i = 0; i < CI; i++) { - io->send_data(image[i].data(), H*W*sizeof(uint64_t)); - } - for(int i = 0; i < newH; i++) { - for(int j = 0; j < newW; j++) { - io->send_data(outArr[0][i][j].data(), sizeof(uint64_t)*data.out_chans); - } - } +void ConvField::verify(int H, int W, int CI, int CO, Image &image, + Filters *filters, + vector<vector<vector<vector<uint64_t>>>> &outArr) { + int newH = outArr[0].size(); + int newW = outArr[0][0].size(); + if (party == BOB) { + for (int i = 0; i < CI; i++) { + io->send_data(image[i].data(), H * W * sizeof(uint64_t)); } - else // party == ALICE - { - Image image_0(CI);// = new Channel[CI]; - for(int i = 0; i < CI; i++) { - // image_0[i] = new uint64_t[H*W]; - image_0[i].resize(H,W); - io->recv_data(image_0[i].data(), H*W*sizeof(uint64_t)); - } - for(int i = 0; i < CI; i++) { - for(int h = 0; h < H; h++) { - for(int w = 0; w < W; w++) { - image[i](h,w) = (image[i](h,w) + image_0[i](h,w)) % prime_mod; - } - } - } - Image result = ideal_functionality(image, *filters); - - vector<vector<vector<vector<uint64_t>>>> outArr_0; - outArr_0.resize(1); - outArr_0[0].resize(newH); - for(int i = 0; i < newH; i++) { - outArr_0[0][i].resize(newW); - for(int j = 0; j < newW; j++) { - outArr_0[0][i][j].resize(CO); - io->recv_data(outArr_0[0][i][j].data(), sizeof(uint64_t)*CO); - } - } - for(int i = 0; i < newH; i++) { - for(int j = 0; j < newW; j++) { - for(int k = 0; k < CO; k++) { - outArr_0[0][i][j][k] - = (outArr_0[0][i][j][k] + outArr[0][i][j][k]) % prime_mod; - } - } + for (int i = 0; i < newH; i++) { + for (int j = 0; j < newW; j++) { + io->send_data(outArr[0][i][j].data(), + sizeof(uint64_t) * data.out_chans); + } + } + } else // party == ALICE + { + Image image_0(CI); // = new Channel[CI]; + for (int i = 0; i < CI; i++) { + // image_0[i] = new uint64_t[H*W]; + image_0[i].resize(H, W); + io->recv_data(image_0[i].data(), H * W * sizeof(uint64_t)); + } + for (int i = 0; i < CI; i++) { + for (int h = 0; h < H; h++) { + for (int w = 0; w < W; w++) { + image[i](h, w) = (image[i](h, w) + image_0[i](h, w)) % prime_mod; } - bool pass = true; - for (int i = 0; i < CO; i++) { - for (int j = 0; j < newH; j++) { - for (int k = 0; k < newW; k++) { - if (outArr_0[0][j][k][i] != neg_mod(result[i](j,k), (int64_t) prime_mod)){ - pass = false; - } - } - } + } + } + Image result = ideal_functionality(image, *filters); + + vector<vector<vector<vector<uint64_t>>>> outArr_0; + outArr_0.resize(1); + outArr_0[0].resize(newH); + for (int i = 0; i < newH; i++) { + outArr_0[0][i].resize(newW); + for (int j = 0; j < newW; j++) { + outArr_0[0][i][j].resize(CO); + io->recv_data(outArr_0[0][i][j].data(), sizeof(uint64_t) * CO); + } + } + for (int i = 0; i < newH; i++) { + for (int j = 0; j < newW; j++) { + for (int k = 0; k < CO; k++) { + outArr_0[0][i][j][k] = + (outArr_0[0][i][j][k] + outArr[0][i][j][k]) % prime_mod; } - if (pass) cout << GREEN << "[Server] Successful Operation" << RESET << endl; - else { - cout << RED << "[Server] Failed Operation" << RESET << endl; - cout << RED << "WARNING: The implementation assumes that the computation" << endl; - cout << "performed locally by the server (on the model and its input share)" << endl; - cout << "fits in a 64-bit integer. The failed operation could be a result" << endl; - cout << "of overflowing the bound." << RESET << endl; + } + } + bool pass = true; + for (int i = 0; i < CO; i++) { + for (int j = 0; j < newH; j++) { + for (int k = 0; k < newW; k++) { + if ((int64_t)outArr_0[0][j][k][i] != + neg_mod(result[i](j, k), (int64_t)prime_mod)) { + pass = false; + } } + } + } + if (pass) + cout << GREEN << "[Server] Successful Operation" << RESET << endl; + else { + cout << RED << "[Server] Failed Operation" << RESET << endl; + cout << RED << "WARNING: The implementation assumes that the computation" + << endl; + cout << "performed locally by the server (on the model and its input " + "share)" + << endl; + cout << "fits in a 64-bit integer. The failed operation could be a result" + << endl; + cout << "of overflowing the bound." << RESET << endl; } + } } diff --git a/SCI/src/LinearHE/conv-field.h b/SCI/src/LinearHE/conv-field.h index 5384f459..40e3b7ad 100644 --- a/SCI/src/LinearHE/conv-field.h +++ b/SCI/src/LinearHE/conv-field.h @@ -30,185 +30,144 @@ Modified by Deevashwer Rathee #include <Eigen/Dense> // This is to keep compatibility for im2col implementations -typedef Eigen::Matrix<uint64_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> Channel; +typedef Eigen::Matrix<uint64_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> + Channel; typedef std::vector<Channel> Image; typedef std::vector<Image> Filters; struct ConvMetadata { - int slot_count; - // Number of plaintext slots in a half ciphertext - // (since ciphertexts are a two column matrix) - int32_t pack_num; - // Number of Channels that can fit in a half ciphertext - int32_t chans_per_half; - // Number of input ciphertexts for convolution - int32_t inp_ct; - // Number of output ciphertexts - int32_t out_ct; - // Image and Filters metadata - int32_t image_h; - int32_t image_w; - int32_t image_size; - int32_t inp_chans; - int32_t filter_h; - int32_t filter_w; - int32_t filter_size; - int32_t out_chans; - // How many total ciphertext halves the input and output take up - int32_t inp_halves; - int32_t out_halves; - // The modulo used when deciding which output channels to pack into a mask - int32_t out_mod; - // How many permutations of ciphertexts are needed to generate all - // intermediate rotation sets - int32_t half_perms; - /* The number of rotations for each ciphertext half */ - int32_t half_rots; - // Total number of convolutions needed to generate all - // intermediate rotations sets - int32_t convs; - int32_t stride_h; - int32_t stride_w; - int32_t output_h; - int32_t output_w; - int32_t pad_t; - int32_t pad_b; - int32_t pad_r; - int32_t pad_l; + int slot_count; + // Number of plaintext slots in a half ciphertext + // (since ciphertexts are a two column matrix) + int32_t pack_num; + // Number of Channels that can fit in a half ciphertext + int32_t chans_per_half; + // Number of input ciphertexts for convolution + int32_t inp_ct; + // Number of output ciphertexts + int32_t out_ct; + // Image and Filters metadata + int32_t image_h; + int32_t image_w; + size_t image_size; + int32_t inp_chans; + int32_t filter_h; + int32_t filter_w; + int32_t filter_size; + int32_t out_chans; + // How many total ciphertext halves the input and output take up + int32_t inp_halves; + int32_t out_halves; + // The modulo used when deciding which output channels to pack into a mask + int32_t out_mod; + // How many permutations of ciphertexts are needed to generate all + // intermediate rotation sets + int32_t half_perms; + /* The number of rotations for each ciphertext half */ + int32_t half_rots; + // Total number of convolutions needed to generate all + // intermediate rotations sets + int32_t convs; + int32_t stride_h; + int32_t stride_w; + int32_t output_h; + int32_t output_w; + int32_t pad_t; + int32_t pad_b; + int32_t pad_r; + int32_t pad_l; }; -/* Use casting to do two conditionals instead of one - check if a > 0 and a < b */ +/* Use casting to do two conditionals instead of one - check if a > 0 and a < b + */ inline bool condition_check(int a, int b) { - return static_cast<unsigned>(a) < static_cast<unsigned>(b); + return static_cast<unsigned>(a) < static_cast<unsigned>(b); } -Image pad_image( - ConvMetadata data, - Image &image); - -void i2c( - Image &image, - Channel &column, - const int filter_h, - const int filter_w, - const int stride_h, - const int stride_w, - const int output_h, - const int output_w); - -std::vector<seal::Ciphertext> HE_preprocess_noise( - const uint64_t* const* secret_share, - const ConvMetadata &data, - seal::Encryptor &encryptor, - seal::BatchEncoder &batch_encoder, - seal::Evaluator &evaluator); - -std::vector<std::vector<uint64_t>> preprocess_image_OP( - Image &image, - ConvMetadata data); - -std::vector<std::vector<seal::Ciphertext>> filter_rotations( - std::vector<seal::Ciphertext> &input, - const ConvMetadata &data, - seal::Evaluator *evaluator = NULL, - seal::GaloisKeys *gal_keys = NULL); - -std::vector<seal::Ciphertext> HE_encrypt( - std::vector<std::vector<uint64_t>> &pt, - const ConvMetadata &data, - seal::Encryptor &encryptor, - seal::BatchEncoder &batch_encoder); - -std::vector<std::vector<std::vector<seal::Plaintext>>> HE_preprocess_filters_OP( - Filters &filters, - const ConvMetadata &data, - seal::BatchEncoder &batch_encoder); - -std::vector<seal::Ciphertext> HE_conv_OP( - std::vector<std::vector<std::vector<seal::Plaintext>>> &masks, - std::vector<std::vector<seal::Ciphertext>> &rotations, - const ConvMetadata &data, - seal::Evaluator &evaluator, - seal::Ciphertext &zero); - -std::vector<seal::Ciphertext> HE_output_rotations( - std::vector<seal::Ciphertext> &convs, - const ConvMetadata &data, - seal::Evaluator &evaluator, - seal::GaloisKeys &gal_keys, - seal::Ciphertext &zero, - std::vector<seal::Ciphertext> &enc_noise); - -uint64_t** HE_decrypt( - std::vector<seal::Ciphertext> &enc_result, - const ConvMetadata &data, - seal::Decryptor &decryptor, - seal::BatchEncoder &batch_encoder); - -class ConvField { +Image pad_image(ConvMetadata data, Image &image); + +void i2c(Image &image, Channel &column, const int filter_h, const int filter_w, + const int stride_h, const int stride_w, const int output_h, + const int output_w); + +std::vector<seal::Ciphertext> +HE_preprocess_noise(const uint64_t *const *secret_share, + const ConvMetadata &data, seal::Encryptor &encryptor, + seal::BatchEncoder &batch_encoder, + seal::Evaluator &evaluator); + +std::vector<std::vector<uint64_t>> preprocess_image_OP(Image &image, + ConvMetadata data); + +std::vector<std::vector<seal::Ciphertext>> +filter_rotations(std::vector<seal::Ciphertext> &input, const ConvMetadata &data, + seal::Evaluator *evaluator = NULL, + seal::GaloisKeys *gal_keys = NULL); + +std::vector<seal::Ciphertext> HE_encrypt(std::vector<std::vector<uint64_t>> &pt, + const ConvMetadata &data, + seal::Encryptor &encryptor, + seal::BatchEncoder &batch_encoder); + +std::vector<std::vector<std::vector<seal::Plaintext>>> +HE_preprocess_filters_OP(Filters &filters, const ConvMetadata &data, + seal::BatchEncoder &batch_encoder); + +std::vector<seal::Ciphertext> +HE_conv_OP(std::vector<std::vector<std::vector<seal::Plaintext>>> &masks, + std::vector<std::vector<seal::Ciphertext>> &rotations, + const ConvMetadata &data, seal::Evaluator &evaluator, + seal::Ciphertext &zero); + +std::vector<seal::Ciphertext> +HE_output_rotations(std::vector<seal::Ciphertext> &convs, + const ConvMetadata &data, seal::Evaluator &evaluator, + seal::GaloisKeys &gal_keys, seal::Ciphertext &zero, + std::vector<seal::Ciphertext> &enc_noise); + +uint64_t **HE_decrypt(std::vector<seal::Ciphertext> &enc_result, + const ConvMetadata &data, seal::Decryptor &decryptor, + seal::BatchEncoder &batch_encoder); + +class ConvField { public: - int party; - sci::NetIO* io; - std::shared_ptr<seal::SEALContext> context[2]; - seal::Encryptor* encryptor[2]; - seal::Decryptor* decryptor[2]; - seal::Evaluator* evaluator[2]; - seal::BatchEncoder* encoder[2]; - seal::GaloisKeys* gal_keys[2]; - seal::Ciphertext* zero[2]; - int slot_count; - ConvMetadata data; - - ConvField(int party, sci::NetIO* io); - - ~ConvField(); - - void configure(); - - Image ideal_functionality( - Image &image, - Filters &filters); - - void non_strided_conv( - int32_t H, - int32_t W, - int32_t CI, - int32_t FH, - int32_t FW, - int32_t CO, - Image* image, - Filters* filters, - std::vector<std::vector<std::vector<uint64_t>>>& outArr, - bool verbose = false); - - void convolution( - int32_t N, - int32_t H, - int32_t W, - int32_t CI, - int32_t FH, - int32_t FW, - int32_t CO, - int32_t zPadHLeft, - int32_t zPadHRight, - int32_t zPadWLeft, - int32_t zPadWRight, - int32_t strideH, - int32_t strideW, - std::vector<std::vector<std::vector<std::vector<uint64_t>>>>& inputArr, - std::vector<std::vector<std::vector<std::vector<uint64_t>>>>& filterArr, - std::vector<std::vector<std::vector<std::vector<uint64_t>>>>& outArr, - bool verify_output = false, - bool verbose = false); - - void verify( - int H, - int W, - int CI, - int CO, - Image &image, - Filters* filters, - std::vector<std::vector<std::vector<std::vector<uint64_t>>>>& outArr); + int party; + sci::NetIO *io; + std::shared_ptr<seal::SEALContext> context[2]; + seal::Encryptor *encryptor[2]; + seal::Decryptor *decryptor[2]; + seal::Evaluator *evaluator[2]; + seal::BatchEncoder *encoder[2]; + seal::GaloisKeys *gal_keys[2]; + seal::Ciphertext *zero[2]; + size_t slot_count; + ConvMetadata data; + + ConvField(int party, sci::NetIO *io); + + ~ConvField(); + + void configure(); + + Image ideal_functionality(Image &image, Filters &filters); + + void non_strided_conv(int32_t H, int32_t W, int32_t CI, int32_t FH, + int32_t FW, int32_t CO, Image *image, Filters *filters, + std::vector<std::vector<std::vector<uint64_t>>> &outArr, + bool verbose = false); + + void convolution( + int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, int32_t FW, + int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, + int32_t zPadWRight, int32_t strideH, int32_t strideW, + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> &inputArr, + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> &filterArr, + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> &outArr, + bool verify_output = false, bool verbose = false); + + void + verify(int H, int W, int CI, int CO, Image &image, Filters *filters, + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> &outArr); }; #endif diff --git a/SCI/src/LinearHE/defines-HE.h b/SCI/src/LinearHE/defines-HE.h index 5e820062..4a4978aa 100644 --- a/SCI/src/LinearHE/defines-HE.h +++ b/SCI/src/LinearHE/defines-HE.h @@ -22,20 +22,21 @@ SOFTWARE. #ifndef DEFINES_HE_H__ #define DEFINES_HE_H__ +#include <cstdint> +#include <cmath> // #define HE_DEBUG extern uint64_t prime_mod; extern int32_t bitlength; -extern const int32_t numThreads; +extern int32_t num_threads; const uint64_t POLY_MOD_DEGREE = 8192; const uint64_t POLY_MOD_DEGREE_LARGE = 32768; -const int32_t SMUDGING_BITLEN = 108-bitlength; +const int32_t SMUDGING_BITLEN = 108 - bitlength; /* Helper function for rounding to the next power of 2 - * Credit: https://stackoverflow.com/questions/466204/rounding-up-to-next-power-of-2 */ -inline int next_pow2(int val) { - return pow(2, ceil(log(val)/log(2))); -} + * Credit: + * https://stackoverflow.com/questions/466204/rounding-up-to-next-power-of-2 */ +inline int next_pow2(int val) { return pow(2, ceil(log(val) / log(2))); } -#endif //DEFINES_HE_H__ +#endif // DEFINES_HE_H__ diff --git a/SCI/src/LinearHE/elemwise-prod-field.cpp b/SCI/src/LinearHE/elemwise-prod-field.cpp index c01fd527..b6f2b749 100644 --- a/SCI/src/LinearHE/elemwise-prod-field.cpp +++ b/SCI/src/LinearHE/elemwise-prod-field.cpp @@ -25,187 +25,188 @@ using namespace std; using namespace seal; using namespace sci; -ElemWiseProdField::ElemWiseProdField(int party, NetIO* io) -{ - this->party = party; - this->io = io; - this->slot_count = POLY_MOD_DEGREE; - generate_new_keys(party, io, slot_count, context, encryptor, decryptor, - evaluator, encoder, gal_keys, zero); +ElemWiseProdField::ElemWiseProdField(int party, NetIO *io) { + this->party = party; + this->io = io; + this->slot_count = POLY_MOD_DEGREE; + generate_new_keys(party, io, slot_count, context, encryptor, decryptor, + evaluator, encoder, gal_keys, zero); } -ElemWiseProdField::~ElemWiseProdField() -{ - free_keys(party, encryptor, decryptor, evaluator, encoder, gal_keys, zero); +ElemWiseProdField::~ElemWiseProdField() { + free_keys(party, encryptor, decryptor, evaluator, encoder, gal_keys, zero); } -vector<uint64_t> ElemWiseProdField::ideal_functionality( - vector<uint64_t> &inArr, - vector<uint64_t> &multArr) -{ - vector<uint64_t> result(inArr.size(), 0ULL); +vector<uint64_t> +ElemWiseProdField::ideal_functionality(vector<uint64_t> &inArr, + vector<uint64_t> &multArr) { + vector<uint64_t> result(inArr.size(), 0ULL); - for (int i = 0; i < inArr.size(); i++){ - result[i] = multArr[i] * inArr[i]; - } - return result; + for (size_t i = 0; i < inArr.size(); i++) { + result[i] = multArr[i] * inArr[i]; + } + return result; } -void ElemWiseProdField::elemwise_product( - int32_t size, - vector<uint64_t>& inArr, - vector<uint64_t>& multArr, - vector<uint64_t>& outputArr, - bool verify_output = false, - bool verbose = false) -{ - int num_ct = ceil(float(size)/slot_count); - - if (party == BOB) - { - vector<Ciphertext> ct(num_ct); - for (int i = 0; i < num_ct; i++) { - int offset = i * slot_count; - vector<uint64_t> tmp_vec(slot_count, 0); - Plaintext tmp_pt; - for (int j = 0; j < slot_count && j + offset < size; j++) { - tmp_vec[j] = neg_mod((int64_t)inArr[j + offset], (int64_t) prime_mod); - } - encoder->encode(tmp_vec, tmp_pt); - encryptor->encrypt(tmp_pt, ct[i]); - } - send_encrypted_vector(io, ct); - - vector<Ciphertext> enc_result(num_ct); - recv_encrypted_vector(io, enc_result); - for (int i = 0; i < num_ct; i++) { - int offset = i * slot_count; - vector<uint64_t> tmp_vec(slot_count, 0); - Plaintext tmp_pt; - decryptor->decrypt(enc_result[i], tmp_pt); - encoder->decode(tmp_pt, tmp_vec); - for (int j = 0; j < slot_count && j + offset < size; j++) { - outputArr[j + offset] = tmp_vec[j]; - } - } - if(verify_output) verify(inArr, nullptr, outputArr); +void ElemWiseProdField::elemwise_product(int32_t size, vector<uint64_t> &inArr, + vector<uint64_t> &multArr, + vector<uint64_t> &outputArr, + bool verify_output, bool verbose) { + int num_ct = ceil(float(size) / slot_count); + + if (party == BOB) { + vector<Ciphertext> ct(num_ct); + for (int i = 0; i < num_ct; i++) { + int offset = i * slot_count; + vector<uint64_t> tmp_vec(slot_count, 0); + Plaintext tmp_pt; + for (int j = 0; j < slot_count && j + offset < size; j++) { + tmp_vec[j] = neg_mod((int64_t)inArr[j + offset], (int64_t)prime_mod); + } + encoder->encode(tmp_vec, tmp_pt); + encryptor->encrypt(tmp_pt, ct[i]); + } + send_encrypted_vector(io, ct); + + vector<Ciphertext> enc_result(num_ct); + recv_encrypted_vector(io, enc_result); + for (int i = 0; i < num_ct; i++) { + int offset = i * slot_count; + vector<uint64_t> tmp_vec(slot_count, 0); + Plaintext tmp_pt; + decryptor->decrypt(enc_result[i], tmp_pt); + encoder->decode(tmp_pt, tmp_vec); + for (int j = 0; j < slot_count && j + offset < size; j++) { + outputArr[j + offset] = tmp_vec[j]; + } } - else // party == ALICE - { - vector<Plaintext> multArr_pt(num_ct); - for (int i = 0; i < num_ct; i++) { - int offset = i * slot_count; - vector<uint64_t> tmp_vec(slot_count, 0); - for (int j = 0; j < slot_count && j + offset < size; j++) { - tmp_vec[j] = neg_mod((int64_t)multArr[j + offset], (int64_t) prime_mod); - } - encoder->encode(tmp_vec, multArr_pt[i]); - } - - PRG128 prg; - vector<Ciphertext> enc_noise(num_ct); - vector<vector<uint64_t>> secret_share(num_ct, vector<uint64_t>(slot_count, 0)); - for (int i = 0; i < num_ct; i++) { - Plaintext tmp_pt; - prg.random_mod_p<uint64_t>(secret_share[i].data(), slot_count, prime_mod); - encoder->encode(secret_share[i], tmp_pt); - encryptor->encrypt(tmp_pt, enc_noise[i]); - } - - vector<Ciphertext> ct(num_ct); - recv_encrypted_vector(io, ct); - - vector<Ciphertext> enc_result(num_ct); - for(int i = 0; i < num_ct; i++) { + if (verify_output) + verify(inArr, nullptr, outputArr); + } else // party == ALICE + { + vector<Plaintext> multArr_pt(num_ct); + for (int i = 0; i < num_ct; i++) { + int offset = i * slot_count; + vector<uint64_t> tmp_vec(slot_count, 0); + for (int j = 0; j < slot_count && j + offset < size; j++) { + tmp_vec[j] = neg_mod((int64_t)multArr[j + offset], (int64_t)prime_mod); + } + encoder->encode(tmp_vec, multArr_pt[i]); + } + + PRG128 prg; + vector<Ciphertext> enc_noise(num_ct); + vector<vector<uint64_t>> secret_share(num_ct, + vector<uint64_t>(slot_count, 0)); + for (int i = 0; i < num_ct; i++) { + Plaintext tmp_pt; + prg.random_mod_p<uint64_t>(secret_share[i].data(), slot_count, prime_mod); + encoder->encode(secret_share[i], tmp_pt); + encryptor->encrypt(tmp_pt, enc_noise[i]); + } + + vector<Ciphertext> ct(num_ct); + recv_encrypted_vector(io, ct); + + vector<Ciphertext> enc_result(num_ct); + for (int i = 0; i < num_ct; i++) { #ifdef HE_DEBUG - if (!i) PRINT_NOISE_BUDGET(decryptor, ct[i], "before product"); + if (!i) + PRINT_NOISE_BUDGET(decryptor, ct[i], "before product"); #endif - if (multArr_pt[i].is_zero()) { - enc_result[i] = *zero; - } else { - evaluator->multiply_plain(ct[i], multArr_pt[i], enc_result[i]); - } - evaluator->add_inplace(enc_result[i], enc_noise[i]); + if (multArr_pt[i].is_zero()) { + enc_result[i] = *zero; + } else { + evaluator->multiply_plain(ct[i], multArr_pt[i], enc_result[i]); + } + evaluator->add_inplace(enc_result[i], enc_noise[i]); #ifdef HE_DEBUG - if (!i) PRINT_NOISE_BUDGET(decryptor, enc_result[i], "after product"); + if (!i) + PRINT_NOISE_BUDGET(decryptor, enc_result[i], "after product"); #endif - evaluator->mod_switch_to_next_inplace(enc_result[i]); + evaluator->mod_switch_to_next_inplace(enc_result[i]); #ifdef HE_DEBUG - if (!i) PRINT_NOISE_BUDGET(decryptor, enc_result[i], "after mod-switch"); + if (!i) + PRINT_NOISE_BUDGET(decryptor, enc_result[i], "after mod-switch"); #endif - parms_id_type parms_id = enc_result[i].parms_id(); - shared_ptr<const SEALContext::ContextData> context_data - = context->get_context_data(parms_id); - flood_ciphertext(enc_result[i], context_data, SMUDGING_BITLEN); + parms_id_type parms_id = enc_result[i].parms_id(); + shared_ptr<const SEALContext::ContextData> context_data = + context->get_context_data(parms_id); + flood_ciphertext(enc_result[i], context_data, SMUDGING_BITLEN); #ifdef HE_DEBUG - if (!i) PRINT_NOISE_BUDGET(decryptor, enc_result[i], "after noise flooding"); + if (!i) + PRINT_NOISE_BUDGET(decryptor, enc_result[i], "after noise flooding"); #endif - evaluator->mod_switch_to_next_inplace(enc_result[i]); + evaluator->mod_switch_to_next_inplace(enc_result[i]); #ifdef HE_DEBUG - if (!i) PRINT_NOISE_BUDGET(decryptor, enc_result[i], "after mod-switch"); + if (!i) + PRINT_NOISE_BUDGET(decryptor, enc_result[i], "after mod-switch"); #endif - } - send_encrypted_vector(io, enc_result); - - auto result = ideal_functionality(inArr, multArr); - - for (int i = 0; i < num_ct; i++) { - int offset = i * slot_count; - for (int j = 0; j < slot_count && j + offset < size; j++) { - outputArr[j + offset] = neg_mod((int64_t) result[j + offset] - - (int64_t) secret_share[i][j], (int64_t) prime_mod); - } - } - if(verify_output) verify(inArr, &multArr, outputArr); } + send_encrypted_vector(io, enc_result); + + auto result = ideal_functionality(inArr, multArr); + + for (int i = 0; i < num_ct; i++) { + int offset = i * slot_count; + for (int j = 0; j < slot_count && j + offset < size; j++) { + outputArr[j + offset] = + neg_mod((int64_t)result[j + offset] - (int64_t)secret_share[i][j], + (int64_t)prime_mod); + } + } + if (verify_output) + verify(inArr, &multArr, outputArr); + } } -void ElemWiseProdField::verify( - vector<uint64_t> &inArr, - vector<uint64_t>* multArr, - vector<uint64_t> &outArr) -{ - if (party == BOB) - { - io->send_data(inArr.data(), inArr.size() * sizeof(uint64_t)); - io->send_data(outArr.data(), outArr.size() * sizeof(uint64_t)); +void ElemWiseProdField::verify(vector<uint64_t> &inArr, + vector<uint64_t> *multArr, + vector<uint64_t> &outArr) { + if (party == BOB) { + io->send_data(inArr.data(), inArr.size() * sizeof(uint64_t)); + io->send_data(outArr.data(), outArr.size() * sizeof(uint64_t)); + } else // party == ALICE + { + vector<uint64_t> inArr_0(inArr.size()); + io->recv_data(inArr_0.data(), inArr.size() * sizeof(uint64_t)); + for (size_t i = 0; i < inArr.size(); i++) { + inArr_0[i] = (inArr[i] + inArr_0[i]) % prime_mod; + } + + auto result = ideal_functionality(inArr_0, *multArr); + + vector<uint64_t> outArr_0(outArr.size()); + io->recv_data(outArr_0.data(), outArr.size() * sizeof(uint64_t)); + for (size_t i = 0; i < outArr.size(); i++) { + outArr_0[i] = (outArr[i] + outArr_0[i]) % prime_mod; + } + bool pass = true; + for (size_t i = 0; i < outArr.size(); i++) { + if (neg_mod(result[i], (int64_t)prime_mod) != (int64_t)outArr_0[i]) { + pass = false; + } } - else // party == ALICE - { - vector<uint64_t> inArr_0(inArr.size()); - io->recv_data(inArr_0.data(), inArr.size() * sizeof(uint64_t)); - for(int i = 0; i < inArr.size(); i++) { - inArr_0[i] = (inArr[i] + inArr_0[i]) % prime_mod; - } - - auto result = ideal_functionality(inArr_0, *multArr); - - vector<uint64_t> outArr_0(outArr.size()); - io->recv_data(outArr_0.data(), outArr.size() * sizeof(uint64_t)); - for(int i = 0; i < outArr.size(); i++) { - outArr_0[i] = (outArr[i] + outArr_0[i]) % prime_mod; - } - bool pass = true; - for (int i = 0; i < outArr.size(); i++) { - if (neg_mod(result[i], (int64_t) prime_mod) != outArr_0[i]) { - pass = false; - } - } - if (pass) cout << GREEN << "[Server] Successful Operation" << RESET << endl; - else { - cout << RED << "[Server] Failed Operation" << RESET << endl; - cout << RED << "WARNING: The implementation assumes that the computation" << endl; - cout << "performed locally by the server (on the model and its input share)" << endl; - cout << "fits in a 64-bit integer. The failed operation could be a result" << endl; - cout << "of overflowing the bound." << RESET << endl; - } + if (pass) + cout << GREEN << "[Server] Successful Operation" << RESET << endl; + else { + cout << RED << "[Server] Failed Operation" << RESET << endl; + cout << RED << "WARNING: The implementation assumes that the computation" + << endl; + cout << "performed locally by the server (on the model and its input " + "share)" + << endl; + cout << "fits in a 64-bit integer. The failed operation could be a result" + << endl; + cout << "of overflowing the bound." << RESET << endl; } + } } diff --git a/SCI/src/LinearHE/elemwise-prod-field.h b/SCI/src/LinearHE/elemwise-prod-field.h index fceaf3e2..e2aadedf 100644 --- a/SCI/src/LinearHE/elemwise-prod-field.h +++ b/SCI/src/LinearHE/elemwise-prod-field.h @@ -24,38 +24,33 @@ SOFTWARE. #include "LinearHE/utils-HE.h" -class ElemWiseProdField { public: - int party; - sci::NetIO* io; - std::shared_ptr<seal::SEALContext> context; - seal::Encryptor* encryptor; - seal::Decryptor* decryptor; - seal::Evaluator* evaluator; - seal::BatchEncoder* encoder; - seal::GaloisKeys* gal_keys; - seal::Ciphertext* zero; - int slot_count; - - ElemWiseProdField(int party, sci::NetIO* io); - - ~ElemWiseProdField(); - - std::vector<uint64_t> ideal_functionality( - std::vector<uint64_t> &inArr, - std::vector<uint64_t> &multArr); - - void elemwise_product( - int32_t size, - std::vector<uint64_t>& inArr, - std::vector<uint64_t>& multArr, - std::vector<uint64_t>& outputArr, - bool verify_output = false, - bool verbose = false); - - void verify( - std::vector<uint64_t> &inArr, - std::vector<uint64_t>* multArr, - std::vector<uint64_t> &outArr); +class ElemWiseProdField { +public: + int party; + sci::NetIO *io; + std::shared_ptr<seal::SEALContext> context; + seal::Encryptor *encryptor; + seal::Decryptor *decryptor; + seal::Evaluator *evaluator; + seal::BatchEncoder *encoder; + seal::GaloisKeys *gal_keys; + seal::Ciphertext *zero; + int slot_count; + + ElemWiseProdField(int party, sci::NetIO *io); + + ~ElemWiseProdField(); + + std::vector<uint64_t> ideal_functionality(std::vector<uint64_t> &inArr, + std::vector<uint64_t> &multArr); + + void elemwise_product(int32_t size, std::vector<uint64_t> &inArr, + std::vector<uint64_t> &multArr, + std::vector<uint64_t> &outputArr, + bool verify_output = false, bool verbose = false); + + void verify(std::vector<uint64_t> &inArr, std::vector<uint64_t> *multArr, + std::vector<uint64_t> &outArr); }; #endif diff --git a/SCI/src/LinearHE/fc-field.cpp b/SCI/src/LinearHE/fc-field.cpp index c81bec25..e605d340 100644 --- a/SCI/src/LinearHE/fc-field.cpp +++ b/SCI/src/LinearHE/fc-field.cpp @@ -29,376 +29,363 @@ using namespace std; using namespace seal; using namespace sci; -Ciphertext preprocess_vec( - const uint64_t* input, - const FCMetadata& data, - Encryptor& encryptor, - BatchEncoder& batch_encoder) -{ - // Create copies of the input vector to fill the ciphertext appropiately. - // Pack using powers of two for easy rotations later - vector<uint64_t> pod_matrix(data.slot_count, 0ULL); - uint64_t size_pow2 = next_pow2(data.image_size); - for(int col = 0; col < data.image_size; col++){ - for(int idx = 0; idx < data.pack_num; idx++){ - pod_matrix[col + size_pow2 * idx] = input[col]; - } +Ciphertext preprocess_vec(const uint64_t *input, const FCMetadata &data, + Encryptor &encryptor, BatchEncoder &batch_encoder) { + // Create copies of the input vector to fill the ciphertext appropiately. + // Pack using powers of two for easy rotations later + vector<uint64_t> pod_matrix(data.slot_count, 0ULL); + uint64_t size_pow2 = next_pow2(data.image_size); + for (int col = 0; col < data.image_size; col++) { + for (int idx = 0; idx < data.pack_num; idx++) { + pod_matrix[col + size_pow2 * idx] = input[col]; } + } - Ciphertext ciphertext; - Plaintext tmp; - batch_encoder.encode(pod_matrix, tmp); - encryptor.encrypt(tmp, ciphertext); - return ciphertext; + Ciphertext ciphertext; + Plaintext tmp; + batch_encoder.encode(pod_matrix, tmp); + encryptor.encrypt(tmp, ciphertext); + return ciphertext; } -vector<Plaintext> preprocess_matrix( - const uint64_t* const* matrix, - const FCMetadata& data, - BatchEncoder& batch_encoder) -{ - // Pack the filter in alternating order of needed ciphertexts. This way we - // rotate the input once per ciphertext - vector<vector<uint64_t>> mat_pack(data.inp_ct, vector<uint64_t>(data.slot_count, 0ULL)); - for(int row = 0; row < data.filter_h; row++){ - int ct_idx = row / data.inp_ct; - for(int col = 0; col < data.filter_w; col++){ - mat_pack[row%data.inp_ct][col+next_pow2(data.filter_w)*ct_idx] = matrix[row][col]; - } +vector<Plaintext> preprocess_matrix(const uint64_t *const *matrix, + const FCMetadata &data, + BatchEncoder &batch_encoder) { + // Pack the filter in alternating order of needed ciphertexts. This way we + // rotate the input once per ciphertext + vector<vector<uint64_t>> mat_pack(data.inp_ct, + vector<uint64_t>(data.slot_count, 0ULL)); + for (int row = 0; row < data.filter_h; row++) { + int ct_idx = row / data.inp_ct; + for (int col = 0; col < data.filter_w; col++) { + mat_pack[row % data.inp_ct][col + next_pow2(data.filter_w) * ct_idx] = + matrix[row][col]; } - - // Take the packed ciphertexts above and repack them in a diagonal ordering. - int mod_mask = (data.inp_ct-1); - int wrap_thresh = min(data.slot_count >> 1, next_pow2(data.filter_w)); - int wrap_mask = wrap_thresh - 1; - vector<vector<uint64_t>> mat_diag(data.inp_ct, vector<uint64_t>(data.slot_count, 0ULL)); - for(int ct = 0; ct < data.inp_ct; ct++){ - for(int col = 0; col < data.slot_count; col++){ - int ct_diag_l = (col-ct) & wrap_mask & mod_mask; - int ct_diag_h = (col^ct) & (data.slot_count/2) & mod_mask; - int ct_diag = (ct_diag_h + ct_diag_l); - - int col_diag_l = (col - ct_diag_l) & wrap_mask; - int col_diag_h = wrap_thresh*(col/wrap_thresh) ^ ct_diag_h; - int col_diag = col_diag_h + col_diag_l; - - mat_diag[ct_diag][col_diag] = mat_pack[ct][col]; - } + } + + // Take the packed ciphertexts above and repack them in a diagonal ordering. + int mod_mask = (data.inp_ct - 1); + int wrap_thresh = min(data.slot_count >> 1, next_pow2(data.filter_w)); + int wrap_mask = wrap_thresh - 1; + vector<vector<uint64_t>> mat_diag(data.inp_ct, + vector<uint64_t>(data.slot_count, 0ULL)); + for (int ct = 0; ct < data.inp_ct; ct++) { + for (int col = 0; col < data.slot_count; col++) { + int ct_diag_l = (col - ct) & wrap_mask & mod_mask; + int ct_diag_h = (col ^ ct) & (data.slot_count / 2) & mod_mask; + int ct_diag = (ct_diag_h + ct_diag_l); + + int col_diag_l = (col - ct_diag_l) & wrap_mask; + int col_diag_h = wrap_thresh * (col / wrap_thresh) ^ ct_diag_h; + int col_diag = col_diag_h + col_diag_l; + + mat_diag[ct_diag][col_diag] = mat_pack[ct][col]; } + } - vector<Plaintext> enc_mat(data.inp_ct); - for (int ct = 0; ct < data.inp_ct; ct++) { - batch_encoder.encode(mat_diag[ct], enc_mat[ct]); - } - return enc_mat; + vector<Plaintext> enc_mat(data.inp_ct); + for (int ct = 0; ct < data.inp_ct; ct++) { + batch_encoder.encode(mat_diag[ct], enc_mat[ct]); + } + return enc_mat; } -/* Generates a masking vector of random noise that will be applied to parts of the ciphertext - * that contain leakage */ -Ciphertext fc_preprocess_noise( - const uint64_t* secret_share, - const FCMetadata &data, - Encryptor& encryptor, - BatchEncoder& batch_encoder) -{ - // Sample randomness into vector - vector<uint64_t> noise(data.slot_count, 0ULL); - PRG128 prg; - prg.random_mod_p<uint64_t>(noise.data(), data.slot_count, prime_mod); - - // Puncture the vector with secret shares where an actual fc result value lives - for (int row = 0; row < data.filter_h; row++) { - int curr_set = row / data.inp_ct; - noise[(row%data.inp_ct)+next_pow2(data.image_size)*curr_set] = secret_share[row]; - } - - Ciphertext enc_noise; - Plaintext tmp; - batch_encoder.encode(noise, tmp); - encryptor.encrypt(tmp, enc_noise); - - return enc_noise; +/* Generates a masking vector of random noise that will be applied to parts of + * the ciphertext that contain leakage */ +Ciphertext fc_preprocess_noise(const uint64_t *secret_share, + const FCMetadata &data, Encryptor &encryptor, + BatchEncoder &batch_encoder) { + // Sample randomness into vector + vector<uint64_t> noise(data.slot_count, 0ULL); + PRG128 prg; + prg.random_mod_p<uint64_t>(noise.data(), data.slot_count, prime_mod); + + // Puncture the vector with secret shares where an actual fc result value + // lives + for (int row = 0; row < data.filter_h; row++) { + int curr_set = row / data.inp_ct; + noise[(row % data.inp_ct) + next_pow2(data.image_size) * curr_set] = + secret_share[row]; + } + + Ciphertext enc_noise; + Plaintext tmp; + batch_encoder.encode(noise, tmp); + encryptor.encrypt(tmp, enc_noise); + + return enc_noise; } +Ciphertext fc_online(Ciphertext &ct, vector<Plaintext> &enc_mat, + const FCMetadata &data, Evaluator &evaluator, + GaloisKeys &gal_keys, Ciphertext &zero, + Ciphertext &enc_noise) { + Ciphertext result = zero; + // For each matrix ciphertext, rotate the input vector once and multiply + add + Ciphertext tmp; + for (int ct_idx = 0; ct_idx < data.inp_ct; ct_idx++) { + if (!enc_mat[ct_idx].is_zero()) { + evaluator.rotate_rows(ct, ct_idx, gal_keys, tmp); + evaluator.multiply_plain_inplace(tmp, enc_mat[ct_idx]); + evaluator.add_inplace(result, tmp); + } + } + evaluator.mod_switch_to_next_inplace(result); + evaluator.mod_switch_to_next_inplace(enc_noise); -Ciphertext fc_online( - Ciphertext& ct, - vector<Plaintext>& enc_mat, - const FCMetadata& data, - Evaluator& evaluator, - GaloisKeys& gal_keys, - Ciphertext& zero, - Ciphertext& enc_noise) -{ - Ciphertext result = zero; - // For each matrix ciphertext, rotate the input vector once and multiply + add + // Rotate all partial sums together + for (int rot = data.inp_ct; rot < next_pow2(data.image_size); rot *= 2) { Ciphertext tmp; - for(int ct_idx = 0; ct_idx < data.inp_ct; ct_idx++) { - if (!enc_mat[ct_idx].is_zero()) { - evaluator.rotate_rows(ct, ct_idx, gal_keys, tmp); - evaluator.multiply_plain_inplace(tmp, enc_mat[ct_idx]); - evaluator.add_inplace(result, tmp); - } - } - evaluator.mod_switch_to_next_inplace(result); - evaluator.mod_switch_to_next_inplace(enc_noise); - - // Rotate all partial sums together - for (int rot = data.inp_ct; rot < next_pow2(data.image_size); rot *= 2){ - Ciphertext tmp; - if (rot == data.slot_count/2) { - evaluator.rotate_columns(result, gal_keys, tmp); - } else { - evaluator.rotate_rows(result, rot, gal_keys, tmp); - } - evaluator.add_inplace(result, tmp); + if (rot == data.slot_count / 2) { + evaluator.rotate_columns(result, gal_keys, tmp); + } else { + evaluator.rotate_rows(result, rot, gal_keys, tmp); } - // Add noise to cover leakage - evaluator.add_inplace(result, enc_noise); - return result; + evaluator.add_inplace(result, tmp); + } + // Add noise to cover leakage + evaluator.add_inplace(result, enc_noise); + return result; } -uint64_t* fc_postprocess( - Ciphertext& ct, - const FCMetadata& data, - BatchEncoder& batch_encoder, - Decryptor& decryptor) -{ - vector<uint64_t> plain(data.slot_count, 0ULL); - Plaintext tmp; - decryptor.decrypt(ct, tmp); - batch_encoder.decode(tmp, plain); - - uint64_t* result = new uint64_t[data.filter_h]; - for (int row = 0; row < data.filter_h; row++) { - int curr_set = row / data.inp_ct; - result[row] = plain[(row % data.inp_ct) + next_pow2(data.image_size)*curr_set]; - } - return result; +uint64_t *fc_postprocess(Ciphertext &ct, const FCMetadata &data, + BatchEncoder &batch_encoder, Decryptor &decryptor) { + vector<uint64_t> plain(data.slot_count, 0ULL); + Plaintext tmp; + decryptor.decrypt(ct, tmp); + batch_encoder.decode(tmp, plain); + + uint64_t *result = new uint64_t[data.filter_h]; + for (int row = 0; row < data.filter_h; row++) { + int curr_set = row / data.inp_ct; + result[row] = + plain[(row % data.inp_ct) + next_pow2(data.image_size) * curr_set]; + } + return result; } -FCField::FCField(int party, NetIO* io) -{ - this->party = party; - this->io = io; - this->slot_count = POLY_MOD_DEGREE; - generate_new_keys(party, io, slot_count, context, encryptor, decryptor, - evaluator, encoder, gal_keys, zero); +FCField::FCField(int party, NetIO *io) { + this->party = party; + this->io = io; + this->slot_count = POLY_MOD_DEGREE; + generate_new_keys(party, io, slot_count, context, encryptor, decryptor, + evaluator, encoder, gal_keys, zero); } -FCField::~FCField() -{ - free_keys(party, encryptor, decryptor, evaluator, encoder, gal_keys, zero); +FCField::~FCField() { + free_keys(party, encryptor, decryptor, evaluator, encoder, gal_keys, zero); } -void FCField::configure() -{ - data.slot_count = slot_count; - // Only works with a ciphertext that fits in a single ciphertext - assert(data.slot_count >= data.image_size); - - data.filter_size = data.filter_h * data.filter_w; - // How many columns of matrix we can fit in a single ciphertext - data.pack_num = slot_count / next_pow2(data.filter_w); - // How many total ciphertexts we'll need - data.inp_ct = ceil((float)next_pow2(data.filter_h) / data.pack_num); +void FCField::configure() { + data.slot_count = slot_count; + // Only works with a ciphertext that fits in a single ciphertext + assert(data.slot_count >= data.image_size); + + data.filter_size = data.filter_h * data.filter_w; + // How many columns of matrix we can fit in a single ciphertext + data.pack_num = slot_count / next_pow2(data.filter_w); + // How many total ciphertexts we'll need + data.inp_ct = ceil((float)next_pow2(data.filter_h) / data.pack_num); } -vector<uint64_t> FCField::ideal_functionality( - uint64_t* vec, - uint64_t** matrix) -{ - vector<uint64_t> result(data.filter_h, 0ULL); - for (int row = 0; row < data.filter_h; row++){ - for (int idx = 0; idx < data.filter_w; idx++){ - uint64_t partial = vec[idx]*matrix[row][idx]; - result[row] = result[row] + partial; - } +vector<uint64_t> FCField::ideal_functionality(uint64_t *vec, + uint64_t **matrix) { + vector<uint64_t> result(data.filter_h, 0ULL); + for (int row = 0; row < data.filter_h; row++) { + for (int idx = 0; idx < data.filter_w; idx++) { + uint64_t partial = vec[idx] * matrix[row][idx]; + result[row] = result[row] + partial; } - return result; + } + return result; } -void FCField::matrix_multiplication( - int32_t num_rows, - int32_t common_dim, - int32_t num_cols, - vector<vector<uint64_t>>& A, - vector<vector<uint64_t>>& B, - vector<vector<uint64_t>>& C, - bool verify_output = false, - bool verbose = false) -{ - assert(num_cols == 1); - data.filter_h = num_rows; - data.filter_w = common_dim; - data.image_size = common_dim; - this->slot_count = min(max(8192,2*next_pow2(common_dim)),SEAL_POLY_MOD_DEGREE_MAX); - configure(); - - shared_ptr<SEALContext> context_; - Encryptor* encryptor_; - Decryptor* decryptor_; - Evaluator* evaluator_; - BatchEncoder* encoder_; - GaloisKeys* gal_keys_; - Ciphertext* zero_; - if (slot_count > POLY_MOD_DEGREE) { - generate_new_keys(party, io, slot_count, context_, encryptor_, decryptor_, - evaluator_, encoder_, gal_keys_, zero_); - } else { - context_ = this->context; - encryptor_ = this->encryptor; - decryptor_ = this->decryptor; - evaluator_ = this->evaluator; - encoder_ = this->encoder; - gal_keys_ = this->gal_keys; - zero_ = this->zero; +void FCField::matrix_multiplication(int32_t num_rows, int32_t common_dim, + int32_t num_cols, + vector<vector<uint64_t>> &A, + vector<vector<uint64_t>> &B, + vector<vector<uint64_t>> &C, + bool verify_output, bool verbose) { + assert(num_cols == 1); + data.filter_h = num_rows; + data.filter_w = common_dim; + data.image_size = common_dim; + this->slot_count = + min(max(8192, 2 * next_pow2(common_dim)), SEAL_POLY_MOD_DEGREE_MAX); + configure(); + + shared_ptr<SEALContext> context_; + Encryptor *encryptor_; + Decryptor *decryptor_; + Evaluator *evaluator_; + BatchEncoder *encoder_; + GaloisKeys *gal_keys_; + Ciphertext *zero_; + if (slot_count > POLY_MOD_DEGREE) { + generate_new_keys(party, io, slot_count, context_, encryptor_, decryptor_, + evaluator_, encoder_, gal_keys_, zero_); + } else { + context_ = this->context; + encryptor_ = this->encryptor; + decryptor_ = this->decryptor; + evaluator_ = this->evaluator; + encoder_ = this->encoder; + gal_keys_ = this->gal_keys; + zero_ = this->zero; + } + + if (party == BOB) { + vector<uint64_t> vec(common_dim); + for (int i = 0; i < common_dim; i++) { + vec[i] = B[i][0]; } - - if (party == BOB) - { - vector<uint64_t> vec(common_dim); - for (int i = 0; i < common_dim; i++) { - vec[i] = B[i][0]; - } - if(verbose) cout << "[Client] Vector Generated" << endl; - - auto ct = preprocess_vec(vec.data(), data, *encryptor_, *encoder_); - send_ciphertext(io, ct); - if(verbose) cout << "[Client] Vector processed and sent" << endl; - - Ciphertext enc_result; - recv_ciphertext(io, enc_result); - auto HE_result = fc_postprocess(enc_result, data, *encoder_, *decryptor_); - if(verbose) cout << "[Client] Result received and decrypted" << endl; - - for (int i = 0; i < num_rows; i++) { - C[i][0] = HE_result[i]; - } - if(verify_output) verify(&vec, nullptr, C); - - delete[] HE_result; + if (verbose) + cout << "[Client] Vector Generated" << endl; + + auto ct = preprocess_vec(vec.data(), data, *encryptor_, *encoder_); + send_ciphertext(io, ct); + if (verbose) + cout << "[Client] Vector processed and sent" << endl; + + Ciphertext enc_result; + recv_ciphertext(io, enc_result); + auto HE_result = fc_postprocess(enc_result, data, *encoder_, *decryptor_); + if (verbose) + cout << "[Client] Result received and decrypted" << endl; + + for (int i = 0; i < num_rows; i++) { + C[i][0] = HE_result[i]; + } + if (verify_output) + verify(&vec, nullptr, C); + + delete[] HE_result; + } else // party == ALICE + { + vector<uint64_t> vec(common_dim); + for (int i = 0; i < common_dim; i++) { + vec[i] = B[i][0]; } - else // party == ALICE - { - vector<uint64_t> vec(common_dim); - for (int i = 0; i < common_dim; i++) { - vec[i] = B[i][0]; - } - if(verbose) cout << "[Server] Vector Generated" << endl; - vector<uint64_t*> matrix_mod_p(num_rows); - vector<uint64_t*> matrix(num_rows); - for (int i = 0; i < num_rows; i++) { - matrix_mod_p[i] = new uint64_t[common_dim]; - matrix[i] = new uint64_t[common_dim]; - for (int j = 0; j < common_dim; j++) { - matrix_mod_p[i][j] = neg_mod((int64_t) A[i][j], (int64_t) prime_mod); - matrix[i][j] = A[i][j]; - } - } - if(verbose) cout << "[Server] Matrix generated" << endl; - - PRG128 prg; - uint64_t* secret_share = new uint64_t[num_rows]; - prg.random_mod_p<uint64_t>(secret_share, num_rows, prime_mod); - - Ciphertext enc_noise = fc_preprocess_noise(secret_share, data, *encryptor_, *encoder_); - auto encoded_mat = preprocess_matrix(matrix_mod_p.data(), data, *encoder_); - if(verbose) cout << "[Server] Matrix and noise processed" << endl; - - Ciphertext ct; - recv_ciphertext(io, ct); + if (verbose) + cout << "[Server] Vector Generated" << endl; + vector<uint64_t *> matrix_mod_p(num_rows); + vector<uint64_t *> matrix(num_rows); + for (int i = 0; i < num_rows; i++) { + matrix_mod_p[i] = new uint64_t[common_dim]; + matrix[i] = new uint64_t[common_dim]; + for (int j = 0; j < common_dim; j++) { + matrix_mod_p[i][j] = neg_mod((int64_t)A[i][j], (int64_t)prime_mod); + matrix[i][j] = A[i][j]; + } + } + if (verbose) + cout << "[Server] Matrix generated" << endl; + + PRG128 prg; + uint64_t *secret_share = new uint64_t[num_rows]; + prg.random_mod_p<uint64_t>(secret_share, num_rows, prime_mod); + + Ciphertext enc_noise = + fc_preprocess_noise(secret_share, data, *encryptor_, *encoder_); + auto encoded_mat = preprocess_matrix(matrix_mod_p.data(), data, *encoder_); + if (verbose) + cout << "[Server] Matrix and noise processed" << endl; + + Ciphertext ct; + recv_ciphertext(io, ct); #ifdef HE_DEBUG - PRINT_NOISE_BUDGET(decryptor_, ct, "before FC Online"); + PRINT_NOISE_BUDGET(decryptor_, ct, "before FC Online"); #endif - auto HE_result = fc_online(ct, encoded_mat, data, *evaluator_, - *gal_keys_, *zero_, enc_noise); + auto HE_result = fc_online(ct, encoded_mat, data, *evaluator_, *gal_keys_, + *zero_, enc_noise); #ifdef HE_DEBUG - PRINT_NOISE_BUDGET(decryptor_, HE_result, "after FC Online"); + PRINT_NOISE_BUDGET(decryptor_, HE_result, "after FC Online"); #endif - parms_id_type parms_id = HE_result.parms_id(); - shared_ptr<const SEALContext::ContextData> context_data - = context_->get_context_data(parms_id); - flood_ciphertext(HE_result, context_data, SMUDGING_BITLEN); + parms_id_type parms_id = HE_result.parms_id(); + shared_ptr<const SEALContext::ContextData> context_data = + context_->get_context_data(parms_id); + flood_ciphertext(HE_result, context_data, SMUDGING_BITLEN); #ifdef HE_DEBUG - PRINT_NOISE_BUDGET(decryptor_, HE_result, "after noise flooding"); + PRINT_NOISE_BUDGET(decryptor_, HE_result, "after noise flooding"); #endif - evaluator_->mod_switch_to_next_inplace(HE_result); + evaluator_->mod_switch_to_next_inplace(HE_result); #ifdef HE_DEBUG - PRINT_NOISE_BUDGET(decryptor_, HE_result, "after mod-switch"); + PRINT_NOISE_BUDGET(decryptor_, HE_result, "after mod-switch"); #endif - send_ciphertext(io, HE_result); - if(verbose) cout << "[Server] Result computed and sent" << endl; + send_ciphertext(io, HE_result); + if (verbose) + cout << "[Server] Result computed and sent" << endl; - auto result = ideal_functionality(vec.data(), matrix.data()); + auto result = ideal_functionality(vec.data(), matrix.data()); - for(int i = 0; i < num_rows; i++) { - C[i][0] = neg_mod((int64_t) result[i] - (int64_t) secret_share[i], - (int64_t) prime_mod); - } - if(verify_output) verify(&vec, &matrix, C); - - for (int i = 0; i < num_rows; i++) { - delete[] matrix_mod_p[i]; - delete[] matrix[i]; - } - delete[] secret_share; + for (int i = 0; i < num_rows; i++) { + C[i][0] = neg_mod((int64_t)result[i] - (int64_t)secret_share[i], + (int64_t)prime_mod); } - if (slot_count > POLY_MOD_DEGREE) { - free_keys(party, encryptor_, decryptor_, evaluator_, - encoder_, gal_keys_, zero_); + if (verify_output) + verify(&vec, &matrix, C); + + for (int i = 0; i < num_rows; i++) { + delete[] matrix_mod_p[i]; + delete[] matrix[i]; } + delete[] secret_share; + } + if (slot_count > POLY_MOD_DEGREE) { + free_keys(party, encryptor_, decryptor_, evaluator_, encoder_, gal_keys_, + zero_); + } } -void FCField::verify( - vector<uint64_t>* vec, - vector<uint64_t*>* matrix, - vector<vector<uint64_t>>& C) -{ - if (party == BOB) - { - io->send_data(vec->data(), data.filter_w * sizeof(uint64_t)); - io->flush(); - for(int i = 0; i < data.filter_h; i++) { - io->send_data(C[i].data(), sizeof(uint64_t)); - } +void FCField::verify(vector<uint64_t> *vec, vector<uint64_t *> *matrix, + vector<vector<uint64_t>> &C) { + if (party == BOB) { + io->send_data(vec->data(), data.filter_w * sizeof(uint64_t)); + io->flush(); + for (int i = 0; i < data.filter_h; i++) { + io->send_data(C[i].data(), sizeof(uint64_t)); + } + } else // party == ALICE + { + vector<uint64_t> vec_0(data.filter_w); + io->recv_data(vec_0.data(), data.filter_w * sizeof(uint64_t)); + for (int i = 0; i < data.filter_w; i++) { + vec_0[i] = (vec_0[i] + (*vec)[i]) % prime_mod; + } + auto result = ideal_functionality(vec_0.data(), matrix->data()); + + vector<vector<uint64_t>> C_0(data.filter_h); + for (int i = 0; i < data.filter_h; i++) { + C_0[i].resize(1); + io->recv_data(C_0[i].data(), sizeof(uint64_t)); + C_0[i][0] = (C_0[i][0] + C[i][0]) % prime_mod; + } + bool pass = true; + for (int i = 0; i < data.filter_h; i++) { + if (neg_mod(result[i], (int64_t)prime_mod) != (int64_t)C_0[i][0]) { + pass = false; + } } - else // party == ALICE - { - vector<uint64_t> vec_0(data.filter_w); - io->recv_data(vec_0.data(), data.filter_w * sizeof(uint64_t)); - for(int i = 0; i < data.filter_w; i++) { - vec_0[i] = (vec_0[i] + (*vec)[i]) % prime_mod; - } - auto result = ideal_functionality(vec_0.data(), matrix->data()); - - vector<vector<uint64_t>> C_0(data.filter_h); - for(int i = 0; i < data.filter_h; i++) { - C_0[i].resize(1); - io->recv_data(C_0[i].data(), sizeof(uint64_t)); - C_0[i][0] = (C_0[i][0] + C[i][0]) % prime_mod; - } - bool pass = true; - for (int i = 0; i < data.filter_h; i++) { - if (neg_mod(result[i], (int64_t) prime_mod) != C_0[i][0]) { - pass = false; - } - } - if (pass) cout << GREEN << "[Server] Successful Operation" << RESET << endl; - else { - cout << RED << "[Server] Failed Operation" << RESET << endl; - cout << RED << "WARNING: The implementation assumes that the computation" << endl; - cout << "performed locally by the server (on the model and its input share)" << endl; - cout << "fits in a 64-bit integer. The failed operation could be a result" << endl; - cout << "of overflowing the bound." << RESET << endl; - } + if (pass) + cout << GREEN << "[Server] Successful Operation" << RESET << endl; + else { + cout << RED << "[Server] Failed Operation" << RESET << endl; + cout << RED << "WARNING: The implementation assumes that the computation" + << endl; + cout << "performed locally by the server (on the model and its input " + "share)" + << endl; + cout << "fits in a 64-bit integer. The failed operation could be a result" + << endl; + cout << "of overflowing the bound." << RESET << endl; } + } } diff --git a/SCI/src/LinearHE/fc-field.h b/SCI/src/LinearHE/fc-field.h index 7e24f1c5..c1ff7ea9 100644 --- a/SCI/src/LinearHE/fc-field.h +++ b/SCI/src/LinearHE/fc-field.h @@ -29,85 +29,70 @@ Modified by Deevashwer Rathee #include "LinearHE/utils-HE.h" struct FCMetadata { - int slot_count; - int32_t pack_num; - int32_t inp_ct; - // Filter is a matrix - int32_t filter_h; - int32_t filter_w; - int32_t filter_size; - // Image is a vector - int32_t image_size; + int slot_count; + int32_t pack_num; + int32_t inp_ct; + // Filter is a matrix + int32_t filter_h; + int32_t filter_w; + int32_t filter_size; + // Image is a vector + int32_t image_size; }; -seal::Ciphertext preprocess_vec( - const uint64_t* input, - const FCMetadata& data, - seal::Encryptor& encryptor, - seal::BatchEncoder& batch_encoder); - -std::vector<seal::Plaintext> preprocess_matrix( - const uint64_t* const* matrix, - const FCMetadata& data, - seal::BatchEncoder& batch_encoder); - -seal::Ciphertext fc_preprocess_noise( - const uint64_t* secret_share, - const FCMetadata& data, - seal::Encryptor& encryptor, - seal::BatchEncoder& batch_encoder); - -seal::Ciphertext fc_online( - seal::Ciphertext& ct, - std::vector<seal::Plaintext>& enc_mat, - const FCMetadata& data, - seal::Evaluator& evaluator, - seal::GaloisKeys& gal_keys, - seal::Ciphertext& zero, - seal::Ciphertext& enc_noise); - -uint64_t* fc_postprocess( - seal::Ciphertext& result, - const FCMetadata& data, - seal::BatchEncoder& batch_encoder, - seal::Decryptor& decryptor); - -class FCField { public: - int party; - sci::NetIO* io; - FCMetadata data; - std::shared_ptr<seal::SEALContext> context; - seal::Encryptor* encryptor; - seal::Decryptor* decryptor; - seal::Evaluator* evaluator; - seal::BatchEncoder* encoder; - seal::GaloisKeys* gal_keys; - seal::Ciphertext* zero; - int slot_count; - - FCField(int party, sci::NetIO* io); - - ~FCField(); - - void configure(); - - std::vector<uint64_t> ideal_functionality( - uint64_t* vec, - uint64_t** matrix); - - void matrix_multiplication( - int32_t num_rows, - int32_t common_dim, - int32_t num_cols, - std::vector<std::vector<uint64_t>>& A, - std::vector<std::vector<uint64_t>>& B, - std::vector<std::vector<uint64_t>>& C, - bool verify_output = false, - bool verbose = false); - - void verify( - std::vector<uint64_t>* vec, - std::vector<uint64_t*>* matrix, - std::vector<std::vector<uint64_t>>& C); +seal::Ciphertext preprocess_vec(const uint64_t *input, const FCMetadata &data, + seal::Encryptor &encryptor, + seal::BatchEncoder &batch_encoder); + +std::vector<seal::Plaintext> +preprocess_matrix(const uint64_t *const *matrix, const FCMetadata &data, + seal::BatchEncoder &batch_encoder); + +seal::Ciphertext fc_preprocess_noise(const uint64_t *secret_share, + const FCMetadata &data, + seal::Encryptor &encryptor, + seal::BatchEncoder &batch_encoder); + +seal::Ciphertext fc_online(seal::Ciphertext &ct, + std::vector<seal::Plaintext> &enc_mat, + const FCMetadata &data, seal::Evaluator &evaluator, + seal::GaloisKeys &gal_keys, seal::Ciphertext &zero, + seal::Ciphertext &enc_noise); + +uint64_t *fc_postprocess(seal::Ciphertext &result, const FCMetadata &data, + seal::BatchEncoder &batch_encoder, + seal::Decryptor &decryptor); + +class FCField { +public: + int party; + sci::NetIO *io; + FCMetadata data; + std::shared_ptr<seal::SEALContext> context; + seal::Encryptor *encryptor; + seal::Decryptor *decryptor; + seal::Evaluator *evaluator; + seal::BatchEncoder *encoder; + seal::GaloisKeys *gal_keys; + seal::Ciphertext *zero; + size_t slot_count; + + FCField(int party, sci::NetIO *io); + + ~FCField(); + + void configure(); + + std::vector<uint64_t> ideal_functionality(uint64_t *vec, uint64_t **matrix); + + void matrix_multiplication(int32_t num_rows, int32_t common_dim, + int32_t num_cols, + std::vector<std::vector<uint64_t>> &A, + std::vector<std::vector<uint64_t>> &B, + std::vector<std::vector<uint64_t>> &C, + bool verify_output = false, bool verbose = false); + + void verify(std::vector<uint64_t> *vec, std::vector<uint64_t *> *matrix, + std::vector<std::vector<uint64_t>> &C); }; #endif diff --git a/SCI/src/LinearHE/utils-HE.cpp b/SCI/src/LinearHE/utils-HE.cpp index d6d38517..5ec77ec5 100644 --- a/SCI/src/LinearHE/utils-HE.cpp +++ b/SCI/src/LinearHE/utils-HE.cpp @@ -27,242 +27,211 @@ using namespace sci; using namespace seal; using namespace seal::util; -void generate_new_keys( - int party, - NetIO* io, - int slot_count, - shared_ptr<SEALContext> &context_, - Encryptor* &encryptor_, - Decryptor* &decryptor_, - Evaluator* &evaluator_, - BatchEncoder* &encoder_, - GaloisKeys* &gal_keys_, - Ciphertext* &zero_, - bool verbose) -{ - EncryptionParameters parms(scheme_type::BFV); - parms.set_poly_modulus_degree(slot_count); - parms.set_coeff_modulus(CoeffModulus::Create(slot_count, {60,60,60,38})); - parms.set_plain_modulus(prime_mod); - // auto context = SEALContext::Create(parms, true, sec_level_type::none); - context_ = SEALContext::Create(parms, true, sec_level_type::none); - encoder_ = new BatchEncoder(context_); - evaluator_ = new Evaluator(context_); - if (party == BOB) - { - KeyGenerator keygen(context_); - auto pub_key = keygen.public_key(); - auto sec_key = keygen.secret_key(); - auto gal_keys_ = keygen.galois_keys(); +void generate_new_keys(int party, NetIO *io, int slot_count, + shared_ptr<SEALContext> &context_, + Encryptor *&encryptor_, Decryptor *&decryptor_, + Evaluator *&evaluator_, BatchEncoder *&encoder_, + GaloisKeys *&gal_keys_, Ciphertext *&zero_, + bool verbose) { + EncryptionParameters parms(scheme_type::BFV); + parms.set_poly_modulus_degree(slot_count); + parms.set_coeff_modulus(CoeffModulus::Create(slot_count, {60, 60, 60, 38})); + parms.set_plain_modulus(prime_mod); + // auto context = SEALContext::Create(parms, true, sec_level_type::none); + context_ = SEALContext::Create(parms, true, sec_level_type::none); + encoder_ = new BatchEncoder(context_); + evaluator_ = new Evaluator(context_); + if (party == BOB) { + KeyGenerator keygen(context_); + auto pub_key = keygen.public_key(); + auto sec_key = keygen.secret_key(); + auto gal_keys_ = keygen.galois_keys(); - stringstream os; - pub_key.save(os); - uint64_t pk_size = os.tellp(); - gal_keys_.save(os); - uint64_t gk_size = (uint64_t)os.tellp()-pk_size; + stringstream os; + pub_key.save(os); + uint64_t pk_size = os.tellp(); + gal_keys_.save(os); + uint64_t gk_size = (uint64_t)os.tellp() - pk_size; - string keys_ser = os.str(); - io->send_data(&pk_size, sizeof(uint64_t)); - io->send_data(&gk_size, sizeof(uint64_t)); - io->send_data(keys_ser.c_str(), pk_size+gk_size); + string keys_ser = os.str(); + io->send_data(&pk_size, sizeof(uint64_t)); + io->send_data(&gk_size, sizeof(uint64_t)); + io->send_data(keys_ser.c_str(), pk_size + gk_size); #ifdef HE_DEBUG - stringstream os_sk; - sec_key.save(os_sk); - uint64_t sk_size = os_sk.tellp(); - string keys_ser_sk = os_sk.str(); - io->send_data(&sk_size, sizeof(uint64_t)); - io->send_data(keys_ser_sk.c_str(), sk_size); + stringstream os_sk; + sec_key.save(os_sk); + uint64_t sk_size = os_sk.tellp(); + string keys_ser_sk = os_sk.str(); + io->send_data(&sk_size, sizeof(uint64_t)); + io->send_data(keys_ser_sk.c_str(), sk_size); #endif - encryptor_ = new Encryptor(context_, pub_key); - decryptor_ = new Decryptor(context_, sec_key); - } - else // party == ALICE - { - uint64_t pk_size; - uint64_t gk_size; - io->recv_data(&pk_size, sizeof(uint64_t)); - io->recv_data(&gk_size, sizeof(uint64_t)); - char* key_share = new char[pk_size+gk_size]; - io->recv_data(key_share, pk_size+gk_size); - stringstream is; - PublicKey pub_key; - is.write(key_share, pk_size); - pub_key.load(context_, is); - gal_keys_ = new GaloisKeys(); - is.write(key_share+pk_size, gk_size); - gal_keys_->load(context_, is); - delete[] key_share; + encryptor_ = new Encryptor(context_, pub_key); + decryptor_ = new Decryptor(context_, sec_key); + } else // party == ALICE + { + uint64_t pk_size; + uint64_t gk_size; + io->recv_data(&pk_size, sizeof(uint64_t)); + io->recv_data(&gk_size, sizeof(uint64_t)); + char *key_share = new char[pk_size + gk_size]; + io->recv_data(key_share, pk_size + gk_size); + stringstream is; + PublicKey pub_key; + is.write(key_share, pk_size); + pub_key.load(context_, is); + gal_keys_ = new GaloisKeys(); + is.write(key_share + pk_size, gk_size); + gal_keys_->load(context_, is); + delete[] key_share; #ifdef HE_DEBUG - uint64_t sk_size; - io->recv_data(&sk_size, sizeof(uint64_t)); - char* key_share_sk = new char[sk_size]; - io->recv_data(key_share_sk, sk_size); - stringstream is_sk; - SecretKey sec_key; - is_sk.write(key_share_sk, sk_size); - sec_key.load(context_, is_sk); - delete[] key_share_sk; - decryptor_ = new Decryptor(context_, sec_key); + uint64_t sk_size; + io->recv_data(&sk_size, sizeof(uint64_t)); + char *key_share_sk = new char[sk_size]; + io->recv_data(key_share_sk, sk_size); + stringstream is_sk; + SecretKey sec_key; + is_sk.write(key_share_sk, sk_size); + sec_key.load(context_, is_sk); + delete[] key_share_sk; + decryptor_ = new Decryptor(context_, sec_key); #endif - encryptor_ = new Encryptor(context_, pub_key); - vector<uint64_t> pod_matrix(slot_count, 0ULL); - Plaintext tmp; - encoder_->encode(pod_matrix, tmp); - zero_ = new Ciphertext; - encryptor_->encrypt(tmp, *zero_); - } - if (verbose) cout << "Keys Generated (slot_count: " << slot_count << ")" << endl; + encryptor_ = new Encryptor(context_, pub_key); + vector<uint64_t> pod_matrix(slot_count, 0ULL); + Plaintext tmp; + encoder_->encode(pod_matrix, tmp); + zero_ = new Ciphertext; + encryptor_->encrypt(tmp, *zero_); + } + if (verbose) + cout << "Keys Generated (slot_count: " << slot_count << ")" << endl; } -void free_keys( - int party, - Encryptor* &encryptor_, - Decryptor* &decryptor_, - Evaluator* &evaluator_, - BatchEncoder* &encoder_, - GaloisKeys* &gal_keys_, - Ciphertext* &zero_) -{ - delete encoder_; - delete evaluator_; - delete encryptor_; - if (party == BOB) - { - delete decryptor_; - } - else // party ==ALICE - { +void free_keys(int party, Encryptor *&encryptor_, Decryptor *&decryptor_, + Evaluator *&evaluator_, BatchEncoder *&encoder_, + GaloisKeys *&gal_keys_, Ciphertext *&zero_) { + delete encoder_; + delete evaluator_; + delete encryptor_; + if (party == BOB) { + delete decryptor_; + } else // party ==ALICE + { #ifdef HE_DEBUG - delete decryptor_; + delete decryptor_; #endif - delete gal_keys_; - delete zero_; - } + delete gal_keys_; + delete zero_; + } } -void send_encrypted_vector( - NetIO* io, - vector<Ciphertext> &ct_vec) -{ - assert(ct_vec.size() > 0); - stringstream os; - uint64_t ct_size; - for(int ct = 0; ct < ct_vec.size(); ct++) { - ct_vec[ct].save(os); - if(!ct) ct_size = os.tellp(); - } - string ct_ser = os.str(); - io->send_data(&ct_size, sizeof(uint64_t)); - io->send_data(ct_ser.c_str(), ct_ser.size()); +void send_encrypted_vector(NetIO *io, vector<Ciphertext> &ct_vec) { + assert(ct_vec.size() > 0); + stringstream os; + uint64_t ct_size; + for (size_t ct = 0; ct < ct_vec.size(); ct++) { + ct_vec[ct].save(os); + if (!ct) + ct_size = os.tellp(); + } + string ct_ser = os.str(); + io->send_data(&ct_size, sizeof(uint64_t)); + io->send_data(ct_ser.c_str(), ct_ser.size()); } -void recv_encrypted_vector( - NetIO* io, - vector<Ciphertext> &ct_vec) -{ - assert(ct_vec.size() > 0); - stringstream is; - uint64_t ct_size; - io->recv_data(&ct_size, sizeof(uint64_t)); - char* c_enc_result = new char[ct_size*ct_vec.size()]; - io->recv_data(c_enc_result, ct_size*ct_vec.size()); - for(int ct = 0; ct < ct_vec.size(); ct++) { - is.write(c_enc_result+ct_size*ct, ct_size); - ct_vec[ct].unsafe_load(is); - } - delete[] c_enc_result; +void recv_encrypted_vector(NetIO *io, vector<Ciphertext> &ct_vec) { + assert(ct_vec.size() > 0); + stringstream is; + uint64_t ct_size; + io->recv_data(&ct_size, sizeof(uint64_t)); + char *c_enc_result = new char[ct_size * ct_vec.size()]; + io->recv_data(c_enc_result, ct_size * ct_vec.size()); + for (size_t ct = 0; ct < ct_vec.size(); ct++) { + is.write(c_enc_result + ct_size * ct, ct_size); + ct_vec[ct].unsafe_load(is); + } + delete[] c_enc_result; } -void send_ciphertext( - NetIO* io, - Ciphertext &ct) -{ - stringstream os; - uint64_t ct_size; - ct.save(os); - ct_size = os.tellp(); - string ct_ser = os.str(); - io->send_data(&ct_size, sizeof(uint64_t)); - io->send_data(ct_ser.c_str(), ct_ser.size()); +void send_ciphertext(NetIO *io, Ciphertext &ct) { + stringstream os; + uint64_t ct_size; + ct.save(os); + ct_size = os.tellp(); + string ct_ser = os.str(); + io->send_data(&ct_size, sizeof(uint64_t)); + io->send_data(ct_ser.c_str(), ct_ser.size()); } -void recv_ciphertext( - NetIO* io, - Ciphertext &ct) -{ - stringstream is; - uint64_t ct_size; - io->recv_data(&ct_size, sizeof(uint64_t)); - char* c_enc_result = new char[ct_size]; - io->recv_data(c_enc_result, ct_size); - is.write(c_enc_result, ct_size); - ct.unsafe_load(is); - delete[] c_enc_result; +void recv_ciphertext(NetIO *io, Ciphertext &ct) { + stringstream is; + uint64_t ct_size; + io->recv_data(&ct_size, sizeof(uint64_t)); + char *c_enc_result = new char[ct_size]; + io->recv_data(c_enc_result, ct_size); + is.write(c_enc_result, ct_size); + ct.unsafe_load(is); + delete[] c_enc_result; } void set_poly_coeffs_uniform( - uint64_t *poly, - uint32_t bitlen, - shared_ptr<UniformRandomGenerator> random, - shared_ptr<const SEALContext::ContextData> &context_data) -{ - assert(bitlen < 128 && bitlen > 0); - auto &parms = context_data->parms(); - auto &coeff_modulus = parms.coeff_modulus(); - size_t coeff_count = parms.poly_modulus_degree(); - size_t coeff_mod_count = coeff_modulus.size(); - uint64_t bitlen_mask = (1ULL << (bitlen % 64)) - 1; - - RandomToStandardAdapter engine(random); - for (size_t i = 0; i < coeff_count; i++) { - if (bitlen < 64) { - uint64_t noise = (uint64_t(engine()) << 32) | engine(); - noise &= bitlen_mask; - for (size_t j = 0; j < coeff_mod_count; j++) { - poly[i + (j * coeff_count)] = barrett_reduce_63(noise, coeff_modulus[j]); - } - } else { - uint64_t noise[2]; // LSB || MSB - for(int j = 0; j < 2; j++){ - noise[0] = (uint64_t(engine()) << 32) | engine(); - noise[1] = (uint64_t(engine()) << 32) | engine(); - } - noise[1] &= bitlen_mask; - for (size_t j = 0; j < coeff_mod_count; j++) { - poly[i + (j * coeff_count)] = barrett_reduce_128(noise, coeff_modulus[j]); - } - } + uint64_t *poly, uint32_t bitlen, shared_ptr<UniformRandomGenerator> random, + shared_ptr<const SEALContext::ContextData> &context_data) { + assert(bitlen < 128 && bitlen > 0); + auto &parms = context_data->parms(); + auto &coeff_modulus = parms.coeff_modulus(); + size_t coeff_count = parms.poly_modulus_degree(); + size_t coeff_mod_count = coeff_modulus.size(); + uint64_t bitlen_mask = (1ULL << (bitlen % 64)) - 1; + + RandomToStandardAdapter engine(random); + for (size_t i = 0; i < coeff_count; i++) { + if (bitlen < 64) { + uint64_t noise = (uint64_t(engine()) << 32) | engine(); + noise &= bitlen_mask; + for (size_t j = 0; j < coeff_mod_count; j++) { + poly[i + (j * coeff_count)] = + barrett_reduce_63(noise, coeff_modulus[j]); + } + } else { + uint64_t noise[2]; // LSB || MSB + for (int j = 0; j < 2; j++) { + noise[0] = (uint64_t(engine()) << 32) | engine(); + noise[1] = (uint64_t(engine()) << 32) | engine(); + } + noise[1] &= bitlen_mask; + for (size_t j = 0; j < coeff_mod_count; j++) { + poly[i + (j * coeff_count)] = + barrett_reduce_128(noise, coeff_modulus[j]); + } } + } } -void flood_ciphertext( - Ciphertext &ct, - shared_ptr<const SEALContext::ContextData> &context_data, - uint32_t noise_len, - MemoryPoolHandle pool) -{ - - auto &parms = context_data->parms(); - auto &coeff_modulus = parms.coeff_modulus(); - size_t coeff_count = parms.poly_modulus_degree(); - size_t coeff_mod_count = coeff_modulus.size(); - - auto noise(allocate_poly(coeff_count, coeff_mod_count, pool)); - shared_ptr<UniformRandomGenerator> random(parms.random_generator()->create()); - - set_poly_coeffs_uniform(noise.get(), noise_len, random, context_data); - for (size_t i = 0; i < coeff_mod_count; i++) { - add_poly_poly_coeffmod(noise.get() + (i * coeff_count), - ct.data() + (i * coeff_count), coeff_count, - coeff_modulus[i], ct.data() + (i * coeff_count)); - } - - set_poly_coeffs_uniform(noise.get(), noise_len, random, context_data); - for (size_t i = 0; i < coeff_mod_count; i++) { - add_poly_poly_coeffmod(noise.get() + (i * coeff_count), - ct.data(1) + (i * coeff_count), coeff_count, - coeff_modulus[i], ct.data(1) + (i * coeff_count)); - } +void flood_ciphertext(Ciphertext &ct, + shared_ptr<const SEALContext::ContextData> &context_data, + uint32_t noise_len, MemoryPoolHandle pool) { + + auto &parms = context_data->parms(); + auto &coeff_modulus = parms.coeff_modulus(); + size_t coeff_count = parms.poly_modulus_degree(); + size_t coeff_mod_count = coeff_modulus.size(); + + auto noise(allocate_poly(coeff_count, coeff_mod_count, pool)); + shared_ptr<UniformRandomGenerator> random(parms.random_generator()->create()); + + set_poly_coeffs_uniform(noise.get(), noise_len, random, context_data); + for (size_t i = 0; i < coeff_mod_count; i++) { + add_poly_poly_coeffmod(noise.get() + (i * coeff_count), + ct.data() + (i * coeff_count), coeff_count, + coeff_modulus[i], ct.data() + (i * coeff_count)); + } + + set_poly_coeffs_uniform(noise.get(), noise_len, random, context_data); + for (size_t i = 0; i < coeff_mod_count; i++) { + add_poly_poly_coeffmod(noise.get() + (i * coeff_count), + ct.data(1) + (i * coeff_count), coeff_count, + coeff_modulus[i], ct.data(1) + (i * coeff_count)); + } } diff --git a/SCI/src/LinearHE/utils-HE.h b/SCI/src/LinearHE/utils-HE.h index 6ca809a2..a06ca458 100644 --- a/SCI/src/LinearHE/utils-HE.h +++ b/SCI/src/LinearHE/utils-HE.h @@ -22,60 +22,49 @@ SOFTWARE. #ifndef UTILS_HE_H__ #define UTILS_HE_H__ -#include "seal/seal.h" #include "LinearHE/defines-HE.h" +#include "seal/seal.h" #include "utils/emp-tool.h" -#define PRINT_NOISE_BUDGET(decryptor,ct,print_msg) if (verbose) std::cout << "[Server] Noise Budget " << print_msg << ": " << YELLOW << decryptor->invariant_noise_budget(ct) << " bits" << RESET << std::endl +#define PRINT_NOISE_BUDGET(decryptor, ct, print_msg) \ + if (verbose) \ + std::cout << "[Server] Noise Budget " << print_msg << ": " << YELLOW \ + << decryptor->invariant_noise_budget(ct) << " bits" << RESET \ + << std::endl -void generate_new_keys( - int party, - sci::NetIO* io, - int slot_count, - std::shared_ptr<seal::SEALContext> &context_, - seal::Encryptor* &encryptor_, - seal::Decryptor* &decryptor_, - seal::Evaluator* &evaluator_, - seal::BatchEncoder* &encoder_, - seal::GaloisKeys* &gal_keys_, - seal::Ciphertext* &zero_, - bool verbose = false); +void generate_new_keys(int party, sci::NetIO *io, int slot_count, + std::shared_ptr<seal::SEALContext> &context_, + seal::Encryptor *&encryptor_, + seal::Decryptor *&decryptor_, + seal::Evaluator *&evaluator_, + seal::BatchEncoder *&encoder_, + seal::GaloisKeys *&gal_keys_, seal::Ciphertext *&zero_, + bool verbose = false); -void free_keys( - int party, - seal::Encryptor* &encryptor_, - seal::Decryptor* &decryptor_, - seal::Evaluator* &evaluator_, - seal::BatchEncoder* &encoder_, - seal::GaloisKeys* &gal_keys_, - seal::Ciphertext* &zero_); +void free_keys(int party, seal::Encryptor *&encryptor_, + seal::Decryptor *&decryptor_, seal::Evaluator *&evaluator_, + seal::BatchEncoder *&encoder_, seal::GaloisKeys *&gal_keys_, + seal::Ciphertext *&zero_); -void send_encrypted_vector( - sci::NetIO* io, - std::vector<seal::Ciphertext> &ct_vec); +void send_encrypted_vector(sci::NetIO *io, + std::vector<seal::Ciphertext> &ct_vec); -void recv_encrypted_vector( - sci::NetIO* io, - std::vector<seal::Ciphertext> &ct_vec); +void recv_encrypted_vector(sci::NetIO *io, + std::vector<seal::Ciphertext> &ct_vec); -void send_ciphertext( - sci::NetIO* io, - seal::Ciphertext &ct); +void send_ciphertext(sci::NetIO *io, seal::Ciphertext &ct); -void recv_ciphertext( - sci::NetIO* io, - seal::Ciphertext &ct); +void recv_ciphertext(sci::NetIO *io, seal::Ciphertext &ct); void set_poly_coeffs_uniform( - uint64_t *poly, - uint32_t bitlen, - std::shared_ptr<seal::UniformRandomGenerator> random, - std::shared_ptr<const seal::SEALContext::ContextData> &context_data); + uint64_t *poly, uint32_t bitlen, + std::shared_ptr<seal::UniformRandomGenerator> random, + std::shared_ptr<const seal::SEALContext::ContextData> &context_data); void flood_ciphertext( - seal::Ciphertext &ct, - std::shared_ptr<const seal::SEALContext::ContextData> &context_data, - uint32_t noise_len, - seal::MemoryPoolHandle pool = seal::MemoryManager::GetPool()); + seal::Ciphertext &ct, + std::shared_ptr<const seal::SEALContext::ContextData> &context_data, + uint32_t noise_len, + seal::MemoryPoolHandle pool = seal::MemoryManager::GetPool()); #endif // UTILS_HE_H__ diff --git a/SCI/src/LinearOT/CMakeLists.txt b/SCI/src/LinearOT/CMakeLists.txt new file mode 100644 index 00000000..430f3be0 --- /dev/null +++ b/SCI/src/LinearOT/CMakeLists.txt @@ -0,0 +1,6 @@ +add_library(SCI-LinearOT linear-ot.cpp) +target_link_libraries(SCI-LinearOT + PUBLIC + SCI-BuildingBlocks + Eigen3::Eigen +) diff --git a/SCI/src/LinearOT/linear-ot.cpp b/SCI/src/LinearOT/linear-ot.cpp new file mode 100644 index 00000000..2eb5baaa --- /dev/null +++ b/SCI/src/LinearOT/linear-ot.cpp @@ -0,0 +1,746 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "LinearOT/linear-ot.h" +#include <cmath> + +#define MAX_NUM_OT (1 << 20) + +#define USE_EIGEN +#ifdef USE_EIGEN +#include <Eigen/Dense> +#endif + +using namespace std; +using namespace sci; + +void matrix_transpose(uint64_t *A, int32_t m, int32_t n, int d = 1) { + uint64_t *tmpA = new uint64_t[m * n * d]; + memcpy(tmpA, A, m * n * d * sizeof(uint64_t)); + for (int i = 0; i < m; i++) { + for (int j = 0; j < n; j++) { + if (d == 1) { + A[j * m + i] = tmpA[i * n + j]; + } else { + memcpy(A + (j * m + i) * d, tmpA + (i * n + j) * d, + d * sizeof(uint64_t)); + } + } + } + delete[] tmpA; +} + +LinearOT::LinearOT(int party, NetIO *io, OTPack<NetIO> *otpack) { + this->party = party; + this->io = io; + this->otpack = otpack; + this->aux = new AuxProtocols(party, io, otpack); + this->trunc = new Truncation(party, io, otpack, aux); + this->xt = new XTProtocol(party, io, otpack, aux); +} + +LinearOT::~LinearOT() { + delete aux; + delete trunc; +} + +void LinearOT::hadamard_cleartext(int dim, uint64_t *inA, uint64_t *inB, + uint64_t *outC) { + matmul_cleartext(1, dim, 1, inA, inB, outC, false); +} + +#ifdef USE_EIGEN +void matmul_cleartext_eigen(int dim1, int dim2, int dim3, uint64_t *inA, + uint64_t *inB, uint64_t *outC) { + Eigen::Matrix<uint64_t, Eigen::Dynamic, Eigen::Dynamic> eigen_A(dim1, dim2); + Eigen::Matrix<uint64_t, Eigen::Dynamic, Eigen::Dynamic> eigen_B(dim2, dim3); + Eigen::Matrix<uint64_t, Eigen::Dynamic, Eigen::Dynamic> eigen_C(dim1, dim3); + + for (int i = 0; i < dim1; i++) { + for (int j = 0; j < dim2; j++) { + eigen_A(i, j) = Arr2DIdxRowM(inA, dim1, dim2, i, j); + } + } + for (int i = 0; i < dim2; i++) { + for (int j = 0; j < dim3; j++) { + eigen_B(i, j) = Arr2DIdxRowM(inB, dim2, dim3, i, j); + } + } + eigen_C = eigen_A * eigen_B; + for (int i = 0; i < dim1; i++) { + for (int j = 0; j < dim3; j++) { + Arr2DIdxRowM(outC, dim1, dim3, i, j) = eigen_C(i, j); + } + } +} +#endif + +void LinearOT::matmul_cleartext(int dim1, int dim2, int dim3, uint64_t *inA, + uint64_t *inB, uint64_t *outC, + bool accumulate) { + if (!accumulate) { + for (int i = 0; i < dim1; i++) { + for (int j = 0; j < dim3; j++) { + for (int k = 0; k < dim2; k++) { + outC[dim2 * dim3 * i + dim2 * j + k] = + inA[dim2 * i + k] * inB[dim3 * k + j]; + } + } + } + return; + } +#ifndef USE_EIGEN + for (int i = 0; i < dim1; i++) { + for (int j = 0; j < dim3; j++) { + outC[i * dim3 + j] = 0; + for (int k = 0; k < dim2; k++) { + outC[i * dim3 + j] += (inA[dim2 * i + k] * inB[dim3 * k + j]); + } + } + } +#else + assert(accumulate == true && "Eigen not configured for accumulate = false"); + matmul_cleartext_eigen(dim1, dim2, dim3, inA, inB, outC); +#endif +} + +void LinearOT::hadamard_cross_terms(int32_t dim, uint64_t *inA, uint64_t *inB, + uint64_t *outC, int32_t bwA, int32_t bwB, + int32_t bwC, MultMode mode) { + matmul_cross_terms(1, dim, 1, inA, inB, outC, bwA, bwB, bwC, false, mode); +} + +void LinearOT::hadamard_product(int32_t dim, uint64_t *inA, uint64_t *inB, + uint64_t *outC, int32_t bwA, int32_t bwB, + int32_t bwC, bool signed_arithmetic, + bool signed_B, MultMode mode, uint8_t *msbA, + uint8_t *msbB) { + matrix_multiplication(1, dim, 1, inA, inB, outC, bwA, bwB, bwC, + signed_arithmetic, signed_B, false, mode, msbA, msbB); +} + +void LinearOT::matmul_cross_terms(int32_t dim1, int32_t dim2, int32_t dim3, + uint64_t *inA, uint64_t *inB, uint64_t *outC, + int32_t bwA, int32_t bwB, int32_t bwC, + bool accumulate, MultMode mode) { + bool use_straight_ot = false, use_reversed_ot = false; + uint64_t maskC = (bwC == 64 ? -1 : ((1ULL << bwC) - 1)); + uint64_t *inS, *inR; + int32_t bwR, dimS1, dimS2, dimR1, dimR2; + // A whole row of values is multiplied to a element using only bwR OTs + bool row_batching; + if (mode == MultMode::Alice_has_A) { + use_straight_ot = true; + row_batching = false; + } else if (mode == MultMode::Bob_has_A) { + use_straight_ot = true; + row_batching = true; + } else if (mode == MultMode::Alice_has_B) { + use_reversed_ot = true; + row_batching = false; + } else if (mode == MultMode::Bob_has_B) { + use_reversed_ot = true; + row_batching = true; + } else { + use_straight_ot = true; + use_reversed_ot = true; + // if (bwA*dim1*dim2 > bwB*dim2*dim3) { + if (bwA > bwB) { + row_batching = false; + } else { + row_batching = true; + } + } + if (row_batching) { + inS = inB; + inR = inA; + bwR = bwA; + dimS1 = dim2; + dimS2 = dim3; + dimR1 = dim1; + dimR2 = dim2; + } else { + // inS = inA; + inS = new uint64_t[dim1 * dim2]; + memcpy(inS, inA, dim1 * dim2 * sizeof(uint64_t)); + inR = inB; + bwR = bwB; + dimS1 = dim1; + dimS2 = dim2; + dimR1 = dim2; + dimR2 = dim3; + } + + int32_t num_ot = dimR1 * dimR2 * bwR; + int32_t msgs_per_ot = (row_batching ? dimS2 : dimS1); + int32_t dim = dimR1 * dimR2; + // max_num_ot is multiple of dim + int32_t max_num_ot = ceil(float(MAX_NUM_OT) / (dim * msgs_per_ot)) * dim; + int32_t batch_size; + if (num_ot < max_num_ot) + batch_size = num_ot; + else + batch_size = max_num_ot; + + uint64_t *corr = new uint64_t[batch_size * msgs_per_ot]; + uint64_t *ABs = new uint64_t[batch_size * msgs_per_ot]; + uint64_t *ABr = new uint64_t[batch_size * msgs_per_ot]; + bool *choice = new bool[batch_size]; + uint64_t *tmpR = new uint64_t[dim]; + memcpy(tmpR, inR, dim * sizeof(uint64_t)); + + memset(ABs, 0, batch_size * msgs_per_ot * sizeof(uint64_t)); + memset(ABr, 0, batch_size * msgs_per_ot * sizeof(uint64_t)); + if (accumulate) { + memset(outC, 0, dim1 * dim3 * sizeof(uint64_t)); + } else { + memset(outC, 0, dim1 * dim2 * dim3 * sizeof(uint64_t)); + } + if (!row_batching) { + // inplace transposing is fine because inS is a copy if row_batching = false + matrix_transpose(inS, dimS1, dimS2); + } + + for (int i = 0; i < num_ot; i += batch_size) { + vector<int> msg_len; + if (batch_size <= num_ot - i) + msg_len.resize(batch_size / dim); + else + msg_len.resize((num_ot - i) / dim); + for (int j = i; j < i + batch_size and j < num_ot; j += dim) { + int bit_offset = i / dim; + int bit_idx = j / dim; + msg_len[bit_idx - bit_offset] = bwC - bit_idx; + for (int k = j; k < j + dim and k < i + batch_size; k++) { + int inp_idx = k - j; + int row_idx_R = inp_idx / dimR2; + int col_idx_R = inp_idx % dimR2; + for (int h = 0; h < msgs_per_ot; h++) { + uint64_t elemS; + if (row_batching) + elemS = inS[col_idx_R * dimS2 + h]; + // To preserve locality, inS is tranposed if row_batching = false + else + elemS = inS[row_idx_R * dimS1 + h]; + // else elemS = inS[h*dimS2 + row_idx_R]; + corr[(k - i) * msgs_per_ot + h] = + ((elemS << bit_idx) & maskC) >> bit_idx; + } + choice[k - i] = (bool)(tmpR[inp_idx] & 1); + tmpR[inp_idx] >>= 1; + } + } + if (use_straight_ot) { + if (party == sci::ALICE) { + if (batch_size <= num_ot - i) { + otpack->iknp_straight->send_batched_cot(ABs, corr, msg_len, + batch_size, msgs_per_ot); + } else { + otpack->iknp_straight->send_batched_cot(ABs, corr, msg_len, + num_ot - i, msgs_per_ot); + } + } else { // party == sci::BOB + if (batch_size <= num_ot - i) { + otpack->iknp_straight->recv_batched_cot(ABr, choice, msg_len, + batch_size, msgs_per_ot); + } else { + otpack->iknp_straight->recv_batched_cot(ABr, choice, msg_len, + num_ot - i, msgs_per_ot); + } + } + } + if (use_reversed_ot) { + if (party == sci::ALICE) { + if (batch_size <= num_ot - i) { + otpack->iknp_reversed->recv_batched_cot(ABr, choice, msg_len, + batch_size, msgs_per_ot); + } else { + otpack->iknp_reversed->recv_batched_cot(ABr, choice, msg_len, + num_ot - i, msgs_per_ot); + } + } else { // party == sci::BOB + if (batch_size <= num_ot - i) { + otpack->iknp_reversed->send_batched_cot(ABs, corr, msg_len, + batch_size, msgs_per_ot); + } else { + otpack->iknp_reversed->send_batched_cot(ABs, corr, msg_len, + num_ot - i, msgs_per_ot); + } + } + } + for (int h = 0; h < dim2; h++) { + for (int j = i; j < i + batch_size and j < num_ot; j += dim) { + int bit_idx = j / dim; + for (int k = 0; k < dim1 * dim3; k++) { + int row_idx = (row_batching ? k / dim3 : k / dim1); + int col_idx = (row_batching ? k % dim3 : k % dim1); + int idx; + if (row_batching) + idx = (j - i + row_idx * dimR2 + h) * msgs_per_ot + col_idx; + // To preserve locality, outC-transpose is computed if row_batching = + // false + else + idx = (j - i + h * dimR2 + row_idx) * msgs_per_ot + col_idx; + if (use_straight_ot) { + uint64_t temp = (party == ALICE ? -ABs[idx] : ABr[idx]) << bit_idx; + if (accumulate) { + outC[k] += temp; + } else { + outC[k * dim2 + h] += temp; + } + } + if (use_reversed_ot) { + uint64_t temp = (party == BOB ? -ABs[idx] : ABr[idx]) << bit_idx; + if (accumulate) { + outC[k] += temp; + } else { + outC[k * dim2 + h] += temp; + } + } + } + } + } + } + if (!row_batching) { + if (accumulate) { + matrix_transpose(outC, dim3, dim1); + } else { + matrix_transpose(outC, dim3, dim1, dim2); + } + } + + if (accumulate) { + for (int k = 0; k < dim1 * dim3; k++) { + outC[k] &= maskC; + } + } else { + for (int k = 0; k < dim1 * dim2 * dim3; k++) { + outC[k] &= maskC; + } + } + + delete[] corr; + delete[] ABs; + delete[] ABr; + delete[] choice; + delete[] tmpR; + if (!row_batching) + delete[] inS; +} + +void LinearOT::matmul_multiplexer(int32_t dim1, int32_t dim2, int32_t dim3, + uint64_t *inA, uint64_t *inB, uint64_t *outC, + int32_t bwA, int32_t bwB, int32_t bwC, + bool accumulate, MultMode mode) { + assert(bwA == 1 || bwB == 1); + assert(bwC < (bwA + bwB)); + + bool use_straight_ot = false, use_reversed_ot = false; + uint64_t maskC = (bwC == 64 ? -1 : ((1ULL << bwC) - 1)); + uint64_t *inS, *inR; + int32_t dimS1, dimS2, dimR1, dimR2; + // A whole row of values is multiplied to a bit + bool row_batching; + if (bwB == 1) { + inS = new uint64_t[dim1 * dim2]; + memcpy(inS, inA, dim1 * dim2 * sizeof(uint64_t)); + inR = inB; + dimS1 = dim1; + dimS2 = dim2; + dimR1 = dim2; + dimR2 = dim3; + if (mode == MultMode::Alice_has_A) + use_straight_ot = true; + else if (mode == MultMode::Bob_has_A) + use_reversed_ot = true; + else { + use_straight_ot = true; + use_reversed_ot = true; + } + row_batching = false; + } else { // bwA == 1 + inS = inB; + inR = inA; + dimS1 = dim2; + dimS2 = dim3; + dimR1 = dim1; + dimR2 = dim2; + if (mode == MultMode::Alice_has_B) + use_straight_ot = true; + else if (mode == MultMode::Bob_has_B) + use_reversed_ot = true; + else { + use_straight_ot = true; + use_reversed_ot = true; + } + row_batching = true; + } + + int32_t dim = dimR1 * dimR2; + int32_t msgs_per_ot = (row_batching ? dimS2 : dimS1); + + PRG128 prg; + uint64_t *data = new uint64_t[2 * dim * msgs_per_ot]; + uint64_t *ABs = new uint64_t[dim * msgs_per_ot]; + uint64_t *ABr = new uint64_t[dim * msgs_per_ot]; + uint8_t *choice = new uint8_t[dim]; + + if (accumulate) { + for (int k = 0; k < dim1 * dim3; k++) { + outC[k] = 0; + } + } else { + for (int k = 0; k < dim1 * dim2 * dim3; k++) { + outC[k] = 0; + } + } + memset(ABs, 0, dim * msgs_per_ot * sizeof(uint64_t)); + memset(ABr, 0, dim * msgs_per_ot * sizeof(uint64_t)); + + if (!row_batching) { + // inplace transposing is fine because inS is a copy if row_batching = false + matrix_transpose(inS, dimS1, dimS2); + } + + if (use_straight_ot && party == ALICE) { + prg.random_data(ABs, dim * msgs_per_ot * sizeof(uint64_t)); + } + if (use_reversed_ot && party == BOB) { + prg.random_data(ABs, dim * msgs_per_ot * sizeof(uint64_t)); + } + + for (int i = 0; i < dim; i++) { + int row_idx_R = i / dimR2; + int col_idx_R = i % dimR2; + + choice[i] = (bool)(inR[i] & 1); + uint64_t choice_bit = choice[i]; + for (int h = 0; h < msgs_per_ot; h++) { + uint64_t elemS; + if (row_batching) + elemS = inS[col_idx_R * dimS2 + h]; + // To preserve locality, inS is tranposed if row_batching = false + else + elemS = inS[row_idx_R * dimS1 + h]; + int idx = i * msgs_per_ot + h; + data[idx * 2] = (ABs[idx] + elemS * choice_bit) & maskC; + data[idx * 2 + 1] = (ABs[idx] + elemS * (1 - choice_bit)) & maskC; + } + } + if (party == sci::ALICE) { + if (use_straight_ot) { + otpack->iknp_straight->send_batched_got(data, dim, bwC, msgs_per_ot); + } + if (use_reversed_ot) { + otpack->iknp_reversed->recv_batched_got(ABr, choice, dim, bwC, + msgs_per_ot); + } + } else { // party == sci::BOB + if (use_straight_ot) { + otpack->iknp_straight->recv_batched_got(ABr, choice, dim, bwC, + msgs_per_ot); + } + if (use_reversed_ot) { + otpack->iknp_reversed->send_batched_got(data, dim, bwC, msgs_per_ot); + } + } + for (int h = 0; h < dim2; h++) { + for (int k = 0; k < dim1 * dim3; k++) { + int row_idx = (row_batching ? k / dim3 : k / dim1); + int col_idx = (row_batching ? k % dim3 : k % dim1); + int idx; + if (row_batching) + idx = (row_idx * dimR2 + h) * msgs_per_ot + col_idx; + // To preserve locality, outC-transpose is computed if row_batching = + // false + else + idx = (h * dimR2 + row_idx) * msgs_per_ot + col_idx; + if (use_straight_ot) { + uint64_t temp = (party == ALICE ? -ABs[idx] : ABr[idx]); + if (accumulate) { + outC[k] += temp; + } else { + outC[k * dim2 + h] += temp; + } + } + if (use_reversed_ot) { + uint64_t temp = (party == BOB ? -ABs[idx] : ABr[idx]); + if (accumulate) { + outC[k] += temp; + } else { + outC[k * dim2 + h] += temp; + } + } + } + } + if (!row_batching) { + if (accumulate) { + matrix_transpose(outC, dim3, dim1); + } else { + matrix_transpose(outC, dim3, dim1, dim2); + } + } + + if (accumulate) { + for (int k = 0; k < dim1 * dim3; k++) { + outC[k] &= maskC; + } + } else { + for (int k = 0; k < dim1 * dim2 * dim3; k++) { + outC[k] &= maskC; + } + } + + delete[] data; + delete[] ABs; + delete[] ABr; + delete[] choice; + if (!row_batching) + delete[] inS; +} + +void LinearOT::matrix_multiplication(int32_t dim1, int32_t dim2, int32_t dim3, + uint64_t *inA, uint64_t *inB, + uint64_t *outC, int32_t bwA, int32_t bwB, + int32_t bwC, bool signed_arithmetic, + bool signed_B, bool accumulate, + MultMode mode, uint8_t *msbA, + uint8_t *msbB) { + assert(bwC <= 64); + assert((bwC <= (bwA + bwB)) && (bwC >= bwA) && (bwC >= bwB)); + int32_t extra_bits = (accumulate ? ceil(log2(dim2)) : 0); + uint64_t *tmpA = new uint64_t[dim1 * dim2]; + uint64_t *tmpB = new uint64_t[dim2 * dim3]; + + bool sender_A = false; + bool sender_B = false; + if (mode == MultMode::Alice_has_A || mode == MultMode::Alice_has_B) { + sender_A = true; + } else if (mode == MultMode::Bob_has_A || mode == MultMode::Bob_has_B) { + sender_B = true; + } else { + if (bwA > bwB) { + sender_A = true; + } else { + sender_B = true; + } + } + if (sender_A) { + if (mode == MultMode::Alice_has_A || mode == MultMode::Bob_has_A) { + for (int i = 0; i < dim1 * dim2; i++) { + tmpA[i] = (signed_arithmetic ? signed_val(inA[i], bwA) : inA[i]); + } + } else { + if (signed_arithmetic) { + xt->s_extend(dim1 * dim2, inA, tmpA, bwA, bwA + extra_bits, msbA); + } else { + xt->z_extend(dim1 * dim2, inA, tmpA, bwA, bwA + extra_bits, msbA); + } + } + memcpy(tmpB, inB, dim2 * dim3 * sizeof(uint64_t)); + bwA = bwA + extra_bits; + } else if (sender_B) { + if (mode == MultMode::Alice_has_B || mode == MultMode::Bob_has_B) { + for (int i = 0; i < dim2 * dim3; i++) { + tmpB[i] = ((signed_arithmetic && signed_B) ? signed_val(inB[i], bwB) + : inB[i]); + } + } else { + if (signed_arithmetic && signed_B) { + xt->s_extend(dim2 * dim3, inB, tmpB, bwB, bwB + extra_bits, msbB); + } else { + xt->z_extend(dim2 * dim3, inB, tmpB, bwB, bwB + extra_bits, msbB); + } + } + memcpy(tmpA, inA, dim1 * dim2 * sizeof(uint64_t)); + bwB = bwB + extra_bits; + } + bwC = bwC + extra_bits; + uint64_t maskA = (bwA == 64 ? -1 : ((1ULL << bwA) - 1)); + uint64_t maskB = (bwB == 64 ? -1 : ((1ULL << bwB) - 1)); + uint64_t maskC = (bwC == 64 ? -1 : ((1ULL << bwC) - 1)); + uint64_t pow_A = 1ULL << bwA; + uint64_t pow_B = 1ULL << bwB; + uint64_t pow_A_2 = (1ULL << (bwA - 1)); + uint64_t pow_B_2 = (1ULL << (bwB - 1)); + int32_t dim; + if (accumulate) + dim = dim1 * dim3; + else + dim = dim1 * dim2 * dim3; + + for (int i = 0; i < dim1 * dim2; i++) { + if (signed_arithmetic) { + if (mode == MultMode::Alice_has_A) { + tmpA[i] = (party == ALICE ? tmpA[i] + pow_A_2 : 0) & maskA; + } else if (mode == MultMode::Bob_has_A) { + tmpA[i] = (party == BOB ? tmpA[i] + pow_A_2 : 0) & maskA; + } else { + tmpA[i] = (tmpA[i] + (party == BOB ? pow_A_2 : 0)) & maskA; + } + } else { + tmpA[i] = tmpA[i] & maskA; + } + } + for (int i = 0; i < dim2 * dim3; i++) { + if (signed_arithmetic && signed_B) { + if (mode == MultMode::Alice_has_B) { + tmpB[i] = (party == ALICE ? tmpB[i] + pow_B_2 : 0) & maskB; + } else if (mode == MultMode::Bob_has_B) { + tmpB[i] = (party == BOB ? tmpB[i] + pow_B_2 : 0) & maskB; + } else { + tmpB[i] = (tmpB[i] + (party == BOB ? pow_B_2 : 0)) & maskB; + } + } else { + tmpB[i] = tmpB[i] & maskB; + } + } + uint64_t *cross_terms = new uint64_t[dim]; + matmul_cross_terms(dim1, dim2, dim3, tmpA, tmpB, cross_terms, bwA, bwB, bwC, + accumulate, mode); + + uint64_t *local_terms = new uint64_t[dim]; + if (party == ALICE && + (mode == MultMode::Alice_has_A || mode == MultMode::Alice_has_B)) { + matmul_cleartext(dim1, dim2, dim3, tmpA, tmpB, local_terms, accumulate); + } else if (party == BOB && + (mode == MultMode::Bob_has_A || mode == MultMode::Bob_has_B)) { + matmul_cleartext(dim1, dim2, dim3, tmpA, tmpB, local_terms, accumulate); + } else if (mode == MultMode::None) { + matmul_cleartext(dim1, dim2, dim3, tmpA, tmpB, local_terms, accumulate); + } else { + memset(local_terms, 0, dim * sizeof(uint64_t)); + } + + uint8_t *wA = new uint8_t[dim1 * dim2]; + uint8_t *wB = new uint8_t[dim2 * dim3]; + uint64_t *wA_B = new uint64_t[dim]; + uint64_t *wB_A = new uint64_t[dim]; + + if (bwC > bwA) { + if (mode == MultMode::Alice_has_A || mode == MultMode::Bob_has_A) { + memset(wA, 0, dim1 * dim2 * sizeof(uint8_t)); + memset(wA_B, 0, dim * sizeof(uint64_t)); + } else { + if (msbA != nullptr) { + uint8_t *tmp_msbA = new uint8_t[dim1 * dim2]; + if (signed_arithmetic) { + for (int i = 0; i < dim1 * dim2; i++) { + tmp_msbA[i] = (party == ALICE ? msbA[i] ^ 1 : msbA[i]); + } + } else { + for (int i = 0; i < dim1 * dim2; i++) { + tmp_msbA[i] = (sender_A && (extra_bits > 0) ? 0 : msbA[i]); + } + } + aux->MSB_to_Wrap(tmpA, tmp_msbA, wA, dim1 * dim2, bwA); + delete[] tmp_msbA; + } else { + aux->wrap_computation(tmpA, wA, dim1 * dim2, bwA); + } + uint64_t *wA64 = new uint64_t[dim1 * dim2]; + for (int i = 0; i < dim1 * dim2; i++) { + wA64[i] = uint64_t(wA[i]); + } + matmul_multiplexer(dim1, dim2, dim3, wA64, tmpB, wA_B, 1, bwB, bwC - bwA, + accumulate, mode); + delete[] wA64; + } + } + if (bwC > bwB) { + if (mode == MultMode::Alice_has_B || mode == MultMode::Bob_has_B) { + memset(wB, 0, dim2 * dim3 * sizeof(uint8_t)); + memset(wB_A, 0, dim * sizeof(uint64_t)); + } else { + if (msbB != nullptr) { + uint8_t *tmp_msbB = new uint8_t[dim2 * dim3]; + if (signed_arithmetic && signed_B) { + for (int i = 0; i < dim2 * dim3; i++) { + tmp_msbB[i] = (party == ALICE ? msbB[i] ^ 1 : msbB[i]); + } + } else { + for (int i = 0; i < dim2 * dim3; i++) { + tmp_msbB[i] = (sender_B && (extra_bits > 0) ? 0 : msbB[i]); + } + } + aux->MSB_to_Wrap(tmpB, tmp_msbB, wB, dim2 * dim3, bwB); + delete[] tmp_msbB; + } else { + aux->wrap_computation(tmpB, wB, dim2 * dim3, bwB); + } + uint64_t *wB64 = new uint64_t[dim2 * dim3]; + for (int i = 0; i < dim2 * dim3; i++) { + wB64[i] = uint64_t(wB[i]); + } + matmul_multiplexer(dim1, dim2, dim3, tmpA, wB64, wB_A, bwA, 1, bwC - bwB, + accumulate, mode); + delete[] wB64; + } + } + + uint64_t *tmpC = new uint64_t[dim]; + int inner_loop_size = (accumulate ? dim2 : 1); + for (int i = 0; i < dim; i++) { + tmpC[i] = + (local_terms[i] + cross_terms[i] - pow_A * wA_B[i] - pow_B * wB_A[i]) & + maskC; + if (signed_arithmetic) { + for (int j = 0; j < inner_loop_size; j++) { + int idx = (accumulate ? i : i / dim2); + int common_idx = (accumulate ? j : i % dim2); + int row_idx = idx / dim3; + int col_idx = idx % dim3; + int A_idx = row_idx * dim2 + common_idx; + int B_idx = common_idx * dim3 + col_idx; + if (signed_B) { + if (party == ALICE) { + tmpC[i] = (tmpC[i] - pow_A_2 * (tmpB[B_idx] - pow_B * wB[B_idx]) - + pow_B_2 * (tmpA[A_idx] - pow_A * wA[A_idx])) & + maskC; + } else { // party == BOB + tmpC[i] = (tmpC[i] - pow_A_2 * (tmpB[B_idx] - pow_B * wB[B_idx]) - + pow_B_2 * (tmpA[A_idx] - pow_A * wA[A_idx]) + + pow_A_2 * pow_B_2) & + maskC; + } + } else { + tmpC[i] = + (tmpC[i] - pow_A_2 * (tmpB[B_idx] - pow_B * wB[B_idx])) & maskC; + } + } + } + } + if (accumulate) { + trunc->truncate_and_reduce(dim1 * dim3, tmpC, outC, extra_bits, bwC); + } else { + memcpy(outC, tmpC, dim * sizeof(uint64_t)); + } + + delete[] cross_terms; + delete[] local_terms; + delete[] wA; + delete[] wB; + delete[] wA_B; + delete[] wB_A; + delete[] tmpA; + delete[] tmpB; + delete[] tmpC; +} diff --git a/SCI/src/LinearOT/linear-ot.h b/SCI/src/LinearOT/linear-ot.h new file mode 100644 index 00000000..37ac5e53 --- /dev/null +++ b/SCI/src/LinearOT/linear-ot.h @@ -0,0 +1,113 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef LINEAR_OT_H__ +#define LINEAR_OT_H__ + +#include "BuildingBlocks/aux-protocols.h" +#include "BuildingBlocks/truncation.h" +#include "BuildingBlocks/value-extension.h" +#include "OT/emp-ot.h" + +enum class MultMode { + None, // Both A and B are secret shared + Alice_has_A, // A is known to ALICE + Alice_has_B, // B is known to ALICE + Bob_has_A, // A is known to BOB + Bob_has_B, // B is known to BOB +}; + +class LinearOT { +public: + int party; + sci::NetIO *io; + sci::OTPack<sci::NetIO> *otpack; + AuxProtocols *aux; + Truncation *trunc; + XTProtocol *xt; + + LinearOT(int party, sci::NetIO *io, sci::OTPack<sci::NetIO> *otpack); + + ~LinearOT(); + + void hadamard_cleartext(int dim, uint64_t *inA, uint64_t *inB, + uint64_t *outC); + + // Outputs the dim1*dim2*dim3 multiplications in inA*inB without accumulating + void matmul_cleartext(int dim1, int dim2, int dim3, uint64_t *inA, + uint64_t *inB, uint64_t *outC, bool accumulate = true); + + // Hadamard cross terms A0B1 + A1B0 + void hadamard_cross_terms(int32_t dim, uint64_t *inA, uint64_t *inB, + uint64_t *outC, int32_t bwA, int32_t bwB, + int32_t bwC, MultMode mode = MultMode::None); + + // Hadamard product of two secret-shared vectors A and B + void hadamard_product(int32_t dim, + // input share vector + uint64_t *inA, uint64_t *inB, + // output share vector + uint64_t *outC, + // bitwidths + int32_t bwA, int32_t bwB, int32_t bwC, + bool signed_arithmetic = true, + // take B as signed input? + bool signed_B = true, MultMode mode = MultMode::None, + uint8_t *msbA = nullptr, uint8_t *msbB = nullptr); + + // Matmul cross terms A0B1 + A1B0 + void matmul_cross_terms( + // (dim1xdim2) X (dim2xdim3) + int32_t dim1, int32_t dim2, int32_t dim3, + // input share matrix + uint64_t *inA, uint64_t *inB, + // output share matrix + uint64_t *outC, + // bitwidths + int32_t bwA, int32_t bwB, int32_t bwC, bool accumulate, + MultMode mode = MultMode::None); + + // Matmul Multiplexer: bwA == 1 || bwB == 1 + void matmul_multiplexer( + // (dim1xdim2) X (dim2xdim3) + int32_t dim1, int32_t dim2, int32_t dim3, + // either A or B will be a bit matrix + uint64_t *inA, uint64_t *inB, uint64_t *outC, + // bitwidths + int32_t bwA, int32_t bwB, int32_t bwC, bool accumulate, MultMode mode); + + // Matrix Multiplication of two secret-shared matrices A and B + void matrix_multiplication( + // (dim1xdim2) X (dim2xdim3) + int32_t dim1, int32_t dim2, int32_t dim3, + // input share matrix + uint64_t *inA, uint64_t *inB, + // output share matrix + uint64_t *outC, + // bitwidths + int32_t bwA, int32_t bwB, int32_t bwC, bool signed_arithmetic = true, + // take B as signed input? + bool signed_B = true, bool accumulate = true, + MultMode mode = MultMode::None, uint8_t *msbA = nullptr, + uint8_t *msbB = nullptr); +}; + +#endif diff --git a/SCI/src/LinearOT/linear-uniform.h b/SCI/src/LinearOT/linear-uniform.h new file mode 100644 index 00000000..f142c3de --- /dev/null +++ b/SCI/src/LinearOT/linear-uniform.h @@ -0,0 +1,750 @@ +/* +Authors: Nishant Kumar +Copyright: +Copyright (c) 2020 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef LINEAR_UNIFORM_H__ +#define LINEAR_UNIFORM_H__ +#include <iostream> + +#ifdef USE_EIGEN +#include <Eigen/Dense> +#endif + +#include "OT/iknp.h" + +// Special case of LinearOT which works only for uniform bitwidth multiplication +// Faster than LinearOT for uniform bitwidth matrix multiplication +template <typename IO, typename intType, typename otType> class MatMulUniform { +public: + IO *io = nullptr; + sci::OT<otType> *otImpl = nullptr; + sci::OT<otType> *otImplRoleReversed = nullptr; + int party; + int bitlength; + const uint32_t batchSizeOTs = + 1ULL << 18; // This is the default size of the batch of OTs that will be + // done in one go for matmul + // This will be scaled appropriately to manage memory if the + // matmul dimensions are too large. + + const uint64_t MaxMemToUseInBytes = 2.5 * (1 << 30); // 2.5 GiB + intType moduloMask; + + MatMulUniform(int party, int bitlength, IO *io, sci::OT<otType> *otImpl, + sci::OT<otType> *otImplRoleReversed) { + this->party = party; + assert(((party == 1) || (party == 2)) && "PartyNum should be 1 or 2."); + this->bitlength = bitlength; + this->io = io; + assert(io != nullptr && "IO can't be nullptr."); + assert(otImpl != nullptr && "otImpl can't be nullptr."); + this->otImpl = otImpl; + this->otImplRoleReversed = otImplRoleReversed; + if (bitlength == 64) + moduloMask = -1; + else + moduloMask = (1ULL << bitlength) - 1; + } + + ~MatMulUniform() {} + +#ifdef USE_EIGEN + void ideal_func_eigen(int s1, int s2, int s3, const intType *A, + const intType *B, intType *C) { + Eigen::Matrix<intType, Eigen::Dynamic, Eigen::Dynamic> eigen_a(s1, s2); + Eigen::Matrix<intType, Eigen::Dynamic, Eigen::Dynamic> eigen_b(s2, s3); + Eigen::Matrix<intType, Eigen::Dynamic, Eigen::Dynamic> eigen_c(s1, s3); + + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s2; j++) { + eigen_a(i, j) = Arr2DIdxRowM(A, s1, s2, i, j); + } + } + for (int i = 0; i < s2; i++) { + for (int j = 0; j < s3; j++) { + eigen_b(i, j) = Arr2DIdxRowM(B, s2, s3, i, j); + } + } + eigen_c = eigen_a * eigen_b; + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s3; j++) { + Arr2DIdxRowM(C, s1, s3, i, j) = eigen_c(i, j); + } + } + } +#endif + + void ideal_func(int s1, int s2, int s3, const intType *A, const intType *B, + intType *C) { +#ifndef USE_EIGEN + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s3; j++) { + Arr2DIdxRowM(C, s1, s3, i, j) = 0; + for (int k = 0; k < s2; k++) { + Arr2DIdxRowM(C, s1, s3, i, j) += + (Arr2DIdxRowM(A, s1, s2, i, k) * Arr2DIdxRowM(B, s2, s3, k, j)); + } + } + } +#else + ideal_func_eigen(s1, s2, s3, A, B, C); +#endif + for (int i = 0; i < s1 * s3; i++) { + C[i] = C[i] & moduloMask; + } + } + + void verifyMatmulShares(int s1, int s2, int s3, const intType *A_share, + const intType *B_share, const intType *C_share) { + if (party == sci::ALICE) { + intType *A_temp_share = new intType[s1 * s2]; + intType *B_temp_share = new intType[s2 * s3]; + intType *C_temp_share = new intType[s1 * s3]; + intType *C_clear = new intType[s1 * s3]; + io->recv_data(A_temp_share, sizeof(intType) * s1 * s2); + io->recv_data(B_temp_share, sizeof(intType) * s2 * s3); + io->recv_data(C_temp_share, sizeof(intType) * s1 * s3); + sci::elemWiseAdd<intType>(s1 * s2, A_share, A_temp_share, A_temp_share); + sci::elemWiseAdd<intType>(s2 * s3, B_share, B_temp_share, B_temp_share); + sci::elemWiseAdd<intType>(s1 * s3, C_share, C_temp_share, C_temp_share); + ideal_func(s1, s2, s3, A_temp_share, B_temp_share, C_clear); + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s3; j++) { + assert(Arr2DIdxRowM(C_clear, s1, s3, i, j) == + (Arr2DIdxRowM(C_temp_share, s1, s3, i, j) & moduloMask)); + } + } + delete[] A_temp_share; + delete[] B_temp_share; + delete[] C_temp_share; + delete[] C_clear; + } else if (party == sci::BOB) { + io->send_data(A_share, sizeof(intType) * s1 * s2); + io->send_data(B_share, sizeof(intType) * s2 * s3); + io->send_data(C_share, sizeof(intType) * s1 * s3); + } else { + assert(false); + } + } + + void fillInSimpleValues(int s1, int s2, intType *arr) { + if (party == sci::ALICE) { + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s2; j++) { + Arr2DIdxRowM(arr, s1, s2, i, j) = i + j + 1; + } + } + } else if (party == sci::BOB) { + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s2; j++) { + Arr2DIdxRowM(arr, s1, s2, i, j) = 0; + } + } + } + } + + /* + This function is not being used anywhere right now + - matmul where dimensions of matrices are (s1,s2) and (s2,s3) + - inp is input of the sender of size (s1,s2) + - outp is the share of the result of size (s1,s3) + */ + void funcOTSenderNonBatched(int s1, int s2, int s3, const intType *inp, + intType *outp, sci::OT<otType> *otInstance) { + uint64_t *corrData = new uint64_t[s1 * s2 * bitlength * s3]; + uint64_t *rData = new uint64_t[s1 * s2 * bitlength * s3]; + uint64_t *chunkSizes = new uint64_t[s2 * bitlength * s3]; + uint64_t *numChunks = new uint64_t[s2 * bitlength * s3]; + + intType *inpColumnMajor = new intType[s1 * s2]; + intType *outpColumnMajor = new intType[s1 * s3]; + sci::convertRowToColMajor<intType>(s1, s2, inp, inpColumnMajor); + + for (int i = 0; i < s1 * s3; i++) { + outpColumnMajor[i] = 0; + } + for (int col = 0; col < s3; col++) { + for (int j = 0; j < s2; j++) { + for (int k = 0; k < bitlength; k++) { + for (int i = 0; i < s1; i++) { + intType curElem = Arr2DIdxColM(inpColumnMajor, s1, s2, i, j); + Arr4DIdxRowM(corrData, s3, s2, bitlength, s1, col, j, k, i) = + ((intType)(((intType)curElem) << k)) >> k; + // casting is imp to make sure that + // right shift happens in apt bitwidth + } + chunkSizes[col * s2 * bitlength + j * bitlength + k] = bitlength - k; + numChunks[col * s2 * bitlength + j * bitlength + k] = s1; + } + } + } + otInstance->template send_cot_matmul<intType>( + rData, corrData, chunkSizes, numChunks, s2 * bitlength * s3); + for (int col = 0; col < s3; col++) { + for (int i = 0; i < s2; i++) { + for (int j = 0; j < bitlength; j++) { + for (int k = 0; k < s1; k++) { + // Arr3DIdxRowM(rData,s2,bitlength,s1,i,j,k) should be of + // bitlength-j bits -- top j bits should be 0. + uint64_t curElem = + Arr4DIdxRowM(rData, s3, s2, bitlength, s1, col, i, j, k); + assert(((((1ULL << j) - 1) << (bitlength - j)) & curElem) == 0 && + "assertion failed"); + Arr2DIdxColM(outpColumnMajor, s1, s3, k, col) -= + (((intType)curElem) << j); + } + } + } + } + + sci::convertColToRowMajor<intType>(s1, s3, outpColumnMajor, outp); + for (int i = 0; i < s1 * s3; i++) { + outp[i] = outp[i] & moduloMask; + } + + delete[] corrData; + delete[] rData; + delete[] chunkSizes; + delete[] numChunks; + } + + /* + This function is not being used anywhere right now + - The matrix multiplication being performed is (s1, s2) * (s2, s3). + - inp is the receiver's array to be multiplied of size (s2, s3) + - outp is the share of the receiver after multiplication of size + (s1,s3) + */ + void funcOTReceiverNonBatched(int s1, int s2, int s3, const intType *inp, + intType *outp, sci::OT<otType> *otInstance) { + // copy inp from row to column and outp from column to row major + uint8_t *choiceBitArr = new uint8_t[s2 * bitlength * s3]; + uint64_t *recv_data = new uint64_t[s1 * s2 * bitlength * s3]; + uint64_t *chunkSizes = new uint64_t[s2 * bitlength * s3]; + uint64_t *numChunks = new uint64_t[s2 * bitlength * s3]; + + intType *inpColumnMajor = new intType[s2 * s3]; + intType *outpColumnMajor = new intType[s1 * s3]; + sci::convertRowToColMajor<intType>(s2, s3, inp, inpColumnMajor); + + for (int j = 0; j < s3; j++) { + for (int i = 0; i < s2; i++) { + for (int k = 0; k < bitlength; k++) { + choiceBitArr[j * s2 * bitlength + i * bitlength + k] = + (Arr2DIdxColM(inpColumnMajor, s2, s3, i, j) & (1ULL << k)) >> + k; // Unsigned right shift + chunkSizes[j * s2 * bitlength + i * bitlength + k] = (bitlength - k); + numChunks[j * s2 * bitlength + i * bitlength + k] = s1; + } + } + } + otInstance->template recv_cot_matmul<intType>( + recv_data, choiceBitArr, chunkSizes, numChunks, s2 * s3 * bitlength); + // recv_data can be interpreted as a 4d array of size(s3,s2,bitlength,s1) + for (int i = 0; i < s1 * s3; i++) { + outpColumnMajor[i] = 0; + } + + for (int i = 0; i < s3; i++) { + for (int j = 0; j < s2; j++) { + for (int k = 0; k < bitlength; k++) { + for (int w = 0; w < s1; w++) { + Arr2DIdxColM(outpColumnMajor, s1, s3, w, i) += + (((intType)Arr4DIdxRowM(recv_data, s3, s2, bitlength, s1, i, j, + k, w)) + << k); + } + } + } + } + + sci::convertColToRowMajor<intType>(s1, s3, outpColumnMajor, outp); + for (int i = 0; i < s1 * s3; i++) { + outp[i] = outp[i] & moduloMask; + } + + delete[] choiceBitArr; + delete[] recv_data; + delete[] chunkSizes; + delete[] numChunks; + } + + int chooseOptimalBatchSize(int senderMatmulDims) { + uint64_t temp = + MaxMemToUseInBytes / ((uint64_t)senderMatmulDims * sizeof(intType)); + if (temp > batchSizeOTs) { + temp = batchSizeOTs; + } + return temp; + } + + /* + - matmul where dimensions of matrices are (s1,s2) and (s2,s3) + - inp is input of the sender of size (s1,s2) + - outp is the share of the result of size (s1,s3) + */ + void funcOTSenderInputA(int s1, int s2, int s3, const intType *inp, + intType *outp, sci::OT<otType> *otInstance, + bool inpAlreadyColumnMajor = false) { + intType *inpColumnMajor = const_cast<intType *>(inp); + if (!inpAlreadyColumnMajor) { + inpColumnMajor = new intType[s1 * s2]; + sci::convertRowToColMajor<intType>(s1, s2, inp, inpColumnMajor); + } + intType *outpColumnMajor = new intType[s1 * s3]; + int curBatchSizeOTs = chooseOptimalBatchSize(s1); + + intType *corrData = new intType[curBatchSizeOTs * s1]; + intType *data = new intType[curBatchSizeOTs * s1]; + uint32_t *chunkSizes = new uint32_t[curBatchSizeOTs]; + uint32_t *numChunks = new uint32_t[curBatchSizeOTs]; + + for (int i = 0; i < s1 * s3; i++) { + outpColumnMajor[i] = 0; + } + int numOTs = s2 * s3 * bitlength; + int bitIdxRecv = 0, rowIdxRecv = 0, colIdxRecv = 0; + for (int i = 0; i < numOTs; i += curBatchSizeOTs) { + int j; + for (j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, s3, s2, bitlength, colIdxRecv, + rowIdxRecv, bitIdxRecv); + for (int k = 0; k < s1; k++) { + corrData[(j - i) * s1 + k] = + (((intType)Arr2DIdxColM(inpColumnMajor, s1, s2, k, rowIdxRecv)) + << bitIdxRecv) >> + bitIdxRecv; + } + chunkSizes[j - i] = bitlength - bitIdxRecv; + numChunks[j - i] = s1; + } + otInstance->template send_cot_matmul<intType>(data, corrData, chunkSizes, + numChunks, j - i, s1); + for (int j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, s3, s2, bitlength, colIdxRecv, + rowIdxRecv, bitIdxRecv); + for (int k = 0; k < s1; k++) { + Arr2DIdxColM(outpColumnMajor, s1, s3, k, colIdxRecv) -= + (((intType)Arr2DIdxRowM(data, curBatchSizeOTs, s1, (j - i), k)) + << bitIdxRecv); + } + } + } + + sci::convertColToRowMajor<intType>(s1, s3, outpColumnMajor, outp); + for (int i = 0; i < s1 * s3; i++) { + outp[i] = outp[i] & moduloMask; + } + + if (!inpAlreadyColumnMajor) + delete[] inpColumnMajor; + delete[] outpColumnMajor; + + delete[] corrData; + delete[] data; + delete[] chunkSizes; + delete[] numChunks; + } + + /* + - The matrix multiplication being performed is (s1, s2) * (s2, s3). + - inp is the receiver's array to be multiplied of size (s2, s3) + - outp is the share of the receiver after multiplication of size + (s1,s3) + */ + void funcOTReceiverInputB(int s1, int s2, int s3, const intType *inp, + intType *outp, sci::OT<otType> *otInstance, + bool inpAlreadyColumnMajor = false) { + // copy inp from row to column and outp from column to row major + intType *inpColumnMajor = const_cast<intType *>(inp); + intType *outpColumnMajor = new intType[s1 * s3]; + if (!inpAlreadyColumnMajor) { + inpColumnMajor = new intType[s2 * s3]; + sci::convertRowToColMajor<intType>(s2, s3, inp, inpColumnMajor); + } + uint64_t masks[64]; + for (int i = 0; i < 64; i++) { + masks[i] = 1ULL << i; + } + + int curBatchSizeOTs = chooseOptimalBatchSize(s1); + + intType *data = new intType[curBatchSizeOTs * s1]; + uint8_t *choiceBitArr = new uint8_t[curBatchSizeOTs]; + uint32_t *chunkSizes = new uint32_t[curBatchSizeOTs]; + uint32_t *numChunks = new uint32_t[curBatchSizeOTs]; + + for (int i = 0; i < s1 * s3; i++) { + outpColumnMajor[i] = 0; + } + + int numOTs = s2 * s3 * bitlength; + int bitIdxRecv = 0, rowIdxRecv = 0, colIdxRecv = 0; + for (int i = 0; i < numOTs; i += curBatchSizeOTs) { + int j; + for (j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, s3, s2, bitlength, colIdxRecv, + rowIdxRecv, bitIdxRecv); + choiceBitArr[j - i] = + (Arr2DIdxColM(inpColumnMajor, s2, s3, rowIdxRecv, colIdxRecv) & + masks[bitIdxRecv]) >> + bitIdxRecv; + chunkSizes[j - i] = bitlength - bitIdxRecv; + numChunks[j - i] = s1; + } + otInstance->template recv_cot_matmul<intType>( + data, choiceBitArr, chunkSizes, numChunks, j - i, s1); + for (int j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, s3, s2, bitlength, colIdxRecv, + rowIdxRecv, bitIdxRecv); + for (int k = 0; k < s1; k++) { + Arr2DIdxColM(outpColumnMajor, s1, s3, k, colIdxRecv) += + (((intType)Arr2DIdxRowM(data, curBatchSizeOTs, s1, (j - i), k)) + << bitIdxRecv); + } + } + } + + sci::convertColToRowMajor<intType>(s1, s3, outpColumnMajor, outp); + for (int i = 0; i < s1 * s3; i++) { + outp[i] = outp[i] & moduloMask; + } + + if (!inpAlreadyColumnMajor) + delete[] inpColumnMajor; + delete[] outpColumnMajor; + + delete[] data; + delete[] choiceBitArr; + delete[] chunkSizes; + delete[] numChunks; + } + + /* + - matmul where dimensions of matrices are (s1,s2) and (s2,s3) + - inp is input of the sender of size (s2,s3) + - outp is the share of the result of size (s1,s3) + */ + void funcOTSenderInputB(int s1, int s2, int s3, const intType *inp, + intType *outp, sci::OT<otType> *otInstance) { + int curBatchSizeOTs = chooseOptimalBatchSize(s3); + + intType *corrData = new intType[curBatchSizeOTs * s3]; + intType *data = new intType[curBatchSizeOTs * s3]; + uint32_t *chunkSizes = new uint32_t[curBatchSizeOTs]; + uint32_t *numChunks = new uint32_t[curBatchSizeOTs]; + + for (int i = 0; i < s1 * s3; i++) { + outp[i] = 0; + } + + int numOTs = s1 * s2 * bitlength; + int bitIdxRecv = 0, rowIdxRecv = 0, colIdxRecv = 0; + for (int i = 0; i < numOTs; i += curBatchSizeOTs) { + int j; + for (j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, s1, s2, bitlength, rowIdxRecv, + colIdxRecv, bitIdxRecv); + for (int k = 0; k < s3; k++) { + corrData[(j - i) * s3 + k] = + (((intType)Arr2DIdxRowM(inp, s2, s3, colIdxRecv, k)) + << bitIdxRecv) >> + bitIdxRecv; + } + chunkSizes[j - i] = bitlength - bitIdxRecv; + numChunks[j - i] = s3; + } + otInstance->template send_cot_matmul<intType>(data, corrData, chunkSizes, + numChunks, j - i, s3); + for (int j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, s1, s2, bitlength, rowIdxRecv, + colIdxRecv, bitIdxRecv); + for (int k = 0; k < s3; k++) { + Arr2DIdxRowM(outp, s1, s3, rowIdxRecv, k) -= + (((intType)Arr2DIdxRowM(data, curBatchSizeOTs, s3, (j - i), k)) + << bitIdxRecv); + } + } + } + for (int i = 0; i < s1 * s3; i++) { + outp[i] = outp[i] & moduloMask; + } + + delete[] corrData; + delete[] data; + delete[] chunkSizes; + delete[] numChunks; + } + + /* + - The matrix multiplication being performed is (s1, s2) * (s2, s3). + - inp is the receiver's array to be multiplied of size (s1, s2) + - outp is the share of the receiver after multiplication of size + (s1,s3) + */ + void funcOTReceiverInputA(int s1, int s2, int s3, const intType *inp, + intType *outp, sci::OT<otType> *otInstance) { + uint64_t masks[64]; + for (int i = 0; i < 64; i++) { + masks[i] = 1ULL << i; + } + + int curBatchSizeOTs = chooseOptimalBatchSize(s3); + + intType *data = new intType[curBatchSizeOTs * s3]; + uint8_t *choiceBitArr = new uint8_t[curBatchSizeOTs]; + uint32_t *chunkSizes = new uint32_t[curBatchSizeOTs]; + uint32_t *numChunks = new uint32_t[curBatchSizeOTs]; + + for (int i = 0; i < s1 * s3; i++) { + outp[i] = 0; + } + + int numOTs = s1 * s2 * bitlength; + int bitIdxRecv = 0, rowIdxRecv = 0, colIdxRecv = 0; + for (int i = 0; i < numOTs; i += curBatchSizeOTs) { + int j; + for (j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, s1, s2, bitlength, rowIdxRecv, + colIdxRecv, bitIdxRecv); + choiceBitArr[j - i] = + (Arr2DIdxRowM(inp, s1, s2, rowIdxRecv, colIdxRecv) & + masks[bitIdxRecv]) >> + bitIdxRecv; + chunkSizes[j - i] = bitlength - bitIdxRecv; + numChunks[j - i] = s3; + } + otInstance->template recv_cot_matmul<intType>( + data, choiceBitArr, chunkSizes, numChunks, j - i, s3); + for (int j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, s1, s2, bitlength, rowIdxRecv, + colIdxRecv, bitIdxRecv); + for (int k = 0; k < s3; k++) { + Arr2DIdxRowM(outp, s1, s3, rowIdxRecv, k) += + (((intType)Arr2DIdxRowM(data, curBatchSizeOTs, s3, (j - i), k)) + << bitIdxRecv); + } + } + } + for (int i = 0; i < s1 * s3; i++) { + outp[i] = outp[i] & moduloMask; + } + + delete[] data; + delete[] choiceBitArr; + delete[] chunkSizes; + delete[] numChunks; + } + + /* + - Dot product functionality + - Sender has input 'inp' of size 'size' + */ + void funcDotProdOTSender(int size, const intType *inp, intType *outp, + sci::OT<otType> *otInstance) { + for (int i = 0; i < size; i++) { + outp[i] = 0; + } + int curBatchSizeOTs = batchSizeOTs; + int numOTs = size * bitlength; + intType *curCorrData = new intType[curBatchSizeOTs]; + uint32_t *curChunkSizes = new uint32_t[curBatchSizeOTs]; + uint32_t *curNumChunks = new uint32_t[curBatchSizeOTs]; + intType *curData = new intType[curBatchSizeOTs]; + int bitIdxRecv = 0, cellIdxRecv = 0; + for (int i = 0; i < numOTs; i += curBatchSizeOTs) { + int j; + for (j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, size, bitlength, cellIdxRecv, + bitIdxRecv); + curCorrData[j - i] = + (((intType)inp[cellIdxRecv]) << bitIdxRecv) >> bitIdxRecv; + curChunkSizes[j - i] = bitlength - bitIdxRecv; + curNumChunks[j - i] = 1; + } + otInstance->template send_cot_matmul<intType>( + curData, curCorrData, curChunkSizes, curNumChunks, j - i, size); + for (int j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, size, bitlength, cellIdxRecv, + bitIdxRecv); + outp[cellIdxRecv] -= (((intType)curData[j - i]) << bitIdxRecv); + } + } + for (int i = 0; i < size; i++) { + outp[i] = outp[i] & moduloMask; + } + + delete[] curCorrData; + delete[] curChunkSizes; + delete[] curNumChunks; + delete[] curData; + } + + /* + - Dot product functionality + - Receiver has input 'inp' of size 'size' + */ + void funcDotProdOTReceiver(int size, const intType *inp, intType *outp, + sci::OT<otType> *otInstance) { + uint64_t masks[64]; + for (int i = 0; i < 64; i++) { + masks[i] = 1ULL << i; + } + for (int i = 0; i < size; i++) { + outp[i] = 0; + } + int curBatchSizeOTs = batchSizeOTs; + int numOTs = size * bitlength; + uint8_t *curChoiceBits = new uint8_t[curBatchSizeOTs]; + uint32_t *curNumChunks = new uint32_t[curBatchSizeOTs]; + uint32_t *curChunkSizes = new uint32_t[curBatchSizeOTs]; + intType *curData = new intType[curBatchSizeOTs]; + int bitIdxRecv = 0, cellIdxRecv = 0; + for (int i = 0; i < numOTs; i += curBatchSizeOTs) { + int j; + for (j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, size, bitlength, cellIdxRecv, + bitIdxRecv); + curChoiceBits[j - i] = + (inp[cellIdxRecv] & masks[bitIdxRecv]) >> bitIdxRecv; + curChunkSizes[j - i] = bitlength - bitIdxRecv; + curNumChunks[j - i] = 1; + } + otInstance->template recv_cot_matmul<intType>( + curData, curChoiceBits, curChunkSizes, curNumChunks, j - i, size); + for (int j = i; (j < numOTs) && (j < i + curBatchSizeOTs); j++) { + // current OT# is j + sci::linIdxRowMInverseMapping(j, size, bitlength, cellIdxRecv, + bitIdxRecv); + outp[cellIdxRecv] += (curData[j - i] << bitIdxRecv); + } + } + for (int i = 0; i < size; i++) { + outp[i] = outp[i] & moduloMask; + } + + delete[] curChoiceBits; + delete[] curNumChunks; + delete[] curChunkSizes; + delete[] curData; + } + + /* + This code is unoptimized and not being used anywhere currently. + - Matrix triplet of size (s1,s2)*(s2,s3) + - A_share, B_share, C_share are shares of A,B,C + - shape(A_share) = (s1,s2) + - shape(B_share) = (s2,s3) + - shape(C_share) = (s1,s3) + */ + void generateBeaverMatrixTriplet(int s1, int s2, int s3, sci::PRG128 prg, + intType *A_share, intType *B_share, + intType *C_share) { + assert(otImplRoleReversed != nullptr); + prg.random_data(A_share, s1 * s2 * sizeof(intType)); + prg.random_data(B_share, s2 * s3 * sizeof(intType)); + intType *temp = new intType[s1 * s3]; + if (party == sci::ALICE) { + // The OTs can be done in parallel + funcOTSenderInputA(s1, s2, s3, A_share, C_share, otImpl); + funcOTReceiverInputB(s1, s2, s3, B_share, temp, otImplRoleReversed); + } else if (party == sci::BOB) { + funcOTReceiverInputB(s1, s2, s3, B_share, C_share, otImpl); + funcOTSenderInputA(s1, s2, s3, A_share, temp, otImplRoleReversed); + } else { + assert(false); + } + + sci::elemWiseAdd<intType>(s1 * s3, C_share, temp, C_share); + ideal_func(s1, s2, s3, A_share, B_share, temp); + sci::elemWiseAdd<intType>(s1 * s3, C_share, temp, C_share); + } + + /* + This code is unoptimized and not being used anywhere currently. + - Run the online phase of beaver + - Matrices to be multiplied are of size (s1,s2) and (s2,s3). + - X_share => size = (s1,s2), share of X + - Y_share => size = (s2,s3), share of Y + - Z_share => size = (s1,s3), share of output Z=X*Y + - A_share, B_share, C_share are shares of the beaver triplet (A,B,C) + */ + void runBeaverOnlinePhase(int s1, int s2, int s3, const intType *X_share, + const intType *Y_share, intType *Z_share, + const intType *A_share, const intType *B_share, + const intType *C_share) { + intType *E_share = new intType[s1 * s2]; + intType *F_share = new intType[s2 * s3]; + intType *E_temp_share = new intType[s1 * s2]; + intType *F_temp_share = new intType[s2 * s3]; + intType *Z_temp_share = new intType[s1 * s3]; + sci::elemWiseSub<intType>(s1 * s2, X_share, A_share, E_share); + sci::elemWiseSub<intType>(s2 * s3, Y_share, B_share, F_share); + + if (party == sci::ALICE) { + io->send_data(E_share, sizeof(intType) * s1 * s2); + io->send_data(F_share, sizeof(intType) * s2 * s3); + io->recv_data(E_temp_share, sizeof(intType) * s1 * s2); + io->recv_data(F_temp_share, sizeof(intType) * s2 * s3); + } else if (party == sci::BOB) { + io->recv_data(E_temp_share, sizeof(intType) * s1 * s2); + io->recv_data(F_temp_share, sizeof(intType) * s2 * s3); + io->send_data(E_share, sizeof(intType) * s1 * s2); + io->send_data(F_share, sizeof(intType) * s2 * s3); + } else { + assert(false); + } + + // Add the shares of E and F to get E and F in the clear + sci::elemWiseAdd<intType>(s1 * s2, E_share, E_temp_share, E_share); + sci::elemWiseAdd<intType>(s2 * s3, F_share, F_temp_share, F_share); + + // Now E_share and F_share hold the clear values of E & F + ideal_func(s1, s2, s3, E_share, Y_share, Z_temp_share); + if (party == sci::ALICE) { + ideal_func(s1, s2, s3, X_share, F_share, Z_share); + } else if (party == sci::BOB) { + sci::elemWiseSub<intType>(s1 * s2, X_share, E_share, E_temp_share); + ideal_func(s1, s2, s3, E_temp_share, F_share, Z_share); + } + + sci::elemWiseAdd<intType>(s1 * s3, Z_share, Z_temp_share, Z_share); + sci::elemWiseAdd<intType>(s1 * s3, C_share, Z_share, Z_share); + + delete[] E_share; + delete[] F_share; + delete[] E_temp_share; + delete[] F_temp_share; + delete[] Z_temp_share; + } +}; + +#endif // LINEAR_UNIFORM_H__ diff --git a/SCI/src/Math/CMakeLists.txt b/SCI/src/Math/CMakeLists.txt new file mode 100644 index 00000000..7fd5df02 --- /dev/null +++ b/SCI/src/Math/CMakeLists.txt @@ -0,0 +1,4 @@ +add_library(SCI-Math math-functions.cpp) +target_link_libraries(SCI-Math + PUBLIC SCI-LinearOT SCI-BuildingBlocks +) diff --git a/SCI/src/Math/math-functions.cpp b/SCI/src/Math/math-functions.cpp new file mode 100644 index 00000000..7039ec94 --- /dev/null +++ b/SCI/src/Math/math-functions.cpp @@ -0,0 +1,895 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "Math/math-functions.h" + +using namespace std; +using namespace sci; + +#define KKOT_LIMIT 8 +#define SQRT_LOOKUP_SCALE 2 + +MathFunctions::MathFunctions(int party, NetIO *io, OTPack<NetIO> *otpack) { + this->party = party; + this->io = io; + this->otpack = otpack; + this->aux = new AuxProtocols(party, io, otpack); + this->xt = new XTProtocol(party, io, otpack, aux); + this->trunc = new Truncation(party, io, otpack, aux); + this->mult = new LinearOT(party, io, otpack); +} + +MathFunctions::~MathFunctions() { + delete aux; + delete xt; + delete trunc; + delete mult; +} + +// A0 \in (1/4, 1) +uint64_t lookup_A0(uint64_t index, int m) { + uint64_t k = 1ULL << m; + double p = 1 + (double(index) / double(k)); + double A1 = 1.0 / (p * (p + 1.0 / double(k))); + int32_t scale = m + 3; + uint64_t mask = (1ULL << scale) - 1; + uint64_t val = uint64_t(A1 * (1ULL << scale)) & mask; + return val; +} + +// A1 \in (1/2, 1) +uint64_t lookup_A1(uint64_t index, int m) { + uint64_t k = 1ULL << m; + double p = 1 + (double(index) / double(k)); + double z = (p * (p + (1.0 / double(k)))); + double A1 = ((1.0 / double(k * 2)) + sqrt(z)) / z; + int32_t scale = 2 * m + 2; + uint64_t mask = (1ULL << scale) - 1; + uint64_t val = uint64_t(A1 * (1ULL << scale)) & mask; + return val; +} + +void MathFunctions::reciprocal_approximation(int32_t dim, int32_t m, + uint64_t *dn, uint64_t *out, + int32_t bw_dn, int32_t bw_out, + int32_t s_dn, int32_t s_out) { + assert(bw_out == m + s_dn + 4); + assert(s_out == m + s_dn + 4); + + uint64_t s_dn_mask = (1ULL << s_dn) - 1; + uint64_t m_mask = (1ULL << m) - 1; + uint64_t s_min_m_mask = (1ULL << (s_dn - m)) - 1; + + uint64_t *tmp_1 = new uint64_t[dim]; + uint64_t *tmp_2 = new uint64_t[dim]; + + for (int i = 0; i < dim; i++) { + tmp_1[i] = dn[i] & s_dn_mask; + } + trunc->truncate_and_reduce(dim, tmp_1, tmp_2, s_dn - m, s_dn); + + int M = (1ULL << m); + uint64_t c0_mask = (1ULL << (m + 4)) - 1; + uint64_t c1_mask = (1ULL << (2 * m + 3)) - 1; + uint64_t *c0 = new uint64_t[dim]; + uint64_t *c1 = new uint64_t[dim]; + if (party == ALICE) { + uint64_t **spec; + spec = new uint64_t *[dim]; + PRG128 prg; + prg.random_data(c0, dim * sizeof(uint64_t)); + prg.random_data(c1, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + spec[i] = new uint64_t[M]; + c0[i] &= c0_mask; + c1[i] &= c1_mask; + for (int j = 0; j < M; j++) { + int idx = (tmp_2[i] + j) & m_mask; + spec[i][j] = (lookup_A0(idx, m) - c0[i]) & c0_mask; + spec[i][j] <<= (2 * m + 3); + spec[i][j] |= (lookup_A1(idx, m) - c1[i]) & c1_mask; + } + } + aux->lookup_table<uint64_t>(spec, nullptr, nullptr, dim, m, 3 * m + 7); + + for (int i = 0; i < dim; i++) + delete[] spec[i]; + delete[] spec; + } else { + aux->lookup_table<uint64_t>(nullptr, tmp_2, c1, dim, m, 3 * m + 7); + + for (int i = 0; i < dim; i++) { + c0[i] = (c1[i] >> (2 * m + 3)) & c0_mask; + c1[i] = c1[i] & c1_mask; + } + } + for (int i = 0; i < dim; i++) { + tmp_1[i] = dn[i] & s_min_m_mask; + } + uint8_t *zero_shares = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + zero_shares[i] = 0; + } + + // Unsigned mult + mult->hadamard_product(dim, c0, tmp_1, tmp_2, m + 4, s_dn - m, s_dn + 4, + false, false, MultMode::None, zero_shares, nullptr); + + xt->z_extend(dim, tmp_2, tmp_1, s_dn + 4, s_dn + m + 4, zero_shares); + + uint64_t out_mask = (1ULL << (s_dn + m + 4)) - 1; + uint64_t scale_up = (1ULL << (s_dn - m + 1)); + for (int i = 0; i < dim; i++) { + out[i] = ((c1[i] * scale_up) - tmp_1[i]) & out_mask; + } + + delete[] tmp_1; + delete[] tmp_2; + delete[] c0; + delete[] c1; + delete[] zero_shares; +} + +void MathFunctions::div(int32_t dim, uint64_t *nm, uint64_t *dn, uint64_t *out, + int32_t bw_nm, int32_t bw_dn, int32_t bw_out, + int32_t s_nm, int32_t s_dn, int32_t s_out, + bool signed_nm, bool compute_msnzb) { + assert(s_out <= s_dn); + + // out_precision = iters * (2*m + 2) + int32_t m, iters; + m = (s_out <= 18 ? ceil((s_out - 2) / 2.0) + : ceil((ceil(s_out / 2.0) - 2) / 2.0)); + iters = (s_out <= 18 ? 0 : 1); + + int32_t s_tmp_dn; + int32_t bw_adjust; + int32_t s_adjust; + uint64_t *tmp_dn; + uint64_t *adjust; + if (compute_msnzb) { + s_tmp_dn = bw_dn - 1; + bw_adjust = bw_dn + 1; + s_adjust = bw_dn - 1 - s_dn; + uint64_t mask_adjust = (bw_adjust == 64 ? -1 : ((1ULL << bw_adjust) - 1)); + // MSB is always 0, thus, not including it + uint8_t *msnzb_vector_bool = new uint8_t[dim * bw_dn]; + uint64_t *msnzb_vector = new uint64_t[dim * bw_dn]; + aux->msnzb_one_hot(dn, msnzb_vector_bool, bw_dn, dim); + aux->B2A(msnzb_vector_bool, msnzb_vector, dim * bw_dn, bw_adjust); + // adjust: bw = bw_dn, scale = bw_dn - 1 - s_dn + adjust = new uint64_t[dim]; + for (int i = 0; i < dim; i++) { + adjust[i] = 0; + for (int j = 0; j < bw_dn; j++) { + adjust[i] += (1ULL << (bw_dn - 1 - j)) * msnzb_vector[i * bw_dn + j]; + } + adjust[i] &= mask_adjust; + } + // tmp_dn: bw = bw_dn, scale = bw_dn - 1 + tmp_dn = new uint64_t[dim]; + mult->hadamard_product(dim, dn, adjust, tmp_dn, bw_dn, bw_dn + 1, bw_dn + 1, + false, false, MultMode::None); + + delete[] msnzb_vector_bool; + delete[] msnzb_vector; + } else { + // tmp_dn: bw = s_dn + 1, scale = s_dn + s_tmp_dn = s_dn; + tmp_dn = dn; + } + + uint64_t *tmp_1 = new uint64_t[dim]; + uint64_t *tmp_2 = new uint64_t[dim]; + // tmp_1: bw = s_tmp_dn + m + 4, scale = s_tmp_dn + m + 3 + reciprocal_approximation(dim, m, tmp_dn, tmp_1, bw_dn, s_tmp_dn + m + 4, + s_tmp_dn, s_tmp_dn + m + 4); + + uint64_t *w0 = new uint64_t[dim]; + // w0: bw = s_out + 1, scale = s_out + trunc->truncate_and_reduce(dim, tmp_1, w0, s_tmp_dn + m + 3 - s_out, + s_tmp_dn + m + 4); + + uint8_t *msb_nm = new uint8_t[dim]; + aux->MSB(nm, msb_nm, dim, bw_nm); + uint8_t *zero_shares = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + zero_shares[i] = 0; + } + + // a0: bw = bw_out, scale = s_out + uint64_t *a0 = new uint64_t[dim]; + // Mixed mult with w0 unsigned + mult->hadamard_product(dim, nm, w0, tmp_1, bw_nm, s_out + 1, s_out + bw_nm, + signed_nm, false, MultMode::None, msb_nm, zero_shares); + trunc->truncate_and_reduce(dim, tmp_1, tmp_2, s_nm, s_out + bw_nm); + if ((bw_nm - s_nm) >= (bw_out - s_out)) { + aux->reduce(dim, tmp_2, a0, bw_nm - s_nm + s_out, bw_out); + } else { + if (signed_nm) { + xt->s_extend(dim, tmp_2, a0, s_out + bw_nm - s_nm, bw_out, msb_nm); + } else { + xt->z_extend(dim, tmp_2, a0, s_out + bw_nm - s_nm, bw_out, nullptr); + } + } + + if (compute_msnzb) { + int32_t bw_tmp1 = + (bw_out + s_adjust < bw_adjust ? bw_adjust : bw_out + s_adjust); + // tmp_1: bw = bw_tmp1, scale = s_out + s_adjust + mult->hadamard_product(dim, a0, adjust, tmp_1, bw_out, bw_adjust, bw_tmp1, + signed_nm, false, MultMode::None, + (signed_nm ? msb_nm : nullptr), zero_shares); + // a0: bw = bw_out, scale = s_out + trunc->truncate_and_reduce(dim, tmp_1, a0, s_adjust, bw_out + s_adjust); + } + + // tmp_1: bw = s_tmp_dn + 2, scale = s_tmp_dn + uint64_t s_plus_2_mask = (1ULL << (s_tmp_dn + 2)) - 1; + for (int i = 0; i < dim; i++) { + tmp_1[i] = tmp_dn[i] & s_plus_2_mask; + } + + if (iters > 0) { + // d0: bw = s_out + 2, scale = s_out + uint64_t *d0 = new uint64_t[dim]; + mult->hadamard_product(dim, w0, tmp_1, tmp_2, s_out + 1, s_tmp_dn + 2, + s_out + s_tmp_dn + 2, false, false, MultMode::None, + zero_shares, zero_shares); + trunc->truncate_and_reduce(dim, tmp_2, d0, s_tmp_dn, s_out + s_tmp_dn + 2); + + // e0: bw = s_out + 2, scale = s_out + // e0 = 1 - d0 + uint64_t *e0 = new uint64_t[dim]; + for (int i = 0; i < dim; i++) { + e0[i] = (party == ALICE ? (1ULL << (s_out)) : 0) - d0[i]; + } + + uint64_t e_mask = (1ULL << (s_out + 2)) - 1; + uint64_t *a_curr = new uint64_t[dim]; + uint64_t *e_curr = new uint64_t[dim]; + uint64_t *a_prev = a0; + uint64_t *e_prev = e0; + for (int i = 0; i < iters - 1; i++) { + // tmp_1: bw = 2*s_out+2, scale: 2*s_out + mult->hadamard_product(dim, e_prev, e_prev, tmp_1, s_out + 2, s_out + 2, + 2 * s_out + 2, true, true, MultMode::None, + zero_shares, zero_shares); + // e_curr: bw = s_out + 2, scale: s_out + trunc->truncate_and_reduce(dim, tmp_1, e_curr, s_out, 2 * s_out + 2); + // e_prev = 1 + e_prev + for (int j = 0; j < dim; j++) { + e_prev[j] = + ((party == ALICE ? (1ULL << (s_out)) : 0) + e_prev[j]) & e_mask; + } + // tmp_1: bw = bw_out + s_out, scale: 2*s_out + mult->hadamard_product(dim, a_prev, e_prev, tmp_1, bw_out, s_out + 2, + bw_out + s_out, signed_nm, true, MultMode::None, + (signed_nm ? msb_nm : nullptr), zero_shares); + // a_curr: bw = bw_out, scale: s_out + trunc->truncate_and_reduce(dim, tmp_1, a_curr, s_out, bw_out + s_out); + memcpy(a_prev, a_curr, dim * sizeof(uint64_t)); + memcpy(e_prev, e_curr, dim * sizeof(uint64_t)); + } + // e_prev = 1 + e_prev + for (int j = 0; j < dim; j++) { + e_prev[j] = + ((party == ALICE ? (1ULL << (s_out)) : 0) + e_prev[j]) & e_mask; + } + // out: bw = bw_out, scale: s_out + // Mixed mult with e_prev unsigned + mult->hadamard_product(dim, a_prev, e_prev, tmp_1, bw_out, s_out + 2, + bw_out + s_out, signed_nm, false, MultMode::None, + (signed_nm ? msb_nm : nullptr), zero_shares); + trunc->truncate_and_reduce(dim, tmp_1, out, s_out, bw_out + s_out); + + delete[] d0; + delete[] e0; + delete[] a_curr; + delete[] e_curr; + } else { + memcpy(out, a0, dim * sizeof(uint64_t)); + } + + delete[] tmp_1; + delete[] tmp_2; + delete[] w0; + delete[] a0; + delete[] msb_nm; + delete[] zero_shares; + if (compute_msnzb) { + delete[] tmp_dn; + delete[] adjust; + } +} + +void MathFunctions::taylor_series_exp(int32_t dim, uint64_t *x, uint64_t *y, + int32_t bw_x, int32_t bw_y, int32_t s_x, + int32_t s_y) { + return; +} + +uint64_t lookup_neg_exp(uint64_t val_in, int32_t s_in, int32_t s_out) { + if (s_in < 0) { + s_in *= -1; + val_in *= (1ULL << (s_in)); + s_in = 0; + } + uint64_t res_val = + exp(-1.0 * (val_in / double(1ULL << s_in))) * (1ULL << s_out); + return res_val; +} + +void MathFunctions::lookup_table_exp(int32_t dim, uint64_t *x, uint64_t *y, + int32_t bw_x, int32_t bw_y, int32_t s_x, + int32_t s_y) { + assert(bw_y >= (s_y + 2)); + + int LUT_size = KKOT_LIMIT; + + uint64_t bw_x_mask = (bw_x == 64 ? -1 : (1ULL << bw_x) - 1); + uint64_t LUT_out_mask = ((s_y + 2) == 64 ? -1 : (1ULL << (s_y + 2)) - 1); + + uint64_t *tmp_1 = new uint64_t[dim]; + for (int i = 0; i < dim; i++) { + tmp_1[i] = (-1 * x[i]) & bw_x_mask; + } + int digit_size = LUT_size; + int num_digits = ceil(double(bw_x) / digit_size); + int last_digit_size = bw_x - (num_digits - 1) * digit_size; + uint64_t *x_digits = new uint64_t[num_digits * dim]; + + aux->digit_decomposition_sci(dim, tmp_1, x_digits, bw_x, digit_size); + + uint64_t digit_mask = (digit_size == 64 ? -1 : (1ULL << digit_size) - 1); + uint64_t last_digit_mask = + (last_digit_size == 64 ? -1 : (1ULL << last_digit_size) - 1); + int N = (1ULL << digit_size); + int last_N = (1ULL << last_digit_size); + int N_digits = (digit_size == last_digit_size ? num_digits : num_digits - 1); + uint64_t *digits_exp = new uint64_t[num_digits * dim]; + if (party == ALICE) { + uint64_t **spec; + spec = new uint64_t *[num_digits * dim]; + PRG128 prg; + prg.random_data(digits_exp, num_digits * dim * sizeof(uint64_t)); + for (int i = 0; i < N_digits * dim; i++) { + int digit_idx = i / dim; + spec[i] = new uint64_t[N]; + digits_exp[i] &= LUT_out_mask; + for (int j = 0; j < N; j++) { + int idx = (x_digits[i] + j) & digit_mask; + spec[i][j] = (lookup_neg_exp(idx, s_x - digit_size * digit_idx, s_y) - + digits_exp[i]) & + LUT_out_mask; + } + } + aux->lookup_table<uint64_t>(spec, nullptr, nullptr, N_digits * dim, + digit_size, s_y + 2); + + if (digit_size != last_digit_size) { + int offset = N_digits * dim; + int digit_idx = N_digits; + for (int i = offset; i < num_digits * dim; i++) { + spec[i] = new uint64_t[last_N]; + digits_exp[i] &= LUT_out_mask; + for (int j = 0; j < last_N; j++) { + int idx = (x_digits[i] + j) & last_digit_mask; + spec[i][j] = (lookup_neg_exp(idx, s_x - digit_size * digit_idx, s_y) - + digits_exp[i]) & + LUT_out_mask; + } + } + aux->lookup_table<uint64_t>(spec + offset, nullptr, nullptr, dim, + last_digit_size, s_y + 2); + } + + for (int i = 0; i < num_digits * dim; i++) + delete[] spec[i]; + delete[] spec; + } else { + aux->lookup_table<uint64_t>(nullptr, x_digits, digits_exp, N_digits * dim, + digit_size, s_y + 2); + if (digit_size != last_digit_size) { + int offset = N_digits * dim; + aux->lookup_table<uint64_t>(nullptr, x_digits + offset, + digits_exp + offset, dim, last_digit_size, + s_y + 2); + } + for (int i = 0; i < num_digits * dim; i++) { + digits_exp[i] &= LUT_out_mask; + } + } + + uint8_t *zero_shares = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + zero_shares[i] = 0; + } + for (int i = 1; i < num_digits; i *= 2) { + for (int j = 0; j < num_digits and j + i < num_digits; j += 2 * i) { + mult->hadamard_product(dim, digits_exp + j * dim, + digits_exp + (j + i) * dim, digits_exp + j * dim, + s_y + 2, s_y + 2, 2 * s_y + 2, false, false, + MultMode::None, zero_shares, zero_shares); + trunc->truncate_and_reduce(dim, digits_exp + j * dim, + digits_exp + j * dim, s_y, 2 * s_y + 2); + } + } + xt->z_extend(dim, digits_exp, y, s_y + 2, bw_y, zero_shares); + + delete[] x_digits; + delete[] tmp_1; + delete[] digits_exp; + delete[] zero_shares; +} + +void MathFunctions::sigmoid(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + int32_t bw_y, int32_t s_x, int32_t s_y) { + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + uint64_t mask_exp_out = ((s_y + 2) == 64 ? -1 : ((1ULL << (s_y + 2)) - 1)); + uint64_t mask_den = ((s_y + 2) == 64 ? -1 : ((1ULL << (s_y + 2)) - 1)); + uint8_t *zero_shares = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + zero_shares[i] = 0; + } + + uint8_t *msb_x = new uint8_t[dim]; + aux->MSB(x, msb_x, dim, bw_x); + + // neg_x = -x + msb_x * (2x) (neg_x is always negative) + uint64_t *tmp_1 = new uint64_t[dim]; + uint64_t *tmp_2 = new uint64_t[dim]; + for (int i = 0; i < dim; i++) { + tmp_1[i] = (-1 * x[i]) & mask_x; + tmp_2[i] = (2 * x[i]) & mask_x; + } + uint64_t *neg_x = new uint64_t[dim]; + aux->multiplexer(msb_x, tmp_2, neg_x, dim, bw_x, bw_x); + for (int i = 0; i < dim; i++) { + neg_x[i] = (neg_x[i] + tmp_1[i]) & mask_x; + } + + // den = tmp_1 = 1 + exp_neg_x + uint64_t *exp_neg_x = new uint64_t[dim]; + lookup_table_exp(dim, neg_x, exp_neg_x, bw_x, s_y + 2, s_x, s_y); + for (int i = 0; i < dim; i++) { + tmp_1[i] = + ((party == ALICE ? (1ULL << s_y) : 0) + exp_neg_x[i]) & mask_exp_out; + } + // den can't be 2^{s_y+1}, so 1 is subtracted if msb_den is 1 + uint8_t *msb_den = new uint8_t[dim]; + aux->MSB(tmp_1, msb_den, dim, s_y + 2); + aux->B2A(msb_den, tmp_2, dim, s_y + 2); + // den = tmp_1 = den - msb_den + // tmp_2 = 1 (all 1 vector) + for (int i = 0; i < dim; i++) { + tmp_1[i] = (tmp_1[i] - tmp_2[i]) & mask_den; + tmp_2[i] = (party == ALICE ? 1 : 0); + } + uint64_t *sig_neg_x = new uint64_t[dim]; + // sig_neg_x = 1/(1 + exp_neg_x) + div(dim, tmp_2, tmp_1, sig_neg_x, 2, s_y + 2, s_y + 2, 0, s_y, s_y, true, + false); + + // tmp_2 = num = 1 + msb_x * (exp_neg_x - 1) + for (int i = 0; i < dim; i++) { + tmp_1[i] = (exp_neg_x[i] - (party == ALICE ? 1ULL << s_y : 0)) & mask_den; + } + aux->multiplexer(msb_x, tmp_1, tmp_2, dim, s_y + 2, s_y + 2); + for (int i = 0; i < dim; i++) { + tmp_2[i] = (tmp_2[i] + (party == ALICE ? 1ULL << s_y : 0)) & mask_den; + } + + mult->hadamard_product(dim, tmp_2, sig_neg_x, tmp_1, s_y + 2, s_y + 2, + 2 * s_y + 2, false, false, MultMode::None, zero_shares, + zero_shares); + trunc->truncate_and_reduce(dim, tmp_1, tmp_2, s_y, 2 * s_y + 2); + + if (bw_y <= (s_y + 2)) { + for (int i = 0; i < dim; i++) { + y[i] = tmp_2[i] & mask_y; + } + } else { + xt->z_extend(dim, tmp_2, y, s_y + 2, bw_y, zero_shares); + } + + delete[] msb_x; + delete[] tmp_1; + delete[] tmp_2; + delete[] neg_x; + delete[] exp_neg_x; + delete[] msb_den; + delete[] sig_neg_x; +} + +void MathFunctions::tanh(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + int32_t bw_y, int32_t s_x, int32_t s_y) { + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + uint64_t mask_exp_out = ((s_y + 3) == 64 ? -1 : ((1ULL << (s_y + 3)) - 1)); + uint64_t mask_den = ((s_y + 2) == 64 ? -1 : ((1ULL << (s_y + 2)) - 1)); + + uint8_t *msb_x = new uint8_t[dim]; + aux->MSB(x, msb_x, dim, bw_x); + + // neg_x = -x + msb_x * (2x) (neg_x is always negative) + uint64_t *tmp_1 = new uint64_t[dim]; + uint64_t *tmp_2 = new uint64_t[dim]; + for (int i = 0; i < dim; i++) { + tmp_1[i] = (-1 * x[i]) & mask_x; + tmp_2[i] = (2 * x[i]) & mask_x; + } + uint64_t *neg_x = new uint64_t[dim]; + aux->multiplexer(msb_x, tmp_2, neg_x, dim, bw_x, bw_x); + for (int i = 0; i < dim; i++) { + neg_x[i] = (neg_x[i] + tmp_1[i]) & mask_x; + } + + uint64_t *exp_neg_2x = new uint64_t[dim]; + // scale of neg_x is reduced by 1 instead of mulitplying it with 2 to get + // neg_2x + lookup_table_exp(dim, neg_x, exp_neg_2x, bw_x, s_y + 2, s_x - 1, s_y); + // den = tmp_1 = 1 + exp_neg_2x + for (int i = 0; i < dim; i++) { + tmp_1[i] = + ((party == ALICE ? (1ULL << s_y) : 0) + exp_neg_2x[i]) & mask_exp_out; + } + // den can't be 2^{s_y+1}, so 1 is subtracted if msb_den is 1 + uint8_t *msb_den = new uint8_t[dim]; + aux->MSB(tmp_1, msb_den, dim, s_y + 2); + aux->B2A(msb_den, tmp_2, dim, s_y + 2); + // den = tmp_1 = den - msb_den + // num = tmp_2 = 1 - exp_neg_2x + for (int i = 0; i < dim; i++) { + tmp_1[i] = (tmp_1[i] - tmp_2[i]) & mask_den; + tmp_2[i] = + ((party == ALICE ? (1ULL << s_y) : 0) - exp_neg_2x[i]) & mask_den; + } + uint64_t *tanh_neg_x = new uint64_t[dim]; + // tanh_neg_x = (1 - exp_neg_2x)/(1 + exp_neg_2x) + div(dim, tmp_2, tmp_1, tanh_neg_x, s_y + 2, s_y + 2, s_y + 2, s_y, s_y, s_y, + true, false); + + // tmp_2 = tanh_neg_x + msb_x * (-2 * tanh_neg_x) + // tmp_1 = -2 * tanh_neg_x + for (int i = 0; i < dim; i++) { + tmp_1[i] = (-2 * tanh_neg_x[i]) & mask_exp_out; + } + aux->multiplexer(msb_x, tmp_1, tmp_2, dim, s_y + 2, s_y + 2); + for (int i = 0; i < dim; i++) { + tmp_2[i] = (tmp_2[i] + tanh_neg_x[i]) & mask_exp_out; + } + + if (bw_y <= (s_y + 2)) { + for (int i = 0; i < dim; i++) { + y[i] = tmp_2[i] & mask_y; + } + } else { + xt->s_extend(dim, tmp_2, y, s_y + 2, bw_y, msb_x); + } + + delete[] msb_x; + delete[] tmp_1; + delete[] tmp_2; + delete[] neg_x; + delete[] exp_neg_2x; + delete[] msb_den; + delete[] tanh_neg_x; +} + +uint64_t lookup_sqrt(int32_t index, int32_t m, int32_t exp_parity) { + int32_t k = 1 << m; + double u = (1.0 + (double(index) / double(k))) * (1 << exp_parity); + double Y = 1.0 / sqrt(u); + int32_t scale = m + SQRT_LOOKUP_SCALE; + uint64_t val = (Y * (1ULL << scale)); + return val; +} + +void MathFunctions::sqrt(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + int32_t bw_y, int32_t s_x, int32_t s_y, bool inverse) { + int32_t m, iters; + if (s_y <= 14) { + m = ceil(s_y / 2.0); + iters = 1; + } else { + m = ceil((ceil(s_y / 2.0)) / 2.0); + iters = 2; + } + assert(m <= KKOT_LIMIT); + int32_t bw_adjust = bw_x - 1; + uint64_t mask_adjust = (bw_adjust == 64 ? -1 : ((1ULL << bw_adjust) - 1)); + // MSB is always 0, thus, not including it + uint8_t *msnzb_vector_bool = new uint8_t[dim * (bw_x - 1)]; + uint64_t *msnzb_vector = new uint64_t[dim * (bw_x - 1)]; + aux->msnzb_one_hot(x, msnzb_vector_bool, bw_x - 1, dim); + aux->B2A(msnzb_vector_bool, msnzb_vector, dim * (bw_x - 1), bw_x - 1); + uint64_t *adjust = new uint64_t[dim]; + uint8_t *exp_parity = new uint8_t[dim]; + for (int i = 0; i < dim; i++) { + adjust[i] = 0; + exp_parity[i] = 0; + for (int j = 0; j < (bw_x - 1); j++) { + adjust[i] += (1ULL << (bw_x - 2 - j)) * msnzb_vector[i * (bw_x - 1) + j]; + if (((j - s_x) & 1)) { + exp_parity[i] ^= msnzb_vector_bool[i * (bw_x - 1) + j]; + } + } + adjust[i] &= mask_adjust; + } + // adjusted_x: bw = bw_x - 1, scale = bw_x - 2 + uint64_t *adjusted_x = new uint64_t[dim]; + mult->hadamard_product(dim, x, adjust, adjusted_x, bw_x - 1, bw_x - 1, + bw_x - 1, false, false, MultMode::None); + // Top m bits of adjusted_x excluding MSB, which is always 1 + // adjusted_x_m: bw = m, scale = m + uint64_t *adjusted_x_m = new uint64_t[dim]; + trunc->truncate_and_reduce(dim, adjusted_x, adjusted_x_m, bw_x - m - 2, + bw_x - 2); + + // m + 1 bits will be input to the lookup table + int32_t M = (1LL << (m + 1)); + uint64_t Y_mask = (1ULL << (m + SQRT_LOOKUP_SCALE + 1)) - 1; + uint64_t m_mask = (1ULL << m) - 1; + // Y: bw = m + SQRT_LOOKUP_SCALE + 1, scale = m + SQRT_LOOKUP_SCALE + uint64_t *Y = new uint64_t[dim]; + if (party == ALICE) { + uint64_t **spec; + spec = new uint64_t *[dim]; + PRG128 prg; + prg.random_data(Y, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + spec[i] = new uint64_t[M]; + Y[i] &= Y_mask; + for (int j = 0; j < M; j++) { + // j = exp_parity || (adjusted_x_m) (LSB -> MSB) + int32_t idx = (adjusted_x_m[i] + (j >> 1)) & m_mask; + int32_t exp_parity_val = (exp_parity[i] ^ (j & 1)); + spec[i][j] = (lookup_sqrt(idx, m, exp_parity_val) - Y[i]) & Y_mask; + } + } + aux->lookup_table<uint64_t>(spec, nullptr, nullptr, dim, m + 1, + m + SQRT_LOOKUP_SCALE + 1); + + for (int i = 0; i < dim; i++) + delete[] spec[i]; + delete[] spec; + } else { + // lut_in = exp_parity || adjusted_x_m + uint64_t *lut_in = new uint64_t[dim]; + for (int i = 0; i < dim; i++) { + lut_in[i] = ((adjusted_x_m[i] & m_mask) << 1) | (exp_parity[i] & 1); + } + aux->lookup_table<uint64_t>(nullptr, lut_in, Y, dim, m + 1, + m + SQRT_LOOKUP_SCALE + 1); + + delete[] lut_in; + } + // X = (exp_parity ? 2 * adjusted_x : adjusted_x); scale = bw_x - 2 + // X: bw = bw_x + uint64_t *X = new uint64_t[dim]; + uint64_t *tmp_1 = new uint64_t[dim]; + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + xt->z_extend(dim, adjusted_x, X, bw_x - 1, bw_x); + aux->multiplexer(exp_parity, X, tmp_1, dim, bw_x, bw_x); + for (int i = 0; i < dim; i++) { + X[i] = (X[i] + tmp_1[i]) & mask_x; + } + + uint64_t *x_prev = new uint64_t[dim]; + if (inverse) { + // x_prev : bw = m + SQRT_LOOKUP_SCALE + 1, scale = m + SQRT_LOOKUP_SCALE + // x_prev \approx 0.5 < 1/sqrt(X) < 1 + memcpy(x_prev, Y, dim * sizeof(uint64_t)); + } else { + // x_prev : bw = s_y + 1, scale = s_y + // x_prev \approx 1 < sqrt(X) < 2 + mult->hadamard_product(dim, X, Y, tmp_1, bw_x, m + SQRT_LOOKUP_SCALE + 1, + bw_x - 1 + m + SQRT_LOOKUP_SCALE, false, false, + MultMode::None); + assert((bw_x - 2 + m + SQRT_LOOKUP_SCALE) >= s_y); + trunc->truncate_and_reduce(dim, tmp_1, x_prev, + bw_x - 2 + m + SQRT_LOOKUP_SCALE - s_y, + bw_x - 1 + m + SQRT_LOOKUP_SCALE); + } + // b_prev: bw = s_y + 2, scale = s_y + uint64_t *b_prev = new uint64_t[dim]; + assert((bw_x - 2) >= s_y); + trunc->truncate_and_reduce(dim, X, b_prev, bw_x - 2 - s_y, bw_x); + // Y_prev: bw = m + SQRT_LOOKUP_SCALE + 1, scale = m + SQRT_LOOKUP_SCALE + uint64_t *Y_prev = new uint64_t[dim]; + memcpy(Y_prev, Y, dim * sizeof(uint64_t)); + + uint64_t b_mask = (1ULL << (s_y + 2)) - 1; + uint64_t *x_curr = new uint64_t[dim]; + uint64_t *b_curr = new uint64_t[dim]; + uint64_t *Y_curr = new uint64_t[dim]; + uint64_t *Y_sq = new uint64_t[dim]; + for (int i = 0; i < iters; i++) { + if (i == 0) { + // Y_sq: bw = 2m + 2SQRT_LOOKUP_SCALE + 1, scale = 2m + 2SQRT_LOOKUP_SCALE + mult->hadamard_product( + dim, Y_prev, Y_prev, Y_sq, m + SQRT_LOOKUP_SCALE + 1, + m + SQRT_LOOKUP_SCALE + 1, 2 * m + 2 * SQRT_LOOKUP_SCALE + 1, false, + false, MultMode::None); + // tmp_1: bw = 2m+2SQRT_LOOKUP_SCALE+s_y+2, scale = + // 2m+2SQRT_LOOKUP_SCALE+s_y + mult->hadamard_product(dim, Y_sq, b_prev, tmp_1, + 2 * m + 2 * SQRT_LOOKUP_SCALE + 1, s_y + 2, + 2 * m + 2 * SQRT_LOOKUP_SCALE + s_y + 2, false, + false, MultMode::None); + // b_curr: bw = s_y + 2, scale = s_y + trunc->truncate_and_reduce(dim, tmp_1, b_curr, + 2 * m + 2 * SQRT_LOOKUP_SCALE, + 2 * m + 2 * SQRT_LOOKUP_SCALE + s_y + 2); + } else { + // tmp_1: bw = 2*s_y + 3, scale = 2*s_y + 2 + mult->hadamard_product(dim, Y_prev, Y_prev, tmp_1, s_y + 2, s_y + 2, + 2 * s_y + 3, false, false, MultMode::None); + // Y_sq: bw = s_y + 1, scale = s_y + trunc->truncate_and_reduce(dim, tmp_1, Y_sq, s_y + 2, 2 * s_y + 3); + // tmp_1: bw = 2s_y + 2, scale = 2s_y + mult->hadamard_product(dim, Y_sq, b_prev, tmp_1, s_y + 1, s_y + 2, + 2 * s_y + 2, false, false, MultMode::None); + // b_curr: bw = s_y + 2, scale = s_y + trunc->truncate_and_reduce(dim, tmp_1, b_curr, s_y, 2 * s_y + 2); + } + for (int j = 0; j < dim; j++) { + // Y_curr: bw = s_y + 2, scale = s_y + 1 + // Y_curr = (3 - b_curr)/2 + Y_curr[j] = ((party == ALICE ? (3ULL << s_y) : 0) - b_curr[j]) & b_mask; + } + if (inverse && (i == 0)) { + // tmp_1: bw = s_y+m+SQRT_LOOKUP_SCALE+2, scale = + // s_y+m+SQRT_LOOKUP_SCALE+1 + mult->hadamard_product( + dim, x_prev, Y_curr, tmp_1, m + SQRT_LOOKUP_SCALE + 1, s_y + 2, + s_y + m + SQRT_LOOKUP_SCALE + 2, false, false, MultMode::None); + // x_curr: bw = s_y + 1, scale = s_y + trunc->truncate_and_reduce(dim, tmp_1, x_curr, m + SQRT_LOOKUP_SCALE + 1, + s_y + m + SQRT_LOOKUP_SCALE + 2); + } else { + // tmp_1: bw = 2*s_y + 2, scale = 2s_y + 1 + mult->hadamard_product(dim, x_prev, Y_curr, tmp_1, s_y + 1, s_y + 2, + 2 * s_y + 2, false, false, MultMode::None); + // x_curr: bw = s_y + 1, scale = s_y + trunc->truncate_and_reduce(dim, tmp_1, x_curr, s_y + 1, 2 * s_y + 2); + } + memcpy(x_prev, x_curr, dim * sizeof(uint64_t)); + memcpy(b_prev, b_curr, dim * sizeof(uint64_t)); + memcpy(Y_prev, Y_curr, dim * sizeof(uint64_t)); + } + + int32_t bw_sqrt_adjust = bw_x / 2; + uint64_t mask_sqrt_adjust = + (bw_sqrt_adjust == 64 ? -1 : ((1ULL << bw_sqrt_adjust) - 1)); + uint64_t *sqrt_adjust = new uint64_t[dim]; + int32_t sqrt_adjust_scale = + (inverse ? floor((bw_x - 1 - s_x) / 2.0) : floor((s_x + 1) / 2.0)); + for (int i = 0; i < dim; i++) { + sqrt_adjust[i] = 0; + for (int j = 0; j < (bw_x - 1); j++) { + if (inverse) { + sqrt_adjust[i] += + (1ULL << int(floor((s_x - j + 1) / 2.0) + sqrt_adjust_scale)) * + msnzb_vector[i * (bw_x - 1) + j]; + } else { + sqrt_adjust[i] += + (1ULL << int(floor((j - s_x) / 2.0) + sqrt_adjust_scale)) * + msnzb_vector[i * (bw_x - 1) + j]; + } + } + sqrt_adjust[i] &= mask_sqrt_adjust; + } + if (iters > 0 || (!inverse)) { + // tmp_1: bw = s_y + 1 + bw_sqrt_adjust, scale = s_y + sqrt_adjust_scale + mult->hadamard_product(dim, x_prev, sqrt_adjust, tmp_1, s_y + 1, + bw_sqrt_adjust, s_y + 1 + bw_sqrt_adjust, false, + false, MultMode::None); + // x_curr: bw = s_y + floor(bw_x/2) + 1 - ceil(s_x/2), scale = s_y + trunc->truncate_and_reduce(dim, tmp_1, x_prev, sqrt_adjust_scale, + s_y + 1 + bw_sqrt_adjust); + if (bw_y > (s_y + 1 + bw_sqrt_adjust - sqrt_adjust_scale)) { + xt->z_extend(dim, x_prev, y, s_y + 1 + bw_sqrt_adjust - sqrt_adjust_scale, + bw_y); + } else { + aux->reduce(dim, x_prev, y, s_y + 1 + bw_sqrt_adjust - sqrt_adjust_scale, + bw_y); + } + } else { + // tmp_1: bw = m + SQRT_LOOKUP_SCALE + 1 + bw_sqrt_adjust, + // scale = m + SQRT_LOOKUP_SCALE + sqrt_adjust_scale + mult->hadamard_product(dim, x_prev, sqrt_adjust, tmp_1, + m + SQRT_LOOKUP_SCALE + 1, bw_sqrt_adjust, + m + SQRT_LOOKUP_SCALE + 1 + bw_sqrt_adjust, false, + false, MultMode::None); + // x_curr: bw = m + floor(bw_x/2) + 1 - ceil(s_x/2), scale = m + // If iters == 0, we know s_y = m + trunc->truncate_and_reduce(dim, tmp_1, x_prev, + sqrt_adjust_scale + SQRT_LOOKUP_SCALE, + m + SQRT_LOOKUP_SCALE + 1 + bw_sqrt_adjust); + if (bw_y > (m + 1 + bw_sqrt_adjust - sqrt_adjust_scale)) { + xt->z_extend(dim, x_prev, y, m + 1 + bw_sqrt_adjust - sqrt_adjust_scale, + bw_y); + } else { + aux->reduce(dim, x_prev, y, m + 1 + bw_sqrt_adjust - sqrt_adjust_scale, + bw_y); + } + } + + delete[] msnzb_vector_bool; + delete[] msnzb_vector; + delete[] adjust; + delete[] exp_parity; + delete[] adjusted_x; + delete[] X; + delete[] tmp_1; + delete[] x_prev; + delete[] b_prev; + delete[] Y_prev; + delete[] x_curr; + delete[] b_curr; + delete[] Y_curr; + delete[] Y_sq; + delete[] sqrt_adjust; + + return; +} + +void MathFunctions::ReLU(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + uint64_t six) { + bool six_comparison = false; + if (six != 0) + six_comparison = true; + int32_t size = (six_comparison ? 2 * dim : dim); + + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + + uint64_t *tmp = new uint64_t[size]; + uint8_t *tmp_msb = new uint8_t[size]; + memcpy(tmp, x, dim * sizeof(uint64_t)); + if (six_comparison) { + for (int i = 0; i < dim; i++) { + tmp[dim + i] = (party == ALICE ? x[i] - six : x[i]) & mask_x; + } + } + aux->MSB(tmp, tmp_msb, size, bw_x); + for (int i = 0; i < size; i++) { + if (party == ALICE) { + tmp_msb[i] = tmp_msb[i] ^ 1; + } + } + if (six_comparison) + aux->AND(tmp_msb, tmp_msb + dim, tmp_msb + dim, dim); + + aux->multiplexer(tmp_msb, tmp, tmp, size, bw_x, bw_x); + + memcpy(y, tmp, dim * sizeof(uint64_t)); + if (six_comparison) { + for (int i = 0; i < dim; i++) { + y[i] = (y[i] - tmp[i + dim]) & mask_x; + } + } + + delete[] tmp; + delete[] tmp_msb; +} diff --git a/SCI/src/Math/math-functions.h b/SCI/src/Math/math-functions.h new file mode 100644 index 00000000..6a40aa31 --- /dev/null +++ b/SCI/src/Math/math-functions.h @@ -0,0 +1,85 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef MATH_FUNCTIONS_H__ +#define MATH_FUNCTIONS_H__ + +#include "BuildingBlocks/aux-protocols.h" +#include "BuildingBlocks/truncation.h" +#include "BuildingBlocks/value-extension.h" +#include "LinearOT/linear-ot.h" + +class MathFunctions { +public: + int party; + sci::NetIO *io; + sci::OTPack<sci::NetIO> *otpack; + AuxProtocols *aux; + XTProtocol *xt; + Truncation *trunc; + LinearOT *mult; + + MathFunctions(int party, sci::NetIO *io, sci::OTPack<sci::NetIO> *otpack); + + ~MathFunctions(); + + // Current implementation assumes that dn is always of the form 1.y1y2y3..yn + void reciprocal_approximation(int32_t dim, int32_t m, uint64_t *dn, + uint64_t *out, int32_t bw_dn, int32_t bw_out, + int32_t s_dn, int32_t s_out); + + // If compute_msnzb = false, dn = 1.y1y2y3.... + // Else if compute_msnzb = true, dn is always positive + void div(int32_t dim, + // numerator + uint64_t *nm, + // denominator + uint64_t *dn, + // output + uint64_t *out, + // bitwidths + int32_t bw_nm, int32_t bw_dn, int32_t bw_out, + // scales + int32_t s_nm, int32_t s_dn, int32_t s_out, bool signed_nm = true, + bool compute_msnzb = false); + + void taylor_series_exp(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + int32_t bw_y, int32_t s_x, int32_t s_y); + + // Assumes x is always negative + void lookup_table_exp(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + int32_t bw_y, int32_t s_x, int32_t s_y); + + void sigmoid(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + int32_t bw_y, int32_t s_x, int32_t s_y); + + void tanh(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, int32_t bw_y, + int32_t s_x, int32_t s_y); + + void sqrt(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, int32_t bw_y, + int32_t s_x, int32_t s_y, bool inverse = false); + + // bw_y = bw_x + void ReLU(int32_t dim, uint64_t *x, uint64_t *y, int32_t bw_x, + uint64_t six = 0); +}; + +#endif diff --git a/SCI/src/Millionaire/CMakeLists.txt b/SCI/src/Millionaire/CMakeLists.txt index ec651482..d097b85c 100644 --- a/SCI/src/Millionaire/CMakeLists.txt +++ b/SCI/src/Millionaire/CMakeLists.txt @@ -1,4 +1,4 @@ add_library(SCI-Millionaire INTERFACE) target_link_libraries(SCI-Millionaire - INTERFACE SCI-OT + INTERFACE SCI-OTPrimitive ) diff --git a/SCI/src/Millionaire/bit-triple-generator.h b/SCI/src/Millionaire/bit-triple-generator.h index ddc6bbf6..cd1e2fc3 100644 --- a/SCI/src/Millionaire/bit-triple-generator.h +++ b/SCI/src/Millionaire/bit-triple-generator.h @@ -24,292 +24,300 @@ SOFTWARE. #include "OT/emp-ot.h" enum TripleGenMethod { - Ideal, // (Insecure) Ideal Functionality - _2ROT, // 1 Bit Triple from 2 ROT - _16KKOT_to_4OT, // 2 Bit Triples from 1oo16 KKOT to 1oo4 OT - _8KKOT, // 2 Correlated Bit Triples from 1oo8 KKOT + Ideal, // (Insecure) Ideal Functionality + _2ROT, // 1 Bit Triple from 2 ROT + _16KKOT_to_4OT, // 2 Bit Triples from 1oo16 KKOT to 1oo4 OT + _8KKOT, // 2 Correlated Bit Triples from 1oo8 KKOT }; class Triple { public: - bool packed; - uint8_t* ai; - uint8_t* bi; - uint8_t* ci; - int num_triples, num_bytes, offset; + bool packed; + uint8_t *ai; + uint8_t *bi; + uint8_t *ci; + int num_triples, num_bytes, offset; - Triple(int num_triples, bool packed = false, int offset = 0) { - assert((offset < num_triples) || (num_triples == 0)); - this->num_triples = num_triples; - this->packed = packed; - if (packed) { - assert(num_triples % 8 == 0); - assert(offset % 8 == 0); - this->num_bytes = num_triples/8; - } - else - this->num_bytes = num_triples; - if(offset == 0) - this->offset = 1; - else - this->offset = offset; - assert((num_triples % this->offset) == 0); - this->ai = new uint8_t[num_bytes]; - this->bi = new uint8_t[num_bytes]; - this->ci = new uint8_t[num_bytes]; - } + Triple(int num_triples, bool packed = false, int offset = 0) { + assert((offset < num_triples) || (num_triples == 0)); + this->num_triples = num_triples; + this->packed = packed; + if (packed) { + assert(num_triples % 8 == 0); + assert(offset % 8 == 0); + this->num_bytes = num_triples / 8; + } else + this->num_bytes = num_triples; + if (offset == 0) + this->offset = 1; + else + this->offset = offset; + assert((num_triples % this->offset) == 0); + this->ai = new uint8_t[num_bytes]; + this->bi = new uint8_t[num_bytes]; + this->ci = new uint8_t[num_bytes]; + } - ~Triple() { - delete[] ai; - delete[] bi; - delete[] ci; - } + ~Triple() { + delete[] ai; + delete[] bi; + delete[] ci; + } }; -template<typename IO> -class TripleGenerator { +template <typename IO> class TripleGenerator { public: - IO* io = nullptr; - sci::OTPack<IO>* otpack = nullptr; - sci::PRG128* prg; - int party; + IO *io = nullptr; + sci::OTPack<IO> *otpack = nullptr; + sci::PRG128 *prg; + int party; - TripleGenerator(int party, IO* io, sci::OTPack<IO>* otpack) { - this->io = io; - this->otpack = otpack; - this->prg = new sci::PRG128; - } - - ~TripleGenerator() { - delete prg; - } + TripleGenerator(int party, IO *io, sci::OTPack<IO> *otpack) { + this->io = io; + this->otpack = otpack; + this->prg = new sci::PRG128; + } - void generate(int party, uint8_t* ai, uint8_t* bi, uint8_t* ci, int num_triples, TripleGenMethod method, bool packed = false, int offset = 1) { - if (!num_triples) return; - switch (method) { - case Ideal: { - int num_bytes = ceil((double)num_triples/8); - if(party == sci::ALICE) { - uint8_t* a = new uint8_t[num_bytes]; - uint8_t* b = new uint8_t[num_bytes]; - uint8_t* c = new uint8_t[num_bytes]; - if (packed) { - prg->random_data(ai, num_bytes); - prg->random_data(bi, num_bytes); - prg->random_data(ci, num_bytes); - } else { - prg->random_bool((bool*)ai, num_triples); - prg->random_bool((bool*)bi, num_triples); - prg->random_bool((bool*)ci, num_triples); - } - prg->random_data(a, num_bytes); - prg->random_data(b, num_bytes); - for(int i = 0; i < num_triples; i+=8){ - c[i/8] = a[i/8] & b[i/8]; - if(packed) { - a[i/8] ^= ai[i/8]; - b[i/8] ^= bi[i/8]; - c[i/8] ^= ci[i/8]; - } else { - uint8_t temp_a, temp_b, temp_c; - if(num_triples-i >= 8){ - temp_a = sci::bool_to_uint8(ai+i, 8); - temp_b = sci::bool_to_uint8(bi+i, 8); - temp_c = sci::bool_to_uint8(ci+i, 8); - } - else{ - temp_a = sci::bool_to_uint8(ai+i, num_triples-i); - temp_b = sci::bool_to_uint8(bi+i, num_triples-i); - temp_c = sci::bool_to_uint8(ci+i, num_triples-i); - } - a[i/8] ^= temp_a; - b[i/8] ^= temp_b; - c[i/8] ^= temp_c; - } - } - io->send_data(a, num_bytes); - io->send_data(b, num_bytes); - io->send_data(c, num_bytes); - delete[] a; - delete[] b; - delete[] c; - } else { - if (packed) { - io->recv_data(ai, num_bytes); - io->recv_data(bi, num_bytes); - io->recv_data(ci, num_bytes); - } else { - uint8_t* a = new uint8_t[num_bytes]; - uint8_t* b = new uint8_t[num_bytes]; - uint8_t* c = new uint8_t[num_bytes]; - io->recv_data(a, num_bytes); - io->recv_data(b, num_bytes); - io->recv_data(c, num_bytes); + ~TripleGenerator() { delete prg; } - for(int i = 0; i < num_triples; i+=8){ - if(num_triples-i >= 8){ - sci::uint8_to_bool(ai+i, a[i/8], 8); - sci::uint8_to_bool(bi+i, b[i/8], 8); - sci::uint8_to_bool(ci+i, c[i/8], 8); - } - else{ - sci::uint8_to_bool(ai+i, a[i/8], num_triples-i); - sci::uint8_to_bool(bi+i, b[i/8], num_triples-i); - sci::uint8_to_bool(ci+i, c[i/8], num_triples-i); - } - } - delete[] a; - delete[] b; - delete[] c; - } - } - break; - } - case _2ROT: { - throw std::invalid_argument("To be implemented"); - break; + void generate(int party, uint8_t *ai, uint8_t *bi, uint8_t *ci, + int num_triples, TripleGenMethod method, bool packed = false, + int offset = 1) { + if (!num_triples) + return; + switch (method) { + case Ideal: { + int num_bytes = ceil((double)num_triples / 8); + if (party == sci::ALICE) { + uint8_t *a = new uint8_t[num_bytes]; + uint8_t *b = new uint8_t[num_bytes]; + uint8_t *c = new uint8_t[num_bytes]; + if (packed) { + prg->random_data(ai, num_bytes); + prg->random_data(bi, num_bytes); + prg->random_data(ci, num_bytes); + } else { + prg->random_bool((bool *)ai, num_triples); + prg->random_bool((bool *)bi, num_triples); + prg->random_bool((bool *)ci, num_triples); + } + prg->random_data(a, num_bytes); + prg->random_data(b, num_bytes); + for (int i = 0; i < num_triples; i += 8) { + c[i / 8] = a[i / 8] & b[i / 8]; + if (packed) { + a[i / 8] ^= ai[i / 8]; + b[i / 8] ^= bi[i / 8]; + c[i / 8] ^= ci[i / 8]; + } else { + uint8_t temp_a, temp_b, temp_c; + if (num_triples - i >= 8) { + temp_a = sci::bool_to_uint8(ai + i, 8); + temp_b = sci::bool_to_uint8(bi + i, 8); + temp_c = sci::bool_to_uint8(ci + i, 8); + } else { + temp_a = sci::bool_to_uint8(ai + i, num_triples - i); + temp_b = sci::bool_to_uint8(bi + i, num_triples - i); + temp_c = sci::bool_to_uint8(ci + i, num_triples - i); } - case _16KKOT_to_4OT: { - assert((num_triples & 1) == 0); // num_triples is even - uint8_t *a, *b, *c; - if (packed) { - a = new uint8_t[num_triples]; - b = new uint8_t[num_triples]; - c = new uint8_t[num_triples]; - } - else { - a = ai; - b = bi; - c = ci; - } - prg->random_bool((bool*)a, num_triples); - prg->random_bool((bool*)b, num_triples); - switch(party) { - case sci::ALICE: { - prg->random_bool((bool*)c, num_triples); - uint8_t** ot_messages; // (num_triples/2) X 16 - ot_messages = new uint8_t*[num_triples/2]; - for(int i = 0; i < num_triples; i+=2) - ot_messages[i/2] = new uint8_t[16]; - for(int j = 0; j < 16; j++) { - uint8_t bits_j[4]; // a01 || b01 || a11 || b11 (LSB->MSB) - sci::uint8_to_bool(bits_j, j, 4); - for(int i = 0; i < num_triples; i+=2) { - ot_messages[i/2][j] = ((((a[i+1]^bits_j[2]) & (b[i+1]^bits_j[3])) - ^ c[i+1]) << 1) - | (((a[i]^bits_j[0]) & (b[i]^bits_j[1])) ^ c[i]); - } - } - otpack->kkot_16->send(ot_messages, num_triples/2, 2); - for(int i = 0; i < num_triples; i+=2) - delete[] ot_messages[i/2]; - delete[] ot_messages; - break; - } - case sci::BOB: { - uint8_t* ot_selection = new uint8_t[(size_t) num_triples/2]; - uint8_t* ot_result = new uint8_t[(size_t) num_triples/2]; - for(int i = 0; i < num_triples; i+=2) { - ot_selection[i/2] = (b[i+1]<<3) | (a[i+1]<<2) | (b[i] << 1) | a[i]; - } - otpack->kkot_16->recv(ot_result, ot_selection, num_triples/2, 2); - for(int i = 0; i < num_triples; i+=2) { - c[i] = ot_result[i/2] & 1; - c[i+1] = ot_result[i/2] >> 1; - } - delete[] ot_selection; - delete[] ot_result; - break; - } - } - if (packed) { - for(int i = 0; i < num_triples; i+=8) { - ai[i/8] = sci::bool_to_uint8(a+i, 8); - bi[i/8] = sci::bool_to_uint8(b+i, 8); - ci[i/8] = sci::bool_to_uint8(c+i, 8); - } - delete[] a; - delete[] b; - delete[] c; - } - break; + a[i / 8] ^= temp_a; + b[i / 8] ^= temp_b; + c[i / 8] ^= temp_c; + } + } + io->send_data(a, num_bytes); + io->send_data(b, num_bytes); + io->send_data(c, num_bytes); + delete[] a; + delete[] b; + delete[] c; + } else { + if (packed) { + io->recv_data(ai, num_bytes); + io->recv_data(bi, num_bytes); + io->recv_data(ci, num_bytes); + } else { + uint8_t *a = new uint8_t[num_bytes]; + uint8_t *b = new uint8_t[num_bytes]; + uint8_t *c = new uint8_t[num_bytes]; + io->recv_data(a, num_bytes); + io->recv_data(b, num_bytes); + io->recv_data(c, num_bytes); + + for (int i = 0; i < num_triples; i += 8) { + if (num_triples - i >= 8) { + sci::uint8_to_bool(ai + i, a[i / 8], 8); + sci::uint8_to_bool(bi + i, b[i / 8], 8); + sci::uint8_to_bool(ci + i, c[i / 8], 8); + } else { + sci::uint8_to_bool(ai + i, a[i / 8], num_triples - i); + sci::uint8_to_bool(bi + i, b[i / 8], num_triples - i); + sci::uint8_to_bool(ci + i, c[i / 8], num_triples - i); } - case _8KKOT: { - assert((num_triples & 1) == 0); // num_triples is even - uint8_t *a, *b, *c; - if (packed) { - a = new uint8_t[num_triples]; - b = new uint8_t[num_triples]; - c = new uint8_t[num_triples]; - } - else { - a = ai; - b = bi; - c = ci; - } - for(int i = 0; i < num_triples; i+=2*offset) { - prg->random_bool((bool*)a+i, offset); - memcpy(a+i+offset, a+i, offset); - } - prg->random_bool((bool*)b, num_triples); - switch(party) { - case sci::ALICE: { - prg->random_bool((bool*)c, num_triples); - uint8_t** ot_messages; // (num_triples/2) X 8 - ot_messages = new uint8_t*[num_triples/2]; - for(int i = 0; i < num_triples; i+=2) - ot_messages[i/2] = new uint8_t[8]; - for(int j = 0; j < 8; j++) { - uint8_t bits_j[3]; // a01 || b01 || b11 (LSB->MSB) - sci::uint8_to_bool(bits_j, j, 3); - for(int i = 0; i < num_triples; i+=2*offset) { - for(int k = 0; k < offset; k++) { - ot_messages[i/2+k][j] = ((((a[i+k]^bits_j[0]) & (b[i+offset+k]^bits_j[2])) ^ c[i+offset+k]) << 1) | (((a[i+k]^bits_j[0]) & (b[i+k]^bits_j[1])) ^ c[i+k]); - } - } - } - otpack->kkot_8->send(ot_messages, num_triples/2, 2); - for(int i = 0; i < num_triples; i+=2) - delete[] ot_messages[i/2]; - delete[] ot_messages; - break; - } - case sci::BOB: { - uint8_t* ot_selection = new uint8_t[(size_t) num_triples/2]; - uint8_t* ot_result = new uint8_t[(size_t) num_triples/2]; - for(int i = 0; i < num_triples; i+=2*offset) { - for(int k = 0; k < offset; k++) - ot_selection[i/2+k] = (b[i+offset+k]<<2) | (b[i+k] << 1) | a[i+k]; - } - otpack->kkot_8->recv(ot_result, ot_selection, num_triples/2, 2); - for(int i = 0; i < num_triples; i+=2*offset) { - for(int k = 0; k < offset; k++) { - c[i+k] = ot_result[i/2+k] & 1; - c[i+offset+k] = ot_result[i/2+k] >> 1; - } - } - delete[] ot_selection; - delete[] ot_result; - break; - } - } - if (packed) { - for(int i = 0; i < num_triples; i+=8) { - ai[i/8] = sci::bool_to_uint8(a+i, 8); - bi[i/8] = sci::bool_to_uint8(b+i, 8); - ci[i/8] = sci::bool_to_uint8(c+i, 8); - } - delete[] a; - delete[] b; - delete[] c; - } - break; + } + delete[] a; + delete[] b; + delete[] c; + } + } + break; + } + case _2ROT: { + throw std::invalid_argument("To be implemented"); + break; + } + case _16KKOT_to_4OT: { + assert((num_triples & 1) == 0); // num_triples is even + uint8_t *a, *b, *c; + if (packed) { + a = new uint8_t[num_triples]; + b = new uint8_t[num_triples]; + c = new uint8_t[num_triples]; + } else { + a = ai; + b = bi; + c = ci; + } + prg->random_bool((bool *)a, num_triples); + prg->random_bool((bool *)b, num_triples); + switch (party) { + case sci::ALICE: { + prg->random_bool((bool *)c, num_triples); + uint8_t **ot_messages; // (num_triples/2) X 16 + ot_messages = new uint8_t *[num_triples / 2]; + for (int i = 0; i < num_triples; i += 2) + ot_messages[i / 2] = new uint8_t[16]; + for (int j = 0; j < 16; j++) { + uint8_t bits_j[4]; // a01 || b01 || a11 || b11 (LSB->MSB) + sci::uint8_to_bool(bits_j, j, 4); + for (int i = 0; i < num_triples; i += 2) { + ot_messages[i / 2][j] = + ((((a[i + 1] ^ bits_j[2]) & (b[i + 1] ^ bits_j[3])) ^ c[i + 1]) + << 1) | + (((a[i] ^ bits_j[0]) & (b[i] ^ bits_j[1])) ^ c[i]); + } + } + // otpack->kkot_16->send(ot_messages, num_triples/2, 2); + otpack->kkot[3]->send(ot_messages, num_triples / 2, 2); + for (int i = 0; i < num_triples; i += 2) + delete[] ot_messages[i / 2]; + delete[] ot_messages; + break; + } + case sci::BOB: { + uint8_t *ot_selection = new uint8_t[(size_t)num_triples / 2]; + uint8_t *ot_result = new uint8_t[(size_t)num_triples / 2]; + for (int i = 0; i < num_triples; i += 2) { + ot_selection[i / 2] = + (b[i + 1] << 3) | (a[i + 1] << 2) | (b[i] << 1) | a[i]; + } + // otpack->kkot_16->recv(ot_result, ot_selection, num_triples/2, 2); + otpack->kkot[3]->recv(ot_result, ot_selection, num_triples / 2, 2); + for (int i = 0; i < num_triples; i += 2) { + c[i] = ot_result[i / 2] & 1; + c[i + 1] = ot_result[i / 2] >> 1; + } + delete[] ot_selection; + delete[] ot_result; + break; + } + } + if (packed) { + for (int i = 0; i < num_triples; i += 8) { + ai[i / 8] = sci::bool_to_uint8(a + i, 8); + bi[i / 8] = sci::bool_to_uint8(b + i, 8); + ci[i / 8] = sci::bool_to_uint8(c + i, 8); + } + delete[] a; + delete[] b; + delete[] c; + } + break; + } + case _8KKOT: { + assert((num_triples & 1) == 0); // num_triples is even + uint8_t *a, *b, *c; + if (packed) { + a = new uint8_t[num_triples]; + b = new uint8_t[num_triples]; + c = new uint8_t[num_triples]; + } else { + a = ai; + b = bi; + c = ci; + } + for (int i = 0; i < num_triples; i += 2 * offset) { + prg->random_bool((bool *)a + i, offset); + memcpy(a + i + offset, a + i, offset); + } + prg->random_bool((bool *)b, num_triples); + switch (party) { + case sci::ALICE: { + prg->random_bool((bool *)c, num_triples); + uint8_t **ot_messages; // (num_triples/2) X 8 + ot_messages = new uint8_t *[num_triples / 2]; + for (int i = 0; i < num_triples; i += 2) + ot_messages[i / 2] = new uint8_t[8]; + for (int j = 0; j < 8; j++) { + uint8_t bits_j[3]; // a01 || b01 || b11 (LSB->MSB) + sci::uint8_to_bool(bits_j, j, 3); + for (int i = 0; i < num_triples; i += 2 * offset) { + for (int k = 0; k < offset; k++) { + ot_messages[i / 2 + k][j] = + ((((a[i + k] ^ bits_j[0]) & (b[i + offset + k] ^ bits_j[2])) ^ + c[i + offset + k]) + << 1) | + (((a[i + k] ^ bits_j[0]) & (b[i + k] ^ bits_j[1])) ^ + c[i + k]); } + } + } + // otpack->kkot_8->send(ot_messages, num_triples/2, 2); + otpack->kkot[2]->send(ot_messages, num_triples / 2, 2); + for (int i = 0; i < num_triples; i += 2) + delete[] ot_messages[i / 2]; + delete[] ot_messages; + break; + } + case sci::BOB: { + uint8_t *ot_selection = new uint8_t[(size_t)num_triples / 2]; + uint8_t *ot_result = new uint8_t[(size_t)num_triples / 2]; + for (int i = 0; i < num_triples; i += 2 * offset) { + for (int k = 0; k < offset; k++) + ot_selection[i / 2 + k] = + (b[i + offset + k] << 2) | (b[i + k] << 1) | a[i + k]; + } + // otpack->kkot_8->recv(ot_result, ot_selection, num_triples/2, 2); + otpack->kkot[2]->recv(ot_result, ot_selection, num_triples / 2, 2); + for (int i = 0; i < num_triples; i += 2 * offset) { + for (int k = 0; k < offset; k++) { + c[i + k] = ot_result[i / 2 + k] & 1; + c[i + offset + k] = ot_result[i / 2 + k] >> 1; + } } + delete[] ot_selection; + delete[] ot_result; + break; + } + } + if (packed) { + for (int i = 0; i < num_triples; i += 8) { + ai[i / 8] = sci::bool_to_uint8(a + i, 8); + bi[i / 8] = sci::bool_to_uint8(b + i, 8); + ci[i / 8] = sci::bool_to_uint8(c + i, 8); + } + delete[] a; + delete[] b; + delete[] c; + } + break; } - - void generate(int party, Triple* triples, TripleGenMethod method) { - generate(party, triples->ai, triples->bi, triples->ci, triples->num_triples, method, triples->packed, triples->offset); } + } + + void generate(int party, Triple *triples, TripleGenMethod method) { + generate(party, triples->ai, triples->bi, triples->ci, triples->num_triples, + method, triples->packed, triples->offset); + } }; -#endif //TRIPLE_GENERATOR_H__ +#endif // TRIPLE_GENERATOR_H__ diff --git a/SCI/src/Millionaire/equality.h b/SCI/src/Millionaire/equality.h new file mode 100644 index 00000000..460c19eb --- /dev/null +++ b/SCI/src/Millionaire/equality.h @@ -0,0 +1,360 @@ +/* +Authors: Mayank Rathee +Copyright: +Copyright (c) 2020 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef EQUALITY_H__ +#define EQUALITY_H__ +#include "Millionaire/millionaire.h" +#include "OT/emp-ot.h" +#include "utils/emp-tool.h" +#include <cmath> + +template <typename IO> class Equality { +public: + IO *io = nullptr; + sci::OTPack<IO> *otpack; + TripleGenerator<IO> *triple_gen; + MillionaireProtocol<IO> *mill; + bool del_mill = false; + int party; + int l, r, log_alpha, beta, beta_pow; + int num_digits, num_triples, log_num_digits; + uint8_t mask_beta, mask_r; + + Equality(int party, IO *io, sci::OTPack<IO> *otpack, + MillionaireProtocol<IO> *mill_in = nullptr, int bitlength = 32, + int radix_base = MILL_PARAM) { + this->party = party; + this->io = io; + this->otpack = otpack; + this->mill = mill_in; + if (mill_in == nullptr) { + del_mill = true; + mill = + new MillionaireProtocol<IO>(party, io, otpack, bitlength, radix_base); + } + this->triple_gen = mill->triple_gen; + configure(bitlength, radix_base); + } + + void configure(int bitlength, int radix_base = MILL_PARAM) { + assert(radix_base <= 8); + assert(bitlength <= 64); + this->l = bitlength; + this->beta = radix_base; + + this->num_digits = ceil((double)l / beta); + this->r = l % beta; + this->log_alpha = sci::bitlen(num_digits) - 1; + this->log_num_digits = log_alpha + 1; + this->num_triples = num_digits - 1; + if (beta == 8) + this->mask_beta = -1; + else + this->mask_beta = (1 << beta) - 1; + this->mask_r = (1 << r) - 1; + this->beta_pow = 1 << beta; + } + + ~Equality() { + if (del_mill) { + delete mill; + } + } + + void bitlen_lt_beta(uint8_t *res_eq, uint64_t *data, int num_eqs, + int bitlength, bool greater_than = true, + int radix_base = MILL_PARAM) { + uint8_t N = 1 << bitlength; + uint8_t mask = N - 1; + if (party == sci::ALICE) { + sci::PRG128 prg; + prg.random_data(res_eq, num_eqs * sizeof(uint8_t)); + uint8_t **leaf_messages = new uint8_t *[num_eqs]; + for (int i = 0; i < num_eqs; i++) { + res_eq[i] &= 1; + leaf_messages[i] = new uint8_t[N]; + this->set_leaf_ot_messages(leaf_messages[i], (data[i] & mask), N, + res_eq[i]); + } + if (bitlength > 1) { + otpack->kkot[bitlength - 1]->send(leaf_messages, num_eqs, 1); + } else { + otpack->iknp_straight->send(leaf_messages, num_eqs, 1); + } + + for (int i = 0; i < num_eqs; i++) + delete[] leaf_messages[i]; + delete[] leaf_messages; + } else { // party == BOB + uint8_t *choice = new uint8_t[num_eqs]; + for (int i = 0; i < num_eqs; i++) { + choice[i] = data[i] & mask; + } + if (bitlength > 1) { + otpack->kkot[bitlength - 1]->recv(res_eq, choice, num_eqs, 1); + } else { + otpack->iknp_straight->recv(res_eq, choice, num_eqs, 1); + } + for (int i = 0; i < num_eqs; i++) { + res_eq[i] = res_eq[i] & 1; + } + delete[] choice; + } + return; + } + + void check_equality(uint8_t *res_eq, uint64_t *data, int num_eqs, + int bitlength, int radix_base = MILL_PARAM) { + configure(bitlength, radix_base); + + if (bitlength <= beta) { + bitlen_lt_beta(res_eq, data, num_eqs, bitlength, radix_base); + return; + } + + int old_num_eqs = num_eqs; + // num_eqs should be a multiple of 8 + num_eqs = ceil(num_eqs / 8.0) * 8; + + // padding with 0s if data dim not multiple of 8 + uint64_t *data_ext; + if (old_num_eqs == num_eqs) + data_ext = data; + else { + data_ext = new uint64_t[num_eqs]; + memcpy(data_ext, data, old_num_eqs * sizeof(uint64_t)); + memset(data_ext + old_num_eqs, 0, + (num_eqs - old_num_eqs) * sizeof(uint64_t)); + } + + uint8_t *digits; // num_digits * num_eqs + uint8_t *leaf_res_eq; // num_digits * num_eqs + + digits = new uint8_t[num_digits * num_eqs]; + leaf_res_eq = new uint8_t[num_digits * num_eqs]; + + // Extract radix-digits from data + for (int i = 0; i < num_digits; i++) // Stored from LSB to MSB + for (int j = 0; j < num_eqs; j++) + if ((i == num_digits - 1) && (r != 0)) + digits[i * num_eqs + j] = (uint8_t)(data_ext[j] >> i * beta) & mask_r; + else + digits[i * num_eqs + j] = + (uint8_t)(data_ext[j] >> i * beta) & mask_beta; + // ====================== + + // Set leaf OT messages now + if (party == sci::ALICE) { + uint8_t **leaf_ot_messages; // (num_digits * num_eqs) X beta_pow (=2^beta) + leaf_ot_messages = new uint8_t *[num_digits * num_eqs]; + for (int i = 0; i < num_digits * num_eqs; i++) + leaf_ot_messages[i] = new uint8_t[beta_pow]; + + // Set Leaf OT messages + triple_gen->prg->random_bool((bool *)leaf_res_eq, num_digits * num_eqs); + for (int i = 0; i < num_digits; i++) { + for (int j = 0; j < num_eqs; j++) { + if (i == (num_digits - 1) && (r > 0)) { + this->set_leaf_ot_messages(leaf_ot_messages[i * num_eqs + j], + digits[i * num_eqs + j], 1ULL << r, + leaf_res_eq[i * num_eqs + j]); + } else { + this->set_leaf_ot_messages(leaf_ot_messages[i * num_eqs + j], + digits[i * num_eqs + j], beta_pow, + leaf_res_eq[i * num_eqs + j]); + } + } + } + + // Perform Leaf OTs with comparison and equality + if (r == 1) { + // All branches except r + otpack->kkot[beta - 1]->send(leaf_ot_messages, + num_eqs * (num_digits - 1), 1); + // r branch + otpack->iknp_straight->send( + leaf_ot_messages + num_eqs * (num_digits - 1), num_eqs, 1); + } else if (r != 0) { + // All branches except r + otpack->kkot[beta - 1]->send(leaf_ot_messages, + num_eqs * (num_digits - 1), 1); + // r branch + otpack->kkot[r - 1]->send(leaf_ot_messages + num_eqs * (num_digits - 1), + num_eqs, 1); + } else { + // All branches including r, r is 0 + otpack->kkot[beta - 1]->send(leaf_ot_messages, num_eqs * (num_digits), + 1); + } + + // Cleanup + for (int i = 0; i < num_digits * num_eqs; i++) + delete[] leaf_ot_messages[i]; + delete[] leaf_ot_messages; + } else // party = sci::BOB + { + // Perform Leaf OTs + if (r == 1) { + // All branches except r + otpack->kkot[beta - 1]->recv(leaf_res_eq, digits, + num_eqs * (num_digits - 1), 1); + // r branch + otpack->iknp_straight->recv(leaf_res_eq + num_eqs * (num_digits - 1), + digits + num_eqs * (num_digits - 1), + num_eqs, 1); + } else if (r != 0) { + // All branches except r + otpack->kkot[beta - 1]->recv(leaf_res_eq, digits, + num_eqs * (num_digits - 1), 1); + // r branch + otpack->kkot[r - 1]->recv(leaf_res_eq + num_eqs * (num_digits - 1), + digits + num_eqs * (num_digits - 1), num_eqs, + 1); + } else { + // All branches including r, r is 0 + otpack->kkot[beta - 1]->recv(leaf_res_eq, digits, + num_eqs * (num_digits), 1); + } + + for (int i = 0; i < num_digits * num_eqs; i++) { + leaf_res_eq[i] = leaf_res_eq[i] & 1; + } + } + + traverse_and_compute_ANDs(num_eqs, leaf_res_eq); + + for (int i = 0; i < old_num_eqs; i++) { + res_eq[i] = leaf_res_eq[i]; + } + + // Cleanup + if (old_num_eqs != num_eqs) + delete[] data_ext; + delete[] digits; + delete[] leaf_res_eq; + } + + /************************************************************************************************** + * AND computation related functions + **************************************************************************************************/ + + void traverse_and_compute_ANDs(int num_eqs, uint8_t *leaf_res_eq) { + Triple triples_std((num_triples)*num_eqs, true); + + // Generate required Bit-Triples + triple_gen->generate(party, &triples_std, _16KKOT_to_4OT); + + // Combine leaf OT results in a bottom-up fashion + int counter_triples_used = 0, old_counter_triples_used = 0; + uint8_t *ei = new uint8_t[(num_triples * num_eqs) / 8]; + uint8_t *fi = new uint8_t[(num_triples * num_eqs) / 8]; + uint8_t *e = new uint8_t[(num_triples * num_eqs) / 8]; + uint8_t *f = new uint8_t[(num_triples * num_eqs) / 8]; + + for (int i = 1; i < num_digits; + i *= 2) { // i denotes the distance between 2 nodes which should be + // ANDed together + for (int j = 0; j < num_digits and j + i < num_digits; + j += 2 * i) { // j=0 is LSD and j=num_digits-1 is MSD + + // EQ_j: Use 1 triple for opening e = a + eq_j and f = b + eq_j+i. + this->mill->AND_step_1( + ei + (counter_triples_used * num_eqs) / 8, + fi + (counter_triples_used * num_eqs) / 8, + leaf_res_eq + j * num_eqs, leaf_res_eq + (j + i) * num_eqs, + (triples_std.ai) + (counter_triples_used * num_eqs) / 8, + (triples_std.bi) + (counter_triples_used * num_eqs) / 8, num_eqs); + counter_triples_used++; + } + int offset = (old_counter_triples_used * num_eqs) / 8; + int size_used = + ((counter_triples_used - old_counter_triples_used) * num_eqs) / 8; + + if (party == sci::ALICE) { + // Send share of e and f + io->send_data(ei + offset, size_used); + io->send_data(ei + offset, size_used); + io->send_data(fi + offset, size_used); + io->send_data(fi + offset, size_used); + // Receive share of e and f + io->recv_data(e + offset, size_used); + io->recv_data(e + offset, size_used); + io->recv_data(f + offset, size_used); + io->recv_data(f + offset, size_used); + } else // party = sci::BOB + { + // Receive share of e and f + io->recv_data(e + offset, size_used); + io->recv_data(e + offset, size_used); + io->recv_data(f + offset, size_used); + io->recv_data(f + offset, size_used); + // Send share of e and f + io->send_data(ei + offset, size_used); + io->send_data(ei + offset, size_used); + io->send_data(fi + offset, size_used); + io->send_data(fi + offset, size_used); + } + + // Reconstruct e and f + for (int i = 0; i < size_used; i++) { + e[i + offset] ^= ei[i + offset]; + f[i + offset] ^= fi[i + offset]; + } + + counter_triples_used = old_counter_triples_used; + + // Step 2 of AND computation + for (int j = 0; j < num_digits and j + i < num_digits; + j += 2 * i) { // j=0 is LSD and j=num_digits-1 is MSD + + // EQ_j: Use 1 triple compute eq_j AND eq_j+i. + this->mill->AND_step_2( + leaf_res_eq + j * num_eqs, e + (counter_triples_used * num_eqs) / 8, + f + (counter_triples_used * num_eqs) / 8, + nullptr, // not used in function + nullptr, // not used in function + (triples_std.ai) + (counter_triples_used * num_eqs) / 8, + (triples_std.bi) + (counter_triples_used * num_eqs) / 8, + (triples_std.ci) + (counter_triples_used * num_eqs) / 8, num_eqs); + counter_triples_used++; + } + + old_counter_triples_used = counter_triples_used; + } + + assert(counter_triples_used == num_triples); + + // cleanup + delete[] ei; + delete[] fi; + delete[] e; + delete[] f; + } + + void set_leaf_ot_messages(uint8_t *ot_messages, uint8_t digit, int N, + uint8_t mask_eq) { + for (int i = 0; i < N; i++) { + ot_messages[i] = ((digit == i) ^ mask_eq); + } + } +}; + +#endif // EQUALITY_H__ diff --git a/SCI/src/Millionaire/millionaire.h b/SCI/src/Millionaire/millionaire.h index 302f6055..6fcbf012 100644 --- a/SCI/src/Millionaire/millionaire.h +++ b/SCI/src/Millionaire/millionaire.h @@ -1,7 +1,7 @@ /* Authors: Deevashwer Rathee, Mayank Rathee Copyright: -Copyright (c) 2020 Microsoft Research +Copyright (c) 2021 Microsoft Research Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights @@ -21,468 +21,566 @@ SOFTWARE. #ifndef MILLIONAIRE_H__ #define MILLIONAIRE_H__ +#include "Millionaire/bit-triple-generator.h" #include "OT/emp-ot.h" #include "utils/emp-tool.h" -#include "Millionaire/bit-triple-generator.h" #include <cmath> -template<typename IO> -class MillionaireProtocol { - public: - IO* io = nullptr; - sci::OTPack<IO>* otpack; - TripleGenerator<IO>* triple_gen; - int party; - int l, r, log_alpha, beta, beta_pow; - int num_digits, num_triples_corr, num_triples_std, log_num_digits; - int num_triples; - uint8_t mask_beta, mask_r; - - MillionaireProtocol(int party, - int bitlength, - int log_radix_base, - IO* io, - sci::OTPack<IO> *otpack) - { - assert(log_radix_base <= 8); - assert(bitlength <= 64); - this->party = party; - this->l = bitlength; - this->beta = log_radix_base; - this->io = io; - this->otpack = otpack; - this->triple_gen = new TripleGenerator<IO>(party, io, otpack); - configure(); - } - - void configure() - { - this->num_digits = ceil((double)l/beta); - this->r = l % beta; - this->log_alpha = sci::bitlen(num_digits) - 1; - this->log_num_digits = log_alpha + 1; - this->num_triples_corr = 2*num_digits - 2 - 2*log_num_digits; - this->num_triples_std = log_num_digits; - this->num_triples = num_triples_std + num_triples_corr; - if (beta == 8) this->mask_beta = -1; - else this->mask_beta = (1 << beta) - 1; - this->mask_r = (1 << r) - 1; - this->beta_pow = 1 << beta; - } - - ~MillionaireProtocol() - { - delete triple_gen; - } - - void compare(uint8_t* res, - uint64_t* data, - int num_cmps, - bool greater_than = true) - { - uint8_t* digits; // num_digits * num_cmps - uint8_t* leaf_res_cmp; // num_digits * num_cmps - uint8_t* leaf_res_eq; // num_digits * num_cmps - - digits = new uint8_t[num_digits*num_cmps]; - leaf_res_cmp = new uint8_t[num_digits*num_cmps]; - leaf_res_eq = new uint8_t[num_digits*num_cmps]; - - // Extract radix-digits from data - for(int i = 0; i < num_digits; i++) // Stored from LSB to MSB - for(int j = 0; j < num_cmps; j++) - if ((i == num_digits-1) && (r != 0)) - digits[i*num_cmps+j] = (uint8_t)(data[j] >> i*beta) & mask_r; - else - digits[i*num_cmps+j] = (uint8_t)(data[j] >> i*beta) & mask_beta; - - if(party == sci::ALICE) - { - uint8_t** leaf_ot_messages; // (num_digits * num_cmps) X beta_pow (=2^beta) - leaf_ot_messages = new uint8_t*[num_digits*num_cmps]; - for(int i = 0; i < num_digits*num_cmps; i++) - leaf_ot_messages[i] = new uint8_t[beta_pow]; - - // Set Leaf OT messages - triple_gen->prg->random_bool((bool*)leaf_res_cmp, num_digits*num_cmps); - triple_gen->prg->random_bool((bool*)leaf_res_eq, num_digits*num_cmps); - for(int i = 0; i < num_digits; i++) { - for(int j = 0; j < num_cmps; j++) { - if (i == 0){ - set_leaf_ot_messages(leaf_ot_messages[i*num_cmps+j], digits[i*num_cmps+j], - beta_pow, leaf_res_cmp[i*num_cmps+j], 0, greater_than, false); - } - else if (i == (num_digits - 1) && (r > 0)){ +#define MILL_PARAM 4 + +template <typename IO> class MillionaireProtocol { +public: + IO *io = nullptr; + sci::OTPack<IO> *otpack; + TripleGenerator<IO> *triple_gen; + int party; + int l, r, log_alpha, beta, beta_pow; + int num_digits, num_triples_corr, num_triples_std, log_num_digits; + int num_triples; + uint8_t mask_beta, mask_r; + + MillionaireProtocol(int party, IO *io, sci::OTPack<IO> *otpack, + int bitlength = 32, int radix_base = MILL_PARAM) { + this->party = party; + this->io = io; + this->otpack = otpack; + this->triple_gen = new TripleGenerator<IO>(party, io, otpack); + configure(bitlength, radix_base); + } + + void configure(int bitlength, int radix_base = MILL_PARAM) { + assert(radix_base <= 8); + assert(bitlength <= 64); + this->l = bitlength; + this->beta = radix_base; + + this->num_digits = ceil((double)l / beta); + this->r = l % beta; + this->log_alpha = sci::bitlen(num_digits) - 1; + this->log_num_digits = log_alpha + 1; + this->num_triples_corr = 2 * num_digits - 2 - 2 * log_num_digits; + this->num_triples_std = log_num_digits; + this->num_triples = num_triples_std + num_triples_corr; + if (beta == 8) + this->mask_beta = -1; + else + this->mask_beta = (1 << beta) - 1; + this->mask_r = (1 << r) - 1; + this->beta_pow = 1 << beta; + } + + ~MillionaireProtocol() { delete triple_gen; } + + void compare(uint8_t *res, uint64_t *data, int num_cmps, int bitlength, + bool greater_than = true, bool equality = false, + int radix_base = MILL_PARAM) { + configure(bitlength, radix_base); + + if (bitlength <= beta) { + uint8_t N = 1 << bitlength; + uint8_t mask = N - 1; + if (party == sci::ALICE) { + sci::PRG128 prg; + prg.random_data(res, num_cmps * sizeof(uint8_t)); + uint8_t **leaf_messages = new uint8_t *[num_cmps]; + for (int i = 0; i < num_cmps; i++) { + res[i] &= 1; + leaf_messages[i] = new uint8_t[N]; + for (int j = 0; j < N; j++) { + if (greater_than) { + leaf_messages[i][j] = ((uint8_t(data[i] & mask) > j) ^ res[i]); + } else { + leaf_messages[i][j] = ((uint8_t(data[i] & mask) < j) ^ res[i]); + } + } + } + if (bitlength > 1) { + otpack->kkot[bitlength - 1]->send(leaf_messages, num_cmps, 1); + } else { + otpack->iknp_straight->send(leaf_messages, num_cmps, 1); + } + + for (int i = 0; i < num_cmps; i++) + delete[] leaf_messages[i]; + delete[] leaf_messages; + } else { // party == BOB + uint8_t *choice = new uint8_t[num_cmps]; + for (int i = 0; i < num_cmps; i++) { + choice[i] = data[i] & mask; + } + if (bitlength > 1) { + otpack->kkot[bitlength - 1]->recv(res, choice, num_cmps, 1); + } else { + otpack->iknp_straight->recv(res, choice, num_cmps, 1); + } + + delete[] choice; + } + return; + } + + int old_num_cmps = num_cmps; + // num_cmps should be a multiple of 8 + num_cmps = ceil(num_cmps / 8.0) * 8; + + uint64_t *data_ext; + if (old_num_cmps == num_cmps) + data_ext = data; + else { + data_ext = new uint64_t[num_cmps]; + memcpy(data_ext, data, old_num_cmps * sizeof(uint64_t)); + memset(data_ext + old_num_cmps, 0, + (num_cmps - old_num_cmps) * sizeof(uint64_t)); + } + + uint8_t *digits; // num_digits * num_cmps + uint8_t *leaf_res_cmp; // num_digits * num_cmps + uint8_t *leaf_res_eq; // num_digits * num_cmps + + digits = new uint8_t[num_digits * num_cmps]; + leaf_res_cmp = new uint8_t[num_digits * num_cmps]; + leaf_res_eq = new uint8_t[num_digits * num_cmps]; + + // Extract radix-digits from data + for (int i = 0; i < num_digits; i++) // Stored from LSB to MSB + for (int j = 0; j < num_cmps; j++) + if ((i == num_digits - 1) && (r != 0)) + digits[i * num_cmps + j] = + (uint8_t)(data_ext[j] >> i * beta) & mask_r; + else + digits[i * num_cmps + j] = + (uint8_t)(data_ext[j] >> i * beta) & mask_beta; + + if (party == sci::ALICE) { + uint8_t * + *leaf_ot_messages; // (num_digits * num_cmps) X beta_pow (=2^beta) + leaf_ot_messages = new uint8_t *[num_digits * num_cmps]; + for (int i = 0; i < num_digits * num_cmps; i++) + leaf_ot_messages[i] = new uint8_t[beta_pow]; + + // Set Leaf OT messages + triple_gen->prg->random_bool((bool *)leaf_res_cmp, num_digits * num_cmps); + triple_gen->prg->random_bool((bool *)leaf_res_eq, num_digits * num_cmps); + for (int i = 0; i < num_digits; i++) { + for (int j = 0; j < num_cmps; j++) { + if (i == 0) { + set_leaf_ot_messages(leaf_ot_messages[i * num_cmps + j], + digits[i * num_cmps + j], beta_pow, + leaf_res_cmp[i * num_cmps + j], 0, + greater_than, false); + } else if (i == (num_digits - 1) && (r > 0)) { #ifdef WAN_EXEC - set_leaf_ot_messages(leaf_ot_messages[i*num_cmps+j], digits[i*num_cmps+j], - beta_pow, leaf_res_cmp[i*num_cmps+j], - leaf_res_eq[i*num_cmps+j], greater_than); + set_leaf_ot_messages(leaf_ot_messages[i * num_cmps + j], + digits[i * num_cmps + j], beta_pow, + leaf_res_cmp[i * num_cmps + j], + leaf_res_eq[i * num_cmps + j], greater_than); #else - set_leaf_ot_messages(leaf_ot_messages[i*num_cmps+j], digits[i*num_cmps+j], - 1 << r, leaf_res_cmp[i*num_cmps+j], - leaf_res_eq[i*num_cmps+j], greater_than); + set_leaf_ot_messages(leaf_ot_messages[i * num_cmps + j], + digits[i * num_cmps + j], 1 << r, + leaf_res_cmp[i * num_cmps + j], + leaf_res_eq[i * num_cmps + j], greater_than); #endif - } - else{ - set_leaf_ot_messages(leaf_ot_messages[i*num_cmps+j], digits[i*num_cmps+j], - beta_pow, leaf_res_cmp[i*num_cmps+j], - leaf_res_eq[i*num_cmps+j], greater_than); - } - } - } - - // Perform Leaf OTs + } else { + set_leaf_ot_messages(leaf_ot_messages[i * num_cmps + j], + digits[i * num_cmps + j], beta_pow, + leaf_res_cmp[i * num_cmps + j], + leaf_res_eq[i * num_cmps + j], greater_than); + } + } + } + + // Perform Leaf OTs #ifdef WAN_EXEC - otpack->kkot_beta->send(leaf_ot_messages, num_cmps*(num_digits), 2); + // otpack->kkot_beta->send(leaf_ot_messages, num_cmps*(num_digits), 2); + otpack->kkot[beta - 1]->send(leaf_ot_messages, num_cmps * (num_digits), + 2); #else - otpack->kkot_beta->send(leaf_ot_messages, num_cmps, 1); - if (r == 1) { - otpack->kkot_beta->send(leaf_ot_messages+num_cmps, num_cmps*(num_digits-2), 2); - otpack->iknp_straight->send(leaf_ot_messages+num_cmps*(num_digits-1), num_cmps, 2); - } - else if (r != 0) { - otpack->kkot_beta->send(leaf_ot_messages+num_cmps, num_cmps*(num_digits-2), 2); - if(r == 2){ - otpack->kkot_4->send(leaf_ot_messages+num_cmps*(num_digits-1), num_cmps, 2); - } - else if(r == 3){ - otpack->kkot_8->send(leaf_ot_messages+num_cmps*(num_digits-1), num_cmps, 2); - } - else if(r == 4){ - otpack->kkot_16->send(leaf_ot_messages+num_cmps*(num_digits-1), num_cmps, 2); - } - else{ - throw std::invalid_argument("Not yet implemented!"); - } - } - else { - otpack->kkot_beta->send(leaf_ot_messages+num_cmps, num_cmps*(num_digits-1), 2); - } + // otpack->kkot_beta->send(leaf_ot_messages, num_cmps, 1); + otpack->kkot[beta - 1]->send(leaf_ot_messages, num_cmps, 1); + if (r == 1) { + // otpack->kkot_beta->send(leaf_ot_messages+num_cmps, + // num_cmps*(num_digits-2), 2); + otpack->kkot[beta - 1]->send(leaf_ot_messages + num_cmps, + num_cmps * (num_digits - 2), 2); + otpack->iknp_straight->send( + leaf_ot_messages + num_cmps * (num_digits - 1), num_cmps, 2); + } else if (r != 0) { + // otpack->kkot_beta->send(leaf_ot_messages+num_cmps, + // num_cmps*(num_digits-2), 2); + otpack->kkot[beta - 1]->send(leaf_ot_messages + num_cmps, + num_cmps * (num_digits - 2), 2); + otpack->kkot[r - 1]->send( + leaf_ot_messages + num_cmps * (num_digits - 1), num_cmps, 2); + /* + if(r == 2){ + otpack->kkot_4->send(leaf_ot_messages+num_cmps*(num_digits-1), + num_cmps, 2); + } + else if(r == 3){ + otpack->kkot_8->send(leaf_ot_messages+num_cmps*(num_digits-1), + num_cmps, 2); + } + else if(r == 4){ + otpack->kkot_16->send(leaf_ot_messages+num_cmps*(num_digits-1), + num_cmps, 2); + } + else{ + throw std::invalid_argument("Not yet + implemented!"); + } + */ + } else { + // otpack->kkot_beta->send(leaf_ot_messages+num_cmps, + // num_cmps*(num_digits-1), 2); + otpack->kkot[beta - 1]->send(leaf_ot_messages + num_cmps, + num_cmps * (num_digits - 1), 2); + } #endif - // Cleanup - for(int i = 0; i < num_digits*num_cmps; i++) - delete[] leaf_ot_messages[i]; - delete[] leaf_ot_messages; - } - else // party = sci::BOB - { - // Perform Leaf OTs + // Cleanup + for (int i = 0; i < num_digits * num_cmps; i++) + delete[] leaf_ot_messages[i]; + delete[] leaf_ot_messages; + } else // party = sci::BOB + { + // Perform Leaf OTs #ifdef WAN_EXEC - otpack->kkot_beta->recv(leaf_res_cmp, digits, num_cmps*(num_digits), 2); + // otpack->kkot_beta->recv(leaf_res_cmp, digits, num_cmps*(num_digits), + // 2); + otpack->kkot[beta - 1]->recv(leaf_res_cmp, digits, + num_cmps * (num_digits), 2); #else - otpack->kkot_beta->recv(leaf_res_cmp, digits, num_cmps, 1); - if (r == 1) { - otpack->kkot_beta->recv(leaf_res_cmp+num_cmps, digits+num_cmps, num_cmps*(num_digits-2), 2); - otpack->iknp_straight->recv(leaf_res_cmp+num_cmps*(num_digits-1), - digits+num_cmps*(num_digits-1), num_cmps, 2); - } - else if (r != 0) { - otpack->kkot_beta->recv(leaf_res_cmp+num_cmps, digits+num_cmps, num_cmps*(num_digits-2), 2); - if(r == 2){ - otpack->kkot_4->recv(leaf_res_cmp+num_cmps*(num_digits-1), - digits+num_cmps*(num_digits-1), num_cmps, 2); - } - else if(r == 3){ - otpack->kkot_8->recv(leaf_res_cmp+num_cmps*(num_digits-1), - digits+num_cmps*(num_digits-1), num_cmps, 2); - } - else if(r == 4){ - otpack->kkot_16->recv(leaf_res_cmp+num_cmps*(num_digits-1), - digits+num_cmps*(num_digits-1), num_cmps, 2); - } - else{ - throw std::invalid_argument("Not yet implemented!"); - } - } - else { - otpack->kkot_beta->recv(leaf_res_cmp+num_cmps, digits+num_cmps, num_cmps*(num_digits-1), 2); - } + // otpack->kkot_beta->recv(leaf_res_cmp, digits, num_cmps, 1); + otpack->kkot[beta - 1]->recv(leaf_res_cmp, digits, num_cmps, 1); + if (r == 1) { + // otpack->kkot_beta->recv(leaf_res_cmp+num_cmps, digits+num_cmps, + // num_cmps*(num_digits-2), 2); + otpack->kkot[beta - 1]->recv(leaf_res_cmp + num_cmps, digits + num_cmps, + num_cmps * (num_digits - 2), 2); + otpack->iknp_straight->recv(leaf_res_cmp + num_cmps * (num_digits - 1), + digits + num_cmps * (num_digits - 1), + num_cmps, 2); + } else if (r != 0) { + // otpack->kkot_beta->recv(leaf_res_cmp+num_cmps, digits+num_cmps, + // num_cmps*(num_digits-2), 2); + otpack->kkot[beta - 1]->recv(leaf_res_cmp + num_cmps, digits + num_cmps, + num_cmps * (num_digits - 2), 2); + otpack->kkot[r - 1]->recv(leaf_res_cmp + num_cmps * (num_digits - 1), + digits + num_cmps * (num_digits - 1), + num_cmps, 2); + /* + if(r == 2){ + otpack->kkot_4->recv(leaf_res_cmp+num_cmps*(num_digits-1), + digits+num_cmps*(num_digits-1), + num_cmps, 2); + } + else if(r == 3){ + otpack->kkot_8->recv(leaf_res_cmp+num_cmps*(num_digits-1), + digits+num_cmps*(num_digits-1), + num_cmps, 2); + } + else if(r == 4){ + otpack->kkot_16->recv(leaf_res_cmp+num_cmps*(num_digits-1), + digits+num_cmps*(num_digits-1), + num_cmps, 2); + } + else{ + throw std::invalid_argument("Not yet + implemented!"); + } + */ + } else { + // otpack->kkot_beta->recv(leaf_res_cmp+num_cmps, digits+num_cmps, + // num_cmps*(num_digits-1), 2); + otpack->kkot[beta - 1]->recv(leaf_res_cmp + num_cmps, digits + num_cmps, + num_cmps * (num_digits - 1), 2); + } #endif - // Extract equality result from leaf_res_cmp - for(int i = num_cmps; i < num_digits*num_cmps; i++) { - leaf_res_eq[i] = leaf_res_cmp[i] & 1; - leaf_res_cmp[i] >>= 1; - } - } - - traverse_and_compute_ANDs(num_cmps, leaf_res_eq, leaf_res_cmp); - - for (int i = 0; i < num_cmps; i++) - res[i] = leaf_res_cmp[i]; - - // Cleanup - delete[] digits; - delete[] leaf_res_cmp; - delete[] leaf_res_eq; - } - - void set_leaf_ot_messages(uint8_t* ot_messages, - uint8_t digit, - int N, - uint8_t mask_cmp, - uint8_t mask_eq, - bool greater_than, - bool eq = true) - { - for(int i = 0; i < N; i++) { - if (greater_than) { - ot_messages[i] = ((digit > i) ^ mask_cmp); - } else { - ot_messages[i] = ((digit < i) ^ mask_cmp); - } - if (eq) { - ot_messages[i] = (ot_messages[i] << 1) | ((digit == i) ^ mask_eq); - } - } - } - - /************************************************************************************************** - * AND computation related functions - **************************************************************************************************/ - - void traverse_and_compute_ANDs(int num_cmps, uint8_t* leaf_res_eq, uint8_t* leaf_res_cmp){ + // Extract equality result from leaf_res_cmp + for (int i = num_cmps; i < num_digits * num_cmps; i++) { + leaf_res_eq[i] = leaf_res_cmp[i] & 1; + leaf_res_cmp[i] >>= 1; + } + } + + traverse_and_compute_ANDs(num_cmps, leaf_res_eq, leaf_res_cmp); + + for (int i = 0; i < old_num_cmps; i++) + res[i] = leaf_res_cmp[i]; + + // Cleanup + if (old_num_cmps != num_cmps) + delete[] data_ext; + delete[] digits; + delete[] leaf_res_cmp; + delete[] leaf_res_eq; + } + + void set_leaf_ot_messages(uint8_t *ot_messages, uint8_t digit, int N, + uint8_t mask_cmp, uint8_t mask_eq, + bool greater_than, bool eq = true) { + for (int i = 0; i < N; i++) { + if (greater_than) { + ot_messages[i] = ((digit > i) ^ mask_cmp); + } else { + ot_messages[i] = ((digit < i) ^ mask_cmp); + } + if (eq) { + ot_messages[i] = (ot_messages[i] << 1) | ((digit == i) ^ mask_eq); + } + } + } + + /************************************************************************************************** + * AND computation related functions + **************************************************************************************************/ + + void traverse_and_compute_ANDs(int num_cmps, uint8_t *leaf_res_eq, + uint8_t *leaf_res_cmp) { #ifdef WAN_EXEC - Triple triples_std((num_triples)*num_cmps, true); + Triple triples_std((num_triples)*num_cmps, true); #else - Triple triples_corr(num_triples_corr*num_cmps, true, num_cmps); - Triple triples_std(num_triples_std*num_cmps, true); + Triple triples_corr(num_triples_corr * num_cmps, true, num_cmps); + Triple triples_std(num_triples_std * num_cmps, true); #endif - // Generate required Bit-Triples + // Generate required Bit-Triples #ifdef WAN_EXEC - //std::cout<<"Running on WAN_EXEC; Skipping correlated triples"<<std::endl; - triple_gen->generate(party, &triples_std, _16KKOT_to_4OT); + // std::cout<<"Running on WAN_EXEC; Skipping correlated triples"<<std::endl; + triple_gen->generate(party, &triples_std, _16KKOT_to_4OT); #else - triple_gen->generate(party, &triples_corr, _8KKOT); - triple_gen->generate(party, &triples_std, _16KKOT_to_4OT); + triple_gen->generate(party, &triples_corr, _8KKOT); + triple_gen->generate(party, &triples_std, _16KKOT_to_4OT); #endif - // std::cout << "Bit Triples Generated" << std::endl; - - // Combine leaf OT results in a bottom-up fashion - int counter_std = 0, old_counter_std = 0; - int counter_corr = 0, old_counter_corr = 0; - int counter_combined = 0, old_counter_combined = 0; - uint8_t* ei = new uint8_t[(num_triples*num_cmps)/8]; - uint8_t* fi = new uint8_t[(num_triples*num_cmps)/8]; - uint8_t* e = new uint8_t[(num_triples*num_cmps)/8]; - uint8_t* f = new uint8_t[(num_triples*num_cmps)/8]; - - for(int i = 1; i < num_digits; i*=2) { - for(int j = 0; j < num_digits and j+i < num_digits; j += 2*i) { - if (j == 0) { + // std::cout << "Bit Triples Generated" << std::endl; + + // Combine leaf OT results in a bottom-up fashion + int counter_std = 0, old_counter_std = 0; + int counter_corr = 0, old_counter_corr = 0; + int counter_combined = 0, old_counter_combined = 0; + uint8_t *ei = new uint8_t[(num_triples * num_cmps) / 8]; + uint8_t *fi = new uint8_t[(num_triples * num_cmps) / 8]; + uint8_t *e = new uint8_t[(num_triples * num_cmps) / 8]; + uint8_t *f = new uint8_t[(num_triples * num_cmps) / 8]; + + for (int i = 1; i < num_digits; i *= 2) { + for (int j = 0; j < num_digits and j + i < num_digits; j += 2 * i) { + if (j == 0) { #ifdef WAN_EXEC - AND_step_1(ei+(counter_std*num_cmps)/8, fi+(counter_std*num_cmps)/8, - leaf_res_cmp+j*num_cmps, leaf_res_eq+(j+i)*num_cmps, - (triples_std.ai)+(counter_combined*num_cmps)/8, - (triples_std.bi)+(counter_combined*num_cmps)/8, num_cmps); - counter_std++; - counter_combined++; + AND_step_1( + ei + (counter_std * num_cmps) / 8, + fi + (counter_std * num_cmps) / 8, leaf_res_cmp + j * num_cmps, + leaf_res_eq + (j + i) * num_cmps, + (triples_std.ai) + (counter_combined * num_cmps) / 8, + (triples_std.bi) + (counter_combined * num_cmps) / 8, num_cmps); + counter_std++; + counter_combined++; #else - AND_step_1(ei+(counter_std*num_cmps)/8, fi+(counter_std*num_cmps)/8, - leaf_res_cmp+j*num_cmps, leaf_res_eq+(j+i)*num_cmps, - (triples_std.ai)+(counter_std*num_cmps)/8, - (triples_std.bi)+(counter_std*num_cmps)/8, num_cmps); - counter_std++; + AND_step_1(ei + (counter_std * num_cmps) / 8, + fi + (counter_std * num_cmps) / 8, + leaf_res_cmp + j * num_cmps, + leaf_res_eq + (j + i) * num_cmps, + (triples_std.ai) + (counter_std * num_cmps) / 8, + (triples_std.bi) + (counter_std * num_cmps) / 8, num_cmps); + counter_std++; #endif - } else { + } else { #ifdef WAN_EXEC - AND_step_1(ei+((num_triples_std+2*counter_corr)*num_cmps)/8, - fi+((num_triples_std+2*counter_corr)*num_cmps)/8, - leaf_res_cmp+j*num_cmps, leaf_res_eq+(j+i)*num_cmps, - (triples_std.ai)+(counter_combined*num_cmps)/8, - (triples_std.bi)+(counter_combined*num_cmps)/8, num_cmps); - counter_combined++; - AND_step_1(ei+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - fi+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - leaf_res_eq+j*num_cmps, leaf_res_eq+(j+i)*num_cmps, - (triples_std.ai)+(counter_combined*num_cmps)/8, - (triples_std.bi)+(counter_combined*num_cmps)/8, num_cmps); - counter_combined++; - counter_corr++; + AND_step_1( + ei + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + fi + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + leaf_res_cmp + j * num_cmps, leaf_res_eq + (j + i) * num_cmps, + (triples_std.ai) + (counter_combined * num_cmps) / 8, + (triples_std.bi) + (counter_combined * num_cmps) / 8, num_cmps); + counter_combined++; + AND_step_1( + ei + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + fi + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + leaf_res_eq + j * num_cmps, leaf_res_eq + (j + i) * num_cmps, + (triples_std.ai) + (counter_combined * num_cmps) / 8, + (triples_std.bi) + (counter_combined * num_cmps) / 8, num_cmps); + counter_combined++; + counter_corr++; #else - AND_step_1(ei+((num_triples_std+2*counter_corr)*num_cmps)/8, - fi+((num_triples_std+2*counter_corr)*num_cmps)/8, - leaf_res_cmp+j*num_cmps, leaf_res_eq+(j+i)*num_cmps, - (triples_corr.ai)+(2*counter_corr*num_cmps)/8, - (triples_corr.bi)+(2*counter_corr*num_cmps)/8, num_cmps); - AND_step_1(ei+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - fi+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - leaf_res_eq+j*num_cmps, leaf_res_eq+(j+i)*num_cmps, - (triples_corr.ai)+((2*counter_corr+1)*num_cmps)/8, - (triples_corr.bi)+((2*counter_corr+1)*num_cmps)/8, num_cmps); - counter_corr++; + AND_step_1( + ei + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + fi + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + leaf_res_cmp + j * num_cmps, leaf_res_eq + (j + i) * num_cmps, + (triples_corr.ai) + (2 * counter_corr * num_cmps) / 8, + (triples_corr.bi) + (2 * counter_corr * num_cmps) / 8, num_cmps); + AND_step_1( + ei + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + fi + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + leaf_res_eq + j * num_cmps, leaf_res_eq + (j + i) * num_cmps, + (triples_corr.ai) + ((2 * counter_corr + 1) * num_cmps) / 8, + (triples_corr.bi) + ((2 * counter_corr + 1) * num_cmps) / 8, + num_cmps); + counter_corr++; #endif - } - } - int offset_std = (old_counter_std*num_cmps)/8; - int size_std = ((counter_std - old_counter_std)*num_cmps)/8; - int offset_corr = ((num_triples_std + 2*old_counter_corr)*num_cmps)/8; - int size_corr = (2*(counter_corr - old_counter_corr)*num_cmps)/8; - - if(party == sci::ALICE) - { - io->send_data(ei+offset_std, size_std); - io->send_data(ei+offset_corr, size_corr); - io->send_data(fi+offset_std, size_std); - io->send_data(fi+offset_corr, size_corr); - io->recv_data(e+offset_std, size_std); - io->recv_data(e+offset_corr, size_corr); - io->recv_data(f+offset_std, size_std); - io->recv_data(f+offset_corr, size_corr); - } - else // party = sci::BOB - { - io->recv_data(e+offset_std, size_std); - io->recv_data(e+offset_corr, size_corr); - io->recv_data(f+offset_std, size_std); - io->recv_data(f+offset_corr, size_corr); - io->send_data(ei+offset_std, size_std); - io->send_data(ei+offset_corr, size_corr); - io->send_data(fi+offset_std, size_std); - io->send_data(fi+offset_corr, size_corr); - } - for(int i = 0; i < size_std; i++) { - e[i+offset_std] ^= ei[i+offset_std]; - f[i+offset_std] ^= fi[i+offset_std]; - } - for(int i = 0; i < size_corr; i++) { - e[i+offset_corr] ^= ei[i+offset_corr]; - f[i+offset_corr] ^= fi[i+offset_corr]; - } - - counter_std = old_counter_std; - counter_corr = old_counter_corr; + } + } + int offset_std = (old_counter_std * num_cmps) / 8; + int size_std = ((counter_std - old_counter_std) * num_cmps) / 8; + int offset_corr = + ((num_triples_std + 2 * old_counter_corr) * num_cmps) / 8; + int size_corr = (2 * (counter_corr - old_counter_corr) * num_cmps) / 8; + + if (party == sci::ALICE) { + io->send_data(ei + offset_std, size_std); + io->send_data(ei + offset_corr, size_corr); + io->send_data(fi + offset_std, size_std); + io->send_data(fi + offset_corr, size_corr); + io->recv_data(e + offset_std, size_std); + io->recv_data(e + offset_corr, size_corr); + io->recv_data(f + offset_std, size_std); + io->recv_data(f + offset_corr, size_corr); + } else // party = sci::BOB + { + io->recv_data(e + offset_std, size_std); + io->recv_data(e + offset_corr, size_corr); + io->recv_data(f + offset_std, size_std); + io->recv_data(f + offset_corr, size_corr); + io->send_data(ei + offset_std, size_std); + io->send_data(ei + offset_corr, size_corr); + io->send_data(fi + offset_std, size_std); + io->send_data(fi + offset_corr, size_corr); + } + for (int i = 0; i < size_std; i++) { + e[i + offset_std] ^= ei[i + offset_std]; + f[i + offset_std] ^= fi[i + offset_std]; + } + for (int i = 0; i < size_corr; i++) { + e[i + offset_corr] ^= ei[i + offset_corr]; + f[i + offset_corr] ^= fi[i + offset_corr]; + } + + counter_std = old_counter_std; + counter_corr = old_counter_corr; #ifdef WAN_EXEC - counter_combined = old_counter_combined; + counter_combined = old_counter_combined; #endif - for(int j = 0; j < num_digits and j+i < num_digits; j += 2*i) { - if (j == 0) { + for (int j = 0; j < num_digits and j + i < num_digits; j += 2 * i) { + if (j == 0) { #ifdef WAN_EXEC - AND_step_2(leaf_res_cmp+j*num_cmps, - e+(counter_std*num_cmps)/8, - f+(counter_std*num_cmps)/8, - ei+(counter_std*num_cmps)/8, - fi+(counter_std*num_cmps)/8, - (triples_std.ai)+(counter_combined*num_cmps)/8, - (triples_std.bi)+(counter_combined*num_cmps)/8, - (triples_std.ci)+(counter_combined*num_cmps)/8, num_cmps); - counter_combined++; + AND_step_2( + leaf_res_cmp + j * num_cmps, e + (counter_std * num_cmps) / 8, + f + (counter_std * num_cmps) / 8, + ei + (counter_std * num_cmps) / 8, + fi + (counter_std * num_cmps) / 8, + (triples_std.ai) + (counter_combined * num_cmps) / 8, + (triples_std.bi) + (counter_combined * num_cmps) / 8, + (triples_std.ci) + (counter_combined * num_cmps) / 8, num_cmps); + counter_combined++; #else - AND_step_2(leaf_res_cmp+j*num_cmps, - e+(counter_std*num_cmps)/8, - f+(counter_std*num_cmps)/8, - ei+(counter_std*num_cmps)/8, - fi+(counter_std*num_cmps)/8, - (triples_std.ai)+(counter_std*num_cmps)/8, - (triples_std.bi)+(counter_std*num_cmps)/8, - (triples_std.ci)+(counter_std*num_cmps)/8, num_cmps); + AND_step_2(leaf_res_cmp + j * num_cmps, + e + (counter_std * num_cmps) / 8, + f + (counter_std * num_cmps) / 8, + ei + (counter_std * num_cmps) / 8, + fi + (counter_std * num_cmps) / 8, + (triples_std.ai) + (counter_std * num_cmps) / 8, + (triples_std.bi) + (counter_std * num_cmps) / 8, + (triples_std.ci) + (counter_std * num_cmps) / 8, num_cmps); #endif - for(int k = 0; k < num_cmps; k++) - leaf_res_cmp[j*num_cmps+k] ^= leaf_res_cmp[(j+i)*num_cmps+k]; - counter_std++; - } else { + for (int k = 0; k < num_cmps; k++) + leaf_res_cmp[j * num_cmps + k] ^= + leaf_res_cmp[(j + i) * num_cmps + k]; + counter_std++; + } else { #ifdef WAN_EXEC - AND_step_2(leaf_res_cmp+j*num_cmps, - e+((num_triples_std+2*counter_corr)*num_cmps)/8, - f+((num_triples_std+2*counter_corr)*num_cmps)/8, - ei+((num_triples_std+2*counter_corr)*num_cmps)/8, - fi+((num_triples_std+2*counter_corr)*num_cmps)/8, - (triples_std.ai)+(counter_combined*num_cmps)/8, - (triples_std.bi)+(counter_combined*num_cmps)/8, - (triples_std.ci)+(counter_combined*num_cmps)/8, num_cmps); - counter_combined++; - AND_step_2(leaf_res_eq+j*num_cmps, - e+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - f+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - ei+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - fi+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - (triples_std.ai)+(counter_combined*num_cmps)/8, - (triples_std.bi)+(counter_combined*num_cmps)/8, - (triples_std.ci)+(counter_combined*num_cmps)/8, num_cmps); - counter_combined++; + AND_step_2(leaf_res_cmp + j * num_cmps, + e + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + f + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + ei + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + fi + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + (triples_std.ai) + (counter_combined * num_cmps) / 8, + (triples_std.bi) + (counter_combined * num_cmps) / 8, + (triples_std.ci) + (counter_combined * num_cmps) / 8, + num_cmps); + counter_combined++; + AND_step_2( + leaf_res_eq + j * num_cmps, + e + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + f + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + ei + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + fi + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + (triples_std.ai) + (counter_combined * num_cmps) / 8, + (triples_std.bi) + (counter_combined * num_cmps) / 8, + (triples_std.ci) + (counter_combined * num_cmps) / 8, num_cmps); + counter_combined++; #else - AND_step_2(leaf_res_cmp+j*num_cmps, - e+((num_triples_std+2*counter_corr)*num_cmps)/8, - f+((num_triples_std+2*counter_corr)*num_cmps)/8, - ei+((num_triples_std+2*counter_corr)*num_cmps)/8, - fi+((num_triples_std+2*counter_corr)*num_cmps)/8, - (triples_corr.ai)+(2*counter_corr*num_cmps)/8, - (triples_corr.bi)+(2*counter_corr*num_cmps)/8, - (triples_corr.ci)+(2*counter_corr*num_cmps)/8, num_cmps); - AND_step_2(leaf_res_eq+j*num_cmps, - e+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - f+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - ei+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - fi+((num_triples_std+(2*counter_corr+1))*num_cmps)/8, - (triples_corr.ai)+((2*counter_corr+1)*num_cmps)/8, - (triples_corr.bi)+((2*counter_corr+1)*num_cmps)/8, - (triples_corr.ci)+((2*counter_corr+1)*num_cmps)/8, num_cmps); + AND_step_2(leaf_res_cmp + j * num_cmps, + e + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + f + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + ei + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + fi + ((num_triples_std + 2 * counter_corr) * num_cmps) / 8, + (triples_corr.ai) + (2 * counter_corr * num_cmps) / 8, + (triples_corr.bi) + (2 * counter_corr * num_cmps) / 8, + (triples_corr.ci) + (2 * counter_corr * num_cmps) / 8, + num_cmps); + AND_step_2( + leaf_res_eq + j * num_cmps, + e + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + f + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + ei + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + fi + ((num_triples_std + (2 * counter_corr + 1)) * num_cmps) / 8, + (triples_corr.ai) + ((2 * counter_corr + 1) * num_cmps) / 8, + (triples_corr.bi) + ((2 * counter_corr + 1) * num_cmps) / 8, + (triples_corr.ci) + ((2 * counter_corr + 1) * num_cmps) / 8, + num_cmps); #endif - for(int k = 0; k < num_cmps; k++) - leaf_res_cmp[j*num_cmps+k] ^= leaf_res_cmp[(j+i)*num_cmps+k]; - counter_corr++; - } - } - old_counter_std = counter_std; - old_counter_corr = counter_corr; + for (int k = 0; k < num_cmps; k++) + leaf_res_cmp[j * num_cmps + k] ^= + leaf_res_cmp[(j + i) * num_cmps + k]; + counter_corr++; + } + } + old_counter_std = counter_std; + old_counter_corr = counter_corr; #ifdef WAN_EXEC - old_counter_combined = counter_combined; + old_counter_combined = counter_combined; #endif - } + } #ifdef WAN_EXEC - assert(counter_combined == num_triples); + assert(counter_combined == num_triples); #else - assert(counter_std == num_triples_std); - assert(2*counter_corr == num_triples_corr); + assert(counter_std == num_triples_std); + assert(2 * counter_corr == num_triples_corr); #endif - //cleanup - delete[] ei; - delete[] fi; - delete[] e; - delete[] f; - - } - - void AND_step_1(uint8_t* ei, // evaluates batch of 8 ANDs - uint8_t* fi, - uint8_t* xi, - uint8_t* yi, - uint8_t* ai, - uint8_t* bi, - int num_ANDs) { - assert(num_ANDs % 8 == 0); - for(int i = 0; i < num_ANDs; i+=8) { - ei[i/8] = ai[i/8]; - fi[i/8] = bi[i/8]; - ei[i/8] ^= sci::bool_to_uint8(xi+i, 8); - fi[i/8] ^= sci::bool_to_uint8(yi+i, 8); - } - } - void AND_step_2(uint8_t* zi, // evaluates batch of 8 ANDs - uint8_t* e, - uint8_t* f, - uint8_t* ei, - uint8_t* fi, - uint8_t* ai, - uint8_t* bi, - uint8_t* ci, - int num_ANDs) - { - assert(num_ANDs % 8 == 0); - for(int i = 0; i < num_ANDs; i+=8) { - uint8_t temp_z; - if (party == sci::ALICE) - temp_z = e[i/8] & f[i/8]; - else - temp_z = 0; - temp_z ^= f[i/8] & ai[i/8]; - temp_z ^= e[i/8] & bi[i/8]; - temp_z ^= ci[i/8]; - sci::uint8_to_bool(zi+i, temp_z, 8); - } - } + // cleanup + delete[] ei; + delete[] fi; + delete[] e; + delete[] f; + } + + void AND_step_1(uint8_t *ei, // evaluates batch of 8 ANDs + uint8_t *fi, uint8_t *xi, uint8_t *yi, uint8_t *ai, + uint8_t *bi, int num_ANDs) { + assert(num_ANDs % 8 == 0); + for (int i = 0; i < num_ANDs; i += 8) { + ei[i / 8] = ai[i / 8]; + fi[i / 8] = bi[i / 8]; + ei[i / 8] ^= sci::bool_to_uint8(xi + i, 8); + fi[i / 8] ^= sci::bool_to_uint8(yi + i, 8); + } + } + void AND_step_2(uint8_t *zi, // evaluates batch of 8 ANDs + uint8_t *e, uint8_t *f, uint8_t *ei, uint8_t *fi, uint8_t *ai, + uint8_t *bi, uint8_t *ci, int num_ANDs) { + assert(num_ANDs % 8 == 0); + for (int i = 0; i < num_ANDs; i += 8) { + uint8_t temp_z; + if (party == sci::ALICE) + temp_z = e[i / 8] & f[i / 8]; + else + temp_z = 0; + temp_z ^= f[i / 8] & ai[i / 8]; + temp_z ^= e[i / 8] & bi[i / 8]; + temp_z ^= ci[i / 8]; + sci::uint8_to_bool(zi + i, temp_z, 8); + } + } }; -#endif //MILLIONAIRE_H__ +#endif // MILLIONAIRE_H__ diff --git a/SCI/src/Millionaire/millionaire_with_equality.h b/SCI/src/Millionaire/millionaire_with_equality.h new file mode 100644 index 00000000..27ffd92f --- /dev/null +++ b/SCI/src/Millionaire/millionaire_with_equality.h @@ -0,0 +1,398 @@ +/* +Authors: Mayank Rathee +Copyright: +Copyright (c) 2020 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef MILLIONAIRE_WITH_EQ_H__ +#define MILLIONAIRE_WITH_EQ_H__ +#include "Millionaire/millionaire.h" +#include "OT/emp-ot.h" +#include "utils/emp-tool.h" +#include <cmath> + +template <typename IO> class MillionaireWithEquality { +public: + IO *io = nullptr; + sci::OTPack<IO> *otpack; + TripleGenerator<IO> *triple_gen; + MillionaireProtocol<IO> *mill; + bool del_mill = false; + int party; + int l, r, log_alpha, beta, beta_pow; + int num_digits, num_triples, log_num_digits; + uint8_t mask_beta, mask_r; + + MillionaireWithEquality(int party, IO *io, sci::OTPack<IO> *otpack, + MillionaireProtocol<IO> *mill_in = nullptr, + int bitlength = 32, int radix_base = MILL_PARAM) { + this->party = party; + this->io = io; + this->otpack = otpack; + this->mill = mill_in; + if (mill_in == nullptr) { + del_mill = true; + mill = + new MillionaireProtocol<IO>(party, io, otpack, bitlength, radix_base); + } + this->triple_gen = mill->triple_gen; + configure(bitlength, radix_base); + } + + void configure(int bitlength, int radix_base = MILL_PARAM) { + assert(radix_base <= 8); + assert(bitlength <= 64); + this->l = bitlength; + this->beta = radix_base; + + this->num_digits = ceil((double)l / beta); + this->r = l % beta; + this->log_alpha = sci::bitlen(num_digits) - 1; + this->log_num_digits = log_alpha + 1; + this->num_triples = 2 * num_digits - 2; + if (beta == 8) + this->mask_beta = -1; + else + this->mask_beta = (1 << beta) - 1; + this->mask_r = (1 << r) - 1; + this->beta_pow = 1 << beta; + } + + ~MillionaireWithEquality() { + if (del_mill) { + delete mill; + } + } + + void bitlen_lt_beta(uint8_t *res_cmp, uint8_t *res_eq, uint64_t *data, + int num_cmps, int bitlength, bool greater_than = true, + int radix_base = MILL_PARAM) { + uint8_t N = 1 << bitlength; + uint8_t mask = N - 1; + if (party == sci::ALICE) { + sci::PRG128 prg; + prg.random_data(res_cmp, num_cmps * sizeof(uint8_t)); + prg.random_data(res_eq, num_cmps * sizeof(uint8_t)); + uint8_t **leaf_messages = new uint8_t *[num_cmps]; + for (int i = 0; i < num_cmps; i++) { + res_cmp[i] &= 1; + res_eq[i] &= 1; + leaf_messages[i] = new uint8_t[N]; + this->mill->set_leaf_ot_messages(leaf_messages[i], (data[i] & mask), N, + res_cmp[i], res_eq[i], greater_than, + true); + } + if (bitlength > 1) { + otpack->kkot[bitlength - 1]->send(leaf_messages, num_cmps, 2); + } else { + otpack->iknp_straight->send(leaf_messages, num_cmps, 2); + } + + for (int i = 0; i < num_cmps; i++) + delete[] leaf_messages[i]; + delete[] leaf_messages; + } else { // party == BOB + uint8_t *choice = new uint8_t[num_cmps]; + for (int i = 0; i < num_cmps; i++) { + choice[i] = data[i] & mask; + } + if (bitlength > 1) { + otpack->kkot[bitlength - 1]->recv(res_cmp, choice, num_cmps, 2); + } else { + otpack->iknp_straight->recv(res_cmp, choice, num_cmps, 2); + } + for (int i = 0; i < num_cmps; i++) { + res_eq[i] = res_cmp[i] & 1; + res_cmp[i] >>= 1; + } + delete[] choice; + } + return; + } + + void compare_with_eq(uint8_t *res_cmp, uint8_t *res_eq, uint64_t *data, + int num_cmps, int bitlength, bool greater_than = true, + int radix_base = MILL_PARAM) { + configure(bitlength, radix_base); + + if (bitlength <= beta) { + bitlen_lt_beta(res_cmp, res_eq, data, num_cmps, bitlength, greater_than, + radix_base); + return; + } + + int old_num_cmps = num_cmps; + // num_cmps should be a multiple of 8 + num_cmps = ceil(num_cmps / 8.0) * 8; + + // padding with 0s if data dim not multiple of 8 + uint64_t *data_ext; + if (old_num_cmps == num_cmps) + data_ext = data; + else { + data_ext = new uint64_t[num_cmps]; + memcpy(data_ext, data, old_num_cmps * sizeof(uint64_t)); + memset(data_ext + old_num_cmps, 0, + (num_cmps - old_num_cmps) * sizeof(uint64_t)); + } + + uint8_t *digits; // num_digits * num_cmps + uint8_t *leaf_res_cmp; // num_digits * num_cmps + uint8_t *leaf_res_eq; // num_digits * num_cmps + + digits = new uint8_t[num_digits * num_cmps]; + leaf_res_cmp = new uint8_t[num_digits * num_cmps]; + leaf_res_eq = new uint8_t[num_digits * num_cmps]; + + // Extract radix-digits from data + for (int i = 0; i < num_digits; i++) // Stored from LSB to MSB + for (int j = 0; j < num_cmps; j++) + if ((i == num_digits - 1) && (r != 0)) + digits[i * num_cmps + j] = + (uint8_t)(data_ext[j] >> i * beta) & mask_r; + else + digits[i * num_cmps + j] = + (uint8_t)(data_ext[j] >> i * beta) & mask_beta; + // ====================== + + // Set leaf OT messages now + if (party == sci::ALICE) { + uint8_t * + *leaf_ot_messages; // (num_digits * num_cmps) X beta_pow (=2^beta) + leaf_ot_messages = new uint8_t *[num_digits * num_cmps]; + for (int i = 0; i < num_digits * num_cmps; i++) + leaf_ot_messages[i] = new uint8_t[beta_pow]; + + // Set Leaf OT messages + triple_gen->prg->random_bool((bool *)leaf_res_cmp, num_digits * num_cmps); + triple_gen->prg->random_bool((bool *)leaf_res_eq, num_digits * num_cmps); + for (int i = 0; i < num_digits; i++) { + for (int j = 0; j < num_cmps; j++) { + if (i == (num_digits - 1) && (r > 0)) { + this->mill->set_leaf_ot_messages( + leaf_ot_messages[i * num_cmps + j], digits[i * num_cmps + j], + 1ULL << r, leaf_res_cmp[i * num_cmps + j], + leaf_res_eq[i * num_cmps + j], greater_than); + } else { + this->mill->set_leaf_ot_messages( + leaf_ot_messages[i * num_cmps + j], digits[i * num_cmps + j], + beta_pow, leaf_res_cmp[i * num_cmps + j], + leaf_res_eq[i * num_cmps + j], greater_than); + } + } + } + + // Perform Leaf OTs with comparison and equality + if (r == 1) { + // All branches except r + otpack->kkot[beta - 1]->send(leaf_ot_messages, + num_cmps * (num_digits - 1), 2); + // r branch + otpack->iknp_straight->send( + leaf_ot_messages + num_cmps * (num_digits - 1), num_cmps, 2); + } else if (r != 0) { + // All branches except r + otpack->kkot[beta - 1]->send(leaf_ot_messages, + num_cmps * (num_digits - 1), 2); + // r branch + otpack->kkot[r - 1]->send( + leaf_ot_messages + num_cmps * (num_digits - 1), num_cmps, 2); + } else { + // All branches including r, r is 0 + otpack->kkot[beta - 1]->send(leaf_ot_messages, num_cmps * (num_digits), + 2); + } + + // Cleanup + for (int i = 0; i < num_digits * num_cmps; i++) + delete[] leaf_ot_messages[i]; + delete[] leaf_ot_messages; + } else // party = sci::BOB + { + // Perform Leaf OTs + if (r == 1) { + // All branches except r + otpack->kkot[beta - 1]->recv(leaf_res_cmp, digits, + num_cmps * (num_digits - 1), 2); + // r branch + otpack->iknp_straight->recv(leaf_res_cmp + num_cmps * (num_digits - 1), + digits + num_cmps * (num_digits - 1), + num_cmps, 2); + } else if (r != 0) { + // All branches except r + otpack->kkot[beta - 1]->recv(leaf_res_cmp, digits, + num_cmps * (num_digits - 1), 2); + // r branch + otpack->kkot[r - 1]->recv(leaf_res_cmp + num_cmps * (num_digits - 1), + digits + num_cmps * (num_digits - 1), + num_cmps, 2); + } else { + // All branches including r, r is 0 + otpack->kkot[beta - 1]->recv(leaf_res_cmp, digits, + num_cmps * (num_digits), 2); + } + + // Extract equality result from leaf_res_cmp + for (int i = 0; i < num_digits * num_cmps; i++) { + leaf_res_eq[i] = leaf_res_cmp[i] & 1; + leaf_res_cmp[i] >>= 1; + } + } + + traverse_and_compute_ANDs(num_cmps, leaf_res_eq, leaf_res_cmp); + + for (int i = 0; i < old_num_cmps; i++) { + res_cmp[i] = leaf_res_cmp[i]; + res_eq[i] = leaf_res_eq[i]; + } + + // Cleanup + if (old_num_cmps != num_cmps) + delete[] data_ext; + delete[] digits; + delete[] leaf_res_cmp; + delete[] leaf_res_eq; + } + + /************************************************************************************************** + * AND computation related functions + **************************************************************************************************/ + + void traverse_and_compute_ANDs(int num_cmps, uint8_t *leaf_res_eq, + uint8_t *leaf_res_cmp) { + Triple triples_corr((num_triples)*num_cmps, true, num_cmps); + + // Generate required Bit-Triples + triple_gen->generate(party, &triples_corr, _8KKOT); + + // Combine leaf OT results in a bottom-up fashion + int counter_triples_used = 0, old_counter_triples_used = 0; + uint8_t *ei = new uint8_t[(num_triples * num_cmps) / 8]; + uint8_t *fi = new uint8_t[(num_triples * num_cmps) / 8]; + uint8_t *e = new uint8_t[(num_triples * num_cmps) / 8]; + uint8_t *f = new uint8_t[(num_triples * num_cmps) / 8]; + + for (int i = 1; i < num_digits; + i *= 2) { // i denotes the distance between 2 nodes which should be + // ANDed together + for (int j = 0; j < num_digits and j + i < num_digits; + j += 2 * i) { // j=0 is LSD and j=num_digits-1 is MSD + + // CMP_j: Use 1 triple for opening e = a + cmp_j and f = b + eq_j+i. + this->mill->AND_step_1( + ei + (2 * counter_triples_used * num_cmps) / 8, + fi + (2 * counter_triples_used * num_cmps) / 8, + leaf_res_cmp + j * num_cmps, leaf_res_eq + (j + i) * num_cmps, + (triples_corr.ai) + (2 * counter_triples_used * num_cmps) / 8, + (triples_corr.bi) + (2 * counter_triples_used * num_cmps) / 8, + num_cmps); + // EQ_j: Use 1 triple for opening e = a + eq_j and f = b + eq_j+i. + this->mill->AND_step_1( + ei + ((2 * counter_triples_used + 1) * num_cmps) / 8, + fi + ((2 * counter_triples_used + 1) * num_cmps) / 8, + leaf_res_eq + j * num_cmps, leaf_res_eq + (j + i) * num_cmps, + (triples_corr.ai) + ((2 * counter_triples_used + 1) * num_cmps) / 8, + (triples_corr.bi) + ((2 * counter_triples_used + 1) * num_cmps) / 8, + num_cmps); + counter_triples_used++; + } + int offset = (2 * old_counter_triples_used * num_cmps) / 8; + int size_used = + (2 * (counter_triples_used - old_counter_triples_used) * num_cmps) / + 8; + + if (party == sci::ALICE) { + // Send share of e and f + io->send_data(ei + offset, size_used); + io->send_data(ei + offset, size_used); + io->send_data(fi + offset, size_used); + io->send_data(fi + offset, size_used); + // Receive share of e and f + io->recv_data(e + offset, size_used); + io->recv_data(e + offset, size_used); + io->recv_data(f + offset, size_used); + io->recv_data(f + offset, size_used); + } else // party = sci::BOB + { + // Receive share of e and f + io->recv_data(e + offset, size_used); + io->recv_data(e + offset, size_used); + io->recv_data(f + offset, size_used); + io->recv_data(f + offset, size_used); + // Send share of e and f + io->send_data(ei + offset, size_used); + io->send_data(ei + offset, size_used); + io->send_data(fi + offset, size_used); + io->send_data(fi + offset, size_used); + } + + // Reconstruct e and f + for (int i = 0; i < size_used; i++) { + e[i + offset] ^= ei[i + offset]; + f[i + offset] ^= fi[i + offset]; + } + + counter_triples_used = old_counter_triples_used; + + // Step 2 of AND computation + for (int j = 0; j < num_digits and j + i < num_digits; + j += 2 * i) { // j=0 is LSD and j=num_digits-1 is MSD + + // CMP_j: Use 1 triple compute cmp_j AND eq_j+i. + this->mill->AND_step_2( + leaf_res_cmp + j * num_cmps, + e + (2 * counter_triples_used * num_cmps) / 8, + f + (2 * counter_triples_used * num_cmps) / 8, + nullptr, // not used in function + nullptr, // not used in function + (triples_corr.ai) + (2 * counter_triples_used * num_cmps) / 8, + (triples_corr.bi) + (2 * counter_triples_used * num_cmps) / 8, + (triples_corr.ci) + (2 * counter_triples_used * num_cmps) / 8, + num_cmps); + // EQ_j: Use 1 triple compute eq_j AND eq_j+i. + this->mill->AND_step_2( + leaf_res_eq + j * num_cmps, + e + ((2 * counter_triples_used + 1) * num_cmps) / 8, + f + ((2 * counter_triples_used + 1) * num_cmps) / 8, + nullptr, // not used in function + nullptr, // not used in function + (triples_corr.ai) + ((2 * counter_triples_used + 1) * num_cmps) / 8, + (triples_corr.bi) + ((2 * counter_triples_used + 1) * num_cmps) / 8, + (triples_corr.ci) + ((2 * counter_triples_used + 1) * num_cmps) / 8, + num_cmps); + for (int k = 0; k < num_cmps; k++) { + leaf_res_cmp[j * num_cmps + k] ^= + leaf_res_cmp[(j + i) * num_cmps + k]; + } + counter_triples_used++; + } + + old_counter_triples_used = counter_triples_used; + } + + assert(2 * counter_triples_used == num_triples); + + // cleanup + delete[] ei; + delete[] fi; + delete[] e; + delete[] f; + } +}; + +#endif // MILLIONAIRE_WITH_EQ_H__ diff --git a/SCI/src/NonLinear/argmax.h b/SCI/src/NonLinear/argmax.h index 4f373f21..32492688 100644 --- a/SCI/src/NonLinear/argmax.h +++ b/SCI/src/NonLinear/argmax.h @@ -22,464 +22,460 @@ SOFTWARE. #ifndef ARGMAX_H__ #define ARGMAX_H__ -#include "NonLinear/relu-ring.h" #include "NonLinear/relu-field.h" +#include "NonLinear/relu-ring.h" + +template <typename IO, typename type> class ArgMaxProtocol { +public: + IO *io = nullptr; + sci::OTPack<IO> *otpack = nullptr; + ReLURingProtocol<IO, type> *relu_oracle = nullptr; + ReLUFieldProtocol<IO, type> *relu_field_oracle = nullptr; + int party; + int algeb_str; + int l, b; + int num_cmps; + uint64_t prime_mod; + uint8_t zero_small = 0; + uint64_t mask32_lower = (1ULL << 32) - 1ULL; + uint64_t mask32_upper = -1ULL - mask32_lower; + uint64_t mask_upper, mask_lower; + bool createdReluObj = false; + type mask_l; + + // Constructor + ArgMaxProtocol(int party, int algeb_str, IO *io, int l, int b, uint64_t prime, + sci::OTPack<IO> *otpack, + ReLUProtocol<IO, type> *relu_obj = nullptr) { + this->party = party; + this->algeb_str = algeb_str; + this->io = io; + this->l = l; + mask_lower = (1ULL << this->l) - 1; + mask_upper = (1ULL << (2 * this->l)) - 1 - mask_lower; + this->b = b; + this->prime_mod = prime; + this->otpack = otpack; + if (algeb_str == RING) { + if (relu_obj == nullptr) { + this->relu_oracle = + new ReLURingProtocol<IO, type>(party, RING, io, l, b, otpack); + createdReluObj = true; + } else { + this->relu_oracle = (ReLURingProtocol<IO, type> *)relu_obj; + } + } else { + if (relu_obj == nullptr) { + this->relu_field_oracle = new ReLUFieldProtocol<IO, type>( + party, FIELD, io, l, b, this->prime_mod, otpack); + createdReluObj = true; + } else { + this->relu_field_oracle = (ReLUFieldProtocol<IO, type> *)relu_obj; + } + } + configure(); + } + + // Destructor + ~ArgMaxProtocol() { + if (createdReluObj) { + if (algeb_str == RING) + delete relu_oracle; + else + delete relu_field_oracle; + } + } + + void configure() { + if (this->l != 32 && this->l != 64) { + mask_l = (type)((1ULL << l) - 1); + } else if (this->l == 32) { + mask_l = -1; + } else { // l = 64 + mask_l = -1ULL; + } + } + + int next_eight_multiple(int val) { + for (int i = 0; i < 8; i++) { + if ((val + i) % 8 == 0) { + return (val + i); + } + } + return 0; + } + + void ArgMaxMPC(int size, type *inpArr, type *maxi, bool get_max_too = false, + type *max_val = nullptr) { + type *input_temp = new type[size + 16]; + type *input_argmax_temp = new type[size + 16]; + for (int i = 0; i < size; i++) { + input_temp[i] = inpArr[i]; + input_argmax_temp[i] = 0; + } + if (party == sci::ALICE) { + for (type i = 0; i < (type)size; i++) { + input_argmax_temp[i] = i; + } + } + if (size & 1) { + input_temp[size] = input_temp[size - 1]; + input_argmax_temp[size] = input_argmax_temp[size - 1]; + size += 1; + } + type *compare_with = new type[size + 16]; + type *compare_with_argmax = new type[size + 16]; + type *relu_res = new type[size + 16]; + type *argmax_res = new type[size + 16]; + int no_of_nodes = size; + int no_of_nodes_child; + int pad1, pad2; + int times_stuck_on_8 = 0; + + while (no_of_nodes > 1) { + // std::cout<<"#nodes = "<<no_of_nodes<<std::endl; + no_of_nodes_child = (int)ceil((float)no_of_nodes / (float)2); + pad1 = next_eight_multiple(no_of_nodes_child); + pad1 = pad1 - no_of_nodes_child; + pad2 = no_of_nodes + 2 * pad1; + no_of_nodes_child += pad1; + if (no_of_nodes_child == 8) { + times_stuck_on_8++; + } + if (times_stuck_on_8 >= 5) { + // The backend code only supports a minimum batch size of 8 + // So, whenever we have less than 8 child nodes, we pad it to get 8 + // nodes. The child nodes are = 8 in the following cases: #parentnodes = + // 16, 8, 4, 2, 1. We will get the argmax result when parent nodes = 1. + // So, times_stuck_on_8 >= 5. + break; + } + for (int i = no_of_nodes; i < pad2; i++) { + input_temp[i] = input_temp[no_of_nodes - 1]; + input_argmax_temp[i] = input_argmax_temp[no_of_nodes - 1]; + } + if (this->algeb_str == FIELD) { + for (int i = 0; i < (pad2); i += 2) { + compare_with[i / 2] = sci::neg_mod( + (int64_t)(input_temp[i] - input_temp[i + 1]), this->prime_mod); + compare_with_argmax[i / 2] = sci::neg_mod( + (int64_t)(input_argmax_temp[i] - input_argmax_temp[i + 1]), + this->prime_mod); + } + } else { // RING + for (int i = 0; i < (pad2); i += 2) { + compare_with[i / 2] = (input_temp[i] - input_temp[i + 1]); + compare_with_argmax[i / 2] = + (input_argmax_temp[i] - input_argmax_temp[i + 1]); + } + } + if (this->l > 32) { + argmax_this_level_super_32(argmax_res, relu_res, compare_with_argmax, + compare_with, no_of_nodes_child); + } else { + argmax_this_level_sub_32(argmax_res, relu_res, compare_with_argmax, + compare_with, no_of_nodes_child); + } + if (this->algeb_str == FIELD) { + for (int i = 0; i < (no_of_nodes_child); i++) { + input_temp[i] = + (relu_res[i] + input_temp[2 * i + 1]) % this->prime_mod; + input_argmax_temp[i] = + (argmax_res[i] + input_argmax_temp[2 * i + 1]) % this->prime_mod; + } + } else { // RING + for (int i = 0; i < (no_of_nodes_child); i++) { + input_temp[i] = (relu_res[i] + input_temp[2 * i + 1]) & mask_l; + input_argmax_temp[i] = + (argmax_res[i] + input_argmax_temp[2 * i + 1]) & mask_l; + } + } + no_of_nodes = no_of_nodes_child; + } + maxi[0] = input_argmax_temp[0]; + if (get_max_too) { + max_val[0] = input_temp[0]; + } + if (this->algeb_str == RING) { + maxi[0] &= mask_l; + if (get_max_too) { + max_val[0] &= mask_l; + } + } + + delete[] argmax_res; + delete[] relu_res; + delete[] compare_with_argmax; + delete[] compare_with; + delete[] input_temp; + delete[] input_argmax_temp; + } + + /************************************************************************************************** + * Compute ArgMax for a tree level + **************************************************************************************************/ -template<typename IO, typename type> -class ArgMaxProtocol -{ - public: - IO* io = nullptr; - sci::OTPack<IO>* otpack = nullptr; - ReLURingProtocol<IO, type>* relu_oracle = nullptr; - ReLUFieldProtocol<IO, type>* relu_field_oracle = nullptr; - int party; - int algeb_str; - int l, b; - int num_cmps; - uint64_t prime_mod; - uint8_t zero_small = 0; - uint64_t mask32_lower = (1ULL<<32) - 1ULL; - uint64_t mask32_upper = -1ULL - mask32_lower; - uint64_t mask_upper, mask_lower; - bool createdReluObj = false; - type mask_l; + void argmax_this_level_super_32(type *argmax, type *result, type *indexshare, + type *share, int num_relu) { + uint8_t *drelu_ans = new uint8_t[num_relu]; + if (this->algeb_str == FIELD) { + relu_field_oracle->relu(result, share, num_relu, drelu_ans, true); + } else { // RING + relu_oracle->relu(result, share, num_relu, drelu_ans, true); + } - //Constructor - ArgMaxProtocol( - int party, - int algeb_str, - IO* io, - int l, - int b, - uint64_t prime, - sci::OTPack<IO>* otpack, - ReLUProtocol<IO, type>* relu_obj = nullptr) - { - this->party = party; - this->algeb_str = algeb_str; - this->io = io; - this->l = l; - mask_lower = (1ULL<<this->l)-1; - mask_upper = (1ULL<<(2*this->l)) - 1 - mask_lower; - this->b = b; - this->prime_mod = prime; - this->otpack = otpack; - if(algeb_str == RING){ - if(relu_obj == nullptr){ - this->relu_oracle = new ReLURingProtocol<IO, type>(party, RING, io, l, b, otpack); - createdReluObj = true; - } - else{ - this->relu_oracle = (ReLURingProtocol<IO, type>*) relu_obj; - } - } - else{ - if(relu_obj == nullptr){ - this->relu_field_oracle = new ReLUFieldProtocol<IO, type>(party, FIELD, io, l, b, this->prime_mod, otpack); - createdReluObj = true; - } - else{ - this->relu_field_oracle = (ReLUFieldProtocol<IO, type>*) relu_obj; - } - } - configure(); - } + // Now perform x.msb(x) + // 2 OTs required with reversed roles + sci::block128 *ot_messages_0 = new sci::block128[num_relu]; + sci::block128 *ot_messages_1 = new sci::block128[num_relu]; - //Destructor - ~ArgMaxProtocol() - { - if(createdReluObj){ - if (algeb_str==RING) delete relu_oracle; - else delete relu_field_oracle; - } - } + uint64_t *additive_masks = new uint64_t[num_relu * 2]; + sci::block128 *received_shares = new sci::block128[num_relu]; + uint64_t *received_shares_0 = new uint64_t[num_relu]; + uint64_t *received_shares_1 = new uint64_t[num_relu]; - void configure() - { - if(this->l != 32 && this->l != 64){ - mask_l = (type)((1ULL<<l)-1); - } - else if(this->l == 32){ - mask_l = -1; - } - else{ //l = 64 - mask_l = -1ULL; - } - } + if (this->algeb_str == FIELD) { + this->relu_field_oracle->triple_gen->prg->template random_mod_p<type>( + (type *)additive_masks, 2 * num_relu, this->prime_mod); + for (int i = 0; i < 2 * num_relu; i++) { + additive_masks[i] %= this->prime_mod; + } + } else { // RING + this->relu_oracle->triple_gen->prg->random_data( + additive_masks, 2 * num_relu * sizeof(type)); + } - int next_eight_multiple( - int val) - { - for(int i=0; i<8; i++){ - if((val + i)%8 == 0){ - return (val+i); - } - } - return 0; - } + if (party == sci::ALICE) { + for (int i = 0; i < num_relu; i++) { + set_argmax_end_ot_messages_super_32( + ot_messages_0 + i, ot_messages_1 + i, share + i, indexshare + i, + drelu_ans + i, ((type *)additive_masks) + i, num_relu); + } + if (this->algeb_str == FIELD) { + relu_field_oracle->otpack->iknp_straight->send(ot_messages_0, + ot_messages_1, num_relu); + relu_field_oracle->otpack->iknp_reversed->recv( + received_shares, (bool *)drelu_ans, num_relu); + } else { + relu_oracle->otpack->iknp_straight->send(ot_messages_0, ot_messages_1, + num_relu); + relu_oracle->otpack->iknp_reversed->recv(received_shares, + (bool *)drelu_ans, num_relu); + } + } else // party = sci::BOB + { + for (int i = 0; i < num_relu; i++) { + set_argmax_end_ot_messages_super_32( + ot_messages_0 + i, ot_messages_1 + i, share + i, indexshare + i, + drelu_ans + i, ((type *)additive_masks) + i, num_relu); + } + if (this->algeb_str == FIELD) { + relu_field_oracle->otpack->iknp_straight->recv( + received_shares, (bool *)drelu_ans, num_relu); + relu_field_oracle->otpack->iknp_reversed->send(ot_messages_0, + ot_messages_1, num_relu); + } else { + relu_oracle->otpack->iknp_straight->recv(received_shares, + (bool *)drelu_ans, num_relu); + relu_oracle->otpack->iknp_reversed->send(ot_messages_0, ot_messages_1, + num_relu); + } + } + for (int i = 0; i < num_relu; i++) { + received_shares_0[i] = _mm_extract_epi64(received_shares[i], 1); + received_shares_1[i] = _mm_extract_epi64(received_shares[i], 0); + } + for (int i = 0; i < num_relu; i++) { + result[i] = ((type *)additive_masks)[i] + + ((type *)received_shares_0)[(8 / sizeof(type)) * i]; + argmax[i] = ((type *)additive_masks)[i + num_relu] + + ((type *)received_shares_1)[(8 / sizeof(type)) * i]; + if (this->algeb_str == FIELD) { + result[i] %= this->prime_mod; + argmax[i] %= this->prime_mod; + } + } - void ArgMaxMPC( - int size, - type* inpArr, - type* maxi, - bool get_max_too = false, - type* max_val = nullptr) - { - type* input_temp = new type[size + 16]; - type* input_argmax_temp = new type[size + 16]; - for(int i=0; i<size; i++){ - input_temp[i] = inpArr[i]; - input_argmax_temp[i] = 0; - } - if(party == sci::ALICE){ - for(type i=0; i<(type)size; i++){ - input_argmax_temp[i] = i; - } - } - if(size & 1){ - input_temp[size] = input_temp[size-1]; - input_argmax_temp[size] = input_argmax_temp[size-1]; - size += 1; - } - type* compare_with = new type[size + 16]; - type* compare_with_argmax = new type[size + 16]; - type* relu_res = new type[size + 16]; - type* argmax_res = new type[size + 16]; - int no_of_nodes = size; - int no_of_nodes_child; - int pad1, pad2; - int times_stuck_on_8 = 0; - - while(no_of_nodes > 1){ - //std::cout<<"#nodes = "<<no_of_nodes<<std::endl; - no_of_nodes_child = (int)ceil((float)no_of_nodes/(float)2); - pad1 = next_eight_multiple(no_of_nodes_child); - pad1 = pad1 - no_of_nodes_child; - pad2 = no_of_nodes + 2*pad1; - no_of_nodes_child += pad1; - if(no_of_nodes_child == 8){ - times_stuck_on_8++; - } - if(times_stuck_on_8 >= 5){ - // The backend code only supports a minimum batch size of 8 - // So, whenever we have less than 8 child nodes, we pad it to get 8 nodes. - // The child nodes are = 8 in the following cases: #parentnodes = 16, 8, 4, 2, 1. - // We will get the argmax result when parent nodes = 1. So, times_stuck_on_8 >= 5. - break; - } - for(int i=no_of_nodes; i<pad2; i++){ - input_temp[i] = input_temp[no_of_nodes-1]; - input_argmax_temp[i] = input_argmax_temp[no_of_nodes-1]; - } - if(this->algeb_str == FIELD){ - for(int i=0; i<(pad2); i+=2){ - compare_with[i/2] = sci::neg_mod((int64_t)(input_temp[i] - input_temp[i+1]), this->prime_mod); - compare_with_argmax[i/2] = sci::neg_mod((int64_t)(input_argmax_temp[i] - input_argmax_temp[i+1]), this->prime_mod); - } - } - else{ //RING - for(int i=0; i<(pad2); i+=2){ - compare_with[i/2] = (input_temp[i] - input_temp[i+1]); - compare_with_argmax[i/2] = (input_argmax_temp[i] - input_argmax_temp[i+1]); - } - } - if(this->l > 32){ - argmax_this_level_super_32(argmax_res, relu_res, compare_with_argmax, compare_with, no_of_nodes_child); - } - else{ - argmax_this_level_sub_32(argmax_res, relu_res, compare_with_argmax, compare_with, no_of_nodes_child); - } - if(this->algeb_str == FIELD){ - for(int i=0; i<(no_of_nodes_child); i++){ - input_temp[i] = (relu_res[i] + input_temp[2*i + 1]) % this->prime_mod; - input_argmax_temp[i] = (argmax_res[i] + input_argmax_temp[2*i + 1]) % this->prime_mod; - } - } - else{ //RING - for(int i=0; i<(no_of_nodes_child); i++){ - input_temp[i] = (relu_res[i] + input_temp[2*i + 1]) & mask_l; - input_argmax_temp[i] = (argmax_res[i] + input_argmax_temp[2*i + 1]) & mask_l; - } - } - no_of_nodes = no_of_nodes_child; - } - maxi[0] = input_argmax_temp[0]; - if(get_max_too){ - max_val[0] = input_temp[0]; - } - if(this->algeb_str == RING){ - maxi[0] &= mask_l; - if(get_max_too){ - max_val[0] &= mask_l; - } - } - - delete[] argmax_res; - delete[] relu_res; - delete[] compare_with_argmax; - delete[] compare_with; - delete[] input_temp; - delete[] input_argmax_temp; - } + delete[] additive_masks; + delete[] received_shares; + delete[] received_shares_0; + delete[] received_shares_1; + delete[] ot_messages_0; + delete[] ot_messages_1; + delete[] drelu_ans; + } - /************************************************************************************************** - * Compute ArgMax for a tree level - **************************************************************************************************/ + void set_argmax_end_ot_messages_super_32(sci::block128 *ot_messages_0, + sci::block128 *ot_messages_1, + type *value_share, type *index_share, + uint8_t *xor_share, + type *additive_mask, int num_relu) { + type temp0, temp1, temp2, temp3; + if (this->algeb_str == FIELD) { + temp0 = sci::neg_mod((int64_t)value_share[0] - (int64_t)additive_mask[0], + this->prime_mod); + temp1 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0], + this->prime_mod); + temp2 = sci::neg_mod((int64_t)index_share[0] - + (int64_t)additive_mask[0 + num_relu], + this->prime_mod); + temp3 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0 + num_relu], + this->prime_mod); + } else { // RING + temp0 = (value_share[0] - additive_mask[0]); + temp1 = (0 - additive_mask[0]); + temp2 = (index_share[0] - additive_mask[0 + num_relu]); + temp3 = (0 - additive_mask[0 + num_relu]); + } + if (*xor_share == zero_small) { + ot_messages_0[0] = sci::makeBlock128(0ULL + temp0, 0ULL + temp2); + ot_messages_1[0] = sci::makeBlock128(0ULL + temp1, 0ULL + temp3); + } else { + ot_messages_0[0] = sci::makeBlock128(0ULL + temp1, 0ULL + temp3); + ot_messages_1[0] = sci::makeBlock128(0ULL + temp0, 0ULL + temp2); + } + } - void argmax_this_level_super_32( - type* argmax, - type* result, - type* indexshare, - type* share, - int num_relu) - { - uint8_t* drelu_ans = new uint8_t[num_relu]; - if(this->algeb_str == FIELD){ - relu_field_oracle->relu(result, share, num_relu, drelu_ans, true); - } - else{ //RING - relu_oracle->relu(result, share, num_relu, drelu_ans, true); - } - - // Now perform x.msb(x) - // 2 OTs required with reversed roles - sci::block128* ot_messages_0 = new sci::block128[num_relu]; - sci::block128* ot_messages_1 = new sci::block128[num_relu]; + void argmax_this_level_sub_32(type *argmax, type *result, type *indexshare, + type *share, int num_relu) { + uint8_t *drelu_ans = new uint8_t[num_relu]; - uint64_t* additive_masks = new uint64_t[num_relu*2]; - sci::block128* received_shares = new sci::block128[num_relu]; - uint64_t* received_shares_0 = new uint64_t[num_relu]; - uint64_t* received_shares_1 = new uint64_t[num_relu]; - - if(this->algeb_str == FIELD){ - this->relu_field_oracle->triple_gen->prg->template random_mod_p<type>((type*)additive_masks, 2*num_relu, this->prime_mod); - for(int i=0; i<2*num_relu; i++){ - additive_masks[i] %= this->prime_mod; - } - } - else{ //RING - this->relu_oracle->triple_gen->prg->random_data(additive_masks, 2*num_relu*sizeof(type)); - } + if (this->algeb_str == FIELD) { + relu_field_oracle->relu(result, share, num_relu, drelu_ans, true); + } else { // RING + relu_oracle->relu(result, share, num_relu, drelu_ans, true); + } - if(party == sci::ALICE) - { - for(int i=0; i<num_relu; i++){ - set_argmax_end_ot_messages_super_32(ot_messages_0+i, ot_messages_1+i, share+i, indexshare+i, drelu_ans+i, ((type*)additive_masks)+i, num_relu); - } - if(this->algeb_str == FIELD){ - relu_field_oracle->otpack->iknp_straight->send(ot_messages_0, ot_messages_1, num_relu); - relu_field_oracle->otpack->iknp_reversed->recv(received_shares, (bool*)drelu_ans, num_relu); - } - else{ - relu_oracle->otpack->iknp_straight->send(ot_messages_0, ot_messages_1, num_relu); - relu_oracle->otpack->iknp_reversed->recv(received_shares, (bool*)drelu_ans, num_relu); - } - } - else // party = sci::BOB - { - for(int i=0; i<num_relu; i++){ - set_argmax_end_ot_messages_super_32(ot_messages_0+i, ot_messages_1+i, share+i, indexshare+i, drelu_ans+i, ((type*)additive_masks)+i, num_relu); - } - if(this->algeb_str == FIELD){ - relu_field_oracle->otpack->iknp_straight->recv(received_shares, (bool*)drelu_ans, num_relu); - relu_field_oracle->otpack->iknp_reversed->send(ot_messages_0, ot_messages_1, num_relu); - } - else{ - relu_oracle->otpack->iknp_straight->recv(received_shares, (bool*)drelu_ans, num_relu); - relu_oracle->otpack->iknp_reversed->send(ot_messages_0, ot_messages_1, num_relu); - } - } - for(int i=0; i<num_relu; i++){ - received_shares_0[i] = _mm_extract_epi64(received_shares[i], 1); - received_shares_1[i] = _mm_extract_epi64(received_shares[i], 0); - } - for(int i=0; i<num_relu; i++){ - result[i] = ((type*)additive_masks)[i] + ((type*)received_shares_0)[(8/sizeof(type))*i]; - argmax[i] = ((type*)additive_masks)[i+num_relu] + ((type*)received_shares_1)[(8/sizeof(type))*i]; - if(this->algeb_str == FIELD){ - result[i] %= this->prime_mod; - argmax[i] %= this->prime_mod; - } - } - - delete[] additive_masks; - delete[] received_shares; - delete[] received_shares_0; - delete[] received_shares_1; - delete[] ot_messages_0; - delete[] ot_messages_1; - delete[] drelu_ans; - } - - void set_argmax_end_ot_messages_super_32( - sci::block128* ot_messages_0, - sci::block128* ot_messages_1, - type* value_share, - type* index_share, - uint8_t* xor_share, - type* additive_mask, - int num_relu) - { - type temp0, temp1, temp2, temp3; - if(this->algeb_str == FIELD){ - temp0 = sci::neg_mod((int64_t)value_share[0] - (int64_t)additive_mask[0], this->prime_mod); - temp1 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0], this->prime_mod); - temp2 = sci::neg_mod((int64_t)index_share[0] - (int64_t)additive_mask[0+num_relu], this->prime_mod); - temp3 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0+num_relu], this->prime_mod); - } - else{ //RING - temp0 = (value_share[0] - additive_mask[0]); - temp1 = (0 - additive_mask[0]); - temp2 = (index_share[0] - additive_mask[0+num_relu]); - temp3 = (0 - additive_mask[0+num_relu]); - } - if(*xor_share == zero_small){ - ot_messages_0[0] = sci::makeBlock128(0ULL + temp0, 0ULL + temp2); - ot_messages_1[0] = sci::makeBlock128(0ULL + temp1, 0ULL + temp3); - } - else{ - ot_messages_0[0] = sci::makeBlock128(0ULL + temp1, 0ULL + temp3); - ot_messages_1[0] = sci::makeBlock128(0ULL + temp0, 0ULL + temp2); - } - } + // Now perform x.msb(x) + // 2 OTs required with reversed roles + uint64_t **ot_messages = new uint64_t *[num_relu]; + for (int i = 0; i < num_relu; i++) { + ot_messages[i] = new uint64_t[2]; + } + uint64_t *additive_masks = new uint64_t[2 * num_relu]; - void argmax_this_level_sub_32( - type* argmax, - type* result, - type* indexshare, - type* share, - int num_relu) - { - uint8_t* drelu_ans = new uint8_t[num_relu]; - - if(this->algeb_str == FIELD){ - relu_field_oracle->relu(result, share, num_relu, drelu_ans, true); - } - else{ //RING - relu_oracle->relu(result, share, num_relu, drelu_ans, true); - } - - // Now perform x.msb(x) - // 2 OTs required with reversed roles - uint64_t** ot_messages = new uint64_t*[num_relu]; - for(int i=0; i<num_relu; i++){ - ot_messages[i] = new uint64_t[2]; - } - uint64_t* additive_masks = new uint64_t[2*num_relu]; + uint64_t *received_shares = new uint64_t[num_relu]; + uint64_t *received_shares_0 = new uint64_t[num_relu]; + uint64_t *received_shares_1 = new uint64_t[num_relu]; - uint64_t* received_shares = new uint64_t[num_relu]; - uint64_t* received_shares_0 = new uint64_t[num_relu]; - uint64_t* received_shares_1 = new uint64_t[num_relu]; - - if(this->algeb_str == FIELD){ - this->relu_field_oracle->triple_gen->prg->template random_mod_p<type>((type*)additive_masks, 2*num_relu, this->prime_mod); - for(int i=0; i<2*num_relu; i++){ - additive_masks[i] %= this->prime_mod; - } - } - else{ //RING - this->relu_oracle->triple_gen->prg->random_data(additive_masks, 2*num_relu*sizeof(type)); - } - if(party == sci::ALICE) - { - for(int i=0; i<num_relu; i++){ - set_argmax_end_ot_messages_sub_32(ot_messages[i], share+i, indexshare+i, drelu_ans+i, ((type*)additive_masks)+i, num_relu); - } - if(this->algeb_str == FIELD){ - relu_field_oracle->otpack->iknp_straight->send(ot_messages, num_relu, this->l*2); - relu_field_oracle->otpack->iknp_reversed->recv(received_shares, drelu_ans, num_relu, this->l*2); - } - else{ //RING - relu_oracle->otpack->iknp_straight->send(ot_messages, num_relu, 64); - relu_oracle->otpack->iknp_reversed->recv(received_shares, drelu_ans, num_relu, 64); - } - } - else //party = sci::BOB - { - for(int i=0; i<num_relu; i++){ - set_argmax_end_ot_messages_sub_32(ot_messages[i], share+i, indexshare+i, drelu_ans+i, ((type*)additive_masks)+i, num_relu); - } - if(this->algeb_str == FIELD){ - relu_field_oracle->otpack->iknp_straight->recv(received_shares, drelu_ans, num_relu, this->l*2); - relu_field_oracle->otpack->iknp_reversed->send(ot_messages, num_relu, this->l*2); - } - else{ //RING - relu_oracle->otpack->iknp_straight->recv(received_shares, drelu_ans, num_relu, 64); - relu_oracle->otpack->iknp_reversed->send(ot_messages, num_relu, 64); - } - } - - for(int i=0; i<num_relu; i++){ - if(this->algeb_str == FIELD){ - // tightly optimized communication for the field case - received_shares_0[i] = (received_shares[i]&mask_upper)>>this->l; - received_shares_1[i] = received_shares[i]&mask_lower; - } - else{ //RING - received_shares_0[i] = (received_shares[i]&mask32_upper)>>32; - received_shares_1[i] = received_shares[i]&mask32_lower; - } - } - for(int i=0; i<num_relu; i++){ - result[i] = ((type*)additive_masks)[i] + ((type*)received_shares_0)[(8/sizeof(type))*i]; - argmax[i] = ((type*)additive_masks)[i+num_relu] + ((type*)received_shares_1)[(8/sizeof(type))*i]; - if(this->algeb_str == FIELD){ - result[i] %= this->prime_mod; - argmax[i] %= this->prime_mod; - } - } - delete[] additive_masks; - delete[] received_shares; - delete[] received_shares_0; - delete[] received_shares_1; - delete[] drelu_ans; - for(int i=0; i<num_relu; i++){ - delete[] ot_messages[i]; - } - delete[] ot_messages; - } + if (this->algeb_str == FIELD) { + this->relu_field_oracle->triple_gen->prg->template random_mod_p<type>( + (type *)additive_masks, 2 * num_relu, this->prime_mod); + for (int i = 0; i < 2 * num_relu; i++) { + additive_masks[i] %= this->prime_mod; + } + } else { // RING + this->relu_oracle->triple_gen->prg->random_data( + additive_masks, 2 * num_relu * sizeof(type)); + } + if (party == sci::ALICE) { + for (int i = 0; i < num_relu; i++) { + set_argmax_end_ot_messages_sub_32( + ot_messages[i], share + i, indexshare + i, drelu_ans + i, + ((type *)additive_masks) + i, num_relu); + } + if (this->algeb_str == FIELD) { + relu_field_oracle->otpack->iknp_straight->send(ot_messages, num_relu, + this->l * 2); + relu_field_oracle->otpack->iknp_reversed->recv( + received_shares, drelu_ans, num_relu, this->l * 2); + } else { // RING + relu_oracle->otpack->iknp_straight->send(ot_messages, num_relu, 64); + relu_oracle->otpack->iknp_reversed->recv(received_shares, drelu_ans, + num_relu, 64); + } + } else // party = sci::BOB + { + for (int i = 0; i < num_relu; i++) { + set_argmax_end_ot_messages_sub_32( + ot_messages[i], share + i, indexshare + i, drelu_ans + i, + ((type *)additive_masks) + i, num_relu); + } + if (this->algeb_str == FIELD) { + relu_field_oracle->otpack->iknp_straight->recv( + received_shares, drelu_ans, num_relu, this->l * 2); + relu_field_oracle->otpack->iknp_reversed->send(ot_messages, num_relu, + this->l * 2); + } else { // RING + relu_oracle->otpack->iknp_straight->recv(received_shares, drelu_ans, + num_relu, 64); + relu_oracle->otpack->iknp_reversed->send(ot_messages, num_relu, 64); + } + } - void set_argmax_end_ot_messages_sub_32( - uint64_t* ot_messages, - type* value_share, - type* index_share, - uint8_t* xor_share, - type* additive_mask, - int num_relu) - { - uint64_t temp0, temp1, temp2, temp3; - uint64_t mask_upper_general, mask_lower_general; - if(this->algeb_str == FIELD){ - temp0 = sci::neg_mod((int64_t)value_share[0] - (int64_t)additive_mask[0], this->prime_mod); - temp1 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0], this->prime_mod); - temp2 = sci::neg_mod((int64_t)index_share[0] - (int64_t)additive_mask[0+num_relu], this->prime_mod); - temp3 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0+num_relu], this->prime_mod); - temp0 = temp0 << this->l; - temp1 = temp1 << this->l; - mask_upper_general = mask_upper; - mask_lower_general = mask_lower; - } - else{ //RING - temp0 = (type)(value_share[0] - additive_mask[0]); - temp0 = temp0 << 32; - temp1 = (type)(0 - additive_mask[0]); - temp1 = temp1 << 32; - temp2 = (type)(index_share[0] - additive_mask[0+num_relu]); - temp3 = (type)(0 - additive_mask[0+num_relu]); - mask_upper_general = mask32_upper; - mask_lower_general = mask32_lower; - } - if(*xor_share == zero_small){ - ot_messages[0] = (mask_upper_general&(0ULL + temp0)) ^ (mask_lower_general&(0ULL + temp2)); - ot_messages[1] = (mask_upper_general&(0ULL + temp1)) ^ (mask_lower_general&(0ULL + temp3)); - } - else{ - ot_messages[0] = (mask_upper_general&(0ULL + temp1)) ^ (mask_lower_general&(0ULL + temp3)); - ot_messages[1] = (mask_upper_general&(0ULL + temp0)) ^ (mask_lower_general&(0ULL + temp2)); - } - } + for (int i = 0; i < num_relu; i++) { + if (this->algeb_str == FIELD) { + // tightly optimized communication for the field case + received_shares_0[i] = (received_shares[i] & mask_upper) >> this->l; + received_shares_1[i] = received_shares[i] & mask_lower; + } else { // RING + received_shares_0[i] = (received_shares[i] & mask32_upper) >> 32; + received_shares_1[i] = received_shares[i] & mask32_lower; + } + } + for (int i = 0; i < num_relu; i++) { + result[i] = ((type *)additive_masks)[i] + + ((type *)received_shares_0)[(8 / sizeof(type)) * i]; + argmax[i] = ((type *)additive_masks)[i + num_relu] + + ((type *)received_shares_1)[(8 / sizeof(type)) * i]; + if (this->algeb_str == FIELD) { + result[i] %= this->prime_mod; + argmax[i] %= this->prime_mod; + } + } + delete[] additive_masks; + delete[] received_shares; + delete[] received_shares_0; + delete[] received_shares_1; + delete[] drelu_ans; + for (int i = 0; i < num_relu; i++) { + delete[] ot_messages[i]; + } + delete[] ot_messages; + } + void set_argmax_end_ot_messages_sub_32(uint64_t *ot_messages, + type *value_share, type *index_share, + uint8_t *xor_share, + type *additive_mask, int num_relu) { + uint64_t temp0, temp1, temp2, temp3; + uint64_t mask_upper_general, mask_lower_general; + if (this->algeb_str == FIELD) { + temp0 = sci::neg_mod((int64_t)value_share[0] - (int64_t)additive_mask[0], + this->prime_mod); + temp1 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0], + this->prime_mod); + temp2 = sci::neg_mod((int64_t)index_share[0] - + (int64_t)additive_mask[0 + num_relu], + this->prime_mod); + temp3 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0 + num_relu], + this->prime_mod); + temp0 = temp0 << this->l; + temp1 = temp1 << this->l; + mask_upper_general = mask_upper; + mask_lower_general = mask_lower; + } else { // RING + temp0 = (type)(value_share[0] - additive_mask[0]); + temp0 = temp0 << 32; + temp1 = (type)(0 - additive_mask[0]); + temp1 = temp1 << 32; + temp2 = (type)(index_share[0] - additive_mask[0 + num_relu]); + temp3 = (type)(0 - additive_mask[0 + num_relu]); + mask_upper_general = mask32_upper; + mask_lower_general = mask32_lower; + } + if (*xor_share == zero_small) { + ot_messages[0] = (mask_upper_general & (0ULL + temp0)) ^ + (mask_lower_general & (0ULL + temp2)); + ot_messages[1] = (mask_upper_general & (0ULL + temp1)) ^ + (mask_lower_general & (0ULL + temp3)); + } else { + ot_messages[0] = (mask_upper_general & (0ULL + temp1)) ^ + (mask_lower_general & (0ULL + temp3)); + ot_messages[1] = (mask_upper_general & (0ULL + temp0)) ^ + (mask_lower_general & (0ULL + temp2)); + } + } }; -#endif //ARGMAX_H__ +#endif // ARGMAX_H__ diff --git a/SCI/src/NonLinear/drelu-field.h b/SCI/src/NonLinear/drelu-field.h index a2153d12..11c3b285 100644 --- a/SCI/src/NonLinear/drelu-field.h +++ b/SCI/src/NonLinear/drelu-field.h @@ -22,333 +22,335 @@ SOFTWARE. #ifndef DRELU_FIELD_H__ #define DRELU_FIELD_H__ -#include "globals.h" +#include "Millionaire/millionaire.h" #include "OT/emp-ot.h" #include "utils/emp-tool.h" -#include "Millionaire/millionaire.h" #include <cmath> -template<typename IO> -class DReLUFieldProtocol -{ - public: - IO* io = nullptr; - sci::OTPack<IO>* otpack; - TripleGenerator<IO>* triple_gen; - MillionaireProtocol<IO>* millionaire; - int party; - int l, r, log_alpha, beta, beta_pow; - int num_digits, num_triples_corr, num_triples_std, log_num_digits; - int num_triples; - uint8_t mask_beta, mask_r, take_lsb; - uint64_t p, p_2; +template <typename IO> class DReLUFieldProtocol { +public: + IO *io = nullptr; + sci::OTPack<IO> *otpack; + TripleGenerator<IO> *triple_gen; + MillionaireProtocol<IO> *millionaire; + int party; + int l, r, log_alpha, beta, beta_pow; + int num_digits, num_triples_corr, num_triples_std, log_num_digits; + int num_triples; + uint8_t mask_beta, mask_r, take_lsb; + uint64_t p, p_2; - DReLUFieldProtocol( - int party, - int bitlength, - int log_radix_base, - uint64_t prime_mod, - IO* io, - sci::OTPack<IO>* otpack) - { - assert(log_radix_base <= 8); - assert(bitlength <= 64); - this->party = party; - this->l = bitlength; - this->beta = log_radix_base; - this->io = io; - this->p = prime_mod; - this->otpack = otpack; - this->millionaire = new MillionaireProtocol<IO>(party, bitlength, log_radix_base, io, otpack); - this->triple_gen = millionaire->triple_gen; - configure(); - } + DReLUFieldProtocol(int party, int bitlength, int log_radix_base, + uint64_t prime_mod, IO *io, sci::OTPack<IO> *otpack) { + assert(log_radix_base <= 8); + assert(bitlength <= 64); + this->party = party; + this->l = bitlength; + this->beta = log_radix_base; + this->io = io; + this->p = prime_mod; + this->otpack = otpack; + this->millionaire = new MillionaireProtocol<IO>(party, io, otpack, + bitlength, log_radix_base); + this->triple_gen = millionaire->triple_gen; + configure(); + } - void configure() - { - this->num_digits = ceil((double)l/beta); - this->r = l % beta; - this->log_alpha = sci::bitlen(num_digits) - 1; - this->log_num_digits = log_alpha + 1; - this->num_triples_corr = 2*num_digits - 2 - 2*log_num_digits; - this->num_triples_std = log_num_digits; - this->num_triples = num_triples_std + num_triples_corr; - if (beta == 8) this->mask_beta = -1; - else this->mask_beta = (1 << beta) - 1; - this->mask_r = (1 << r) - 1; - this->beta_pow = 1 << beta; - this->take_lsb = 1; - this->p_2 = (p - 1)/2; - } + void configure() { + this->num_digits = ceil((double)l / beta); + this->r = l % beta; + this->log_alpha = sci::bitlen(num_digits) - 1; + this->log_num_digits = log_alpha + 1; + this->num_triples_corr = 2 * num_digits - 2 - 2 * log_num_digits; + this->num_triples_std = log_num_digits; + this->num_triples = num_triples_std + num_triples_corr; + if (beta == 8) + this->mask_beta = -1; + else + this->mask_beta = (1 << beta) - 1; + this->mask_r = (1 << r) - 1; + this->beta_pow = 1 << beta; + this->take_lsb = 1; + this->p_2 = (p - 1) / 2; + } - ~DReLUFieldProtocol() { - delete millionaire; - } + ~DReLUFieldProtocol() { delete millionaire; } - void compute_drelu( - uint8_t* drelu, - uint64_t* share, - int num_relu) - { - int num_cmps = 2*num_relu; - uint8_t* digits; // num_digits * num_cmps - uint8_t* leaf_res_cmp; // num_digits * num_cmps - uint8_t* leaf_res_eq; // num_digits * num_cmps + void compute_drelu(uint8_t *drelu, uint64_t *share, int num_relu) { + int num_cmps = 2 * num_relu; + uint8_t *digits; // num_digits * num_cmps + uint8_t *leaf_res_cmp; // num_digits * num_cmps + uint8_t *leaf_res_eq; // num_digits * num_cmps - // To save number of rounds in WAN over slight increase in communication + // To save number of rounds in WAN over slight increase in communication #ifdef WAN_EXEC - Triple triples_std((num_triples)*num_cmps, true); + Triple triples_std((num_triples)*num_cmps, true); #else - Triple triples_corr(num_triples_corr*num_cmps, true, num_cmps); - Triple triples_std(num_triples_std*num_cmps, true); + Triple triples_corr(num_triples_corr * num_cmps, true, num_cmps); + Triple triples_std(num_triples_std * num_cmps, true); #endif - digits = new uint8_t[num_digits*num_cmps]; - leaf_res_cmp = new uint8_t[num_digits*num_cmps]; - leaf_res_eq = new uint8_t[num_digits*num_cmps]; + digits = new uint8_t[num_digits * num_cmps]; + leaf_res_cmp = new uint8_t[num_digits * num_cmps]; + leaf_res_eq = new uint8_t[num_digits * num_cmps]; - // Extract radix-digits from data - assert((beta <= 8) && "Base beta > 8 is not implemented"); - if(party == sci::ALICE) - { - for(int j = 0; j < num_relu; j++){ - uint64_t input_wrap_cmp = (p - 1 - share[j]) + p_2; - uint64_t input_drelu_cmp; - if (share[j] > p_2) { - input_drelu_cmp = 2*p - 1 - share[j]; - } else { - input_drelu_cmp = p - 1 - share[j]; - } - for(int i = 0; i < num_digits; i++){ // Stored from LSB to MSB - if ((i == num_digits-1) && (r != 0)){ // A partially full last digit - digits[i*num_relu*2 + j*2 + 0] = (uint8_t)(input_wrap_cmp >> i*beta) & mask_r; - digits[i*num_relu*2 + j*2 + 1] = (uint8_t)(input_drelu_cmp >> i*beta) & mask_r; - } - else{ - digits[i*num_relu*2 + j*2 + 0] = (uint8_t)(input_wrap_cmp >> i*beta) & mask_beta; - digits[i*num_relu*2 + j*2 + 1] = (uint8_t)(input_drelu_cmp >> i*beta) & mask_beta; - } - } - } - } - else // party = sci::BOB - { - for(int j = 0; j < num_relu; j++){ - uint64_t input_cmp = p_2 + share[j]; - for(int i = 0; i < num_digits; i++){ // Stored from LSB to MSB - if ((i == num_digits-1) && (r != 0)){ // A partially full last digit - digits[i*num_relu + j*1 + 0] = (uint8_t)(input_cmp >> i*beta) & mask_r; - } - else{ - digits[i*num_relu + j*1 + 0] = (uint8_t)(input_cmp >> i*beta) & mask_beta; - } - } - } - } + // Extract radix-digits from data + assert((beta <= 8) && "Base beta > 8 is not implemented"); + if (party == sci::ALICE) { + for (int j = 0; j < num_relu; j++) { + uint64_t input_wrap_cmp = (p - 1 - share[j]) + p_2; + uint64_t input_drelu_cmp; + if (share[j] > p_2) { + input_drelu_cmp = 2 * p - 1 - share[j]; + } else { + input_drelu_cmp = p - 1 - share[j]; + } + for (int i = 0; i < num_digits; i++) { // Stored from LSB to MSB + if ((i == num_digits - 1) && + (r != 0)) { // A partially full last digit + digits[i * num_relu * 2 + j * 2 + 0] = + (uint8_t)(input_wrap_cmp >> i * beta) & mask_r; + digits[i * num_relu * 2 + j * 2 + 1] = + (uint8_t)(input_drelu_cmp >> i * beta) & mask_r; + } else { + digits[i * num_relu * 2 + j * 2 + 0] = + (uint8_t)(input_wrap_cmp >> i * beta) & mask_beta; + digits[i * num_relu * 2 + j * 2 + 1] = + (uint8_t)(input_drelu_cmp >> i * beta) & mask_beta; + } + } + } + } else // party = sci::BOB + { + for (int j = 0; j < num_relu; j++) { + uint64_t input_cmp = p_2 + share[j]; + for (int i = 0; i < num_digits; i++) { // Stored from LSB to MSB + if ((i == num_digits - 1) && + (r != 0)) { // A partially full last digit + digits[i * num_relu + j * 1 + 0] = + (uint8_t)(input_cmp >> i * beta) & mask_r; + } else { + digits[i * num_relu + j * 1 + 0] = + (uint8_t)(input_cmp >> i * beta) & mask_beta; + } + } + } + } - if(party == sci::ALICE) - { - uint8_t** leaf_ot_messages; // (num_digits * num_relu) X beta_pow (=2^beta) - // Do the two relu_comparisons together in 1 leaf OT. - leaf_ot_messages = new uint8_t*[num_digits*num_relu]; - for(int i = 0; i < num_digits*num_relu; i++) - leaf_ot_messages[i] = new uint8_t[beta_pow]; + if (party == sci::ALICE) { + uint8_t * + *leaf_ot_messages; // (num_digits * num_relu) X beta_pow (=2^beta) + // Do the two relu_comparisons together in 1 leaf OT. + leaf_ot_messages = new uint8_t *[num_digits * num_relu]; + for (int i = 0; i < num_digits * num_relu; i++) + leaf_ot_messages[i] = new uint8_t[beta_pow]; - // Set Leaf OT messages - triple_gen->prg->random_bool((bool*)leaf_res_cmp, num_digits*num_relu*2); - triple_gen->prg->random_bool((bool*)leaf_res_eq, num_digits*num_relu*2); - for(int i = 0; i < num_digits; i++) { - for(int j = 0; j < num_relu; j++) { - if (i == 0){ - set_leaf_ot_messages(leaf_ot_messages[i*num_relu+j], digits+i*num_relu*2+j*2, - beta_pow, leaf_res_cmp+i*num_relu*2+j*2, 0, false); - } - else if (i == (num_digits - 1) && (r > 0)){ + // Set Leaf OT messages + triple_gen->prg->random_bool((bool *)leaf_res_cmp, + num_digits * num_relu * 2); + triple_gen->prg->random_bool((bool *)leaf_res_eq, + num_digits * num_relu * 2); + for (int i = 0; i < num_digits; i++) { + for (int j = 0; j < num_relu; j++) { + if (i == 0) { + set_leaf_ot_messages(leaf_ot_messages[i * num_relu + j], + digits + i * num_relu * 2 + j * 2, beta_pow, + leaf_res_cmp + i * num_relu * 2 + j * 2, 0, + false); + } else if (i == (num_digits - 1) && (r > 0)) { #ifdef WAN_EXEC - set_leaf_ot_messages(leaf_ot_messages[i*num_relu+j], digits+i*num_relu*2+j*2, - beta_pow, leaf_res_cmp+i*num_relu*2+j*2, leaf_res_eq+i*num_relu*2+j*2); + set_leaf_ot_messages(leaf_ot_messages[i * num_relu + j], + digits + i * num_relu * 2 + j * 2, beta_pow, + leaf_res_cmp + i * num_relu * 2 + j * 2, + leaf_res_eq + i * num_relu * 2 + j * 2); #else - set_leaf_ot_messages(leaf_ot_messages[i*num_relu+j], digits+i*num_relu*2+j*2, - 1 << r, leaf_res_cmp+i*num_relu*2+j*2, leaf_res_eq+i*num_relu*2+j*2); + set_leaf_ot_messages(leaf_ot_messages[i * num_relu + j], + digits + i * num_relu * 2 + j * 2, 1 << r, + leaf_res_cmp + i * num_relu * 2 + j * 2, + leaf_res_eq + i * num_relu * 2 + j * 2); #endif - } - else{ - set_leaf_ot_messages(leaf_ot_messages[i*num_relu+j], digits+i*num_relu*2+j*2, - beta_pow, leaf_res_cmp+i*num_relu*2+j*2, leaf_res_eq+i*num_relu*2+j*2); - } - } - } + } else { + set_leaf_ot_messages(leaf_ot_messages[i * num_relu + j], + digits + i * num_relu * 2 + j * 2, beta_pow, + leaf_res_cmp + i * num_relu * 2 + j * 2, + leaf_res_eq + i * num_relu * 2 + j * 2); + } + } + } - // Perform Leaf OTs + // Perform Leaf OTs - // Each ReLU has the first digit of which equality is not required. + // Each ReLU has the first digit of which equality is not required. #ifdef WAN_EXEC - otpack->kkot_beta->send(leaf_ot_messages, num_relu*(num_digits), 2*2); + otpack->kkot[beta - 1]->send(leaf_ot_messages, num_relu * (num_digits), + 2 * 2); #else - otpack->kkot_beta->send(leaf_ot_messages, num_relu, 1*2); - if (r == 1) { - // For the last digit (MSB), use IKNP because it is just 1-bit - otpack->kkot_beta->send(leaf_ot_messages+num_relu, num_relu*(num_digits-2), 2*2); - otpack->iknp_straight->send(leaf_ot_messages+num_relu*(num_digits-1), num_relu, 2*2); - } - else if (r != 0) { - otpack->kkot_beta->send(leaf_ot_messages+num_relu, num_relu*(num_digits-2), 2*2); - if(r == 2){ - otpack->kkot_4->send(leaf_ot_messages+num_relu*(num_digits-1), num_relu, 2*2); - } - else if(r == 3){ - otpack->kkot_8->send(leaf_ot_messages+num_relu*(num_digits-1), num_relu, 2*2); - } - else if(r == 4){ - otpack->kkot_16->send(leaf_ot_messages+num_relu*(num_digits-1), num_relu, 2*2); - } - else{ - throw std::invalid_argument("Not yet implemented!"); - } - } - else - otpack->kkot_beta->send(leaf_ot_messages+num_relu, num_relu*(num_digits-1), 2*2); + otpack->kkot[beta - 1]->send(leaf_ot_messages, num_relu, 1 * 2); + if (r == 1) { + // For the last digit (MSB), use IKNP because it is just 1-bit + otpack->kkot[beta - 1]->send(leaf_ot_messages + num_relu, + num_relu * (num_digits - 2), 2 * 2); + otpack->iknp_straight->send( + leaf_ot_messages + num_relu * (num_digits - 1), num_relu, 2 * 2); + } else if (r != 0) { + otpack->kkot[beta - 1]->send(leaf_ot_messages + num_relu, + num_relu * (num_digits - 2), 2 * 2); + if (r == 2) { + otpack->kkot[1]->send(leaf_ot_messages + num_relu * (num_digits - 1), + num_relu, 2 * 2); + } else if (r == 3) { + otpack->kkot[2]->send(leaf_ot_messages + num_relu * (num_digits - 1), + num_relu, 2 * 2); + } else if (r == 4) { + otpack->kkot[3]->send(leaf_ot_messages + num_relu * (num_digits - 1), + num_relu, 2 * 2); + } else { + throw std::invalid_argument("Not yet implemented!"); + } + } else + otpack->kkot[beta - 1]->send(leaf_ot_messages + num_relu, + num_relu * (num_digits - 1), 2 * 2); #endif - // Cleanup - for(int i = 0; i < num_digits*num_relu; i++) - delete[] leaf_ot_messages[i]; - delete[] leaf_ot_messages; - // Alice's shares are: cmp1, cmp2 and cmp3 are at leaf_res_cmp[0+3*j], leaf_res_cmp[1+3*j] and leaf_res_cmp[2+3*j] - } - else // party = sci::BOB - { - // Perform Leaf OTs - uint8_t* leaf_ot_recvd = new uint8_t[num_digits*num_relu]; + // Cleanup + for (int i = 0; i < num_digits * num_relu; i++) + delete[] leaf_ot_messages[i]; + delete[] leaf_ot_messages; + // Alice's shares are: cmp1, cmp2 and cmp3 are at leaf_res_cmp[0+3*j], + // leaf_res_cmp[1+3*j] and leaf_res_cmp[2+3*j] + } else // party = sci::BOB + { + // Perform Leaf OTs + uint8_t *leaf_ot_recvd = new uint8_t[num_digits * num_relu]; #ifdef WAN_EXEC - otpack->kkot_beta->recv(leaf_ot_recvd, digits, num_relu*(num_digits), 2*2); + otpack->kkot[beta - 1]->recv(leaf_ot_recvd, digits, + num_relu * (num_digits), 2 * 2); #else - otpack->kkot_beta->recv(leaf_ot_recvd, digits, num_relu, 1*2); - if (r == 1) { - otpack->kkot_beta->recv(leaf_ot_recvd+num_relu, digits+num_relu, num_relu*(num_digits-2), 2*2); - otpack->iknp_straight->recv(leaf_ot_recvd+num_relu*(num_digits-1), - digits+num_relu*(num_digits-1), num_relu, 2*2); - } - else if (r != 0) { - otpack->kkot_beta->recv(leaf_ot_recvd+num_relu, digits+num_relu, num_relu*(num_digits-2), 2*2); - if(r == 2){ - otpack->kkot_4->recv(leaf_ot_recvd+num_relu*(num_digits-1), - digits+num_relu*(num_digits-1), num_relu, 2*2); - } - else if(r == 3){ - otpack->kkot_8->recv(leaf_ot_recvd+num_relu*(num_digits-1), - digits+num_relu*(num_digits-1), num_relu, 2*2); - } - else if(r == 4){ - otpack->kkot_16->recv(leaf_ot_recvd+num_relu*(num_digits-1), - digits+num_relu*(num_digits-1), num_relu, 2*2); - } - else{ - throw std::invalid_argument("Not yet implemented!"); - } - } - else - otpack->kkot_beta->recv(leaf_ot_recvd+num_relu, digits+num_relu, num_relu*(num_digits-1), 2*2); + otpack->kkot[beta - 1]->recv(leaf_ot_recvd, digits, num_relu, 1 * 2); + if (r == 1) { + otpack->kkot[beta - 1]->recv(leaf_ot_recvd + num_relu, + digits + num_relu, + num_relu * (num_digits - 2), 2 * 2); + otpack->iknp_straight->recv(leaf_ot_recvd + num_relu * (num_digits - 1), + digits + num_relu * (num_digits - 1), + num_relu, 2 * 2); + } else if (r != 0) { + otpack->kkot[beta - 1]->recv(leaf_ot_recvd + num_relu, + digits + num_relu, + num_relu * (num_digits - 2), 2 * 2); + if (r == 2) { + otpack->kkot[1]->recv(leaf_ot_recvd + num_relu * (num_digits - 1), + digits + num_relu * (num_digits - 1), num_relu, + 2 * 2); + } else if (r == 3) { + otpack->kkot[2]->recv(leaf_ot_recvd + num_relu * (num_digits - 1), + digits + num_relu * (num_digits - 1), num_relu, + 2 * 2); + } else if (r == 4) { + otpack->kkot[3]->recv(leaf_ot_recvd + num_relu * (num_digits - 1), + digits + num_relu * (num_digits - 1), num_relu, + 2 * 2); + } else { + throw std::invalid_argument("Not yet implemented!"); + } + } else + otpack->kkot[beta - 1]->recv(leaf_ot_recvd + num_relu, + digits + num_relu, + num_relu * (num_digits - 1), 2 * 2); #endif - // Extract equality result from leaf_res_cmp - for(int i = 0; i<num_relu; i++){ - leaf_res_cmp[2*i] = (leaf_ot_recvd[i] & (1<<1))>>1; - leaf_res_cmp[2*i + 1] = (leaf_ot_recvd[i] & (1<<0))>>0; - } - for(int i = num_relu; i < num_digits*num_relu; i++) { - leaf_res_cmp[2*i] = (leaf_ot_recvd[i] & (1<<3))>>3; - leaf_res_cmp[2*i + 1] = (leaf_ot_recvd[i] & (1<<2))>>2; - - leaf_res_eq[2*i] = (leaf_ot_recvd[i] & (1<<1))>>1; - leaf_res_eq[2*i + 1] = (leaf_ot_recvd[i] & (1<<0))>>0; - } - delete[] leaf_ot_recvd; - } + // Extract equality result from leaf_res_cmp + for (int i = 0; i < num_relu; i++) { + leaf_res_cmp[2 * i] = (leaf_ot_recvd[i] & (1 << 1)) >> 1; + leaf_res_cmp[2 * i + 1] = (leaf_ot_recvd[i] & (1 << 0)) >> 0; + } + for (int i = num_relu; i < num_digits * num_relu; i++) { + leaf_res_cmp[2 * i] = (leaf_ot_recvd[i] & (1 << 3)) >> 3; + leaf_res_cmp[2 * i + 1] = (leaf_ot_recvd[i] & (1 << 2)) >> 2; - // Generate required Bit-Triples and traverse tree to compute the results of comparsions - millionaire->traverse_and_compute_ANDs(num_cmps, leaf_res_eq, leaf_res_cmp); + leaf_res_eq[2 * i] = (leaf_ot_recvd[i] & (1 << 1)) >> 1; + leaf_res_eq[2 * i + 1] = (leaf_ot_recvd[i] & (1 << 0)) >> 0; + } + delete[] leaf_ot_recvd; + } - assert(num_relu % 8 == 0 && "Number of ReLUs should be a multiple of 8"); + // Generate required Bit-Triples and traverse tree to compute the results of + // comparsions + millionaire->traverse_and_compute_ANDs(num_cmps, leaf_res_eq, leaf_res_cmp); - if(party == sci::ALICE) - { - uint8_t** mux_ot_messages = new uint8_t*[num_relu]; - for(int j = 0; j < num_relu; j++) { - mux_ot_messages[j] = new uint8_t[4]; - } - triple_gen->prg->random_bool((bool*)drelu, num_relu); - for(int j = 0; j < num_relu; j++) { - //drelu[j] = 0; - bool neg_share = (share[j] > p_2); - set_mux_ot_messages(mux_ot_messages[j], leaf_res_cmp + j*2, - drelu[j], neg_share); - } - otpack->kkot_4->send(mux_ot_messages, num_relu, 1); - for(int j = 0; j < num_relu; j++) { - delete[] mux_ot_messages[j]; - } - delete[] mux_ot_messages; - } - else // sci::BOB - { - uint8_t* mux_ot_selection = new uint8_t[num_relu]; - for(int j = 0; j < num_relu; j++) { - mux_ot_selection[j] = (leaf_res_cmp[j*2 + 1] << 1) | leaf_res_cmp[j*2]; - } - otpack->kkot_4->recv(drelu, mux_ot_selection, num_relu, 1); - delete[] mux_ot_selection; - } + assert(num_relu % 8 == 0 && "Number of ReLUs should be a multiple of 8"); - delete[] digits; - delete[] leaf_res_cmp; - delete[] leaf_res_eq; - } + if (party == sci::ALICE) { + uint8_t **mux_ot_messages = new uint8_t *[num_relu]; + for (int j = 0; j < num_relu; j++) { + mux_ot_messages[j] = new uint8_t[4]; + } + triple_gen->prg->random_bool((bool *)drelu, num_relu); + for (int j = 0; j < num_relu; j++) { + // drelu[j] = 0; + bool neg_share = (share[j] > p_2); + set_mux_ot_messages(mux_ot_messages[j], leaf_res_cmp + j * 2, drelu[j], + neg_share); + } + otpack->kkot[1]->send(mux_ot_messages, num_relu, 1); + for (int j = 0; j < num_relu; j++) { + delete[] mux_ot_messages[j]; + } + delete[] mux_ot_messages; + } else // sci::BOB + { + uint8_t *mux_ot_selection = new uint8_t[num_relu]; + for (int j = 0; j < num_relu; j++) { + mux_ot_selection[j] = + (leaf_res_cmp[j * 2 + 1] << 1) | leaf_res_cmp[j * 2]; + } + otpack->kkot[1]->recv(drelu, mux_ot_selection, num_relu, 1); + delete[] mux_ot_selection; + } - void set_leaf_ot_messages( - uint8_t* ot_messages, - uint8_t* digits, - int N, - uint8_t* additive_mask_cmp, - uint8_t* additive_mask_eq, - bool eq = true) - { - for(int i = 0; i < N; i++) { - if (eq){ - ot_messages[i] = 0; - // For comparisons - ot_messages[i] = (ot_messages[i] << 1) | ((digits[0] < i) ^ additive_mask_cmp[0]); - ot_messages[i] = (ot_messages[i] << 1) | ((digits[1] < i) ^ additive_mask_cmp[1]); - // For equality - ot_messages[i] = (ot_messages[i] << 1) | ((digits[0] == i) ^ additive_mask_eq[0]); - ot_messages[i] = (ot_messages[i] << 1) | ((digits[1] == i) ^ additive_mask_eq[1]); - } - else{ - ot_messages[i] = 0; - ot_messages[i] = (ot_messages[i] << 1) | ((digits[0] < i) ^ additive_mask_cmp[0]); - ot_messages[i] = (ot_messages[i] << 1) | ((digits[1] < i) ^ additive_mask_cmp[1]); - } - } - } + delete[] digits; + delete[] leaf_res_cmp; + delete[] leaf_res_eq; + } - void set_mux_ot_messages( - uint8_t* ot_messages, - uint8_t* cmp_results, - uint8_t drelu_mask, - bool neg_share) - { - uint8_t bits_i[2]; - for(int i = 0; i < 4; i++) { - sci::uint8_to_bool(bits_i, i, 2); // wrap_cmp || !drelu_cmp - uint8_t drelu_cmp = bits_i[1] ^ cmp_results[1]; - uint8_t wrap = bits_i[0] ^ cmp_results[0]; - if (neg_share){ - ot_messages[i] = ((1 ^ drelu_cmp) & wrap) ^ 1; - } - else{ - ot_messages[i] = drelu_cmp ^ (drelu_cmp & wrap); - } - ot_messages[i] ^= drelu_mask; - } - } + void set_leaf_ot_messages(uint8_t *ot_messages, uint8_t *digits, int N, + uint8_t *additive_mask_cmp, + uint8_t *additive_mask_eq, bool eq = true) { + for (int i = 0; i < N; i++) { + if (eq) { + ot_messages[i] = 0; + // For comparisons + ot_messages[i] = + (ot_messages[i] << 1) | ((digits[0] < i) ^ additive_mask_cmp[0]); + ot_messages[i] = + (ot_messages[i] << 1) | ((digits[1] < i) ^ additive_mask_cmp[1]); + // For equality + ot_messages[i] = + (ot_messages[i] << 1) | ((digits[0] == i) ^ additive_mask_eq[0]); + ot_messages[i] = + (ot_messages[i] << 1) | ((digits[1] == i) ^ additive_mask_eq[1]); + } else { + ot_messages[i] = 0; + ot_messages[i] = + (ot_messages[i] << 1) | ((digits[0] < i) ^ additive_mask_cmp[0]); + ot_messages[i] = + (ot_messages[i] << 1) | ((digits[1] < i) ^ additive_mask_cmp[1]); + } + } + } + void set_mux_ot_messages(uint8_t *ot_messages, uint8_t *cmp_results, + uint8_t drelu_mask, bool neg_share) { + uint8_t bits_i[2]; + for (int i = 0; i < 4; i++) { + sci::uint8_to_bool(bits_i, i, 2); // wrap_cmp || !drelu_cmp + uint8_t drelu_cmp = bits_i[1] ^ cmp_results[1]; + uint8_t wrap = bits_i[0] ^ cmp_results[0]; + if (neg_share) { + ot_messages[i] = ((1 ^ drelu_cmp) & wrap) ^ 1; + } else { + ot_messages[i] = drelu_cmp ^ (drelu_cmp & wrap); + } + ot_messages[i] ^= drelu_mask; + } + } }; #endif // DRELU_FIELD_H__ diff --git a/SCI/src/NonLinear/maxpool.h b/SCI/src/NonLinear/maxpool.h index 100a51a8..e982bab1 100644 --- a/SCI/src/NonLinear/maxpool.h +++ b/SCI/src/NonLinear/maxpool.h @@ -1,5 +1,5 @@ /* -Authors: Mayank Rathee +Authors: Mayank Rathee, Deevashwer Rathee Copyright: Copyright (c) 2020 Microsoft Research Permission is hereby granted, free of charge, to any person obtaining a copy @@ -22,193 +22,166 @@ SOFTWARE. #ifndef MAXPOOL_PRIMARY_H__ #define MAXPOOL_PRIMARY_H__ -#include "NonLinear/relu-ring.h" #include "NonLinear/relu-field.h" +#include "NonLinear/relu-ring.h" -template<typename IO, typename type> -class MaxPoolProtocol -{ +template <typename IO, typename type> class MaxPoolProtocol { public: - IO* io = nullptr; - sci::OTPack<IO>* otpack = nullptr; - TripleGenerator<IO>* triple_gen = nullptr; - ReLURingProtocol<IO, type>* relu_oracle = nullptr; - ReLUFieldProtocol<IO, type>* relu_field_oracle = nullptr; - int party; - int algeb_str; - int l, b; - int num_cmps; - uint64_t prime_mod; - type mask_l; + IO *io = nullptr; + sci::OTPack<IO> *otpack = nullptr; + TripleGenerator<IO> *triple_gen = nullptr; + ReLURingProtocol<IO, type> *relu_oracle = nullptr; + ReLUFieldProtocol<IO, type> *relu_field_oracle = nullptr; + int party; + int algeb_str; + int l, b; + int num_cmps; + uint64_t prime_mod; + type mask_l; - //Constructor - MaxPoolProtocol( - int party, - int algeb_str, - IO* io, - int l, - int b, - uint64_t prime, - sci::OTPack<IO> *otpack, - ReLUProtocol<IO, type>* relu_obj = nullptr) - { - this->party = party; - this->algeb_str = algeb_str; - this->io = io; - this->l = l; - this->b = b; + // Constructor + MaxPoolProtocol(int party, int algeb_str, IO *io, int l, int b, + uint64_t prime, sci::OTPack<IO> *otpack, + ReLUProtocol<IO, type> *relu_obj = nullptr) { + this->party = party; + this->algeb_str = algeb_str; + this->io = io; + this->l = l; + this->b = b; this->prime_mod = prime; this->otpack = otpack; - if(algeb_str == RING){ - if(relu_obj == nullptr){ - this->relu_oracle = new ReLURingProtocol<IO, type>(party, RING, io, l, b, otpack); - } else { - this->relu_oracle = (ReLURingProtocol<IO, type>*) relu_obj; - } - } - else{ - if(relu_obj == nullptr){ - this->relu_field_oracle = new ReLUFieldProtocol<IO, type>(party, FIELD, io, l, b, this->prime_mod, otpack); - } - else{ - this->relu_field_oracle = (ReLUFieldProtocol<IO, type>*) relu_obj; - } - } - configure(); - } - - //Destructor - ~MaxPoolProtocol() - { - //Empty - } + if (algeb_str == RING) { + if (relu_obj == nullptr) { + this->relu_oracle = + new ReLURingProtocol<IO, type>(party, RING, io, l, b, otpack); + } else { + this->relu_oracle = (ReLURingProtocol<IO, type> *)relu_obj; + } + } else { + if (relu_obj == nullptr) { + this->relu_field_oracle = new ReLUFieldProtocol<IO, type>( + party, FIELD, io, l, b, this->prime_mod, otpack); + } else { + this->relu_field_oracle = (ReLUFieldProtocol<IO, type> *)relu_obj; + } + } + configure(); + } - void configure() - { - if(this->l != 32 && this->l != 64){ - mask_l = (type)((1ULL<<l)-1); - } - else if(this->l == 32){ - mask_l = -1; - } - else{ //l = 64 - mask_l = -1ULL; - } + // Destructor + ~MaxPoolProtocol() { + // Empty + } - } + void configure() { + if (this->l != 32 && this->l != 64) { + mask_l = (type)((1ULL << l) - 1); + } else if (this->l == 32) { + mask_l = -1; + } else { // l = 64 + mask_l = -1ULL; + } + } - void funcMaxMPC( - int rows, - int cols, - type* inpArr, - type* maxi, - type* maxiIdx, - bool computeMaxIdx=false) - { - type* max_temp = new type[rows]; - type* compare_with = new type[rows]; - if(this->algeb_str == FIELD){ - for(int r=0; r<rows; r++){ - max_temp[r] = inpArr[r*cols]; - } - for(int c=1; c<cols; c++){ - for(int r=0; r<rows; r++){ - compare_with[r] = sci::neg_mod((int64_t)((int64_t)max_temp[r] - (int64_t)inpArr[r*cols + c]), this->prime_mod); - } - relu_field_oracle->relu(max_temp, compare_with, rows); - for(int r=0; r<rows; r++){ - max_temp[r] = (max_temp[r] + inpArr[r*cols + c]) % this->prime_mod; - } - } - for(int r=0; r<rows; r++){ - maxi[r] = max_temp[r]; - } - } - else{ //RING - for(int r=0; r<rows; r++){ - max_temp[r] = inpArr[r*cols]; - } - for(int c=1; c<cols; c++){ - for(int r=0; r<rows; r++){ - compare_with[r] = max_temp[r] - inpArr[r*cols + c]; - } - relu_oracle->relu(max_temp, compare_with, rows); - for(int r=0; r<rows; r++){ - max_temp[r] += inpArr[r*cols + c]; - } - } - for(int r=0; r<rows; r++){ - maxi[r] = max_temp[r]; - maxi[r] &= mask_l; - } - } - } + void funcMaxMPC(int rows, int cols, type *inpArr, type *maxi, type *maxiIdx, + bool computeMaxIdx = false) { + type *max_temp = new type[rows]; + type *compare_with = new type[rows]; + if (this->algeb_str == FIELD) { + for (int r = 0; r < rows; r++) { + max_temp[r] = inpArr[r * cols]; + } + for (int c = 1; c < cols; c++) { + for (int r = 0; r < rows; r++) { + compare_with[r] = sci::neg_mod( + (int64_t)((int64_t)max_temp[r] - (int64_t)inpArr[r * cols + c]), + this->prime_mod); + } + relu_field_oracle->relu(max_temp, compare_with, rows); + for (int r = 0; r < rows; r++) { + max_temp[r] = (max_temp[r] + inpArr[r * cols + c]) % this->prime_mod; + } + } + for (int r = 0; r < rows; r++) { + maxi[r] = max_temp[r]; + } + } else { // RING + for (int r = 0; r < rows; r++) { + max_temp[r] = inpArr[r * cols]; + } + for (int c = 1; c < cols; c++) { + for (int r = 0; r < rows; r++) { + compare_with[r] = max_temp[r] - inpArr[r * cols + c]; + } + relu_oracle->relu(max_temp, compare_with, rows); + for (int r = 0; r < rows; r++) { + max_temp[r] += inpArr[r * cols + c]; + } + } + for (int r = 0; r < rows; r++) { + maxi[r] = max_temp[r]; + maxi[r] &= mask_l; + } + } + } - void funcMaxMPCIdeal( - int rows, - int cols, - type* inpArr, - type* maxi, - type* maxiIdx, - bool computeMaxIdx=false) - { - type* otherPartyData = new type[rows*cols]; - if (party==SERVER){ - io->send_data(inpArr, sizeof(type)*rows*cols); - for(int i=0;i<rows;i++){ - maxi[i] = 0; - maxiIdx[i] = 0; - } - } - else{ - io->recv_data(otherPartyData, sizeof(type)*rows*cols); - if (this->algeb_str==RING){ - for(int i=0;i<rows*cols;i++){ - otherPartyData[i] = otherPartyData[i] + inpArr[i]; - } - for(int i=0;i<rows;i++){ - maxi[i] = otherPartyData[i*cols]; - maxiIdx[i] = 0; - } - for(int j=1;j<cols;j++){ - for(int i=0;i<rows;i++){ - if (((signedIntType)otherPartyData[i*cols+j])>((signedIntType)maxi[i])) { - //Do signed comparison - maxi[i] = otherPartyData[i*cols+j]; - maxiIdx[i] = j; - } - } - } - } - else{ - for(int i=0;i<rows*cols;i++){ - otherPartyData[i] = (otherPartyData[i] + inpArr[i])%prime_mod; - } - for(int i=0;i<rows;i++){ - maxi[i] = otherPartyData[i*cols]; - maxiIdx[i] = 0; - } - for(int j=1;j<cols;j++){ - for(int i=0;i<rows;i++){ - int64_t curValSigned = otherPartyData[i*cols+j]; - int64_t curMaxSigned = maxi[i]; - if (curValSigned > (prime_mod/2)){ - curValSigned = curValSigned - prime_mod; - } - if (curMaxSigned > (prime_mod/2)){ - curMaxSigned = curMaxSigned - prime_mod; - } - if (curValSigned>curMaxSigned) { - //Do signed comparison - maxi[i] = otherPartyData[i*cols+j]; - maxiIdx[i] = j; - } - } - } - } - } - delete[] otherPartyData; - } + void funcMaxMPCIdeal(int rows, int cols, type *inpArr, type *maxi, + type *maxiIdx, bool computeMaxIdx = false) { + type *otherPartyData = new type[rows * cols]; + if (party == 1) { + io->send_data(inpArr, sizeof(type) * rows * cols); + for (int i = 0; i < rows; i++) { + maxi[i] = 0; + maxiIdx[i] = 0; + } + } else { + io->recv_data(otherPartyData, sizeof(type) * rows * cols); + if (this->algeb_str == RING) { + for (int i = 0; i < rows * cols; i++) { + otherPartyData[i] = otherPartyData[i] + inpArr[i]; + } + for (int i = 0; i < rows; i++) { + maxi[i] = otherPartyData[i * cols]; + maxiIdx[i] = 0; + } + for (int j = 1; j < cols; j++) { + for (int i = 0; i < rows; i++) { + if (((int64_t)otherPartyData[i * cols + j]) > ((int64_t)maxi[i])) { + // Do signed comparison + maxi[i] = otherPartyData[i * cols + j]; + maxiIdx[i] = j; + } + } + } + } else { + for (int i = 0; i < rows * cols; i++) { + otherPartyData[i] = (otherPartyData[i] + inpArr[i]) % prime_mod; + } + for (int i = 0; i < rows; i++) { + maxi[i] = otherPartyData[i * cols]; + maxiIdx[i] = 0; + } + for (int j = 1; j < cols; j++) { + for (int i = 0; i < rows; i++) { + int64_t curValSigned = otherPartyData[i * cols + j]; + int64_t curMaxSigned = maxi[i]; + if (curValSigned > (prime_mod / 2)) { + curValSigned = curValSigned - prime_mod; + } + if (curMaxSigned > (prime_mod / 2)) { + curMaxSigned = curMaxSigned - prime_mod; + } + if (curValSigned > curMaxSigned) { + // Do signed comparison + maxi[i] = otherPartyData[i * cols + j]; + maxiIdx[i] = j; + } + } + } + } + } + delete[] otherPartyData; + } }; -#endif //MAXPOOL_PRIMARY_H__ +#endif // MAXPOOL_PRIMARY_H__ diff --git a/SCI/src/NonLinear/relu-field.h b/SCI/src/NonLinear/relu-field.h index 53516c06..eeec76a5 100644 --- a/SCI/src/NonLinear/relu-field.h +++ b/SCI/src/NonLinear/relu-field.h @@ -1,5 +1,5 @@ /* -Authors: Mayank Rathee +Authors: Mayank Rathee, Deevashwer Rathee Copyright: Copyright (c) 2020 Microsoft Research Permission is hereby granted, free of charge, to any person obtaining a copy @@ -22,220 +22,194 @@ SOFTWARE. #ifndef RELU_FIELD_H__ #define RELU_FIELD_H__ -#include "globals.h" #include "Millionaire/millionaire.h" #include "NonLinear/drelu-field.h" +#include "NonLinear/relu-interface.h" #define FIELD 1 -template<typename IO, typename type> -class ReLUFieldProtocol : public ReLUProtocol<IO, type> -{ +template <typename IO, typename type> +class ReLUFieldProtocol : public ReLUProtocol<IO, type> { public: - IO* io = nullptr; - sci::OTPack<IO>* otpack = nullptr; - TripleGenerator<IO>* triple_gen = nullptr; - DReLUFieldProtocol<IO>* relu_triple_compare_oracle = nullptr; - int party; - int algeb_str; - int l, b; - int num_cmps; - uint64_t p; - uint64_t p_bitlen; - uint64_t p_bitlen_triple_comparison; - uint64_t rhs_wrap; - uint64_t rhs_wrap_off; - uint64_t rhs_wrap_on; - uint8_t zero_small = 0; - - //Constructor - ReLUFieldProtocol( - int party, - int algeb_str, - IO* io, - int l, - int b, - uint64_t mod, - sci::OTPack<IO>* otpack) - { - this->party = party; - this->algeb_str = algeb_str; - this->io = io; - this->l = l; - this->b = b; - this->p = mod; - this->p_bitlen = l; - this->p_bitlen_triple_comparison = l+1; - this->otpack = otpack; - this->triple_gen = new TripleGenerator<IO>(party, io, otpack); - this->relu_triple_compare_oracle = new DReLUFieldProtocol<IO>(party, l+1, b, mod, io, otpack); - configure(); - } - - //Destructor - ~ReLUFieldProtocol() - { - delete triple_gen; - delete relu_triple_compare_oracle; - } - - void configure() - { - // Set all the inequality RHS values here. - rhs_wrap = this->p; - rhs_wrap_off = this->p/2; - rhs_wrap_on = this->p + this->p/2; - } - - //Tester Ideal Functionality - void drelu_field_ideal_func( - uint8_t* result, - uint64_t* sh1, - uint64_t* sh2, - int num_relu) - { - uint8_t *wrap, *relu_wrap_off, *relu_wrap_on, *expected_drelu, *actual_drelu; - wrap = new uint8_t[num_relu]; - relu_wrap_off = new uint8_t[num_relu]; - relu_wrap_on = new uint8_t[num_relu]; - expected_drelu = new uint8_t[num_relu]; - actual_drelu = new uint8_t[num_relu]; - for(int i=0; i<num_relu; i++){ - wrap[i] = greater_than_wrap(sh1[i], sci::neg_mod((int64_t)(this->rhs_wrap - sh2[i]), this->p)); - relu_wrap_off[i] = greater_than_relu_wrap_off(sh1[i], sci::neg_mod((int64_t)(this->rhs_wrap_off - sh2[i]), this->p)); - relu_wrap_on[i] = greater_than_relu_wrap_on(sh1[i], sci::neg_mod((int64_t)(this->rhs_wrap_on - sh2[i]), this->p)); - expected_drelu[i] = (relu_wrap_on[i] & wrap[i]) ^ ((1 ^ wrap[i]) & relu_wrap_off[i]); - expected_drelu[i] = 1 ^ expected_drelu[i]; - actual_drelu[i] = (((sh1[i] + sh2[i]) % this->p) > this->rhs_wrap_off); - result[i] = 1 ^ actual_drelu[i]; - assert(((result[i] & 1) == (1 & expected_drelu[i])) && "The computed DReLU did not match the actual DReLU"); - } - } - - // To handle the case when RHS is taken modulo p - uint8_t greater_than_wrap( - uint64_t lhs, - uint64_t rhs) - { - if(rhs == 0ULL){ - return 0; - } - else{ - return (lhs >= rhs); - } - } - - uint8_t greater_than_relu_wrap_off( - uint64_t lhs, - uint64_t rhs) - { - if(rhs <= this->rhs_wrap_off){ - return (lhs > rhs); - } - else{ - return 1; - } - } - - uint8_t greater_than_relu_wrap_on( - uint64_t lhs, - uint64_t rhs) - { - if(rhs <= this->rhs_wrap_off){ - return 0; - } - else{ - return (lhs > rhs); - } - } - - void drelu( - uint8_t* drelu_res, - uint64_t* share, - int num_relu) - { - this->relu_triple_compare_oracle->compute_drelu(drelu_res, share, num_relu); - } - - void relu( - type* result, - type* share, - int num_relu, - uint8_t* drelu_res = nullptr, - bool skip_ot = false) - { - uint8_t* drelu_ans = new uint8_t[num_relu]; - drelu(drelu_ans, (uint64_t*)share, num_relu); - if(drelu_res != nullptr){ - memcpy(drelu_res, drelu_ans, num_relu*sizeof(uint8_t)); - } - if(skip_ot){ - delete[] drelu_ans; - // std::cout<<"Doing Max and ArgMax OTs together"<<std::endl; - return; - } - // Now perform x.msb(x) - // 2 OTs required with reversed roles - uint64_t** ot_messages = new uint64_t*[num_relu]; - for(int i=0; i<num_relu; i++){ - ot_messages[i] = new uint64_t[2]; - } - uint64_t* additive_masks = new uint64_t[num_relu]; - uint64_t* received_shares = new uint64_t[num_relu]; - this->triple_gen->prg->template random_mod_p<type>((type*)additive_masks, num_relu, this->p); - for(int i=0; i<num_relu; i++){ - additive_masks[i] %= this->p; - } - - switch (this->party) { - case sci::ALICE: { - for(int i=0; i<num_relu; i++){ - set_relu_end_ot_messages(ot_messages[i], share+i, drelu_ans+i, ((type*)additive_masks)+i); - } - otpack->iknp_straight->send(ot_messages, num_relu, this->l); - otpack->iknp_reversed->recv(received_shares, drelu_ans, num_relu, this->l); - break; - } - case sci::BOB: { - for(int i=0; i<num_relu; i++){ - set_relu_end_ot_messages(ot_messages[i], share+i, drelu_ans+i, ((type*)additive_masks)+i); - } - otpack->iknp_straight->recv(received_shares, drelu_ans, num_relu, this->l); - otpack->iknp_reversed->send(ot_messages, num_relu, this->l); - break; - } - } - for(int i=0; i<num_relu; i++){ - result[i] = ((type*)additive_masks)[i] + ((type*)received_shares)[(8/sizeof(type))*i]; - result[i] %= this->p; - } - delete[] additive_masks; - delete[] received_shares; - for(int i=0; i<num_relu; i++){ - delete[] ot_messages[i]; - } - delete[] ot_messages; - } - - void set_relu_end_ot_messages( - uint64_t* ot_messages, - type* value_share, - uint8_t* xor_share, - type* additive_mask) - { - type temp0, temp1; - temp0 = sci::neg_mod((int64_t)value_share[0] - (int64_t)additive_mask[0], this->p); - temp1 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0], this->p); - if(*xor_share == zero_small){ - ot_messages[0] = 0ULL + temp0; - ot_messages[1] = 0ULL + temp1; - } - else{ - ot_messages[0] = 0ULL + temp1; - ot_messages[1] = 0ULL + temp0; - } - } + IO *io = nullptr; + sci::OTPack<IO> *otpack = nullptr; + TripleGenerator<IO> *triple_gen = nullptr; + DReLUFieldProtocol<IO> *relu_triple_compare_oracle = nullptr; + int party; + int algeb_str; + int l, b; + int num_cmps; + uint64_t p; + uint64_t p_bitlen; + uint64_t p_bitlen_triple_comparison; + uint64_t rhs_wrap; + uint64_t rhs_wrap_off; + uint64_t rhs_wrap_on; + uint8_t zero_small = 0; + // Constructor + ReLUFieldProtocol(int party, int algeb_str, IO *io, int l, int b, + uint64_t mod, sci::OTPack<IO> *otpack) { + this->party = party; + this->algeb_str = algeb_str; + this->io = io; + this->l = l; + this->b = b; + this->p = mod; + this->p_bitlen = l; + this->p_bitlen_triple_comparison = l + 1; + this->otpack = otpack; + this->triple_gen = new TripleGenerator<IO>(party, io, otpack); + this->relu_triple_compare_oracle = + new DReLUFieldProtocol<IO>(party, l + 1, b, mod, io, otpack); + configure(); + } + + // Destructor + virtual ~ReLUFieldProtocol() { + delete triple_gen; + delete relu_triple_compare_oracle; + } + + void configure() { + // Set all the inequality RHS values here. + rhs_wrap = this->p; + rhs_wrap_off = this->p / 2; + rhs_wrap_on = this->p + this->p / 2; + } + + // Tester Ideal Functionality + void drelu_field_ideal_func(uint8_t *result, uint64_t *sh1, uint64_t *sh2, + int num_relu) { + uint8_t *wrap, *relu_wrap_off, *relu_wrap_on, *expected_drelu, + *actual_drelu; + wrap = new uint8_t[num_relu]; + relu_wrap_off = new uint8_t[num_relu]; + relu_wrap_on = new uint8_t[num_relu]; + expected_drelu = new uint8_t[num_relu]; + actual_drelu = new uint8_t[num_relu]; + for (int i = 0; i < num_relu; i++) { + wrap[i] = greater_than_wrap( + sh1[i], sci::neg_mod((int64_t)(this->rhs_wrap - sh2[i]), this->p)); + relu_wrap_off[i] = greater_than_relu_wrap_off( + sh1[i], + sci::neg_mod((int64_t)(this->rhs_wrap_off - sh2[i]), this->p)); + relu_wrap_on[i] = greater_than_relu_wrap_on( + sh1[i], sci::neg_mod((int64_t)(this->rhs_wrap_on - sh2[i]), this->p)); + expected_drelu[i] = + (relu_wrap_on[i] & wrap[i]) ^ ((1 ^ wrap[i]) & relu_wrap_off[i]); + expected_drelu[i] = 1 ^ expected_drelu[i]; + actual_drelu[i] = (((sh1[i] + sh2[i]) % this->p) > this->rhs_wrap_off); + result[i] = 1 ^ actual_drelu[i]; + assert(((result[i] & 1) == (1 & expected_drelu[i])) && + "The computed DReLU did not match the actual DReLU"); + } + } + + // To handle the case when RHS is taken modulo p + uint8_t greater_than_wrap(uint64_t lhs, uint64_t rhs) { + if (rhs == 0ULL) { + return 0; + } else { + return (lhs >= rhs); + } + } + + uint8_t greater_than_relu_wrap_off(uint64_t lhs, uint64_t rhs) { + if (rhs <= this->rhs_wrap_off) { + return (lhs > rhs); + } else { + return 1; + } + } + + uint8_t greater_than_relu_wrap_on(uint64_t lhs, uint64_t rhs) { + if (rhs <= this->rhs_wrap_off) { + return 0; + } else { + return (lhs > rhs); + } + } + + void drelu(uint8_t *drelu_res, uint64_t *share, int num_relu) { + this->relu_triple_compare_oracle->compute_drelu(drelu_res, share, num_relu); + } + + void relu(type *result, type *share, int num_relu, + uint8_t *drelu_res = nullptr, bool skip_ot = false) { + uint8_t *drelu_ans = new uint8_t[num_relu]; + drelu(drelu_ans, (uint64_t *)share, num_relu); + if (drelu_res != nullptr) { + memcpy(drelu_res, drelu_ans, num_relu * sizeof(uint8_t)); + } + if (skip_ot) { + delete[] drelu_ans; + // std::cout<<"Doing Max and ArgMax OTs together"<<std::endl; + return; + } + // Now perform x.msb(x) + // 2 OTs required with reversed roles + uint64_t **ot_messages = new uint64_t *[num_relu]; + for (int i = 0; i < num_relu; i++) { + ot_messages[i] = new uint64_t[2]; + } + uint64_t *additive_masks = new uint64_t[num_relu]; + uint64_t *received_shares = new uint64_t[num_relu]; + this->triple_gen->prg->template random_mod_p<type>((type *)additive_masks, + num_relu, this->p); + for (int i = 0; i < num_relu; i++) { + additive_masks[i] %= this->p; + } + + switch (this->party) { + case sci::ALICE: { + for (int i = 0; i < num_relu; i++) { + set_relu_end_ot_messages(ot_messages[i], share + i, drelu_ans + i, + ((type *)additive_masks) + i); + } + otpack->iknp_straight->send(ot_messages, num_relu, this->l); + otpack->iknp_reversed->recv(received_shares, drelu_ans, num_relu, + this->l); + break; + } + case sci::BOB: { + for (int i = 0; i < num_relu; i++) { + set_relu_end_ot_messages(ot_messages[i], share + i, drelu_ans + i, + ((type *)additive_masks) + i); + } + otpack->iknp_straight->recv(received_shares, drelu_ans, num_relu, + this->l); + otpack->iknp_reversed->send(ot_messages, num_relu, this->l); + break; + } + } + for (int i = 0; i < num_relu; i++) { + result[i] = ((type *)additive_masks)[i] + + ((type *)received_shares)[(8 / sizeof(type)) * i]; + result[i] %= this->p; + } + delete[] additive_masks; + delete[] received_shares; + for (int i = 0; i < num_relu; i++) { + delete[] ot_messages[i]; + } + delete[] ot_messages; + } + + void set_relu_end_ot_messages(uint64_t *ot_messages, type *value_share, + uint8_t *xor_share, type *additive_mask) { + type temp0, temp1; + temp0 = sci::neg_mod((int64_t)value_share[0] - (int64_t)additive_mask[0], + this->p); + temp1 = sci::neg_mod((int64_t)0LL - (int64_t)additive_mask[0], this->p); + if (*xor_share == zero_small) { + ot_messages[0] = 0ULL + temp0; + ot_messages[1] = 0ULL + temp1; + } else { + ot_messages[0] = 0ULL + temp1; + ot_messages[1] = 0ULL + temp0; + } + } }; -#endif //RELU_FIELD_H__ +#endif // RELU_FIELD_H__ diff --git a/SCI/src/NonLinear/relu-interface.h b/SCI/src/NonLinear/relu-interface.h index 7a1d2c23..7c2a01af 100644 --- a/SCI/src/NonLinear/relu-interface.h +++ b/SCI/src/NonLinear/relu-interface.h @@ -1,37 +1,31 @@ -/* -Authors: Nishant Kumar -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#ifndef RELU_INTERFACE_H__ -#define RELU_INTERFACE_H__ - -template<typename IO, typename intType> -class ReLUProtocol -{ -public: - virtual void relu( - intType* outp, - intType* inp, - int numRelu, - uint8_t* drelu_res = nullptr, - bool skip_ot = false) = 0; -}; - -#endif //RELU_INTERFACE_H__ +/* +Authors: Nishant Kumar +Copyright: +Copyright (c) 2020 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef RELU_INTERFACE_H__ +#define RELU_INTERFACE_H__ + +template <typename IO, typename intType> class ReLUProtocol { +public: + virtual void relu(intType *outp, intType *inp, int numRelu, + uint8_t *drelu_res = nullptr, bool skip_ot = false) = 0; +}; + +#endif // RELU_INTERFACE_H__ diff --git a/SCI/src/NonLinear/relu-ring.h b/SCI/src/NonLinear/relu-ring.h index 7a854dd9..b3b86dbe 100644 --- a/SCI/src/NonLinear/relu-ring.h +++ b/SCI/src/NonLinear/relu-ring.h @@ -22,254 +22,230 @@ SOFTWARE. #ifndef RELU_RING_H__ #define RELU_RING_H__ -#include "globals.h" #include "Millionaire/millionaire.h" +#include "NonLinear/relu-interface.h" #define RING 0 #define OFF_PLACE -template<typename IO, typename type> -class ReLURingProtocol : public ReLUProtocol<IO, type> -{ +template <typename IO, typename type> +class ReLURingProtocol : public ReLUProtocol<IO, type> { public: - IO* io = nullptr; - sci::OTPack<IO>* otpack; - TripleGenerator<IO>* triple_gen = nullptr; - MillionaireProtocol<IO>* millionaire = nullptr; - int party; - int algeb_str; - int l, b; - int num_cmps; - uint8_t two_small = 1<<1; - uint8_t zero_small = 0; - uint64_t mask_take_32 = -1; - uint64_t msb_one; - uint64_t cut_mask; - uint64_t relu_comparison_rhs; - type mask_l; - type relu_comparison_rhs_type; - type cut_mask_type; - type msb_one_type; - - //Constructor - ReLURingProtocol( - int party, - int algeb_str, - IO* io, - int l, - int b, - sci::OTPack<IO>* otpack) - { - this->party = party; - this->algeb_str = algeb_str; - this->io = io; - this->l = l; - this->b = b; - this->otpack = otpack; - this->millionaire = new MillionaireProtocol<IO>(party, l-1, b, io, otpack); - this->triple_gen = this->millionaire->triple_gen; - configure(); - } + IO *io = nullptr; + sci::OTPack<IO> *otpack; + TripleGenerator<IO> *triple_gen = nullptr; + MillionaireProtocol<IO> *millionaire = nullptr; + int party; + int algeb_str; + int l, b; + int num_cmps; + uint8_t two_small = 1 << 1; + uint8_t zero_small = 0; + uint64_t mask_take_32 = -1; + uint64_t msb_one; + uint64_t cut_mask; + uint64_t relu_comparison_rhs; + type mask_l; + type relu_comparison_rhs_type; + type cut_mask_type; + type msb_one_type; - //Destructor - ~ReLURingProtocol() - { - delete millionaire; - } + // Constructor + ReLURingProtocol(int party, int algeb_str, IO *io, int l, int b, + sci::OTPack<IO> *otpack) { + this->party = party; + this->algeb_str = algeb_str; + this->io = io; + this->l = l; + this->b = b; + this->otpack = otpack; + this->millionaire = new MillionaireProtocol<IO>(party, io, otpack); + this->triple_gen = this->millionaire->triple_gen; + configure(); + } - void configure() - { - if(this->l != 32 && this->l != 64){ - mask_l = (type)((1ULL<<l)-1); - } - else if(this->l == 32){ - mask_l = -1; - } - else{ //l = 64 - mask_l = -1ULL; - } - if(sizeof(type) == sizeof(uint64_t)){ - msb_one = (1ULL<<(this->l-1)); - relu_comparison_rhs_type = msb_one-1ULL; - relu_comparison_rhs = relu_comparison_rhs_type; - cut_mask_type = relu_comparison_rhs_type; - cut_mask = cut_mask_type; - } - else{ - msb_one_type = (1<<(this->l-1)); - relu_comparison_rhs_type = msb_one_type-1; - relu_comparison_rhs = relu_comparison_rhs_type + 0ULL; - cut_mask_type = relu_comparison_rhs_type; - cut_mask = cut_mask_type + 0ULL; - } - } + // Destructor + virtual ~ReLURingProtocol() { delete millionaire; } - //Ideal Functionality - void drelu_ring_ideal_func( - uint8_t* result, - type* sh1, - type* sh2, - int num_relu) - { - uint8_t* msb1 = new uint8_t[num_relu]; - uint8_t* msb2 = new uint8_t[num_relu]; - type* plain_value = new type[num_relu]; - for(int i=0; i<num_relu; i++){ - plain_value[i] = sh1[i] + sh2[i]; - } - uint8_t* actual_drelu = new uint8_t[num_relu]; - - uint64_t index_fetch = (sizeof(type) == sizeof(uint64_t))?7:3; - for(int i=0; i<num_relu; i++){ - msb1[i] = (*((uint8_t*)(&(sh1[i]))+index_fetch))>>7; - msb2[i] = (*((uint8_t*)(&(sh2[i]))+index_fetch))>>7; - actual_drelu[i] = (*((uint8_t*)(&(plain_value[i]))+index_fetch))>>7; - } + void configure() { + if (this->l != 32 && this->l != 64) { + mask_l = (type)((1ULL << l) - 1); + } else if (this->l == 32) { + mask_l = -1; + } else { // l = 64 + mask_l = -1ULL; + } + if (sizeof(type) == sizeof(uint64_t)) { + msb_one = (1ULL << (this->l - 1)); + relu_comparison_rhs_type = msb_one - 1ULL; + relu_comparison_rhs = relu_comparison_rhs_type; + cut_mask_type = relu_comparison_rhs_type; + cut_mask = cut_mask_type; + } else { + msb_one_type = (1 << (this->l - 1)); + relu_comparison_rhs_type = msb_one_type - 1; + relu_comparison_rhs = relu_comparison_rhs_type + 0ULL; + cut_mask_type = relu_comparison_rhs_type; + cut_mask = cut_mask_type + 0ULL; + } + } - type* sh1_cut = new type[num_relu]; - type* sh2_cut = new type[num_relu]; - uint8_t* wrap = new uint8_t[num_relu]; - uint8_t* wrap_orig = new uint8_t[num_relu]; - uint8_t* relu_comparison_avoid_warning = new uint8_t[sizeof(type)]; - memcpy(relu_comparison_avoid_warning, &relu_comparison_rhs, sizeof(type)); - for(int i=0; i<num_relu; i++){ - sh1_cut[i] = sh1[i] & cut_mask; - sh2_cut[i] = sh2[i] & cut_mask; - wrap_orig[i] = ((sh1_cut[i] + sh2_cut[i]) > *(type*)relu_comparison_avoid_warning); - wrap[i] = wrap_orig[i]; - wrap[i] ^= msb1[i]; - wrap[i] ^= msb2[i]; - } - memcpy(result, wrap, num_relu); - for(int i=0; i<num_relu; i++){ - assert((wrap[i] == actual_drelu[i]) && "The computed DReLU did not match the actual DReLU"); - } - } - - void relu( - type* result, - type* share, - int num_relu, - uint8_t* drelu_res = nullptr, - bool skip_ot = false) - { - uint8_t* msb_local_share = new uint8_t[num_relu]; - uint64_t* array64; - type* array_type; - array64 = new uint64_t[num_relu]; - array_type = new type[num_relu]; - - if(this->algeb_str == RING){ - this->num_cmps = num_relu; - } - else{ - abort(); - } - uint8_t* wrap = new uint8_t[num_cmps]; - for(int i=0; i<num_relu; i++){ - msb_local_share[i] = (uint8_t)(share[i]>>(l-1)); - array_type[i] = share[i] & cut_mask_type; - } - - type temp; + // Ideal Functionality + void drelu_ring_ideal_func(uint8_t *result, type *sh1, type *sh2, + int num_relu) { + uint8_t *msb1 = new uint8_t[num_relu]; + uint8_t *msb2 = new uint8_t[num_relu]; + type *plain_value = new type[num_relu]; + for (int i = 0; i < num_relu; i++) { + plain_value[i] = sh1[i] + sh2[i]; + } + uint8_t *actual_drelu = new uint8_t[num_relu]; - switch (this->party){ - case sci::ALICE: { - for(int i=0; i<num_relu; i++){ - array64[i] = array_type[i] + 0ULL; - } - break; - } - case sci::BOB: { - for(int i=0; i<num_relu; i++){ - temp = this->relu_comparison_rhs_type - array_type[i]; // This value is never negative. - array64[i] = 0ULL + temp; - } - break; - } - } - - this->millionaire->compare(wrap, array64, num_cmps); - for(int i=0; i<num_relu; i++){ - msb_local_share[i] = (msb_local_share[i] + wrap[i])%two_small; - } + uint64_t index_fetch = (sizeof(type) == sizeof(uint64_t)) ? 7 : 3; + for (int i = 0; i < num_relu; i++) { + msb1[i] = (*((uint8_t *)(&(sh1[i])) + index_fetch)) >> 7; + msb2[i] = (*((uint8_t *)(&(sh2[i])) + index_fetch)) >> 7; + actual_drelu[i] = (*((uint8_t *)(&(plain_value[i])) + index_fetch)) >> 7; + } - if(drelu_res != nullptr){ - for(int i=0; i<num_relu; i++){ - drelu_res[i] = msb_local_share[i]; - } - } + type *sh1_cut = new type[num_relu]; + type *sh2_cut = new type[num_relu]; + uint8_t *wrap = new uint8_t[num_relu]; + uint8_t *wrap_orig = new uint8_t[num_relu]; + uint8_t *relu_comparison_avoid_warning = new uint8_t[sizeof(type)]; + memcpy(relu_comparison_avoid_warning, &relu_comparison_rhs, sizeof(type)); + for (int i = 0; i < num_relu; i++) { + sh1_cut[i] = sh1[i] & cut_mask; + sh2_cut[i] = sh2[i] & cut_mask; + wrap_orig[i] = + ((sh1_cut[i] + sh2_cut[i]) > *(type *)relu_comparison_avoid_warning); + wrap[i] = wrap_orig[i]; + wrap[i] ^= msb1[i]; + wrap[i] ^= msb2[i]; + } + memcpy(result, wrap, num_relu); + for (int i = 0; i < num_relu; i++) { + assert((wrap[i] == actual_drelu[i]) && + "The computed DReLU did not match the actual DReLU"); + } + } - if(skip_ot){ - delete[] msb_local_share; - delete[] array64; - delete[] array_type; - return; - } + void relu(type *result, type *share, int num_relu, + uint8_t *drelu_res = nullptr, bool skip_ot = false) { + uint8_t *msb_local_share = new uint8_t[num_relu]; + uint64_t *array64; + type *array_type; + array64 = new uint64_t[num_relu]; + array_type = new type[num_relu]; - // Now perform x.msb(x) - uint64_t** ot_messages = new uint64_t*[num_relu]; - for(int i=0; i<num_relu; i++){ - ot_messages[i] = new uint64_t[2]; - } - uint64_t* additive_masks = new uint64_t[num_relu]; - uint64_t* received_shares = new uint64_t[num_relu]; - this->triple_gen->prg->random_data(additive_masks, num_relu*sizeof(type)); - switch (this->party) { - case sci::ALICE: { - for(int i=0; i<num_relu; i++){ - set_relu_end_ot_messages(ot_messages[i], share+i, msb_local_share+i, ((type*)additive_masks)+i); - } - otpack->iknp_straight->send(ot_messages, num_relu, this->l); - otpack->iknp_reversed->recv(received_shares, msb_local_share, num_relu, this->l); - break; - } - case sci::BOB: { - for(int i=0; i<num_relu; i++){ - set_relu_end_ot_messages(ot_messages[i], share+i, msb_local_share+i, ((type*)additive_masks)+i); - } - otpack->iknp_straight->recv(received_shares, msb_local_share, num_relu, this->l); - otpack->iknp_reversed->send(ot_messages, num_relu, this->l); - break; - } - } - for(int i=0; i<num_relu; i++){ - result[i] = ((type*)additive_masks)[i] + ((type*)received_shares)[(8/sizeof(type))*i]; - result[i] &= mask_l; - } - delete[] msb_local_share; - delete[] array64; - delete[] array_type; - delete[] additive_masks; - delete[] received_shares; - for(int i=0; i<num_relu; i++){ - delete[] ot_messages[i]; - } - delete[] ot_messages; - delete[] wrap; - - } - - void set_relu_end_ot_messages( - uint64_t* ot_messages, - type* value_share, - uint8_t* xor_share, - type* additive_mask) - { - type temp0, temp1; - temp0 = (value_share[0] - additive_mask[0]); - temp1 = (0 - additive_mask[0]); - if(*xor_share == zero_small){ - ot_messages[0] = 0ULL + temp0; - ot_messages[1] = 0ULL + temp1; - } - else{ - ot_messages[0] = 0ULL + temp1; - ot_messages[1] = 0ULL + temp0; - } - } + if (this->algeb_str == RING) { + this->num_cmps = num_relu; + } else { + abort(); + } + uint8_t *wrap = new uint8_t[num_cmps]; + for (int i = 0; i < num_relu; i++) { + msb_local_share[i] = (uint8_t)(share[i] >> (l - 1)); + array_type[i] = share[i] & cut_mask_type; + } -}; + type temp; + + switch (this->party) { + case sci::ALICE: { + for (int i = 0; i < num_relu; i++) { + array64[i] = array_type[i] + 0ULL; + } + break; + } + case sci::BOB: { + for (int i = 0; i < num_relu; i++) { + temp = this->relu_comparison_rhs_type - + array_type[i]; // This value is never negative. + array64[i] = 0ULL + temp; + } + break; + } + } + + this->millionaire->compare(wrap, array64, num_cmps, l - 1, true, false, b); + for (int i = 0; i < num_relu; i++) { + msb_local_share[i] = (msb_local_share[i] + wrap[i]) % two_small; + } + + if (drelu_res != nullptr) { + for (int i = 0; i < num_relu; i++) { + drelu_res[i] = msb_local_share[i]; + } + } -#endif //RELU_RING_H__ + if (skip_ot) { + delete[] msb_local_share; + delete[] array64; + delete[] array_type; + return; + } + + // Now perform x.msb(x) + uint64_t **ot_messages = new uint64_t *[num_relu]; + for (int i = 0; i < num_relu; i++) { + ot_messages[i] = new uint64_t[2]; + } + uint64_t *additive_masks = new uint64_t[num_relu]; + uint64_t *received_shares = new uint64_t[num_relu]; + this->triple_gen->prg->random_data(additive_masks, num_relu * sizeof(type)); + switch (this->party) { + case sci::ALICE: { + for (int i = 0; i < num_relu; i++) { + set_relu_end_ot_messages(ot_messages[i], share + i, msb_local_share + i, + ((type *)additive_masks) + i); + } + otpack->iknp_straight->send(ot_messages, num_relu, this->l); + otpack->iknp_reversed->recv(received_shares, msb_local_share, num_relu, + this->l); + break; + } + case sci::BOB: { + for (int i = 0; i < num_relu; i++) { + set_relu_end_ot_messages(ot_messages[i], share + i, msb_local_share + i, + ((type *)additive_masks) + i); + } + otpack->iknp_straight->recv(received_shares, msb_local_share, num_relu, + this->l); + otpack->iknp_reversed->send(ot_messages, num_relu, this->l); + break; + } + } + for (int i = 0; i < num_relu; i++) { + result[i] = ((type *)additive_masks)[i] + + ((type *)received_shares)[(8 / sizeof(type)) * i]; + result[i] &= mask_l; + } + delete[] msb_local_share; + delete[] array64; + delete[] array_type; + delete[] additive_masks; + delete[] received_shares; + for (int i = 0; i < num_relu; i++) { + delete[] ot_messages[i]; + } + delete[] ot_messages; + delete[] wrap; + } + + void set_relu_end_ot_messages(uint64_t *ot_messages, type *value_share, + uint8_t *xor_share, type *additive_mask) { + type temp0, temp1; + temp0 = (value_share[0] - additive_mask[0]); + temp1 = (0 - additive_mask[0]); + if (*xor_share == zero_small) { + ot_messages[0] = 0ULL + temp0; + ot_messages[1] = 0ULL + temp1; + } else { + ot_messages[0] = 0ULL + temp1; + ot_messages[1] = 0ULL + temp0; + } + } +}; +#endif // RELU_RING_H__ diff --git a/SCI/src/OT/CMakeLists.txt b/SCI/src/OT/CMakeLists.txt index 0646dd79..bf9097cd 100644 --- a/SCI/src/OT/CMakeLists.txt +++ b/SCI/src/OT/CMakeLists.txt @@ -1,4 +1,4 @@ -add_library(SCI-OT INTERFACE) -target_link_libraries(SCI-OT +add_library(SCI-OTPrimitive INTERFACE) +target_link_libraries(SCI-OTPrimitive INTERFACE SCI-utils ) diff --git a/SCI/src/OT/emp-ot.h b/SCI/src/OT/emp-ot.h index 7027e369..f330fe65 100644 --- a/SCI/src/OT/emp-ot.h +++ b/SCI/src/OT/emp-ot.h @@ -1,13 +1,13 @@ /** @defgroup OT Oblivious Transfer -*/ + */ -#include "OT/ot.h" #include "OT/ideal.h" +#include "OT/ot.h" -#include "OT/np.h" #include "OT/iknp.h" +#include "OT/np.h" -#include "OT/split-iknp.h" #include "OT/kkot.h" -#include "OT/split-kkot.h" #include "OT/ot_pack.h" +#include "OT/split-iknp.h" +#include "OT/split-kkot.h" diff --git a/SCI/src/OT/ideal.h b/SCI/src/OT/ideal.h index 6a7ddfe5..c826591a 100644 --- a/SCI/src/OT/ideal.h +++ b/SCI/src/OT/ideal.h @@ -33,122 +33,127 @@ Modified by Nishant Kumar, Deevashwer Rathee @{ */ namespace sci { -template<typename IO> -class OTIdeal: public OT<OTIdeal<IO>> { +template <typename IO> class OTIdeal : public OT<OTIdeal<IO>> { public: - int cnt = 0; - IO* io = nullptr; - OTIdeal(IO * io) { - this->io = io; - } + int cnt = 0; + IO *io = nullptr; + OTIdeal(IO *io) { this->io = io; } - void send_impl(const block128* data0, const block128* data1, int length) { - cnt+=length; - io->send_block(data0, length); - io->send_block(data1, length); - } + void send_impl(const block128 *data0, const block128 *data1, int length) { + cnt += length; + io->send_block(data0, length); + io->send_block(data1, length); + } - void send_impl(const block256* data0, const block256* data1, int length) { - cnt+=length; - io->send_block(data0, length); - io->send_block(data1, length); - } + void send_impl(const block256 *data0, const block256 *data1, int length) { + cnt += length; + io->send_block(data0, length); + io->send_block(data1, length); + } - void recv_impl(block128* data, const bool* b, int length) { - cnt+=length; - block128 *data1 = new block128[length]; - io->recv_block(data, length); - io->recv_block(data1, length); - for(int i = 0; i < length; ++i) - if(b[i]) - data[i] = data1[i]; - delete []data1; - } + void recv_impl(block128 *data, const bool *b, int length) { + cnt += length; + block128 *data1 = new block128[length]; + io->recv_block(data, length); + io->recv_block(data1, length); + for (int i = 0; i < length; ++i) + if (b[i]) + data[i] = data1[i]; + delete[] data1; + } - void recv_impl(block256* data, const bool* b, int length) { - cnt+=length; - block256 data1[length]; - io->recv_block(data, length); - io->recv_block(data1, length); - for(int i = 0; i < length; ++i) - if(b[i]) - data[i] = data1[i]; - } + void recv_impl(block256 *data, const bool *b, int length) { + cnt += length; + alignas(32) block256 data1[length]; + io->recv_block(data, length); + io->recv_block(data1, length); + for (int i = 0; i < length; ++i) + if (b[i]) + data[i] = data1[i]; + } - void send_impl(uint8_t** data, int length, int N, int l) { - assert(N <= 256 && N >= 2); - assert(l <= 8 && l >= 1 && (8 % l) == 0); - assert((N*l % 8) == 0); - uint8_t* b = new uint8_t[length]; - io->recv_data(b, length); - for(int i = 0; i < length; i++) - io->send_data(&data[i][b[i]], 1); - delete[] b; - } + void send_impl(uint8_t **data, int length, int N, int l) { + assert(N <= 256 && N >= 2); + assert(l <= 8 && l >= 1 && (8 % l) == 0); + assert((N * l % 8) == 0); + uint8_t *b = new uint8_t[length]; + io->recv_data(b, length); + for (int i = 0; i < length; i++) + io->send_data(&data[i][b[i]], 1); + delete[] b; + } - void recv_impl(uint8_t* data, const uint8_t* b, int length, int N, int l) { - assert(N <= 256 && N >= 2); - assert(l <= 8 && l >= 1 && (8 % l) == 0); - assert((N*l % 8) == 0); - io->send_data(b, length); - for(int i = 0; i < length; i++) - io->recv_data(&data[i], 1); - } + void recv_impl(uint8_t *data, const uint8_t *b, int length, int N, int l) { + assert(N <= 256 && N >= 2); + assert(l <= 8 && l >= 1 && (8 % l) == 0); + assert((N * l % 8) == 0); + io->send_data(b, length); + for (int i = 0; i < length; i++) + io->recv_data(&data[i], 1); + } - /* - COT function for packed multiplication correlation - - Does numOTs COTs for the correlation which is used in matmul - - corr is the array which contains the correlated values (i.e. a in the case of matmul). Each value is stored in a separate - uint64_t. - - For each OT, the chunkSizes[i] denotes the bitlen used for that OT (again referring to matmul) - - For each OT, the numChunks[i] denotes the #values of that particular bitlen. Hence, size of corr = summation of numChunks - - rdata is the r value which is returned to the sender - */ - void send_cot_matmul(uint64_t* rdata, const uint64_t* corr, const uint64_t* chunkSizes, - const uint64_t* numChunks, const int numOTs){ - // std::cout<<"Using Ideal OT"<<std::endl; - uint8_t choices[numOTs]; - io->recv_data(choices, numOTs); - uint64_t corrPtr = 0; - for(int i=0;i<numOTs;i++){ - // std::cout<<" i = "<<i<<" choice bit = "<<unsigned(choices[i])<<std::endl; - uint64_t curNumChunks = numChunks[i]; - uint64_t curChunkSize = chunkSizes[i]; - uint64_t recv_arr[curNumChunks]; - for(uint64_t j=0;j<curNumChunks;j++){ - rdata[corrPtr+j] = (1<<curChunkSize)-1; //Fill deterministic random values - // rdata[corrPtr+j] = 0; //Fill deterministic random values - if (choices[i]==0){ - recv_arr[j] = rdata[corrPtr+j]; - } - else{ - assert((choices[i]==1) && "unknown choice bit"); - recv_arr[j] = (rdata[corrPtr+j] + corr[corrPtr+j])&(all1Mask(curChunkSize)); - // std::cout<<" ** "<<rdata[corrPtr+j]<<" "<<corr[corrPtr+j]<<" "<<recv_arr[j]<<" chunksize = "<<curChunkSize<<std::endl; - } - // std::cout<<"j = "<<j<<" recv_data = "<<recv_arr[j]<<std::endl; - } - io->send_data(recv_arr, sizeof(uint64_t)*curNumChunks); - corrPtr += curNumChunks; - } + /* + COT function for packed multiplication correlation + - Does numOTs COTs for the correlation which is used in matmul + - corr is the array which contains the correlated values (i.e. a in the + case of matmul). Each value is stored in a separate uint64_t. + - For each OT, the chunkSizes[i] denotes the bitlen used for that OT + (again referring to matmul) + - For each OT, the numChunks[i] denotes the #values of that particular + bitlen. Hence, size of corr = summation of numChunks + - rdata is the r value which is returned to the sender + */ + void send_cot_matmul(uint64_t *rdata, const uint64_t *corr, + const uint64_t *chunkSizes, const uint64_t *numChunks, + const int numOTs) { + // std::cout<<"Using Ideal OT"<<std::endl; + uint8_t choices[numOTs]; + io->recv_data(choices, numOTs); + uint64_t corrPtr = 0; + for (int i = 0; i < numOTs; i++) { + // std::cout<<" i = "<<i<<" choice bit = + // "<<unsigned(choices[i])<<std::endl; + uint64_t curNumChunks = numChunks[i]; + uint64_t curChunkSize = chunkSizes[i]; + uint64_t recv_arr[curNumChunks]; + for (uint64_t j = 0; j < curNumChunks; j++) { + rdata[corrPtr + j] = + (1 << curChunkSize) - 1; // Fill deterministic random values + // rdata[corrPtr+j] = 0; //Fill deterministic random values + if (choices[i] == 0) { + recv_arr[j] = rdata[corrPtr + j]; + } else { + assert((choices[i] == 1) && "unknown choice bit"); + recv_arr[j] = (rdata[corrPtr + j] + corr[corrPtr + j]) & + (all1Mask(curChunkSize)); + // std::cout<<" ** "<<rdata[corrPtr+j]<<" "<<corr[corrPtr+j]<<" + // "<<recv_arr[j]<<" chunksize = "<<curChunkSize<<std::endl; + } + // std::cout<<"j = "<<j<<" recv_data = "<<recv_arr[j]<<std::endl; + } + io->send_data(recv_arr, sizeof(uint64_t) * curNumChunks); + corrPtr += curNumChunks; } + } - /* - COT function for packed multiplication correlation - - data is the data which will be read - - Rest of parameters have same meaning as specified in sender's description - */ - void recv_cot_matmul(uint64_t* data, const uint8_t* choices, const uint64_t* chunkSizes, - const uint64_t* numChunks, const int numOTs){ - // std::cout<<"Using Ideal OT"<<std::endl; - io->send_data(choices, numOTs); - uint64_t dataPtr = 0; - for(int i=0;i<numOTs;i++){ - uint64_t curNumChunks = numChunks[i]; - io->recv_data(&data[dataPtr], sizeof(uint64_t)*curNumChunks); - dataPtr += curNumChunks; - } + /* + COT function for packed multiplication correlation + - data is the data which will be read + - Rest of parameters have same meaning as specified in sender's + description + */ + void recv_cot_matmul(uint64_t *data, const uint8_t *choices, + const uint64_t *chunkSizes, const uint64_t *numChunks, + const int numOTs) { + // std::cout<<"Using Ideal OT"<<std::endl; + io->send_data(choices, numOTs); + uint64_t dataPtr = 0; + for (int i = 0; i < numOTs; i++) { + uint64_t curNumChunks = numChunks[i]; + io->recv_data(&data[dataPtr], sizeof(uint64_t) * curNumChunks); + dataPtr += curNumChunks; } + } }; -} -#endif// OT_IDEAL_H__ +} // namespace sci +#endif // OT_IDEAL_H__ diff --git a/SCI/src/OT/iknp.h b/SCI/src/OT/iknp.h index 6c069396..a96b6bcc 100644 --- a/SCI/src/OT/iknp.h +++ b/SCI/src/OT/iknp.h @@ -27,717 +27,757 @@ Modified by Nishant Kumar #ifndef OT_IKNP_H__ #define OT_IKNP_H__ -#include "OT/ot.h" #include "OT/np.h" +#include "OT/ot.h" #include <algorithm> namespace sci { -template<typename IO> -class IKNP : public OT<IKNP<IO>> -{ +template <typename IO> class IKNP : public OT<IKNP<IO>> { public: - OTNP<IO> * base_ot; - PRG128 prg; - const int lambda = 128; - const int block_size = 1024*16; - int l; - - block128 *k0 = nullptr, *k1 = nullptr, - * qT = nullptr, *tT = nullptr, *tmp = nullptr, block_s; - PRG128 *G0, *G1; - bool *s = nullptr, * extended_r = nullptr, setup = false; - IO *io = nullptr; - CRH crh; - - IKNP( - IO * io) - { - this->io = io; - base_ot = new OTNP<IO>(io); - s = new bool[lambda]; - k0 = new block128[lambda]; - k1 = new block128[lambda]; - G0 = new PRG128[lambda]; - G1 = new PRG128[lambda]; - tmp = new block128[block_size/128]; - extended_r = new bool[block_size]; - } - - ~IKNP() - { - delete base_ot; - delete[] s; - delete[] k0; - delete[] k1; - delete[] G0; - delete[] G1; - delete[] tmp; - delete[] extended_r; - } - - void setup_send( - block128 * in_k0 = nullptr, - bool * in_s = nullptr) - { - setup = true; - if(in_s != nullptr) { - memcpy(k0, in_k0, lambda*sizeof(block128)); - memcpy(s, in_s, lambda); - block_s = bool_to128(s); - } else { - prg.random_bool(s, lambda); - base_ot->recv(k0, s, lambda); - block_s = bool_to128(s); - } - for(int i = 0; i < lambda; ++i) - G0[i].reseed(&k0[i]); - } - - void setup_recv( - block128 * in_k0 = nullptr, - block128 * in_k1 =nullptr) - { - setup = true; - if(in_k0 !=nullptr) { - memcpy(k0, in_k0, lambda*sizeof(block128)); - memcpy(k1, in_k1, lambda*sizeof(block128)); - } else { - prg.random_block(k0, lambda); - prg.random_block(k1, lambda); - base_ot->send(k0, k1, lambda); - } - for(int i = 0; i < lambda; ++i) { - G0[i].reseed(&k0[i]); - G1[i].reseed(&k1[i]); - } - } - - int padded_length( - int length) - { - return ((length + block_size - 1) / block_size) * block_size; - } - - void send_pre( - int length) - { - length = padded_length(length); - block128 q[block_size]; - qT = new block128[length]; - if(!setup) setup_send(); - - for (int j = 0; j < length/block_size; ++j) { - for(int i = 0; i < lambda; ++i) { - G0[i].random_data(q+(i*block_size/128), block_size/8); - io->recv_data(tmp, block_size/8); - if (s[i]) - xorBlocks_arr(q+(i*block_size/128), q+(i*block_size/128), tmp, block_size/128); - } - sse_trans((uint8_t *)(qT+j*block_size), (uint8_t*)q, 128, block_size); - } - } - - void recv_pre( - const bool* r, - int length) - { - int old_length = length; - length = padded_length(length); - block128 t[block_size]; - tT = new block128[length]; - - if(not setup) setup_recv(); - - bool * r2 = new bool[length]; - prg.random_bool(extended_r, block_size); - memcpy(r2, r, old_length); - memcpy(r2+old_length, extended_r, length - old_length); - - block128 *block_r = new block128[length/128]; - for(int i = 0; i < length/128; ++i) { - block_r[i] = bool_to128(r2+i*128); - } - for (int j = 0; j * block_size < length; ++j) { - for(int i = 0; i < lambda; ++i) { - G0[i].random_data(t+(i*block_size/128), block_size/8); - G1[i].random_data(tmp, block_size/8); - xorBlocks_arr(tmp, t+(i*block_size/128), tmp, block_size/128); - xorBlocks_arr(tmp, block_r+(j*block_size/128), tmp, block_size/128); - io->send_data(tmp, block_size/8); - } - sse_trans((uint8_t *)(tT+j*block_size), (uint8_t*)t, 128, block_size); - } - - delete[] block_r; - delete[] r2; - } - - void got_send_post( - const block128* data0, - const block128* data1, - int length) - { - const int bsize = AES_BATCH_SIZE/2; - block128 pad[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - crh.H<2*bsize>(pad, pad); - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = xorBlocks(pad[2*(j-i)], data0[j]); - pad[2*(j-i)+1] = xorBlocks(pad[2*(j-i)+1], data1[j]); - } - io->send_data(pad, 2*sizeof(block128)*std::min(bsize,length-i)); - } - delete[] qT; - } - - void got_recv_post( - block128* data, - const bool* r, - int length) - { - const int bsize = AES_BATCH_SIZE; - block128 res[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - io->recv_data(res, 2*sizeof(block128)*std::min(bsize,length-i)); - if (bsize <= length-i) crh.H<bsize>(tT+i, tT+i); - else crh.Hn(tT+i, tT+i, length-i); - for(int j = 0; j < bsize and j < length-i; ++j) { - data[i+j] = xorBlocks(res[2*j+r[i+j]], tT[i+j]); - } - } - delete[] tT; - } - - void got_send_post( - uint64_t** data, - int length) - { - assert(this->l <= 64 && this->l > 8); - const int bsize = AES_BATCH_SIZE/2; - block128 pad[2*bsize]; - uint32_t pad2_size = (uint32_t)ceil((2*bsize*this->l)/((float)sizeof(uint64_t)*8)); - uint64_t pad2[pad2_size]; - int start_pos = 0; - int end_pos = 0; - int start_block64 = 0; - int end_block64 = 0; - uint64_t temp_bl = 0; - uint64_t mask; - if(this->l < 64){ - mask = (1ULL<<this->l)-1ULL; - } - else{ - mask = -1ULL; - } - int temp = 0; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - for(int j = 0; j < (int)pad2_size; ++j) { - pad2[j] = 0ULL; - } - crh.H<2*bsize>(pad, pad); - for(int j = i; j < i+bsize and j < length; ++j) { - //OT message 0 - start_pos = this->l*2*(j-i); //inclusive - end_pos = start_pos + this->l; //exclusive - end_pos -= 1; //inclusive - start_block64 = start_pos/(8*sizeof(uint64_t)); - end_block64 = end_pos/(8*sizeof(uint64_t)); - if(start_block64 == end_block64){ - pad2[start_block64] ^= ((((uint64_t)_mm_extract_epi64(pad[2*(j-i)], 0)) ^ data[j][0]) & mask)<<(start_pos % (8*sizeof(uint64_t))); - } - else{ - temp_bl = ((((uint64_t)_mm_extract_epi64(pad[2*(j-i)], 0)) ^ data[j][0]) & mask); - pad2[start_block64] ^= (temp_bl)<<(start_pos % (8*sizeof(uint64_t))); - pad2[end_block64] ^= (temp_bl)>>((8*sizeof(uint64_t)) - (start_pos % (8*sizeof(uint64_t)))); - } - //OT message 1 - start_pos = this->l*2*(j-i)+this->l; //inclusive - end_pos = start_pos + this->l; //exclusive - end_pos -= 1; //inclusive - start_block64 = start_pos/(8*sizeof(uint64_t)); - end_block64 = end_pos/(8*sizeof(uint64_t)); - if(start_block64 == end_block64){ - pad2[start_block64] ^= ((((uint64_t)_mm_extract_epi64(pad[2*(j-i)+1], 0)) ^ data[j][1]) & mask)<<(start_pos % (8*sizeof(uint64_t))); - } - else{ - temp_bl = ((((uint64_t)_mm_extract_epi64(pad[2*(j-i)+1], 0)) ^ data[j][1]) & mask); - pad2[start_block64] ^= (temp_bl)<<(start_pos % (8*sizeof(uint64_t))); - pad2[end_block64] ^= (temp_bl)>>((8*sizeof(uint64_t)) - (start_pos % (8*sizeof(uint64_t)))); - } - temp = (temp > end_block64)?temp:end_block64; - } - uint32_t pad2_size_correct = (uint32_t)ceil((2*std::min(bsize, length-i)*this->l)/((float)sizeof(uint64_t)*8)); - io->send_data(pad2, sizeof(uint64_t)*(pad2_size_correct)); - } - delete[] qT; - } - - void got_recv_post( - uint64_t* data, - const uint8_t* r, - int length) - { - assert(this->l <= 64 && this->l > 8); - const int bsize = AES_BATCH_SIZE; - uint32_t res_size = (uint32_t)ceil((2*bsize*this->l)/((float)sizeof(uint64_t)*8)); - uint64_t res[res_size]; - int start_pos = 0; - int end_pos = 0; - int start_block64 = 0; - int end_block64 = 0; - uint64_t mask; - if(this->l < 64){ - mask = (1ULL<<this->l)-1ULL; - } - else{ - mask = -1ULL; - } - for(int i = 0; i < length; i+=bsize) { - uint32_t res_size_correct = (uint32_t)ceil((2*std::min(bsize, length-i)*this->l)/((float)sizeof(uint64_t)*8)); - io->recv_data(res, sizeof(uint64_t)*(res_size_correct)); - if (bsize <= length-i) crh.H<bsize>(tT+i, tT+i); - else crh.Hn(tT+i, tT+i, length-i); - for(int j = 0; j < bsize and j < length-i; ++j) { - start_pos = 2*j*this->l + r[i+j]*this->l; //inclusive - end_pos = start_pos + this->l - 1; //inclusive - start_block64 = start_pos/(8*sizeof(uint64_t)); - end_block64 = end_pos/(8*sizeof(uint64_t)); - if(start_block64 == end_block64){ - data[i+j] = (((res[start_block64]>>(start_pos % (8*sizeof(uint64_t))))) ^ ((uint64_t)_mm_extract_epi64(tT[i+j], 0))) & mask; - } - else{ - data[i+j] = 0ULL; - data[i+j] ^= (res[start_block64]>>(start_pos % (8*sizeof(uint64_t)))); - data[i+j] ^= (res[end_block64]<<(8*sizeof(uint64_t) - (start_pos % (8*sizeof(uint64_t))))); - data[i+j] = (data[i+j] ^ ((uint64_t)_mm_extract_epi64(tT[i+j], 0))) & mask; - } - } - } - delete[] tT; - } - - void cot_send_post( - block128* data0, - block128 delta, - int length) - { - const int bsize = AES_BATCH_SIZE/2; - block128 pad[2*bsize]; - block128 tmp[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - crh.H<2*bsize>(pad, pad); - for(int j = i; j < i+bsize and j < length; ++j) { - data0[j] = pad[2*(j-i)]; - pad[2*(j-i)] = xorBlocks(pad[2*(j-i)], delta); - tmp[j-i] = xorBlocks(pad[2*(j-i)+1], pad[2*(j-i)]); - } - io->send_data(tmp, sizeof(block128)*std::min(bsize,length-i)); - } - delete[] qT; - } - - void cot_recv_post( - block128* data, - const bool* r, - int length) - { - const int bsize = AES_BATCH_SIZE; - block128 res[bsize]; - for(int i = 0; i < length; i+=bsize) { - io->recv_data(res, sizeof(block128)*std::min(bsize,length-i)); - if (bsize <= length-i) crh.H<bsize>(data+i, tT+i); - else crh.Hn(data+i, tT+i, length-i); - for(int j = 0; j < bsize and j < length-i; ++j) { - if(r[i+j]) data[i+j] = xorBlocks(res[j], data[i+j]); - } - } - delete[] tT; - } - - void rot_send_post( - block128* data0, - block128* data1, - int length) - { - const int bsize = AES_BATCH_SIZE/2; - block128 pad[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - crh.H<2*bsize>(pad, pad); - for(int j = i; j < i+bsize and j < length; ++j) { - data0[j] = pad[2*(j-i)]; - data1[j] = pad[2*(j-i)+1]; - } - } - delete[] qT; - } - - void rot_recv_post( - block128* data, - const bool* r, - int length) - { - const int bsize = AES_BATCH_SIZE; - for(int i = 0; i < length; i+=bsize) { - if (bsize <= length-i) crh.H<bsize>(data+i, tT+i); - else crh.Hn(data+i, tT+i, length-i); - } - delete[] tT; - } - - void send_impl( - const block128* data0, - const block128* data1, - int length) - { - if (length < 1) return; - send_pre(length); - got_send_post(data0, data1, length); - } - - void recv_impl( - block128* data, - const bool* b, - int length) - { - if (length < 1) return; - recv_pre(b, length); - got_recv_post(data, b, length); - } - - void send_impl( - uint64_t** data, - int length, - int l) - { - if (length < 1) return; - this->l = l; - send_pre(length); - got_send_post(data, length); - } - - void recv_impl( - uint64_t* data, - const uint8_t* b, - int length, - int l) - { - if (length < 1) return; - this->l = l; - recv_pre((bool*)b, length); - got_recv_post(data, b, length); - } - - void send_cot( - block128 * data0, - block128 delta, - int length) - { - if (length < 1) return; - send_pre(length); - cot_send_post(data0, delta, length); - } - - void recv_cot( - block128* data, - const bool* b, - int length) - { - if (length < 1) return; - recv_pre(b, length); - cot_recv_post(data, b, length); - } - - void send_rot( - block128 * data0, - block128 * data1, - int length) - { - if (length < 1) return; - send_pre(length); - rot_send_post(data0, data1, length); - } - - void recv_rot( - block128* data, - const bool* b, - int length) - { - if (length < 1) return; - recv_pre(b, length); - rot_recv_post(data, b, length); - } - - template<typename intType> - void cot_send_post_matmul(intType* rdata, const intType* corr, const uint32_t* chunkSizes, - const uint32_t* numChunks, const int numOTs, int senderMatmulDims) - { - // TODO(nishkum): replace this maxing logic by replacing array of numChunks by a constant (row size of sender) - uint64_t maxHashLen = 0; - for(int i=0;i<numOTs;i++){ - maxHashLen = std::max(maxHashLen, uint64_t(2*ceil_val(chunkSizes[i]*numChunks[i],128))); - } - - block128 hashArr[maxHashLen+1]; //First half of this will contain H(q_i) and second half H(q_i \xor s) - //The +1 is there because readFromPackedArr will be called on this arry - // and while reading it reads a uint64_t directly. So, to leave sufficient - // space ahead and to prevent reading out of bounds, the +1. - block128 corrHashArr[(maxHashLen/2)+1]; //Since maxHashLen is max of even values, its divisible by 2 - // This will contain the final packed correlation(H(q_i)) - // The +1 is there because writePackedArr requires one extra uint64_t space at end. - block128 scratchArr[maxHashLen/2]; //This will temporarily contain the value to be copied in dataToBeSent - // Since one OT is treated as atomic (as in fully sent or not sent), - // need some bound on the data to be sent. - // Maximum #blocks coming from one OT is ceil(numChunks*bitlen/128). - // Taking bitlen as maximum = 64, we get ceil(numChunks/2). - // So, assuming numChunks<=256, we get 128 -- which is the maximum number of 128 bit blocks which can - // get added in one OT. So, declare an array of size AES_BATCH_SIZE + 130. - block128* dataToBeSent = new block128[AES_BATCH_SIZE+(senderMatmulDims/2)+10]; - uint64_t dataToBeSentByteAlignedPtr = 0; - uint64_t corrPtr = 0; - for(int i=0;i<numOTs;i++){ - uint64_t curNumChunks = numChunks[i]; - uint64_t curChunkSize = chunkSizes[i]; - uint64_t curNumHashes = ceil_val(curNumChunks*curChunkSize,128); - for(uint64_t j=0;j<curNumHashes;j++){ - hashArr[j] = xorBlocks(qT[i],toBlock(j)); - hashArr[j+curNumHashes] = xorBlocks(hashArr[j],block_s); - } - crh.Hn(hashArr,hashArr,2*curNumHashes); - // Now calculate f(Hash), where f represents the correlation - for(uint64_t j=0;j<curNumChunks;j++){ - // read from corrPtr onwards for curNumChunks uint64s - uint64_t curCorrVal = corr[corrPtr+j]; - // Now extract the corresponding random value from hashArr - uint64_t curRandVal = readFromPackedArr((uint8_t*)hashArr,16*curNumHashes,j*curChunkSize,curChunkSize); - uint64_t curFinalVal = (curRandVal + curCorrVal) & (all1Mask(curChunkSize)); - // Now pack this curFinalVal in data to be xored with H(q \xor s) - writeToPackedArr((uint8_t*)corrHashArr,16*curNumHashes,j*curChunkSize,curChunkSize,curFinalVal); - rdata[corrPtr+j] = (intType)curRandVal; - } - // The packed correlated value is ready. Now xor with H(q_i \xor s) and then its ready to be sent - for(uint64_t j=0;j<curNumHashes;j++){ - scratchArr[j] = xorBlocks(corrHashArr[j],hashArr[curNumHashes+j]); - } - uint64_t bytesToBeSent = ceil_val(curNumChunks*curChunkSize,8); //Byte align data to be sent - memcpy(((uint8_t*)dataToBeSent)+dataToBeSentByteAlignedPtr,scratchArr,bytesToBeSent); - dataToBeSentByteAlignedPtr += bytesToBeSent; - corrPtr += curNumChunks; - - // If either enough data is accumulated or this is the last OT, send the data - if ((dataToBeSentByteAlignedPtr >= (AES_BATCH_SIZE*16)) || (i==numOTs-1)){ //Each 128 bit block has 16 bytes - // Send this data to receiver for pipelining - io->send_data(dataToBeSent,dataToBeSentByteAlignedPtr); - io->flush(); - dataToBeSentByteAlignedPtr = 0; - } - } - delete[] dataToBeSent; - delete[] qT; - } - - template<typename intType> - void cot_recv_post_matmul(intType* data, const uint8_t* choices, const uint32_t* chunkSizes, - const uint32_t* numChunks, const int numOTs, int senderMatmulDims) - { - block128 dataToBeRecvd[AES_BATCH_SIZE+(senderMatmulDims/2)+10]; //For logic of this bound, refer to the function above. - - /* - Logic for the bound used in the following line: - In each OT, except for the last hash evluation, whatever is hashed is also accounted for in the data sent. - It is only in the last hash evaluation for that OT that data to be sent < data to be stored - (for example, if data to be sent is 1 byte misaligned). - So, at worst, the maximum amount of extra blocks needed = #OTs which are processed before sending < #totalOTs. - Hence, the bound. - And it is not that bad either, assuming numOTs = 2048*64 (for row side of right side matrix of receiver of size 2048 in 64 bits) - mem consumption of this array = ((2048+130+(2048*64))*16)/(1<<20) MiB = 2.03 MiB. - - Also, since this can be a large array, allocating on heap is better. - */ - block128* hashesStored = new block128[AES_BATCH_SIZE+(senderMatmulDims/2)+10+numOTs]; - uint64_t hashesStoredPtr = 0; //Indexes into hashesStored to keep track of which hash block to be used to start storing hashes - // for given OT. This is used in the outer loop to fill in hashes, which gets consumed in the inner - // loop when enough data is present. - uint64_t dataToBeRecvdCummulativeCtr = 0; //Keeps track of how much data is expected to be received. - // When budget is full, it receives the expected amount of data. - // This should work because sender and receiver follow the same deterministic logic of - // calculating the amount of data to be sent/received. - int otDataStartCtr = 0; //Represents the OT number from which data is being collected in dataToBeRecvd - //When time comes, data received is OT data of OT #[otDataStartCtr,i] - uint64_t dataPtr = 0; //Indexes into data to keep track that when OT data starts to be unpacked, which index in data represents its start - for(int i=0;i<numOTs;i++){ - uint64_t curNumChunks = numChunks[i]; - uint64_t curChunkSize = chunkSizes[i]; - uint64_t curNumHashes = ceil_val(curNumChunks*curChunkSize,128); - - // For current OT, the hashes need to be stored in hashesStored array starting at idx = hashesStoredPtr. - for(uint64_t j=0;j<curNumHashes;j++){ - hashesStored[hashesStoredPtr+j] = xorBlocks(tT[i],toBlock(j)); - } - crh.Hn(hashesStored+hashesStoredPtr, hashesStored+hashesStoredPtr, curNumHashes); - uint64_t bytesToBeRecvd = ceil_val(curNumChunks*curChunkSize,8); - dataToBeRecvdCummulativeCtr += bytesToBeRecvd; - hashesStoredPtr += curNumHashes; - if ((dataToBeRecvdCummulativeCtr >= (AES_BATCH_SIZE*16)) || (i==numOTs-1)){ //Each 128 bit block has 16 bytes - //Expect these many bytes from the sender - io->recv_data(dataToBeRecvd, dataToBeRecvdCummulativeCtr); - // Now that data has been received for past OTs, process those OTs. - // The OTs to be processed are from [otDataStartCtr,i] - assert(otDataStartCtr<=i); - uint64_t hashBlockCtr = 0; //The hashes of the OTs from #[otDataStartCtr,i] have already been calculated. - // We only need to consume them now. - // This variable indexes into hashesStored. - uint64_t dataRecvByteAlignedCtr = 0; //Indexes into dataToBeRecvd to keep track of from where the data needs to be read - // for current OT. Note that this variable represents byte aligned read. - for(int j=otDataStartCtr;j<=i;j++){ - uint64_t curOTChunkSize = chunkSizes[j]; - uint64_t curOTNumChunks = numChunks[j]; - uint64_t numHashBlocks = ceil_val(curOTChunkSize*curOTNumChunks,128); - block128* curOTRecvDataStartBlock = (block128*)(((uint8_t*)dataToBeRecvd)+dataRecvByteAlignedCtr); - if (choices[j]==1){ - for(uint64_t k=0;k<numHashBlocks;k++){ - // Following is a simple trick. - // curOTRecvDataStartBlock is a block128* starting at the byte from which the data of current OT is - // expected. Rem that all OT data is packed with byte alignment. So, this casting to block128* should work. - // We read in chunks of block128 from this array. But also rem that this array wasn't designed for block128 read. - // However, I claim that this should still work. - // This is because: at worst for a middle OT, the next OT's data will get hashed. However, while reading, - // only required amount of data will get read. So, all good here. For the last OT also, nothing bad should - // happen because dataToBeRecvd is created with at least one more extra block128 than required. - // Hence, this should work and no seg fault should come. - hashesStored[hashBlockCtr+k] = xorBlocks(hashesStored[hashBlockCtr+k],_mm_loadu_si128(curOTRecvDataStartBlock+k)); - } - } - // Now hashesStored[hashBlockCtr:hashBlockCtr+numHashBlocks] contains the final data to be used. - // Unpack and fill in the output variable data - for(uint64_t k=0;k<curOTNumChunks;k++){ - data[dataPtr+k] = (intType)readFromPackedArr((uint8_t*)(hashesStored+hashBlockCtr),16*numHashBlocks,k*curOTChunkSize,curOTChunkSize); - } - dataPtr += curOTNumChunks; - dataRecvByteAlignedCtr += ceil_val(curOTChunkSize*curOTNumChunks,8); - hashBlockCtr += numHashBlocks; - } - - otDataStartCtr = i+1; - dataToBeRecvdCummulativeCtr = 0; - assert(hashBlockCtr == hashesStoredPtr); - hashesStoredPtr = 0; - } - } - - // Assertion for my understanding - uint64_t totalChunks = 0; - for(int i=0;i<numOTs;i++) totalChunks += numChunks[i]; - assert(dataPtr == totalChunks); - assert(otDataStartCtr==numOTs); - delete[] hashesStored; - delete[] tT; - } - - /* - COT function for packed multiplication correlation - - Does numOTs COTs for the correlation which is used in matmul - - corr is the array which contains the correlated values (i.e. a in the case of matmul). Each value is stored in a separate - uint64_t. - - For each OT, the chunkSizes[i] denotes the bitlen used for that OT (again referring to matmul) - - For each OT, the numChunks[i] denotes the #values of that particular bitlen. Hence, size of corr = summation of numChunks - - rdata is the r value which is returned to the sender - */ - template<typename intType> - void send_cot_matmul(intType* rdata, const intType* corr, const uint32_t* chunkSizes, - const uint32_t* numChunks, const int numOTs, int senderMatmulDims) - { - send_pre(numOTs); - cot_send_post_matmul<intType>(rdata,corr,chunkSizes,numChunks,numOTs,senderMatmulDims); - } - - /* - COT function for packed multiplication correlation - - data is the data which will be read - - Rest of parameters have same meaning as specified in sender's description - */ - template<typename intType> - void recv_cot_matmul(intType* data, const uint8_t* choices, const uint32_t* chunkSizes, - const uint32_t* numChunks, const int numOTs, int senderMatmulDims) - { - recv_pre((bool*)choices, numOTs); - cot_recv_post_matmul<intType>(data,choices,chunkSizes,numChunks,numOTs,senderMatmulDims); - } - - template<typename intType> - void cot_send_post_moduloAdd(intType* rdata, const intType* delta, const int length){ - const int bsize = AES_BATCH_SIZE/2; - block128 pad[2*bsize]; - intType tmp[bsize]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - crh.H<2*bsize>(pad, pad); - for(int j = i; j < i+bsize and j < length; ++j) { - rdata[j] = (intType)_mm_extract_epi64(pad[2*(j-i)],0); //Use lower bits - intType corrVal = rdata[j]+delta[j]; - intType mask = (intType)_mm_extract_epi64(pad[2*(j-i)+1],0); - intType msgToBeSent = corrVal ^ mask; - tmp[j-i] = msgToBeSent; - } - io->send_data(tmp, sizeof(intType)*std::min(bsize,length-i)); - } - delete[] qT; - } - - template<typename intType> - void cot_recv_post_moduloAdd(intType* data, const uint8_t* choices, const int length){ - const int bsize = AES_BATCH_SIZE; - intType res[bsize]; - block128 hashes[bsize]; - for(int i = 0; i < length; i+=bsize) { - io->recv_data(res, sizeof(intType)*std::min(bsize,length-i)); - if (bsize <= length-i) crh.H<bsize>(hashes, tT+i); - else crh.Hn(hashes, tT+i, length-i); - for(int j = 0; j < bsize and j < length-i; ++j) { - data[i+j] = (intType)_mm_extract_epi64(hashes[j],0);//Use lower bits convention - if(choices[i+j]){ - data[i+j] = data[i+j] ^ res[j]; - } - } - } - delete[] tT; - } - - /* - - For the correlation f(r) = (r+delta[i])mod 2^l - */ - template<typename intType> - void send_cot_moduloAdd(intType* rdata, const intType* delta, const int numOTs){ - send_pre(numOTs); - cot_send_post_moduloAdd<intType>(rdata,delta,numOTs); - } - - /* - - For the correlation f(r) = (r+delta[i])mod 2^l - */ - template<typename intType> - void recv_cot_moduloAdd(intType* data, const uint8_t* choices, const int numOTs){ - recv_pre((bool*)choices, numOTs); - cot_recv_post_moduloAdd<intType>(data,choices,numOTs); - } + OTNP<IO> *base_ot; + PRG128 prg; + const int lambda = 128; + const int block_size = 1024 * 16; + int l; + + block128 *k0 = nullptr, *k1 = nullptr, *qT = nullptr, *tT = nullptr, + *tmp = nullptr, block_s; + PRG128 *G0, *G1; + bool *s = nullptr, *extended_r = nullptr, setup = false; + IO *io = nullptr; + CRH crh; + + IKNP(IO *io) { + this->io = io; + base_ot = new OTNP<IO>(io); + s = new bool[lambda]; + k0 = new block128[lambda]; + k1 = new block128[lambda]; + G0 = new PRG128[lambda]; + G1 = new PRG128[lambda]; + tmp = new block128[block_size / 128]; + extended_r = new bool[block_size]; + } + + ~IKNP() { + delete base_ot; + delete[] s; + delete[] k0; + delete[] k1; + delete[] G0; + delete[] G1; + delete[] tmp; + delete[] extended_r; + } + + void setup_send(block128 *in_k0 = nullptr, bool *in_s = nullptr) { + setup = true; + if (in_s != nullptr) { + memcpy(k0, in_k0, lambda * sizeof(block128)); + memcpy(s, in_s, lambda); + block_s = bool_to128(s); + } else { + prg.random_bool(s, lambda); + base_ot->recv(k0, s, lambda); + block_s = bool_to128(s); + } + for (int i = 0; i < lambda; ++i) + G0[i].reseed(&k0[i]); + } + + void setup_recv(block128 *in_k0 = nullptr, block128 *in_k1 = nullptr) { + setup = true; + if (in_k0 != nullptr) { + memcpy(k0, in_k0, lambda * sizeof(block128)); + memcpy(k1, in_k1, lambda * sizeof(block128)); + } else { + prg.random_block(k0, lambda); + prg.random_block(k1, lambda); + base_ot->send(k0, k1, lambda); + } + for (int i = 0; i < lambda; ++i) { + G0[i].reseed(&k0[i]); + G1[i].reseed(&k1[i]); + } + } + + int padded_length(int length) { + return ((length + block_size - 1) / block_size) * block_size; + } + + void send_pre(int length) { + length = padded_length(length); + block128 q[block_size]; + qT = new block128[length]; + if (!setup) + setup_send(); + + for (int j = 0; j < length / block_size; ++j) { + for (int i = 0; i < lambda; ++i) { + G0[i].random_data(q + (i * block_size / 128), block_size / 8); + io->recv_data(tmp, block_size / 8); + if (s[i]) + xorBlocks_arr(q + (i * block_size / 128), q + (i * block_size / 128), + tmp, block_size / 128); + } + sse_trans((uint8_t *)(qT + j * block_size), (uint8_t *)q, 128, + block_size); + } + } + + void recv_pre(const bool *r, int length) { + int old_length = length; + length = padded_length(length); + block128 t[block_size]; + tT = new block128[length]; + + if (not setup) + setup_recv(); + + bool *r2 = new bool[length]; + prg.random_bool(extended_r, block_size); + memcpy(r2, r, old_length); + memcpy(r2 + old_length, extended_r, length - old_length); + + block128 *block_r = new block128[length / 128]; + for (int i = 0; i < length / 128; ++i) { + block_r[i] = bool_to128(r2 + i * 128); + } + for (int j = 0; j * block_size < length; ++j) { + for (int i = 0; i < lambda; ++i) { + G0[i].random_data(t + (i * block_size / 128), block_size / 8); + G1[i].random_data(tmp, block_size / 8); + xorBlocks_arr(tmp, t + (i * block_size / 128), tmp, block_size / 128); + xorBlocks_arr(tmp, block_r + (j * block_size / 128), tmp, + block_size / 128); + io->send_data(tmp, block_size / 8); + } + sse_trans((uint8_t *)(tT + j * block_size), (uint8_t *)t, 128, + block_size); + } + + delete[] block_r; + delete[] r2; + } + + void got_send_post(const block128 *data0, const block128 *data1, int length) { + const int bsize = AES_BATCH_SIZE / 2; + block128 pad[2 * bsize]; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = qT[j]; + pad[2 * (j - i) + 1] = xorBlocks(qT[j], block_s); + } + crh.H<2 * bsize>(pad, pad); + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = xorBlocks(pad[2 * (j - i)], data0[j]); + pad[2 * (j - i) + 1] = xorBlocks(pad[2 * (j - i) + 1], data1[j]); + } + io->send_data(pad, 2 * sizeof(block128) * std::min(bsize, length - i)); + } + delete[] qT; + } + + void got_recv_post(block128 *data, const bool *r, int length) { + const int bsize = AES_BATCH_SIZE; + block128 res[2 * bsize]; + for (int i = 0; i < length; i += bsize) { + io->recv_data(res, 2 * sizeof(block128) * std::min(bsize, length - i)); + if (bsize <= length - i) + crh.H<bsize>(tT + i, tT + i); + else + crh.Hn(tT + i, tT + i, length - i); + for (int j = 0; j < bsize and j < length - i; ++j) { + data[i + j] = xorBlocks(res[2 * j + r[i + j]], tT[i + j]); + } + } + delete[] tT; + } + + void got_send_post(uint64_t **data, int length) { + assert(this->l <= 64 && this->l > 8); + const int bsize = AES_BATCH_SIZE / 2; + block128 pad[2 * bsize]; + uint32_t pad2_size = + (uint32_t)ceil((2 * bsize * this->l) / ((float)sizeof(uint64_t) * 8)); + uint64_t pad2[pad2_size]; + int start_pos = 0; + int end_pos = 0; + int start_block64 = 0; + int end_block64 = 0; + uint64_t temp_bl = 0; + uint64_t mask; + if (this->l < 64) { + mask = (1ULL << this->l) - 1ULL; + } else { + mask = -1ULL; + } + int temp = 0; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = qT[j]; + pad[2 * (j - i) + 1] = xorBlocks(qT[j], block_s); + } + for (int j = 0; j < (int)pad2_size; ++j) { + pad2[j] = 0ULL; + } + crh.H<2 * bsize>(pad, pad); + for (int j = i; j < i + bsize and j < length; ++j) { + // OT message 0 + start_pos = this->l * 2 * (j - i); // inclusive + end_pos = start_pos + this->l; // exclusive + end_pos -= 1; // inclusive + start_block64 = start_pos / (8 * sizeof(uint64_t)); + end_block64 = end_pos / (8 * sizeof(uint64_t)); + if (start_block64 == end_block64) { + pad2[start_block64] ^= + ((((uint64_t)_mm_extract_epi64(pad[2 * (j - i)], 0)) ^ + data[j][0]) & + mask) + << (start_pos % (8 * sizeof(uint64_t))); + } else { + temp_bl = ((((uint64_t)_mm_extract_epi64(pad[2 * (j - i)], 0)) ^ + data[j][0]) & + mask); + pad2[start_block64] ^= (temp_bl) + << (start_pos % (8 * sizeof(uint64_t))); + pad2[end_block64] ^= + (temp_bl) >> + ((8 * sizeof(uint64_t)) - (start_pos % (8 * sizeof(uint64_t)))); + } + // OT message 1 + start_pos = this->l * 2 * (j - i) + this->l; // inclusive + end_pos = start_pos + this->l; // exclusive + end_pos -= 1; // inclusive + start_block64 = start_pos / (8 * sizeof(uint64_t)); + end_block64 = end_pos / (8 * sizeof(uint64_t)); + if (start_block64 == end_block64) { + pad2[start_block64] ^= + ((((uint64_t)_mm_extract_epi64(pad[2 * (j - i) + 1], 0)) ^ + data[j][1]) & + mask) + << (start_pos % (8 * sizeof(uint64_t))); + } else { + temp_bl = ((((uint64_t)_mm_extract_epi64(pad[2 * (j - i) + 1], 0)) ^ + data[j][1]) & + mask); + pad2[start_block64] ^= (temp_bl) + << (start_pos % (8 * sizeof(uint64_t))); + pad2[end_block64] ^= + (temp_bl) >> + ((8 * sizeof(uint64_t)) - (start_pos % (8 * sizeof(uint64_t)))); + } + temp = (temp > end_block64) ? temp : end_block64; + } + uint32_t pad2_size_correct = + (uint32_t)ceil((2 * std::min(bsize, length - i) * this->l) / + ((float)sizeof(uint64_t) * 8)); + io->send_data(pad2, sizeof(uint64_t) * (pad2_size_correct)); + } + delete[] qT; + } + + void got_recv_post(uint64_t *data, const uint8_t *r, int length) { + assert(this->l <= 64 && this->l > 8); + const int bsize = AES_BATCH_SIZE; + uint32_t res_size = + (uint32_t)ceil((2 * bsize * this->l) / ((float)sizeof(uint64_t) * 8)); + uint64_t res[res_size]; + int start_pos = 0; + int end_pos = 0; + int start_block64 = 0; + int end_block64 = 0; + uint64_t mask; + if (this->l < 64) { + mask = (1ULL << this->l) - 1ULL; + } else { + mask = -1ULL; + } + for (int i = 0; i < length; i += bsize) { + uint32_t res_size_correct = + (uint32_t)ceil((2 * std::min(bsize, length - i) * this->l) / + ((float)sizeof(uint64_t) * 8)); + io->recv_data(res, sizeof(uint64_t) * (res_size_correct)); + if (bsize <= length - i) + crh.H<bsize>(tT + i, tT + i); + else + crh.Hn(tT + i, tT + i, length - i); + for (int j = 0; j < bsize and j < length - i; ++j) { + start_pos = 2 * j * this->l + r[i + j] * this->l; // inclusive + end_pos = start_pos + this->l - 1; // inclusive + start_block64 = start_pos / (8 * sizeof(uint64_t)); + end_block64 = end_pos / (8 * sizeof(uint64_t)); + if (start_block64 == end_block64) { + data[i + j] = + (((res[start_block64] >> (start_pos % (8 * sizeof(uint64_t))))) ^ + ((uint64_t)_mm_extract_epi64(tT[i + j], 0))) & + mask; + } else { + data[i + j] = 0ULL; + data[i + j] ^= + (res[start_block64] >> (start_pos % (8 * sizeof(uint64_t)))); + data[i + j] ^= + (res[end_block64] << (8 * sizeof(uint64_t) - + (start_pos % (8 * sizeof(uint64_t))))); + data[i + j] = + (data[i + j] ^ ((uint64_t)_mm_extract_epi64(tT[i + j], 0))) & + mask; + } + } + } + delete[] tT; + } + + void cot_send_post(block128 *data0, block128 delta, int length) { + const int bsize = AES_BATCH_SIZE / 2; + block128 pad[2 * bsize]; + block128 tmp[2 * bsize]; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = qT[j]; + pad[2 * (j - i) + 1] = xorBlocks(qT[j], block_s); + } + crh.H<2 * bsize>(pad, pad); + for (int j = i; j < i + bsize and j < length; ++j) { + data0[j] = pad[2 * (j - i)]; + pad[2 * (j - i)] = xorBlocks(pad[2 * (j - i)], delta); + tmp[j - i] = xorBlocks(pad[2 * (j - i) + 1], pad[2 * (j - i)]); + } + io->send_data(tmp, sizeof(block128) * std::min(bsize, length - i)); + } + delete[] qT; + } + + void cot_recv_post(block128 *data, const bool *r, int length) { + const int bsize = AES_BATCH_SIZE; + block128 res[bsize]; + for (int i = 0; i < length; i += bsize) { + io->recv_data(res, sizeof(block128) * std::min(bsize, length - i)); + if (bsize <= length - i) + crh.H<bsize>(data + i, tT + i); + else + crh.Hn(data + i, tT + i, length - i); + for (int j = 0; j < bsize and j < length - i; ++j) { + if (r[i + j]) + data[i + j] = xorBlocks(res[j], data[i + j]); + } + } + delete[] tT; + } + + void rot_send_post(block128 *data0, block128 *data1, int length) { + const int bsize = AES_BATCH_SIZE / 2; + block128 pad[2 * bsize]; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = qT[j]; + pad[2 * (j - i) + 1] = xorBlocks(qT[j], block_s); + } + crh.H<2 * bsize>(pad, pad); + for (int j = i; j < i + bsize and j < length; ++j) { + data0[j] = pad[2 * (j - i)]; + data1[j] = pad[2 * (j - i) + 1]; + } + } + delete[] qT; + } + + void rot_recv_post(block128 *data, const bool *r, int length) { + const int bsize = AES_BATCH_SIZE; + for (int i = 0; i < length; i += bsize) { + if (bsize <= length - i) + crh.H<bsize>(data + i, tT + i); + else + crh.Hn(data + i, tT + i, length - i); + } + delete[] tT; + } + + void send_impl(const block128 *data0, const block128 *data1, int length) { + if (length < 1) + return; + send_pre(length); + got_send_post(data0, data1, length); + } + + void recv_impl(block128 *data, const bool *b, int length) { + if (length < 1) + return; + recv_pre(b, length); + got_recv_post(data, b, length); + } + + void send_impl(uint64_t **data, int length, int l) { + if (length < 1) + return; + this->l = l; + send_pre(length); + got_send_post(data, length); + } + + void recv_impl(uint64_t *data, const uint8_t *b, int length, int l) { + if (length < 1) + return; + this->l = l; + recv_pre((bool *)b, length); + got_recv_post(data, b, length); + } + + void send_cot(block128 *data0, block128 delta, int length) { + if (length < 1) + return; + send_pre(length); + cot_send_post(data0, delta, length); + } + + void recv_cot(block128 *data, const bool *b, int length) { + if (length < 1) + return; + recv_pre(b, length); + cot_recv_post(data, b, length); + } + + void send_rot(block128 *data0, block128 *data1, int length) { + if (length < 1) + return; + send_pre(length); + rot_send_post(data0, data1, length); + } + + void recv_rot(block128 *data, const bool *b, int length) { + if (length < 1) + return; + recv_pre(b, length); + rot_recv_post(data, b, length); + } + + template <typename intType> + void cot_send_post_matmul(intType *rdata, const intType *corr, + const uint32_t *chunkSizes, + const uint32_t *numChunks, const int numOTs, + int senderMatmulDims) { + // TODO(nishkum): replace this maxing logic by replacing array of numChunks + // by a constant (row size of sender) + uint64_t maxHashLen = 0; + for (int i = 0; i < numOTs; i++) { + maxHashLen = + std::max(maxHashLen, + uint64_t(2 * ceil_val(chunkSizes[i] * numChunks[i], 128))); + } + + block128 hashArr[maxHashLen + + 1]; // First half of this will contain H(q_i) and second + // half H(q_i \xor s) The +1 is there because + // readFromPackedArr will be called on this arry + // and while reading it reads a uint64_t directly. So, + // to leave sufficient space ahead and to prevent + // reading out of bounds, the +1. + block128 corrHashArr + [(maxHashLen / 2) + + 1]; // Since maxHashLen is max of even values, its divisible by 2 + // This will contain the final packed correlation(H(q_i)) + // The +1 is there because writePackedArr requires one extra + // uint64_t space at end. + block128 scratchArr[maxHashLen / + 2]; // This will temporarily contain the value to be + // copied in dataToBeSent + // Since one OT is treated as atomic (as in fully + // sent or not sent), + // need some bound on the data to be sent. + // Maximum #blocks coming from one OT is + // ceil(numChunks*bitlen/128). Taking bitlen as + // maximum = 64, we get ceil(numChunks/2). So, + // assuming numChunks<=256, we get 128 -- which is + // the maximum number of 128 bit blocks which can + // get added in one OT. So, declare an array of + // size AES_BATCH_SIZE + 130. + block128 *dataToBeSent = + new block128[AES_BATCH_SIZE + (senderMatmulDims / 2) + 10]; + uint64_t dataToBeSentByteAlignedPtr = 0; + uint64_t corrPtr = 0; + for (int i = 0; i < numOTs; i++) { + uint64_t curNumChunks = numChunks[i]; + uint64_t curChunkSize = chunkSizes[i]; + uint64_t curNumHashes = ceil_val(curNumChunks * curChunkSize, 128); + for (uint64_t j = 0; j < curNumHashes; j++) { + hashArr[j] = xorBlocks(qT[i], toBlock(j)); + hashArr[j + curNumHashes] = xorBlocks(hashArr[j], block_s); + } + crh.Hn(hashArr, hashArr, 2 * curNumHashes); + // Now calculate f(Hash), where f represents the correlation + for (uint64_t j = 0; j < curNumChunks; j++) { + // read from corrPtr onwards for curNumChunks uint64s + uint64_t curCorrVal = corr[corrPtr + j]; + // Now extract the corresponding random value from hashArr + uint64_t curRandVal = + readFromPackedArr((uint8_t *)hashArr, 16 * curNumHashes, + j * curChunkSize, curChunkSize); + uint64_t curFinalVal = + (curRandVal + curCorrVal) & (all1Mask(curChunkSize)); + // Now pack this curFinalVal in data to be xored with H(q \xor s) + writeToPackedArr((uint8_t *)corrHashArr, 16 * curNumHashes, + j * curChunkSize, curChunkSize, curFinalVal); + rdata[corrPtr + j] = (intType)curRandVal; + } + // The packed correlated value is ready. Now xor with H(q_i \xor s) and + // then its ready to be sent + for (uint64_t j = 0; j < curNumHashes; j++) { + scratchArr[j] = xorBlocks(corrHashArr[j], hashArr[curNumHashes + j]); + } + uint64_t bytesToBeSent = ceil_val(curNumChunks * curChunkSize, + 8); // Byte align data to be sent + memcpy(((uint8_t *)dataToBeSent) + dataToBeSentByteAlignedPtr, scratchArr, + bytesToBeSent); + dataToBeSentByteAlignedPtr += bytesToBeSent; + corrPtr += curNumChunks; + + // If either enough data is accumulated or this is the last OT, send the + // data + if ((dataToBeSentByteAlignedPtr >= (AES_BATCH_SIZE * 16)) || + (i == numOTs - 1)) { // Each 128 bit block has 16 bytes + // Send this data to receiver for pipelining + io->send_data(dataToBeSent, dataToBeSentByteAlignedPtr); + io->flush(); + dataToBeSentByteAlignedPtr = 0; + } + } + delete[] dataToBeSent; + delete[] qT; + } + + template <typename intType> + void cot_recv_post_matmul(intType *data, const uint8_t *choices, + const uint32_t *chunkSizes, + const uint32_t *numChunks, const int numOTs, + int senderMatmulDims) { + block128 dataToBeRecvd[AES_BATCH_SIZE + (senderMatmulDims / 2) + + 10]; // For logic of this bound, refer to the + // function above. + + /* + Logic for the bound used in the following line: + In each OT, except for the last hash evluation, whatever is hashed + is also accounted for in the data sent. It is only in the last hash + evaluation for that OT that data to be sent < data to be stored (for + example, if data to be sent is 1 byte misaligned). So, at worst, the + maximum amount of extra blocks needed = #OTs which are processed before + sending < #totalOTs. Hence, the bound. And it is not that bad either, + assuming numOTs = 2048*64 (for row side of right side matrix of receiver + of size 2048 in 64 bits) mem consumption of this array = + ((2048+130+(2048*64))*16)/(1<<20) MiB = 2.03 MiB. + + Also, since this can be a large array, allocating on heap is better. + */ + block128 *hashesStored = + new block128[AES_BATCH_SIZE + (senderMatmulDims / 2) + 10 + numOTs]; + uint64_t hashesStoredPtr = + 0; // Indexes into hashesStored to keep track of which hash block to be + // used to start storing hashes + // for given OT. This is used in the outer loop to fill in hashes, + // which gets consumed in the inner loop when enough data is present. + uint64_t dataToBeRecvdCummulativeCtr = + 0; // Keeps track of how much data is expected to be received. + // When budget is full, it receives the expected amount of data. + // This should work because sender and receiver follow the same + // deterministic logic of calculating the amount of data to be + // sent/received. + int otDataStartCtr = 0; // Represents the OT number from which data is being + // collected in dataToBeRecvd When time comes, data + // received is OT data of OT #[otDataStartCtr,i] + uint64_t dataPtr = + 0; // Indexes into data to keep track that when OT data starts to be + // unpacked, which index in data represents its start + for (int i = 0; i < numOTs; i++) { + uint64_t curNumChunks = numChunks[i]; + uint64_t curChunkSize = chunkSizes[i]; + uint64_t curNumHashes = ceil_val(curNumChunks * curChunkSize, 128); + + // For current OT, the hashes need to be stored in hashesStored array + // starting at idx = hashesStoredPtr. + for (uint64_t j = 0; j < curNumHashes; j++) { + hashesStored[hashesStoredPtr + j] = xorBlocks(tT[i], toBlock(j)); + } + crh.Hn(hashesStored + hashesStoredPtr, hashesStored + hashesStoredPtr, + curNumHashes); + uint64_t bytesToBeRecvd = ceil_val(curNumChunks * curChunkSize, 8); + dataToBeRecvdCummulativeCtr += bytesToBeRecvd; + hashesStoredPtr += curNumHashes; + if ((dataToBeRecvdCummulativeCtr >= (AES_BATCH_SIZE * 16)) || + (i == numOTs - 1)) { // Each 128 bit block has 16 bytes + // Expect these many bytes from the sender + io->recv_data(dataToBeRecvd, dataToBeRecvdCummulativeCtr); + // Now that data has been received for past OTs, process those OTs. + // The OTs to be processed are from [otDataStartCtr,i] + assert(otDataStartCtr <= i); + uint64_t hashBlockCtr = + 0; // The hashes of the OTs from #[otDataStartCtr,i] have already + // been calculated. + // We only need to consume them now. + // This variable indexes into hashesStored. + uint64_t dataRecvByteAlignedCtr = + 0; // Indexes into dataToBeRecvd to keep track of from where the + // data needs to be read + // for current OT. Note that this variable represents byte + // aligned read. + for (int j = otDataStartCtr; j <= i; j++) { + uint64_t curOTChunkSize = chunkSizes[j]; + uint64_t curOTNumChunks = numChunks[j]; + uint64_t numHashBlocks = + ceil_val(curOTChunkSize * curOTNumChunks, 128); + block128 *curOTRecvDataStartBlock = + (block128 *)(((uint8_t *)dataToBeRecvd) + dataRecvByteAlignedCtr); + if (choices[j] == 1) { + for (uint64_t k = 0; k < numHashBlocks; k++) { + // Following is a simple trick. + // curOTRecvDataStartBlock is a block128* starting at the byte + // from which the data of current OT is expected. Rem that all OT + // data is packed with byte alignment. So, this casting to + // block128* should work. We read in chunks of block128 from this + // array. But also rem that this array wasn't designed for + // block128 read. However, I claim that this should still work. + // This is because: at worst for a middle OT, the next OT's data + // will get hashed. However, while reading, only required amount + // of data will get read. So, all good here. For the last OT + // also, nothing bad should happen because dataToBeRecvd is + // created with at least one more extra block128 than required. + // Hence, this should work and no seg fault should come. + hashesStored[hashBlockCtr + k] = + xorBlocks(hashesStored[hashBlockCtr + k], + _mm_loadu_si128(curOTRecvDataStartBlock + k)); + } + } + // Now hashesStored[hashBlockCtr:hashBlockCtr+numHashBlocks] contains + // the final data to be used. Unpack and fill in the output variable + // data + for (uint64_t k = 0; k < curOTNumChunks; k++) { + data[dataPtr + k] = (intType)readFromPackedArr( + (uint8_t *)(hashesStored + hashBlockCtr), 16 * numHashBlocks, + k * curOTChunkSize, curOTChunkSize); + } + dataPtr += curOTNumChunks; + dataRecvByteAlignedCtr += + ceil_val(curOTChunkSize * curOTNumChunks, 8); + hashBlockCtr += numHashBlocks; + } + + otDataStartCtr = i + 1; + dataToBeRecvdCummulativeCtr = 0; + assert(hashBlockCtr == hashesStoredPtr); + hashesStoredPtr = 0; + } + } + + // Assertion for my understanding + uint64_t totalChunks = 0; + for (int i = 0; i < numOTs; i++) + totalChunks += numChunks[i]; + assert(dataPtr == totalChunks); + assert(otDataStartCtr == numOTs); + delete[] hashesStored; + delete[] tT; + } + + /* + COT function for packed multiplication correlation + - Does numOTs COTs for the correlation which is used in matmul + - corr is the array which contains the correlated values (i.e. a in the case + of matmul). Each value is stored in a separate uint64_t. + - For each OT, the chunkSizes[i] denotes the bitlen used for that OT (again + referring to matmul) + - For each OT, the numChunks[i] denotes the #values of that particular bitlen. + Hence, size of corr = summation of numChunks + - rdata is the r value which is returned to the sender + */ + template <typename intType> + void send_cot_matmul(intType *rdata, const intType *corr, + const uint32_t *chunkSizes, const uint32_t *numChunks, + const int numOTs, int senderMatmulDims) { + send_pre(numOTs); + cot_send_post_matmul<intType>(rdata, corr, chunkSizes, numChunks, numOTs, + senderMatmulDims); + } + + /* + COT function for packed multiplication correlation + - data is the data which will be read + - Rest of parameters have same meaning as specified in sender's description + */ + template <typename intType> + void recv_cot_matmul(intType *data, const uint8_t *choices, + const uint32_t *chunkSizes, const uint32_t *numChunks, + const int numOTs, int senderMatmulDims) { + recv_pre((bool *)choices, numOTs); + cot_recv_post_matmul<intType>(data, choices, chunkSizes, numChunks, numOTs, + senderMatmulDims); + } + + template <typename intType> + void cot_send_post_moduloAdd(intType *rdata, const intType *delta, + const int length) { + const int bsize = AES_BATCH_SIZE / 2; + block128 pad[2 * bsize]; + intType tmp[bsize]; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = qT[j]; + pad[2 * (j - i) + 1] = xorBlocks(qT[j], block_s); + } + crh.H<2 * bsize>(pad, pad); + for (int j = i; j < i + bsize and j < length; ++j) { + rdata[j] = + (intType)_mm_extract_epi64(pad[2 * (j - i)], 0); // Use lower bits + intType corrVal = rdata[j] + delta[j]; + intType mask = (intType)_mm_extract_epi64(pad[2 * (j - i) + 1], 0); + intType msgToBeSent = corrVal ^ mask; + tmp[j - i] = msgToBeSent; + } + io->send_data(tmp, sizeof(intType) * std::min(bsize, length - i)); + } + delete[] qT; + } + + template <typename intType> + void cot_recv_post_moduloAdd(intType *data, const uint8_t *choices, + const int length) { + const int bsize = AES_BATCH_SIZE; + intType res[bsize]; + block128 hashes[bsize]; + for (int i = 0; i < length; i += bsize) { + io->recv_data(res, sizeof(intType) * std::min(bsize, length - i)); + if (bsize <= length - i) + crh.H<bsize>(hashes, tT + i); + else + crh.Hn(hashes, tT + i, length - i); + for (int j = 0; j < bsize and j < length - i; ++j) { + data[i + j] = (intType)_mm_extract_epi64( + hashes[j], 0); // Use lower bits convention + if (choices[i + j]) { + data[i + j] = data[i + j] ^ res[j]; + } + } + } + delete[] tT; + } + + /* + - For the correlation f(r) = (r+delta[i])mod 2^l + */ + template <typename intType> + void send_cot_moduloAdd(intType *rdata, const intType *delta, + const int numOTs) { + send_pre(numOTs); + cot_send_post_moduloAdd<intType>(rdata, delta, numOTs); + } + + /* + - For the correlation f(r) = (r+delta[i])mod 2^l + */ + template <typename intType> + void recv_cot_moduloAdd(intType *data, const uint8_t *choices, + const int numOTs) { + recv_pre((bool *)choices, numOTs); + cot_recv_post_moduloAdd<intType>(data, choices, numOTs); + } }; -} -#endif// IKNP_H__ +} // namespace sci +#endif // IKNP_H__ diff --git a/SCI/src/OT/kkot.h b/SCI/src/OT/kkot.h index 01d27a70..314f3868 100644 --- a/SCI/src/OT/kkot.h +++ b/SCI/src/OT/kkot.h @@ -21,242 +21,219 @@ SOFTWARE. #ifndef OT_KKOT_H__ #define OT_KKOT_H__ -#include "OT/ot.h" #include "OT/np.h" +#include "OT/ot.h" namespace sci { -template<typename IO> -class KKOT : public OT<KKOT<IO>> -{ +template <typename IO> class KKOT : public OT<KKOT<IO>> { public: - OTNP<IO> * base_ot; - PRG128 prg; - const int lambda = 256; - int block_size = 1024*16; - int ro_batch_size = 2048; - int N, l, max_N = 0; - - block256 *k0 = nullptr, *k1 = nullptr, *d = nullptr, *c_AND_s = nullptr, - *qT = nullptr, *tT = nullptr, *tmp = nullptr, block_s; - PRG256 *G0, *G1; - bool *s = nullptr, setup = false, precomp_masks = false; - uint8_t *extended_r = nullptr; - IO *io = nullptr; - - KKOT( - IO * io) - { - this->io = io; - base_ot = new OTNP<IO>(io); - s = new bool[lambda]; - k0 = new block256[lambda]; - k1 = new block256[lambda]; - d = new block256[block_size]; - c_AND_s = new block256[lambda]; - G0 = new PRG256[lambda]; - G1 = new PRG256[lambda]; - tmp = new block256[block_size/256]; - extended_r = new uint8_t[block_size]; - } - - ~KKOT() - { - delete base_ot; - delete[] s; - delete[] k0; - delete[] k1; - delete[] d; - delete[] c_AND_s; - delete[] G0; - delete[] G1; - delete[] tmp; - delete[] extended_r; - } - - void setup_send( - block256 * in_k0 = nullptr, - bool * in_s = nullptr) - { - setup = true; - if(in_s != nullptr) { - memcpy(k0, in_k0, lambda*sizeof(block256)); - memcpy(s, in_s, lambda); - block_s = bool_to256(s); - } else { - prg.random_bool(s, lambda); - base_ot->recv(k0, s, lambda); - block_s = bool_to256(s); - } - for(int i = 0; i < lambda; ++i) - G0[i].reseed(&k0[i]); - } - - void setup_recv( - block256 * in_k0 = nullptr, - block256 * in_k1 =nullptr) - { - setup = true; - if(in_k0 !=nullptr) { - memcpy(k0, in_k0, lambda*sizeof(block256)); - memcpy(k1, in_k1, lambda*sizeof(block256)); - } else { - prg.random_block(k0, lambda); - prg.random_block(k1, lambda); - base_ot->send(k0, k1, lambda); - } - for(int i = 0; i < lambda; ++i) { - G0[i].reseed(&k0[i]); - G1[i].reseed(&k1[i]); - } - } - - void precompute_masks() - { - assert(setup == true); - assert(N > 0); - precomp_masks = true; - for(int i = max_N; i < N; i++) { - c_AND_s[i] = andBlocks(_mm256_lddqu_si256((const __m256i*) WH_Code[i]), block_s); - } - max_N = N; - } - - int padded_length( - int length) - { - return ((length + block_size - 1) / block_size) * block_size; - } - - void send_pre( - int length) - { - length = padded_length(length); - block256 q[block_size]; - qT = new block256[length]; - if(!setup) setup_send(); - if(!precomp_masks) precompute_masks(); - - for (int j = 0; j < length/block_size; ++j) { - for(int i = 0; i < lambda; ++i) { - G0[i].random_data(q+(i*block_size/256), block_size/8); - io->recv_data(tmp, block_size/8); - if (s[i]) - xorBlocks_arr(q+(i*block_size/256), q+(i*block_size/256), tmp, block_size/256); - } - sse_trans((uint8_t*)(qT+j*block_size), (uint8_t*)q, 256, block_size); - } - } - - void recv_pre( - const uint8_t* r, - int length) - { - int old_length = length; - length = padded_length(length); - block256 t[block_size]; - tT = new block256[length]; - - if(not setup) setup_recv(); - - uint8_t* r2 = new uint8_t[length]; - prg.random_data(extended_r, block_size); - memcpy(r2, r, old_length); - memcpy(r2+old_length, extended_r, length - old_length); - - block256* dT = new block256[length]; - for(int i = 0; i < length; i++) - dT[i] = _mm256_lddqu_si256((const __m256i*) WH_Code[r2[i]]); - - for (int j = 0; j * block_size < length; ++j) { - sse_trans((uint8_t*)d, (uint8_t*)(dT+j*block_size), block_size, 256); - for(int i = 0; i < lambda; ++i) { - G0[i].random_data(t+(i*block_size/256), block_size/8); - G1[i].random_data(tmp, block_size/8); - xorBlocks_arr(tmp, t+(i*block_size/256), tmp, block_size/256); - xorBlocks_arr(tmp, d+(i*block_size/256), tmp, block_size/256); - io->send_data(tmp, block_size/8); - } - sse_trans((uint8_t*)(tT+j*block_size), (uint8_t*)t, 256, block_size); - } - - delete[] dT; - delete[] r2; - } - - void got_send_post( - block128** data, - int length) - { - const int bsize = ro_batch_size; - block256 *key = new block256[N*bsize]; - block128 *y = new block128[N*bsize]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - for(int k = 0; k < N; k++) { - key[N*(j-i)+k] = xorBlocks(qT[j], c_AND_s[k]); - } - } - CCRF(y, key, N*bsize); - for(int j = i; j < i+bsize and j < length; ++j) { - for(int k = 0; k < N; k++) { - y[N*(j-i)+k] = xorBlocks(y[N*(j-i)+k], data[j][k]); - } - } - io->send_data(y, N*sizeof(block128)*std::min(bsize,length-i)); - } - delete[] key; - delete[] y; - delete[] qT; - } - - void got_recv_post( - block128* data, - const uint8_t* r, - int length) - { - const int bsize = ro_batch_size; - block128 *pad = new block128[bsize]; - block128 *res = new block128[N*bsize]; - for(int i = 0; i < length; i+=bsize) { - io->recv_data(res, N*sizeof(block128)*std::min(bsize,length-i)); - if (bsize <= length-i) CCRF(pad, tT+i, bsize); - else CCRF(pad, tT+i, length-i); - for(int j = 0; j < bsize and j < length-i; ++j) { - data[i+j] = xorBlocks(res[N*j+r[i+j]], pad[j]); - } - } - delete[] pad; - delete[] res; - delete[] tT; - } - - void send_impl( - block128** data, - int length, - int N) - { - if (length < 1) return; - assert(N <= lambda && N >= 2); - this->N = N; - if((this->max_N < N) && setup == true) precompute_masks(); - send_pre(length); - got_send_post(data, length); - } - - void recv_impl( - block128* data, - const uint8_t* b, - int length, - int N) - { - if (length < 1) return; - assert(N <= lambda && N >= 2); - this->N = N; - recv_pre(b, length); - got_recv_post(data, b, length); - } - + OTNP<IO> *base_ot; + PRG128 prg; + const int lambda = 256; + int block_size = 1024 * 16; + int ro_batch_size = 2048; + int N, l, max_N = 0; + + block256 *k0 = nullptr, *k1 = nullptr, *d = nullptr, *c_AND_s = nullptr, + *qT = nullptr, *tT = nullptr, *tmp = nullptr, block_s; + PRG256 *G0, *G1; + bool *s = nullptr, setup = false, precomp_masks = false; + uint8_t *extended_r = nullptr; + IO *io = nullptr; + + KKOT(IO *io) { + this->io = io; + base_ot = new OTNP<IO>(io); + s = new bool[lambda]; + k0 = new (std::align_val_t(32)) block256[lambda]; + k1 = new (std::align_val_t(32)) block256[lambda]; + d = new (std::align_val_t(32)) block256[block_size]; + c_AND_s = new (std::align_val_t(32)) block256[lambda]; + G0 = new PRG256[lambda]; + G1 = new PRG256[lambda]; + tmp = new (std::align_val_t(32)) block256[block_size / 256]; + extended_r = new uint8_t[block_size]; + } + + ~KKOT() { + delete base_ot; + delete[] s; + delete[] k0; + delete[] k1; + delete[] d; + delete[] c_AND_s; + delete[] G0; + delete[] G1; + delete[] tmp; + delete[] extended_r; + } + + void setup_send(block256 *in_k0 = nullptr, bool *in_s = nullptr) { + setup = true; + if (in_s != nullptr) { + memcpy(k0, in_k0, lambda * sizeof(block256)); + memcpy(s, in_s, lambda); + block_s = bool_to256(s); + } else { + prg.random_bool(s, lambda); + base_ot->recv(k0, s, lambda); + block_s = bool_to256(s); + } + for (int i = 0; i < lambda; ++i) + G0[i].reseed(&k0[i]); + } + + void setup_recv(block256 *in_k0 = nullptr, block256 *in_k1 = nullptr) { + setup = true; + if (in_k0 != nullptr) { + memcpy(k0, in_k0, lambda * sizeof(block256)); + memcpy(k1, in_k1, lambda * sizeof(block256)); + } else { + prg.random_block(k0, lambda); + prg.random_block(k1, lambda); + base_ot->send(k0, k1, lambda); + } + for (int i = 0; i < lambda; ++i) { + G0[i].reseed(&k0[i]); + G1[i].reseed(&k1[i]); + } + } + + void precompute_masks() { + assert(setup == true); + assert(N > 0); + precomp_masks = true; + for (int i = max_N; i < N; i++) { + c_AND_s[i] = + andBlocks(_mm256_lddqu_si256((const __m256i *)WH_Code[i]), block_s); + } + max_N = N; + } + + int padded_length(int length) { + return ((length + block_size - 1) / block_size) * block_size; + } + + void send_pre(int length) { + length = padded_length(length); + alignas(32) block256 q[block_size]; + qT = new (std::align_val_t(32)) block256[length]; + if (!setup) + setup_send(); + if (!precomp_masks) + precompute_masks(); + + for (int j = 0; j < length / block_size; ++j) { + for (int i = 0; i < lambda; ++i) { + G0[i].random_data(q + (i * block_size / 256), block_size / 8); + io->recv_data(tmp, block_size / 8); + if (s[i]) + xorBlocks_arr(q + (i * block_size / 256), q + (i * block_size / 256), + tmp, block_size / 256); + } + sse_trans((uint8_t *)(qT + j * block_size), (uint8_t *)q, 256, + block_size); + } + } + + void recv_pre(const uint8_t *r, int length) { + int old_length = length; + length = padded_length(length); + alignas(32) block256 t[block_size]; + tT = new (std::align_val_t(32)) block256[length]; + + if (not setup) + setup_recv(); + + uint8_t *r2 = new uint8_t[length]; + prg.random_data(extended_r, block_size); + memcpy(r2, r, old_length); + memcpy(r2 + old_length, extended_r, length - old_length); + + block256 *dT = new (std::align_val_t(32)) block256[length]; + for (int i = 0; i < length; i++) + dT[i] = _mm256_lddqu_si256((const __m256i *)WH_Code[r2[i]]); + + for (int j = 0; j * block_size < length; ++j) { + sse_trans((uint8_t *)d, (uint8_t *)(dT + j * block_size), block_size, + 256); + for (int i = 0; i < lambda; ++i) { + G0[i].random_data(t + (i * block_size / 256), block_size / 8); + G1[i].random_data(tmp, block_size / 8); + xorBlocks_arr(tmp, t + (i * block_size / 256), tmp, block_size / 256); + xorBlocks_arr(tmp, d + (i * block_size / 256), tmp, block_size / 256); + io->send_data(tmp, block_size / 8); + } + sse_trans((uint8_t *)(tT + j * block_size), (uint8_t *)t, 256, + block_size); + } + + delete[] dT; + delete[] r2; + } + + void got_send_post(block128 **data, int length) { + const int bsize = ro_batch_size; + block256 *key = new (std::align_val_t(32)) block256[N * bsize]; + block128 *y = new block128[N * bsize]; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + for (int k = 0; k < N; k++) { + key[N * (j - i) + k] = xorBlocks(qT[j], c_AND_s[k]); + } + } + CCRF(y, key, N * bsize); + for (int j = i; j < i + bsize and j < length; ++j) { + for (int k = 0; k < N; k++) { + y[N * (j - i) + k] = xorBlocks(y[N * (j - i) + k], data[j][k]); + } + } + io->send_data(y, N * sizeof(block128) * std::min(bsize, length - i)); + } + delete[] key; + delete[] y; + delete[] qT; + } + + void got_recv_post(block128 *data, const uint8_t *r, int length) { + const int bsize = ro_batch_size; + block128 *pad = new block128[bsize]; + block128 *res = new block128[N * bsize]; + for (int i = 0; i < length; i += bsize) { + io->recv_data(res, N * sizeof(block128) * std::min(bsize, length - i)); + if (bsize <= length - i) + CCRF(pad, tT + i, bsize); + else + CCRF(pad, tT + i, length - i); + for (int j = 0; j < bsize and j < length - i; ++j) { + data[i + j] = xorBlocks(res[N * j + r[i + j]], pad[j]); + } + } + delete[] pad; + delete[] res; + delete[] tT; + } + + void send_impl(block128 **data, int length, int N) { + if (length < 1) + return; + assert(N <= lambda && N >= 2); + this->N = N; + if ((this->max_N < N) && setup == true) + precompute_masks(); + send_pre(length); + got_send_post(data, length); + } + + void recv_impl(block128 *data, const uint8_t *b, int length, int N) { + if (length < 1) + return; + assert(N <= lambda && N >= 2); + this->N = N; + recv_pre(b, length); + got_recv_post(data, b, length); + } }; -} -#endif// OT_KKOT_H__ +} // namespace sci +#endif // OT_KKOT_H__ diff --git a/SCI/src/OT/np.h b/SCI/src/OT/np.h index 9a945b05..dcea2134 100644 --- a/SCI/src/OT/np.h +++ b/SCI/src/OT/np.h @@ -29,192 +29,190 @@ Modified by Deevashwer Rathee #define OT_NP_H__ #include "OT/ot.h" /** @addtogroup OT - @{ + @{ */ namespace sci { -template<typename IO> -class OTNP: public OT<OTNP<IO>> { public: - IO* io; - Group *G = nullptr; - bool delete_G = true; - OTNP(IO* io, Group * _G = nullptr) { - this->io = io; - if (_G == nullptr) - G = new Group(); - else { - G = _G; - delete_G = false; - } - } - ~OTNP() { - if (delete_G) - delete G; - } - - void send_impl(const block128* data0, const block128* data1, int length) { - BigInt d; - G->get_rand_bn(d); - Point C = G->mul_gen(d); - io->send_pt(&C);io->flush(); - - BigInt * r = new BigInt[length]; - BigInt * rc = new BigInt[length]; - Point * pk0 = new Point[length], - pk1, - *gr = new Point[length], - *Cr = new Point[length]; - for(int i = 0; i < length; ++i) { - G->get_rand_bn(r[i]); - gr[i] = G->mul_gen(r[i]); - rc[i] = r[i].mul(d, G->bn_ctx); - rc[i] = rc[i].mod(G->order, G->bn_ctx); - Cr[i] = G->mul_gen(rc[i]); - } - - for(int i = 0; i < length; ++i) { - io->recv_pt(G, &pk0[i]); - } - for(int i = 0; i < length; ++i) { - io->send_pt(&gr[i]); - } - io->flush(); - - block128 m[2]; - for(int i = 0 ; i < length; ++i) { - pk0[i] = pk0[i].mul(r[i]); - Point inv = pk0[i].inv(); - pk1 = Cr[i].add(inv); - m[0] = Hash::KDF128(pk0[i]); - m[0] = xorBlocks(data0[i], m[0]); - m[1] = Hash::KDF128(pk1); - m[1] = xorBlocks(data1[i], m[1]); - io->send_data(m, 2*sizeof(block128)); - } - - delete[] r; - delete[] gr; - delete[] Cr; - delete[] rc; - delete[] pk0; - } - - void send_impl(const block256* data0, const block256* data1, int length) { - BigInt d; - G->get_rand_bn(d); - Point C = G->mul_gen(d); - io->send_pt(&C);io->flush(); - - BigInt * r = new BigInt[length]; - BigInt * rc = new BigInt[length]; - Point * pk0 = new Point[length], - pk1, - *gr = new Point[length], - *Cr = new Point[length]; - for(int i = 0; i < length; ++i) { - G->get_rand_bn(r[i]); - gr[i] = G->mul_gen(r[i]); - rc[i] = r[i].mul(d, G->bn_ctx); - rc[i] = rc[i].mod(G->order, G->bn_ctx); - Cr[i] = G->mul_gen(rc[i]); - } - - for(int i = 0; i < length; ++i) { - io->recv_pt(G, &pk0[i]); - } - for(int i = 0; i < length; ++i) { - io->send_pt(&gr[i]); - } - io->flush(); - - block256 m[2]; - for(int i = 0 ; i < length; ++i) { - pk0[i] = pk0[i].mul(r[i]); - Point inv = pk0[i].inv(); - pk1 = Cr[i].add(inv); - m[0] = Hash::KDF256(pk0[i]); - m[0] = xorBlocks(data0[i], m[0]); - m[1] = Hash::KDF256(pk1); - m[1] = xorBlocks(data1[i], m[1]); - io->send_data(m, 2*sizeof(block256)); - } - - delete[] r; - delete[] gr; - delete[] Cr; - delete[] rc; - delete[] pk0; - } - - void recv_impl(block128* data, const bool* b, int length) { - BigInt * k = new BigInt[length]; - Point * gr = new Point[length]; - Point pk[2]; - block128 m[2]; - Point C; - for(int i = 0; i < length; ++i) - G->get_rand_bn(k[i]); - - io->recv_pt(G, &C); - - for(int i = 0; i< length; ++i) { - if(b[i]) { - pk[1] = G->mul_gen(k[i]); - Point inv = pk[1].inv(); - pk[0] = C.add(inv); - } else { - pk[0] = G->mul_gen(k[i]); - } - io->send_pt(&pk[0]); - } - - for(int i = 0; i < length; ++i) { - io->recv_pt(G, &gr[i]); - gr[i] = gr[i].mul(k[i]); - } - for(int i = 0; i < length; ++i) { - int ind = b[i] ? 1 : 0; - io->recv_data(m, 2*sizeof(block128)); - data[i] = xorBlocks(m[ind], Hash::KDF128(gr[i])); - } - delete[] k; - delete[] gr; - } - - void recv_impl(block256* data, const bool* b, int length) { - BigInt * k = new BigInt[length]; - Point * gr = new Point[length]; - Point pk[2]; - block256 m[2]; - Point C; - for(int i = 0; i < length; ++i) - G->get_rand_bn(k[i]); - - io->recv_pt(G, &C); - - for(int i = 0; i< length; ++i) { - if(b[i]) { - pk[1] = G->mul_gen(k[i]); - Point inv = pk[1].inv(); - pk[0] = C.add(inv); - } else { - pk[0] = G->mul_gen(k[i]); - } - io->send_pt(&pk[0]); - } - - for(int i = 0; i < length; ++i) { - io->recv_pt(G, &gr[i]); - gr[i] = gr[i].mul(k[i]); - } - for(int i = 0; i < length; ++i) { - int ind = b[i] ? 1 : 0; - io->recv_data(m, 2*sizeof(block256)); - data[i] = xorBlocks(m[ind], Hash::KDF256(gr[i])); - } - delete[] k; - delete[] gr; - } +template <typename IO> class OTNP : public OT<OTNP<IO>> { +public: + IO *io; + emp::Group *G = nullptr; + bool delete_G = true; + OTNP(IO *io, emp::Group *_G = nullptr) { + this->io = io; + if (_G == nullptr) + G = new emp::Group(); + else { + G = _G; + delete_G = false; + } + } + ~OTNP() { + if (delete_G) + delete G; + } + + void send_impl(const block128 *data0, const block128 *data1, int length) { + emp::BigInt d; + G->get_rand_bn(d); + emp::Point C = G->mul_gen(d); + io->send_pt(&C); + io->flush(); + + emp::BigInt *r = new emp::BigInt[length]; + emp::BigInt *rc = new emp::BigInt[length]; + emp::Point *pk0 = new emp::Point[length], pk1, *gr = new emp::Point[length], + *Cr = new emp::Point[length]; + for (int i = 0; i < length; ++i) { + G->get_rand_bn(r[i]); + gr[i] = G->mul_gen(r[i]); + rc[i] = r[i].mul(d, G->bn_ctx); + rc[i] = rc[i].mod(G->order, G->bn_ctx); + Cr[i] = G->mul_gen(rc[i]); + } + + for (int i = 0; i < length; ++i) { + io->recv_pt(G, &pk0[i]); + } + for (int i = 0; i < length; ++i) { + io->send_pt(&gr[i]); + } + io->flush(); + + block128 m[2]; + for (int i = 0; i < length; ++i) { + pk0[i] = pk0[i].mul(r[i]); + emp::Point inv = pk0[i].inv(); + pk1 = Cr[i].add(inv); + m[0] = Hash::KDF128(pk0[i]); + m[0] = xorBlocks(data0[i], m[0]); + m[1] = Hash::KDF128(pk1); + m[1] = xorBlocks(data1[i], m[1]); + io->send_data(m, 2 * sizeof(block128)); + } + + delete[] r; + delete[] gr; + delete[] Cr; + delete[] rc; + delete[] pk0; + } + + void send_impl(const block256 *data0, const block256 *data1, int length) { + emp::BigInt d; + G->get_rand_bn(d); + emp::Point C = G->mul_gen(d); + io->send_pt(&C); + io->flush(); + + emp::BigInt *r = new emp::BigInt[length]; + emp::BigInt *rc = new emp::BigInt[length]; + emp::Point *pk0 = new emp::Point[length], pk1, *gr = new emp::Point[length], + *Cr = new emp::Point[length]; + for (int i = 0; i < length; ++i) { + G->get_rand_bn(r[i]); + gr[i] = G->mul_gen(r[i]); + rc[i] = r[i].mul(d, G->bn_ctx); + rc[i] = rc[i].mod(G->order, G->bn_ctx); + Cr[i] = G->mul_gen(rc[i]); + } + + for (int i = 0; i < length; ++i) { + io->recv_pt(G, &pk0[i]); + } + for (int i = 0; i < length; ++i) { + io->send_pt(&gr[i]); + } + io->flush(); + + alignas(32) block256 m[2]; + for (int i = 0; i < length; ++i) { + pk0[i] = pk0[i].mul(r[i]); + emp::Point inv = pk0[i].inv(); + pk1 = Cr[i].add(inv); + m[0] = Hash::KDF256(pk0[i]); + m[0] = xorBlocks(data0[i], m[0]); + m[1] = Hash::KDF256(pk1); + m[1] = xorBlocks(data1[i], m[1]); + io->send_data(m, 2 * sizeof(block256)); + } + + delete[] r; + delete[] gr; + delete[] Cr; + delete[] rc; + delete[] pk0; + } + + void recv_impl(block128 *data, const bool *b, int length) { + emp::BigInt *k = new emp::BigInt[length]; + emp::Point *gr = new emp::Point[length]; + emp::Point pk[2]; + block128 m[2]; + emp::Point C; + for (int i = 0; i < length; ++i) + G->get_rand_bn(k[i]); + + io->recv_pt(G, &C); + + for (int i = 0; i < length; ++i) { + if (b[i]) { + pk[1] = G->mul_gen(k[i]); + emp::Point inv = pk[1].inv(); + pk[0] = C.add(inv); + } else { + pk[0] = G->mul_gen(k[i]); + } + io->send_pt(&pk[0]); + } + + for (int i = 0; i < length; ++i) { + io->recv_pt(G, &gr[i]); + gr[i] = gr[i].mul(k[i]); + } + for (int i = 0; i < length; ++i) { + int ind = b[i] ? 1 : 0; + io->recv_data(m, 2 * sizeof(block128)); + data[i] = xorBlocks(m[ind], Hash::KDF128(gr[i])); + } + delete[] k; + delete[] gr; + } + + void recv_impl(block256 *data, const bool *b, int length) { + emp::BigInt *k = new emp::BigInt[length]; + emp::Point *gr = new emp::Point[length]; + emp::Point pk[2]; + alignas(32) block256 m[2]; + emp::Point C; + for (int i = 0; i < length; ++i) + G->get_rand_bn(k[i]); + + io->recv_pt(G, &C); + + for (int i = 0; i < length; ++i) { + if (b[i]) { + pk[1] = G->mul_gen(k[i]); + emp::Point inv = pk[1].inv(); + pk[0] = C.add(inv); + } else { + pk[0] = G->mul_gen(k[i]); + } + io->send_pt(&pk[0]); + } + + for (int i = 0; i < length; ++i) { + io->recv_pt(G, &gr[i]); + gr[i] = gr[i].mul(k[i]); + } + for (int i = 0; i < length; ++i) { + int ind = b[i] ? 1 : 0; + io->recv_data(m, 2 * sizeof(block256)); + data[i] = xorBlocks(m[ind], Hash::KDF256(gr[i])); + } + delete[] k; + delete[] gr; + } }; /**@}*/ -} -#endif// OT_NP_H__ +} // namespace sci +#endif // OT_NP_H__ diff --git a/SCI/src/OT/ot-utils.h b/SCI/src/OT/ot-utils.h index 2ce1b70a..7d013b9c 100644 --- a/SCI/src/OT/ot-utils.h +++ b/SCI/src/OT/ot-utils.h @@ -1,5 +1,5 @@ /* -Authors: Mayank Rathee +Authors: Mayank Rathee, Deevashwer Rathee Copyright: Copyright (c) 2020 Microsoft Research Permission is hereby granted, free of charge, to any person obtaining a copy @@ -23,134 +23,195 @@ SOFTWARE. #define OT_UTIL_H__ #include "OT/ot.h" -namespace sci{ - template<typename basetype> - void pack_ot_messages(basetype* y, - basetype** data, - block128* pad, - int ysize, - int bsize, - int bitsize, - int N) - { - assert(y != nullptr && data != nullptr && pad != nullptr); - uint64_t start_pos = 0; - uint64_t end_pos = 0; - uint64_t start_block = 0; - uint64_t end_block = 0; - basetype temp_bl = 0; - basetype mask = (1<<bitsize)-1; - if(8*sizeof(basetype) == 64){ - mask = (basetype)((1ULL<<bitsize)-1ULL); - } - if(8*sizeof(basetype) == bitsize){ - if(bitsize == 64){ - mask = (basetype)(-1ULL); - } - else{ - mask = (basetype)(-1); - } - } - uint64_t carriersize = 8*(sizeof(basetype)); - for(int i=0; i<ysize; i++){ - y[i] = 0; - } - for(int i=0; i<bsize; i++){ - for(int k=0; k<N; k++){ - // OT message k - start_pos = i*N*bitsize + k*bitsize; //inclusive - end_pos = start_pos + bitsize; - end_pos -= 1; //inclusive - start_block = start_pos/carriersize; - end_block = end_pos/carriersize; - if(carriersize == 64){ - if(start_block == end_block){ - y[start_block] ^= ((((basetype)_mm_extract_epi64(pad[(N*i)+k], 0)) ^ data[i][k]) & mask)<<(start_pos % carriersize); - } - else{ - temp_bl = ((((basetype)_mm_extract_epi64(pad[(N*i)+k], 0)) ^ data[i][k]) & mask); - y[start_block] ^= (temp_bl)<<(start_pos % carriersize); - y[end_block] ^= (temp_bl)>>(carriersize - (start_pos % carriersize)); - } - } - else if(carriersize == 8){ - if(start_block == end_block){ - y[start_block] ^= ((((basetype)_mm_extract_epi8(pad[(N*i)+k], 0)) ^ data[i][k]) & mask)<<(start_pos % carriersize); - } - else{ - temp_bl = ((((basetype)_mm_extract_epi8(pad[(N*i)+k], 0)) ^ data[i][k]) & mask); - y[start_block] ^= (temp_bl)<<(start_pos % carriersize); - y[end_block] ^= (temp_bl)>>(carriersize - (start_pos % carriersize)); - } - } - else{ - throw std::invalid_argument("Not implemented"); - } - } - } - } +namespace sci { +template <typename basetype> +void pack_ot_messages(basetype *y, basetype **data, block128 *pad, int ysize, + int bsize, int bitsize, int N) { + assert(y != nullptr && data != nullptr && pad != nullptr); + uint64_t start_pos = 0; + uint64_t end_pos = 0; + uint64_t start_block = 0; + uint64_t end_block = 0; + basetype temp_bl = 0; + basetype mask = (1 << bitsize) - 1; + if (8 * sizeof(basetype) == 64) { + mask = (basetype)((1ULL << bitsize) - 1ULL); + } + if (8 * sizeof(basetype) == bitsize) { + if (bitsize == 64) { + mask = (basetype)(-1ULL); + } else { + mask = (basetype)(-1); + } + } + uint64_t carriersize = 8 * (sizeof(basetype)); + for (int i = 0; i < ysize; i++) { + y[i] = 0; + } + for (int i = 0; i < bsize; i++) { + for (int k = 0; k < N; k++) { + // OT message k + start_pos = i * N * bitsize + k * bitsize; // inclusive + end_pos = start_pos + bitsize; + end_pos -= 1; // inclusive + start_block = start_pos / carriersize; + end_block = end_pos / carriersize; + if (carriersize == 64) { + if (start_block == end_block) { + y[start_block] ^= + ((((basetype)_mm_extract_epi64(pad[(N * i) + k], 0)) ^ + data[i][k]) & + mask) + << (start_pos % carriersize); + } else { + temp_bl = ((((basetype)_mm_extract_epi64(pad[(N * i) + k], 0)) ^ + data[i][k]) & + mask); + y[start_block] ^= (temp_bl) << (start_pos % carriersize); + y[end_block] ^= + (temp_bl) >> (carriersize - (start_pos % carriersize)); + } + } else if (carriersize == 8) { + if (start_block == end_block) { + y[start_block] ^= + ((((basetype)_mm_extract_epi8(pad[(N * i) + k], 0)) ^ + data[i][k]) & + mask) + << (start_pos % carriersize); + } else { + temp_bl = ((((basetype)_mm_extract_epi8(pad[(N * i) + k], 0)) ^ + data[i][k]) & + mask); + y[start_block] ^= (temp_bl) << (start_pos % carriersize); + y[end_block] ^= + (temp_bl) >> (carriersize - (start_pos % carriersize)); + } + } else { + throw std::invalid_argument("Not implemented"); + } + } + } +} + +template <typename basetype> +void unpack_ot_messages(basetype *data, const uint8_t *r, basetype *recvd, + block128 *pad, int bsize, int bitsize, int N) { + assert(data != nullptr && recvd != nullptr && pad != nullptr); + uint64_t start_pos = 0; + uint64_t end_pos = 0; + uint64_t start_block = 0; + uint64_t end_block = 0; + basetype mask = (1 << bitsize) - 1; + if (8 * sizeof(basetype) == 64) { + mask = (basetype)((1ULL << bitsize) - 1ULL); + } + if (8 * sizeof(basetype) == bitsize) { + if (bitsize == 64) { + mask = (basetype)(-1ULL); + } else { + mask = (basetype)(-1); + } + } + uint64_t carriersize = 8 * (sizeof(basetype)); + + for (int i = 0; i < bsize; i++) { + start_pos = i * N * bitsize + r[i] * bitsize; + end_pos = start_pos + bitsize - 1; // inclusive + start_block = start_pos / carriersize; + end_block = end_pos / carriersize; + if (carriersize == 64) { + if (start_block == end_block) { + data[i] = ((recvd[start_block] >> (start_pos % carriersize)) ^ + ((basetype)_mm_extract_epi64(pad[i], 0))) & + mask; + } else { + data[i] = 0; + data[i] ^= (recvd[start_block] >> (start_pos % carriersize)); + data[i] ^= + (recvd[end_block] << (carriersize - (start_pos % carriersize))); + data[i] = (data[i] ^ ((basetype)_mm_extract_epi64(pad[i], 0))) & mask; + } + } else if (carriersize == 8) { + if (start_block == end_block) { + data[i] = ((recvd[start_block] >> (start_pos % carriersize)) ^ + ((basetype)_mm_extract_epi8(pad[i], 0))) & + mask; + } else { + data[i] = 0; + data[i] ^= (recvd[start_block] >> (start_pos % carriersize)); + data[i] ^= + (recvd[end_block] << (carriersize - (start_pos % carriersize))); + data[i] = (data[i] ^ ((basetype)_mm_extract_epi8(pad[i], 0))) & mask; + } + } else { + throw std::invalid_argument("Not implemented"); + } + } +} + +inline void pack_cot_messages(uint64_t *y, uint64_t *corr_data, int ysize, + int bsize, int bitsize) { + assert(y != nullptr && corr_data != nullptr); + uint64_t start_pos = 0; + uint64_t end_pos = 0; + uint64_t start_block = 0; + uint64_t end_block = 0; + uint64_t temp_bl = 0; + uint64_t mask = (1ULL << bitsize) - 1; + if (bitsize == 64) + mask = -1; + + uint64_t carriersize = 64; + for (int i = 0; i < ysize; i++) { + y[i] = 0; + } + for (int i = 0; i < bsize; i++) { + start_pos = i * bitsize; // inclusive + end_pos = start_pos + bitsize; + end_pos -= 1; // inclusive + start_block = start_pos / carriersize; + end_block = end_pos / carriersize; + if (carriersize == 64) { + if (start_block == end_block) { + y[start_block] ^= (corr_data[i] & mask) << (start_pos % carriersize); + } else { + temp_bl = (corr_data[i] & mask); + y[start_block] ^= (temp_bl) << (start_pos % carriersize); + y[end_block] ^= (temp_bl) >> (carriersize - (start_pos % carriersize)); + } + } + } +} + +inline void unpack_cot_messages(uint64_t *corr_data, uint64_t *recvd, int bsize, + int bitsize) { + assert(corr_data != nullptr && recvd != nullptr); + uint64_t start_pos = 0; + uint64_t end_pos = 0; + uint64_t start_block = 0; + uint64_t end_block = 0; + uint64_t mask = (1ULL << bitsize) - 1; + if (bitsize == 64) + mask = -1; + uint64_t carriersize = 64; - template<typename basetype> - void unpack_ot_messages(basetype* data, - const uint8_t* r, - basetype* recvd, - block128* pad, - int bsize, - int bitsize, - int N) - { - assert(data != nullptr && recvd != nullptr && pad != nullptr); - uint64_t start_pos = 0; - uint64_t end_pos = 0; - uint64_t start_block = 0; - uint64_t end_block = 0; - basetype mask = (1<<bitsize)-1; - if(8*sizeof(basetype) == 64){ - mask = (basetype)((1ULL<<bitsize)-1ULL); - } - if(8*sizeof(basetype) == bitsize){ - if(bitsize == 64){ - mask = (basetype)(-1ULL); - } - else{ - mask = (basetype)(-1); - } - } - uint64_t carriersize = 8*(sizeof(basetype)); - - for(int i=0; i<bsize; i++){ - start_pos = i*N*bitsize + r[i]*bitsize; - end_pos = start_pos + bitsize - 1; //inclusive - start_block = start_pos/carriersize; - end_block = end_pos/carriersize; - if(carriersize == 64){ - if(start_block == end_block){ - data[i] = ((recvd[start_block]>>(start_pos % carriersize)) ^ ((basetype)_mm_extract_epi64(pad[i], 0))) & mask; - } - else{ - data[i] = 0; - data[i] ^= (recvd[start_block]>>(start_pos % carriersize)); - data[i] ^= (recvd[end_block]<<(carriersize - (start_pos % carriersize))); - data[i] = (data[i] ^ ((basetype)_mm_extract_epi64(pad[i], 0))) & mask; - } - } - else if(carriersize == 8){ - if(start_block == end_block){ - data[i] = ((recvd[start_block]>>(start_pos % carriersize)) ^ ((basetype)_mm_extract_epi8(pad[i], 0))) & mask; - } - else{ - data[i] = 0; - data[i] ^= (recvd[start_block]>>(start_pos % carriersize)); - data[i] ^= (recvd[end_block]<<(carriersize - (start_pos % carriersize))); - data[i] = (data[i] ^ ((basetype)_mm_extract_epi8(pad[i], 0))) & mask; - } - } - else{ - throw std::invalid_argument("Not implemented"); - } - } - } - + for (int i = 0; i < bsize; i++) { + start_pos = i * bitsize; + end_pos = start_pos + bitsize - 1; // inclusive + start_block = start_pos / carriersize; + end_block = end_pos / carriersize; + if (carriersize == 64) { + if (start_block == end_block) { + corr_data[i] = (recvd[start_block] >> (start_pos % carriersize)) & mask; + } else { + corr_data[i] = 0; + corr_data[i] ^= (recvd[start_block] >> (start_pos % carriersize)); + corr_data[i] ^= + (recvd[end_block] << (carriersize - (start_pos % carriersize))); + } + } + } } +} // namespace sci -#endif //OT_UTIL_H__ +#endif // OT_UTIL_H__ diff --git a/SCI/src/OT/ot.h b/SCI/src/OT/ot.h index 570c894c..bfdf2cfb 100644 --- a/SCI/src/OT/ot.h +++ b/SCI/src/OT/ot.h @@ -29,87 +29,96 @@ Modified by Deevashwer Rathee, Nishant Kumar, Mayank Rathee #define OT_H__ #include "utils/emp-tool.h" namespace sci { -template<typename T> -class OT { +template <typename T> class OT { public: - void send(const block128* data0, const block128* data1, int length) { - static_cast<T*>(this)->send_impl(data0, data1, length); - } - void recv(block128* data, const bool* b, int length) { - static_cast<T*>(this)->recv_impl(data, b, length); - } - void send(const block256* data0, const block256* data1, int length) { - static_cast<T*>(this)->send_impl(data0, data1, length); - } - void recv(block256* data, const bool* b, int length) { - static_cast<T*>(this)->recv_impl(data, b, length); - } - void send(block128** data, int length, int N) { - static_cast<T*>(this)->send_impl(data, length, N); - } - void recv(block128* data, const uint8_t* b, int length, int N) { - static_cast<T*>(this)->recv_impl(data, b, length, N); - } - void send(uint8_t** data, int length, int N, int l) { - static_cast<T*>(this)->send_impl(data, length, N, l); - } - void recv(uint8_t* data, const uint8_t* b, int length, int N, int l) { - static_cast<T*>(this)->recv_impl(data, b, length, N, l); - } - void recv(uint8_t* data, uint8_t* b, int length, int N, int l) { - static_cast<T*>(this)->recv_impl(data, b, length, N, l); - } - void send(uint8_t** data, int length, int l) { - static_cast<T*>(this)->send_impl(data, length, l); - } - void recv(uint8_t* data, const uint8_t* b, int length, int l) { - static_cast<T*>(this)->recv_impl(data, b, length, l); - } - void recv(uint8_t* data, uint8_t* b, int length, int l) { - static_cast<T*>(this)->recv_impl(data, b, length, l); - } - void send(uint64_t** data, int length, int l) { - static_cast<T*>(this)->send_impl(data, length, l); - } - void recv(uint64_t* data, const uint8_t* b, int length, int l) { - static_cast<T*>(this)->recv_impl(data, b, length, l); - } - void recv(uint64_t* data, uint8_t* b, int length, int l) { - static_cast<T*>(this)->recv_impl(data, b, length, l); - } + void send(const block128 *data0, const block128 *data1, int length) { + static_cast<T *>(this)->send_impl(data0, data1, length); + } + void recv(block128 *data, const bool *b, int length) { + static_cast<T *>(this)->recv_impl(data, b, length); + } + void send(const block256 *data0, const block256 *data1, int length) { + static_cast<T *>(this)->send_impl(data0, data1, length); + } + void recv(block256 *data, const bool *b, int length) { + static_cast<T *>(this)->recv_impl(data, b, length); + } + void send(block128 **data, int length, int N) { + static_cast<T *>(this)->send_impl(data, length, N); + } + void recv(block128 *data, const uint8_t *b, int length, int N) { + static_cast<T *>(this)->recv_impl(data, b, length, N); + } + void send(uint8_t **data, int length, int N, int l) { + static_cast<T *>(this)->send_impl(data, length, N, l); + } + void recv(uint8_t *data, const uint8_t *b, int length, int N, int l) { + static_cast<T *>(this)->recv_impl(data, b, length, N, l); + } + void recv(uint8_t *data, uint8_t *b, int length, int N, int l) { + static_cast<T *>(this)->recv_impl(data, b, length, N, l); + } + void send(uint8_t **data, int length, int l) { + static_cast<T *>(this)->send_impl(data, length, l); + } + void recv(uint8_t *data, const uint8_t *b, int length, int l) { + static_cast<T *>(this)->recv_impl(data, b, length, l); + } + void recv(uint8_t *data, uint8_t *b, int length, int l) { + static_cast<T *>(this)->recv_impl(data, b, length, l); + } + void send(uint64_t **data, int length, int l) { + static_cast<T *>(this)->send_impl(data, length, l); + } + void recv(uint64_t *data, const uint8_t *b, int length, int l) { + static_cast<T *>(this)->recv_impl(data, b, length, l); + } + void recv(uint64_t *data, uint8_t *b, int length, int l) { + static_cast<T *>(this)->recv_impl(data, b, length, l); + } - template<typename intType> - void send_cot_matmul(intType* rdata, const intType* corr, const uint32_t* chunkSizes, - const uint32_t* numChunks, const int numOTs, int senderMatmulDims) - { - static_cast<T*>(this)->send_cot_matmul(rdata, corr, chunkSizes, numChunks, numOTs, senderMatmulDims); - } - - template<typename intType> - void recv_cot_matmul(intType* data, const uint8_t* choices, const uint32_t* chunkSizes, - const uint32_t* numChunks, const int numOTs, int senderMatmulDims) - { - static_cast<T*>(this)->recv_cot_matmul(data, choices, chunkSizes, numChunks, numOTs, senderMatmulDims); - } - - void send(uint8_t** data, int length, int N, int l, bool type) { - static_cast<T*>(this)->send_impl(data, length, N, l, type); - } - void recv(uint8_t* data, const uint8_t* b, int length, int N, int l, bool type) { - static_cast<T*>(this)->recv_impl(data, b, length, N, l, type); - } - void recv(uint8_t* data, uint8_t* b, int length, int N, int l, bool type) { - static_cast<T*>(this)->recv_impl(data, b, length, N, l, type); - } - void send(uint8_t** data, int length, int l, bool type) { - static_cast<T*>(this)->send_impl(data, length, l, type); - } - void recv(uint8_t* data, const uint8_t* b, int length, int l, bool type) { - static_cast<T*>(this)->recv_impl(data, b, length, l, type); - } - void recv(uint8_t* data, uint8_t* b, int length, int l, bool type) { - static_cast<T*>(this)->recv_impl(data, b, length, l, type); - } + void send_cot(uint64_t *data0, uint64_t *corr, int length, int l) { + static_cast<T *>(this)->send_cot(data0, corr, length, l); + } + void recv_cot(uint64_t *data, bool *b, int length, int l) { + static_cast<T *>(this)->recv_cot(data, b, length, l); + } + + template <typename intType> + void send_cot_matmul(intType *rdata, const intType *corr, + const uint32_t *chunkSizes, const uint32_t *numChunks, + const int numOTs, int senderMatmulDims) { + static_cast<T *>(this)->send_cot_matmul(rdata, corr, chunkSizes, numChunks, + numOTs, senderMatmulDims); + } + + template <typename intType> + void recv_cot_matmul(intType *data, const uint8_t *choices, + const uint32_t *chunkSizes, const uint32_t *numChunks, + const int numOTs, int senderMatmulDims) { + static_cast<T *>(this)->recv_cot_matmul( + data, choices, chunkSizes, numChunks, numOTs, senderMatmulDims); + } + + void send(uint8_t **data, int length, int N, int l, bool type) { + static_cast<T *>(this)->send_impl(data, length, N, l, type); + } + void recv(uint8_t *data, const uint8_t *b, int length, int N, int l, + bool type) { + static_cast<T *>(this)->recv_impl(data, b, length, N, l, type); + } + void recv(uint8_t *data, uint8_t *b, int length, int N, int l, bool type) { + static_cast<T *>(this)->recv_impl(data, b, length, N, l, type); + } + void send(uint8_t **data, int length, int l, bool type) { + static_cast<T *>(this)->send_impl(data, length, l, type); + } + void recv(uint8_t *data, const uint8_t *b, int length, int l, bool type) { + static_cast<T *>(this)->recv_impl(data, b, length, l, type); + } + void recv(uint8_t *data, uint8_t *b, int length, int l, bool type) { + static_cast<T *>(this)->recv_impl(data, b, length, l, type); + } }; -} -#endif// OT_H__ +} // namespace sci +#endif // OT_H__ diff --git a/SCI/src/OT/ot_pack.h b/SCI/src/OT/ot_pack.h index b6948ee2..ff6b3e38 100644 --- a/SCI/src/OT/ot_pack.h +++ b/SCI/src/OT/ot_pack.h @@ -21,142 +21,122 @@ SOFTWARE. #ifndef OT_PACK_H__ #define OT_PACK_H__ -#include "utils/emp-tool.h" #include "OT/emp-ot.h" +#include "utils/emp-tool.h" -/* - * DISCLAIMER: - * OTPack avoids computing PRG keys for each OT instance by reusing the keys generated - * (through base OTs) for another OT instance. Ideally, the PRGs within OT instances, - * using the same keys, should use mutually exclusive counters for security. However, - * the current implementation does not support this. - */ +#define KKOT_TYPES 8 namespace sci { -template<typename T> -class OTPack { +template <typename T> class OTPack { public: - SplitKKOT<T> *kkot_beta; - SplitKKOT<T> *kkot_4; - SplitKKOT<T> *kkot_16; - SplitKKOT<T> *kkot_8; - // iknp_straight and iknp_reversed: party - // acts as sender in straight and receiver in reversed. - // Needed for MUX calls. - SplitIKNP<T> *iknp_straight; - SplitIKNP<T> *iknp_reversed; - T *io; - int beta, r, l, party; - bool do_setup = false; + SplitKKOT<T> *kkot[KKOT_TYPES]; - OTPack(T* io, int party, int beta, int l, bool do_setup = true){ - this->beta = beta; - this->l = l; - this->r = l%beta; - this->party = party; - this->do_setup = do_setup; - this->io = io; + // iknp_straight and iknp_reversed: party + // acts as sender in straight and receiver in reversed. + // Needed for MUX calls. + SplitIKNP<T> *iknp_straight; + SplitIKNP<T> *iknp_reversed; + T *io; + int party; + bool do_setup = false; - kkot_beta = new SplitKKOT<NetIO>(party, io, 1<<beta); - kkot_4 = new SplitKKOT<NetIO>(party, io, 4); - kkot_16 = new SplitKKOT<NetIO>(party, io, 16); - kkot_8 = new SplitKKOT<NetIO>(party, io, 8); + OTPack(T *io, int party, bool do_setup = true) { + this->party = party; + this->do_setup = do_setup; + this->io = io; - iknp_straight = new SplitIKNP<NetIO>(party, io); - iknp_reversed = new SplitIKNP<NetIO>(3-party, io); + for (int i = 0; i < KKOT_TYPES; i++) { + kkot[i] = new SplitKKOT<NetIO>(party, io, 1 << (i + 1)); + } - if(do_setup){ - SetupBaseOTs(); - } - } - - ~OTPack(){ - delete kkot_beta; - delete kkot_4; - delete kkot_8; - delete kkot_16; - delete iknp_straight; - delete iknp_reversed; - } + iknp_straight = new SplitIKNP<NetIO>(party, io); + iknp_reversed = new SplitIKNP<NetIO>(3 - party, io); - void SetupBaseOTs(){ - switch (party) { - case 1: - kkot_beta->setup_send(); - iknp_straight->setup_send(); - iknp_reversed->setup_recv(); - kkot_4->setup_send(kkot_beta->k0, kkot_beta->s); - kkot_16->setup_send(kkot_beta->k0, kkot_beta->s); - kkot_8->setup_send(kkot_beta->k0, kkot_beta->s); - break; - case 2: - kkot_beta->setup_recv(); - iknp_straight->setup_recv(); - iknp_reversed->setup_send(); - kkot_4->setup_recv(kkot_beta->k0, kkot_beta->k1); - kkot_16->setup_recv(kkot_beta->k0, kkot_beta->k1); - kkot_8->setup_recv(kkot_beta->k0, kkot_beta->k1); - break; + if (do_setup) { + SetupBaseOTs(); } - } + } - OTPack<T>* operator=(OTPack<T> *copy_from){ - assert(this->do_setup == false && copy_from->do_setup == true); - OTPack<T> *temp = new OTPack<T>(this->io, copy_from->party, copy_from->beta, copy_from->l, false); - SplitKKOT<T> *kkot_base = copy_from->kkot_beta; - SplitIKNP<T> *iknp_s_base = copy_from->iknp_straight; - SplitIKNP<T> *iknp_r_base = copy_from->iknp_reversed; + ~OTPack() { + for (int i = 0; i < KKOT_TYPES; i++) + delete kkot[i]; + delete iknp_straight; + delete iknp_reversed; + } - switch (party) { - case 1: - temp->kkot_beta->setup_send(kkot_base->k0, kkot_base->s); - temp->iknp_straight->setup_send(iknp_s_base->k0, iknp_s_base->s); - temp->iknp_reversed->setup_recv(iknp_r_base->k0, iknp_r_base->k1); - temp->kkot_4->setup_send(temp->kkot_beta->k0, temp->kkot_beta->s); - temp->kkot_16->setup_send(temp->kkot_beta->k0, temp->kkot_beta->s); - temp->kkot_8->setup_send(temp->kkot_beta->k0, temp->kkot_beta->s); - break; - case 2: - temp->kkot_beta->setup_recv(kkot_base->k0, kkot_base->k1); - temp->iknp_straight->setup_recv(iknp_s_base->k0, iknp_s_base->k1); - temp->iknp_reversed->setup_send(iknp_s_base->k0, iknp_s_base->s); - temp->kkot_4->setup_recv(temp->kkot_beta->k0, temp->kkot_beta->k1); - temp->kkot_16->setup_recv(temp->kkot_beta->k0, temp->kkot_beta->k1); - temp->kkot_8->setup_recv(temp->kkot_beta->k0, temp->kkot_beta->k1); - break; - } - temp->do_setup = true; - return temp; + void SetupBaseOTs() { + switch (party) { + case 1: + kkot[0]->setup_send(); + iknp_straight->setup_send(); + iknp_reversed->setup_recv(); + for (int i = 1; i < KKOT_TYPES; i++) { + kkot[i]->setup_send(kkot[0]->k0, kkot[0]->s); + } + break; + case 2: + kkot[0]->setup_recv(); + iknp_straight->setup_recv(); + iknp_reversed->setup_send(); + for (int i = 1; i < KKOT_TYPES; i++) { + kkot[i]->setup_recv(kkot[0]->k0, kkot[0]->k1); + } + break; } + } - void copy(OTPack<T> *copy_from){ - assert(this->do_setup == false && copy_from->do_setup == true); - SplitKKOT<T> *kkot_base = copy_from->kkot_beta; - SplitIKNP<T> *iknp_s_base = copy_from->iknp_straight; - SplitIKNP<T> *iknp_r_base = copy_from->iknp_reversed; + OTPack<T> *operator=(OTPack<T> *copy_from) { + assert(this->do_setup == false && copy_from->do_setup == true); + OTPack<T> *temp = new OTPack<T>(this->io, copy_from->party, false); + SplitKKOT<T> *kkot_base = copy_from->kkot[0]; + SplitIKNP<T> *iknp_s_base = copy_from->iknp_straight; + SplitIKNP<T> *iknp_r_base = copy_from->iknp_reversed; - switch (this->party) { - case 1: - this->kkot_beta->setup_send(kkot_base->k0, kkot_base->s); - this->iknp_straight->setup_send(iknp_s_base->k0, iknp_s_base->s); - this->iknp_reversed->setup_recv(iknp_r_base->k0, iknp_r_base->k1); - this->kkot_4->setup_send(this->kkot_beta->k0, this->kkot_beta->s); - this->kkot_16->setup_send(this->kkot_beta->k0, this->kkot_beta->s); - this->kkot_8->setup_send(this->kkot_beta->k0, this->kkot_beta->s); - break; - case 2: - this->kkot_beta->setup_recv(kkot_base->k0, kkot_base->k1); - this->iknp_straight->setup_recv(iknp_s_base->k0, iknp_s_base->k1); - this->iknp_reversed->setup_send(iknp_r_base->k0, iknp_r_base->s); - this->kkot_4->setup_recv(this->kkot_beta->k0, this->kkot_beta->k1); - this->kkot_16->setup_recv(this->kkot_beta->k0, this->kkot_beta->k1); - this->kkot_8->setup_recv(this->kkot_beta->k0, this->kkot_beta->k1); - break; - } - this->do_setup = true; - return; + switch (party) { + case 1: + for (int i = 0; i < KKOT_TYPES; i++) { + temp->kkot[i]->setup_send(kkot_base->k0, kkot_base->s); + } + temp->iknp_straight->setup_send(iknp_s_base->k0, iknp_s_base->s); + temp->iknp_reversed->setup_recv(iknp_r_base->k0, iknp_r_base->k1); + break; + case 2: + for (int i = 0; i < KKOT_TYPES; i++) { + temp->kkot[i]->setup_recv(kkot_base->k0, kkot_base->k1); + } + temp->iknp_straight->setup_recv(iknp_s_base->k0, iknp_s_base->k1); + temp->iknp_reversed->setup_send(iknp_s_base->k0, iknp_s_base->s); + break; } + temp->do_setup = true; + return temp; + } + void copy(OTPack<T> *copy_from) { + assert(this->do_setup == false && copy_from->do_setup == true); + SplitKKOT<T> *kkot_base = copy_from->kkot[0]; + SplitIKNP<T> *iknp_s_base = copy_from->iknp_straight; + SplitIKNP<T> *iknp_r_base = copy_from->iknp_reversed; + + switch (this->party) { + case 1: + for (int i = 0; i < KKOT_TYPES; i++) { + this->kkot[i]->setup_send(kkot_base->k0, kkot_base->s); + } + this->iknp_straight->setup_send(iknp_s_base->k0, iknp_s_base->s); + this->iknp_reversed->setup_recv(iknp_r_base->k0, iknp_r_base->k1); + break; + case 2: + for (int i = 0; i < KKOT_TYPES; i++) { + this->kkot[i]->setup_recv(kkot_base->k0, kkot_base->k1); + } + this->iknp_straight->setup_recv(iknp_s_base->k0, iknp_s_base->k1); + this->iknp_reversed->setup_send(iknp_r_base->k0, iknp_r_base->s); + break; + } + this->do_setup = true; + return; + } }; -} +} // namespace sci #endif // OT_PACK_H__ diff --git a/SCI/src/OT/split-iknp.h b/SCI/src/OT/split-iknp.h index 0a15cb1c..da00b87d 100644 --- a/SCI/src/OT/split-iknp.h +++ b/SCI/src/OT/split-iknp.h @@ -1,5 +1,5 @@ /* -Authors: Mayank Rathee +Authors: Mayank Rathee, Deevashwer Rathee Copyright: Copyright (c) 2020 Microsoft Research Permission is hereby granted, free of charge, to any person obtaining a copy @@ -25,737 +25,999 @@ SOFTWARE. // In split functions, OT is split // into offline and online phase. -#include "OT/ot.h" #include "OT/np.h" -#include "split-utils.h" #include "OT/ot-utils.h" +#include "OT/ot.h" +#include "split-utils.h" namespace sci { -template<typename IO> -class SplitIKNP : public OT<SplitIKNP<IO>> -{ +template <typename IO> class SplitIKNP : public OT<SplitIKNP<IO>> { public: - OTNP<IO> * base_ot; - PRG128 prg; - int party; - const int lambda = 128; - int block_size = 1024*16; - - // This specifies how much OTs to preprocess in one go. - // 0 means no preprocessing and all everything will be - // run in the online phase. - int precomp_batch_size = 0; - // counter denotes the number of pre-generated OTs used - int counter = precomp_batch_size; - int l; - - block128 *k0 = nullptr, *k1 = nullptr, - * qT = nullptr, *tT = nullptr, *tmp = nullptr, block_s; - PRG128 *G0, *G1; - bool *s = nullptr, * extended_r = nullptr, setup = false; - IO *io = nullptr; - CRH crh; - - // h holds the precomputed hashes which can be used directly in the online phase by xoring - // with the respective OT messages. - uint8_t **h; - uint64_t **h64; - - // r_off is the choice input set used for the offline random OT. - // This is corrected in the online phase when actual choice_input comes. - uint8_t *r_off; - int N = 2; - SplitIKNP( - int party, IO * io) - { - assert(party == ALICE || party == BOB); - this->party = party; - this->io = io; - base_ot = new OTNP<IO>(io); - s = new bool[lambda]; - k0 = new block128[lambda]; - k1 = new block128[lambda]; - switch (party) { - case ALICE: { - h = new uint8_t*[N]; - h64 = new uint64_t*[N]; - for (int i = 0; i < N; i++){ - h[i] = new uint8_t[precomp_batch_size]; - h64[i] = new uint64_t[precomp_batch_size]; - } - break; - } - case BOB: { - h = new uint8_t*[1]; - h64 = new uint64_t*[1]; - r_off = new uint8_t[precomp_batch_size]; - for (int i = 0; i < 1; i++){ - h[i] = new uint8_t[precomp_batch_size]; - h64[i] = new uint64_t[precomp_batch_size]; - } - break; - } - } - G0 = new PRG128[lambda]; - G1 = new PRG128[lambda]; - tmp = new block128[block_size/128]; - extended_r = new bool[block_size]; - } - - ~SplitIKNP() - { - delete base_ot; - delete[] s; - delete[] k0; - delete[] k1; - switch (party) { - case ALICE: { - for(int i = 0; i < N; i++){ - delete[] h[i]; - delete[] h64[i]; - } - delete[] h; - delete[] h64; - break; - } - case BOB:{ - delete[] h[0]; - delete[] h; - delete[] h64[0]; - delete[] h64; - delete[] r_off; - break; - } - } - delete[] G0; - delete[] G1; - delete[] tmp; - delete[] extended_r; - } - - void set_precomp_batch_size( - int batch_size) - { - this->precomp_batch_size = batch_size; - this->counter = batch_size; - switch (party) { - case ALICE: { - for(int i = 0; i < N; i++){ - delete[] h[i]; - delete[] h64[i]; - } - delete[] h; - delete[] h64; - break; - } - case BOB:{ - delete[] h[0]; - delete[] h; - delete[] h64[0]; - delete[] h64; - delete[] r_off; - break; - } - } - switch (party) { - case ALICE: - h = new uint8_t*[N]; - h64 = new uint64_t*[N]; - for (int i = 0; i < N; i++){ - h[i] = new uint8_t[precomp_batch_size]; - h64[i] = new uint64_t[precomp_batch_size]; - } - break; - case BOB: - h = new uint8_t*[1]; - h64 = new uint64_t*[1]; - r_off = new uint8_t[precomp_batch_size]; - for (int i = 0; i < 1; i++){ - h[i] = new uint8_t[precomp_batch_size]; - h64[i] = new uint64_t[precomp_batch_size]; - } - break; - } - } - - void setup_send( - block128 * in_k0 = nullptr, - bool * in_s = nullptr) - { - setup = true; - if(in_s != nullptr) { - memcpy(k0, in_k0, lambda*sizeof(block128)); - memcpy(s, in_s, lambda); - block_s = bool_to128(s); - } else { - prg.random_bool(s, lambda); - base_ot->recv(k0, s, lambda); - block_s = bool_to128(s); - } - for(int i = 0; i < lambda; ++i) - G0[i].reseed(&k0[i]); - } - - void setup_recv( - block128 * in_k0 = nullptr, - block128 * in_k1 =nullptr) - { - setup = true; - if(in_k0 !=nullptr) { - memcpy(k0, in_k0, lambda*sizeof(block128)); - memcpy(k1, in_k1, lambda*sizeof(block128)); - } else { - prg.random_block(k0, lambda); - prg.random_block(k1, lambda); - base_ot->send(k0, k1, lambda); - } - for(int i = 0; i < lambda; ++i) { - G0[i].reseed(&k0[i]); - G1[i].reseed(&k1[i]); - } - } - - int padded_length( - int length) - { - return ((length + block_size - 1) / block_size) * block_size; - } - - void send_pre( - int length) - { - length = padded_length(length); - block128 q[block_size]; - qT = new block128[length]; - if(!setup) setup_send(); - - for (int j = 0; j < length/block_size; ++j) { - for(int i = 0; i < lambda; ++i) { - G0[i].random_data(q+(i*block_size/128), block_size/8); - io->recv_data(tmp, block_size/8); - if (s[i]) - xorBlocks_arr(q+(i*block_size/128), q+(i*block_size/128), tmp, block_size/128); - } - sse_trans((uint8_t *)(qT+j*block_size), (uint8_t*)q, 128, block_size); - } - } - - void recv_pre( - bool* r, - int length) - { - int old_length = length; - length = padded_length(length); - block128 t[block_size]; - tT = new block128[length]; - - if(not setup) setup_recv(); - - bool * r2 = new bool[length]; - prg.random_bool(extended_r, block_size); - memcpy(r2, r, old_length); - memcpy(r2+old_length, extended_r, length - old_length); - - block128 *block_r = new block128[length/128]; - for(int i = 0; i < length/128; ++i) { - block_r[i] = bool_to128(r2+i*128); - } - - for (int j = 0; j * block_size < length; ++j) { - for(int i = 0; i < lambda; ++i) { - G0[i].random_data(t+(i*block_size/128), block_size/8); - G1[i].random_data(tmp, block_size/8); - xorBlocks_arr(tmp, t+(i*block_size/128), tmp, block_size/128); - xorBlocks_arr(tmp, block_r+(j*block_size/128), tmp, block_size/128); - io->send_data(tmp, block_size/8); - } - sse_trans((uint8_t *)(tT+j*block_size), (uint8_t*)t, 128, block_size); - } - - delete[] block_r; - delete[] r2; - } - - /********************************************************* - * Online Offline GOT functions * - ********************************************************/ - - void preprocess() - { - switch (party) { - case ALICE: { - send_pre(counter); - got_send_offline(counter); - break; - } - case BOB: { - prg.random_data(r_off, counter); - uint8_t mask = N - 1; // N is a power of 2 - for (int i = 0; i < counter; i++) { - r_off[i] &= mask; - } - recv_pre((bool*)r_off, counter); - got_recv_offline(counter); - break; - } - } - counter = 0; - } - - void got_send_offline( - int length) - { - const int bsize = AES_BATCH_SIZE; - block128* pad = new block128[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - crh.H<2*bsize>(pad, pad); - for(int j = i; j < i+bsize and j < length; ++j) { - h64[0][j] = ((uint64_t)_mm_extract_epi64(pad[2*(j-i)], 0)); - h[0][j] = ((uint8_t)_mm_extract_epi8(pad[2*(j-i)], 0)); - h64[1][j] = ((uint64_t)_mm_extract_epi64(pad[2*(j-i) + 1], 0)); - h[1][j] = ((uint8_t)_mm_extract_epi8(pad[2*(j-i) + 1], 0)); - } - } - delete[] qT; - delete[] pad; - } - - void got_recv_offline( - int length) - { - const int bsize = AES_BATCH_SIZE; - block128* pad = new block128[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - if (bsize <= length-i) crh.H<bsize>(pad, tT+i); - else crh.Hn(pad, tT+i, length-i); - for(int j = 0; j < bsize and j < length-i; ++j) { - h64[0][i+j] = ((uint64_t)_mm_extract_epi64(pad[j], 0)); - h[0][i+j] = ((uint8_t)_mm_extract_epi8(pad[j], 0)); - } - } - delete[] tT; - delete[] pad; - - } - - template <typename T> - void got_send_online( - T** data, - int length) - { - const int bsize = AES_BATCH_SIZE/2; - int bits_in_sel_input = 1; - uint32_t y_size = (uint32_t)ceil((2*bsize*this->l)/((float)sizeof(T)*8)); - uint32_t a_size = (uint32_t)ceil((bsize*bits_in_sel_input)/((float)sizeof(uint8_t)*8)); - uint32_t corrected_bsize, corrected_y_size, corrected_a_size;; - T y[y_size]; - uint8_t a_packed[a_size]; - uint8_t a[length]; - T **maskeddata = new T*[bsize]; - for(int i=0; i<bsize; i++){ - maskeddata[i] = new T[2]; - } - for(int ctr=0; ctr<length; ctr+=bsize){ - corrected_bsize = std::min(bsize, length-ctr); - corrected_y_size = (uint32_t)ceil((N*corrected_bsize*l)/((float)sizeof(T)*8)); - corrected_a_size = (uint32_t)ceil((corrected_bsize*bits_in_sel_input)/((float)sizeof(uint8_t)*8)); - // Receive correction of choice input - io->recv_data(a_packed, sizeof(uint8_t)*corrected_a_size); - unpack_a<uint8_t>(a, a_packed, corrected_bsize, bits_in_sel_input); - - for(int i=0; i<corrected_bsize; i++){ - for(int k=0; k<2; k++){ - if(sizeof(T) == 8){ - maskeddata[i][k] = (h64[k ^ a[i]][counter] ^ data[ctr+i][k]); - } - else if(sizeof(T) == 1){ - maskeddata[i][k] = (h[k ^ a[i]][counter] ^ data[ctr+i][k]); - } - else{ - throw std::invalid_argument("Not implemented"); - } - } - counter++; - } - pack_messages<T>(y, maskeddata, corrected_y_size, corrected_bsize, l, 2); - io->send_data(y, sizeof(T)*corrected_y_size); - } - for(int i=0; i<bsize; i++){ - delete[] maskeddata[i]; - } - delete[] maskeddata; - } - - template <typename T> - void got_recv_online( - T* data, - const uint8_t* r, - int length) - { - const int bsize = AES_BATCH_SIZE/2; - int bits_in_sel_input = 1; - uint32_t res_size = (uint32_t)ceil((2*bsize*this->l)/((float)sizeof(T)*8)); - uint32_t a_size = (uint32_t)ceil((bsize*bits_in_sel_input)/((float)sizeof(uint8_t)*8)); - uint32_t corrected_bsize, corrected_res_size, corrected_a_size;; - T res[res_size]; - uint8_t a_unpacked[length]; - uint8_t a[a_size]; - for(int ctr=0; ctr<length; ctr+=bsize){ - corrected_bsize = std::min(bsize, length-ctr); - corrected_res_size = (uint32_t)ceil((N*corrected_bsize*l)/((float)sizeof(T)*8)); - corrected_a_size = (uint32_t)ceil((corrected_bsize*bits_in_sel_input)/((float)sizeof(uint8_t)*8)); - - int counter_memory = counter; - // Send corrected choice inputs - for(int i=0; i<corrected_bsize; i++){ - a_unpacked[i] = r_off[counter++] ^ r[ctr+i]; - } - pack_a<uint8_t>(a, a_unpacked, corrected_a_size, corrected_bsize, bits_in_sel_input); - io->send_data(a, sizeof(uint8_t)*corrected_a_size); - counter = counter_memory; - // Receive OT messages - io->recv_data(res, sizeof(T)*corrected_res_size); - if(sizeof(T) == 8){ - unpack_messages<uint64_t>((uint64_t*)data+ctr, r+ctr, (uint64_t*)res, h64[0], corrected_bsize, l, 2, counter); - } - else if(sizeof(T) == 1){ - unpack_messages<uint8_t>((uint8_t*)data+ctr, r+ctr, (uint8_t*)res, h[0], corrected_bsize, l, 2, counter); - } - else{ - throw std::invalid_argument("Not implemented"); - } - } - } - - - /********************************************************* - * Normal GOT functions * - ********************************************************/ - - void got_send_post( - const block128* data0, - const block128* data1, - int length) - { - const int bsize = AES_BATCH_SIZE/2; - block128 pad[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - crh.H<2*bsize>(pad, pad); - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = xorBlocks(pad[2*(j-i)], data0[j]); - pad[2*(j-i)+1] = xorBlocks(pad[2*(j-i)+1], data1[j]); - } - io->send_data(pad, 2*sizeof(block128)*std::min(bsize,length-i)); - } - delete[] qT; - } - - void got_recv_post( - block128* data, - const bool* r, - int length) - { - const int bsize = AES_BATCH_SIZE; - block128 res[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - io->recv_data(res, 2*sizeof(block128)*std::min(bsize,length-i)); - if (bsize <= length-i) crh.H<bsize>(tT+i, tT+i); - else crh.Hn(tT+i, tT+i, length-i); - for(int j = 0; j < bsize and j < length-i; ++j) { - data[i+j] = xorBlocks(res[2*j+r[i+j]], tT[i+j]); - } - } - delete[] tT; - } - - template <typename T> - void got_send_post( - T** data, - int length) - { - const int bsize = AES_BATCH_SIZE/2; - block128 pad[2*bsize]; - uint32_t y_size = (uint32_t)ceil((2*bsize*this->l)/((float)sizeof(T)*8)); - uint32_t corrected_y_size, corrected_bsize; - T y[y_size]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - crh.H<2*bsize>(pad, pad); - corrected_y_size = (uint32_t)ceil((2*std::min(bsize, length-i)*this->l)/((float)sizeof(T)*8)); - corrected_bsize = std::min(bsize, length-i); - if(sizeof(T) == 8){ - pack_ot_messages<uint64_t>((uint64_t*)y, (uint64_t**)data+i, pad, corrected_y_size, corrected_bsize, this->l, 2); - } - else if(sizeof(T) == 1){ - pack_ot_messages<uint8_t>((uint8_t*)y, (uint8_t**)data+i, pad, corrected_y_size, corrected_bsize, this->l, 2); - } - else{ - throw std::invalid_argument("Not implemented"); - } - io->send_data(y, sizeof(T)*(corrected_y_size)); - } - delete[] qT; - } - - template <typename T> - void got_recv_post( - T* data, - const uint8_t* r, - int length) - { - const int bsize = AES_BATCH_SIZE; - uint32_t recvd_size = (uint32_t)ceil((2*bsize*this->l)/((float)sizeof(T)*8)); - uint32_t corrected_recvd_size, corrected_bsize; - uint64_t recvd[recvd_size]; - - for(int i = 0; i < length; i+=bsize) { - corrected_recvd_size = (uint32_t)ceil((2*std::min(bsize, length-i)*this->l)/((float)sizeof(T)*8)); - corrected_bsize = std::min(bsize, length-i); - io->recv_data(recvd, sizeof(T)*(corrected_recvd_size)); - if (bsize <= length-i) crh.H<bsize>(tT+i, tT+i); - else crh.Hn(tT+i, tT+i, length-i); - if(sizeof(T) == 8){ - unpack_ot_messages<uint64_t>((uint64_t*)data+i, r+i, (uint64_t*)recvd, tT+i, corrected_bsize, this->l, 2); - } - else if(sizeof(T) == 1){ - unpack_ot_messages<uint8_t>((uint8_t*)data+i, r+i, (uint8_t*)recvd, tT+i, corrected_bsize, this->l, 2); - } - else{ - throw std::invalid_argument("Not implemented"); - } - } - delete[] tT; - } - - /********************************************************* - * COT functions * - ********************************************************/ - - void cot_send_post( - block128* data0, - block128 delta, - int length) - { - const int bsize = AES_BATCH_SIZE/2; - block128 pad[2*bsize]; - block128 tmp[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - crh.H<2*bsize>(pad, pad); - for(int j = i; j < i+bsize and j < length; ++j) { - data0[j] = pad[2*(j-i)]; - pad[2*(j-i)] = xorBlocks(pad[2*(j-i)], delta); - tmp[j-i] = xorBlocks(pad[2*(j-i)+1], pad[2*(j-i)]); - } - io->send_data(tmp, sizeof(block128)*std::min(bsize,length-i)); - } - delete[] qT; - } - - void cot_recv_post( - block128* data, - const bool* r, - int length) - { - const int bsize = AES_BATCH_SIZE; - block128 res[bsize]; - for(int i = 0; i < length; i+=bsize) { - io->recv_data(res, sizeof(block128)*std::min(bsize,length-i)); - if (bsize <= length-i) crh.H<bsize>(data+i, tT+i); - else crh.Hn(data+i, tT+i, length-i); - for(int j = 0; j < bsize and j < length-i; ++j) { - if(r[i+j]) data[i+j] = xorBlocks(res[j], data[i+j]); - } - } - delete[] tT; - } - - /********************************************************* - * ROT functions * - ********************************************************/ - - void rot_send_post( - block128* data0, - block128* data1, - int length) - { - const int bsize = AES_BATCH_SIZE/2; - block128 pad[2*bsize]; - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - pad[2*(j-i)] = qT[j]; - pad[2*(j-i)+1] = xorBlocks(qT[j], block_s); - } - crh.H<2*bsize>(pad, pad); - for(int j = i; j < i+bsize and j < length; ++j) { - data0[j] = pad[2*(j-i)]; - data1[j] = pad[2*(j-i)+1]; - } - } - delete[] qT; - } - - void rot_recv_post( - block128* data, - const bool* r, - int length) - { - const int bsize = AES_BATCH_SIZE; - for(int i = 0; i < length; i+=bsize) { - if (bsize <= length-i) crh.H<bsize>(data+i, tT+i); - else crh.Hn(data+i, tT+i, length-i); - } - delete[] tT; - } - - /********************************************************* - * Send/Recv wrapper functions * - ********************************************************/ - - void send_impl( - const block128* data0, - const block128* data1, - int length) - { - send_pre(length); - got_send_post(data0, data1, length); - } - - void recv_impl( - block128* data, - const bool* b, - int length) - { - recv_pre((bool*)b, length); - got_recv_post(data, b, length); - } - - void send_impl( - uint64_t** data, - int length, - int l) - { - this->l = l; - if (length <= precomp_batch_size) { - if (length > (precomp_batch_size - counter)) { - preprocess(); - } - got_send_online<uint64_t>(data, length); - } - else { - send_pre(length); - got_send_post<uint64_t>(data, length); - } - } - - void recv_impl( - uint64_t* data, - uint8_t* b, - int length, - int l) - { - this->l = l; - if (length <= precomp_batch_size) { - if (length > (precomp_batch_size - counter)) { - preprocess(); - } - got_recv_online<uint64_t>(data, b, length); - } - else { - recv_pre((bool*)b, length); - got_recv_post<uint64_t>(data, b, length); - } - } - - void send_impl( - uint8_t** data, - int length, - int l) - { - assert(l <= 8 && l >= 1); - this->l = l; - if (length <= precomp_batch_size) { - if (length > (precomp_batch_size - counter)) { - preprocess(); - } - got_send_online<uint8_t>(data, length); - } - else { - send_pre(length); - got_send_post<uint8_t>(data, length); - } - } - - void recv_impl( - uint8_t* data, - uint8_t* b, - int length, - int l) - { - assert(l <= 8 && l >= 1); - this->l = l; - if (length <= precomp_batch_size) { - if (length > (precomp_batch_size - counter)) { - preprocess(); - } - got_recv_online<uint8_t>(data, b, length); - } - else { - recv_pre((bool*)b, length); - got_recv_post<uint8_t>(data, b, length); - } - } - - void send_cot( - block128 * data0, - block128 delta, - int length) - { - send_pre(length); - cot_send_post(data0, delta, length); - } - - void recv_cot( - block128* data, - const bool* b, - int length) - { - recv_pre(b, length); - cot_recv_post(data, b, length); - } - - void send_rot( - block128 * data0, - block128 * data1, - int length) - { - send_pre(length); - rot_send_post(data0, data1, length); - } - - void recv_rot( - block128* data, - const bool* b, - int length) - { - recv_pre(b, length); - rot_recv_post(data, b, length); - } - + OTNP<IO> *base_ot; + PRG128 prg; + int party; + const int lambda = 128; + int block_size = 1024 * 16; + + // This specifies how much OTs to preprocess in one go. + // 0 means no preprocessing and all everything will be + // run in the online phase. + int precomp_batch_size = 0; + // counter denotes the number of pre-generated OTs used + int counter = precomp_batch_size; + int l; + + block128 *k0 = nullptr, *k1 = nullptr, *qT = nullptr, *tT = nullptr, + *tmp = nullptr, block_s; + PRG128 *G0, *G1; + bool *s = nullptr, *extended_r = nullptr, setup = false; + IO *io = nullptr; + CRH crh; + + // h holds the precomputed hashes which can be used directly in the online + // phase by xoring with the respective OT messages. + uint8_t **h; + uint64_t **h64; + + // r_off is the choice input set used for the offline random OT. + // This is corrected in the online phase when actual choice_input comes. + uint8_t *r_off; + int N = 2; + SplitIKNP(int party, IO *io) { + assert(party == ALICE || party == BOB); + this->party = party; + this->io = io; + base_ot = new OTNP<IO>(io); + s = new bool[lambda]; + k0 = new block128[lambda]; + k1 = new block128[lambda]; + switch (party) { + case ALICE: { + h = new uint8_t *[N]; + h64 = new uint64_t *[N]; + for (int i = 0; i < N; i++) { + h[i] = new uint8_t[precomp_batch_size]; + h64[i] = new uint64_t[precomp_batch_size]; + } + break; + } + case BOB: { + h = new uint8_t *[1]; + h64 = new uint64_t *[1]; + r_off = new uint8_t[precomp_batch_size]; + for (int i = 0; i < 1; i++) { + h[i] = new uint8_t[precomp_batch_size]; + h64[i] = new uint64_t[precomp_batch_size]; + } + break; + } + } + G0 = new PRG128[lambda]; + G1 = new PRG128[lambda]; + tmp = new block128[block_size / 128]; + extended_r = new bool[block_size]; + } + + ~SplitIKNP() { + delete base_ot; + delete[] s; + delete[] k0; + delete[] k1; + switch (party) { + case ALICE: { + for (int i = 0; i < N; i++) { + delete[] h[i]; + delete[] h64[i]; + } + delete[] h; + delete[] h64; + break; + } + case BOB: { + delete[] h[0]; + delete[] h; + delete[] h64[0]; + delete[] h64; + delete[] r_off; + break; + } + } + delete[] G0; + delete[] G1; + delete[] tmp; + delete[] extended_r; + } + + void set_precomp_batch_size(int batch_size) { + this->precomp_batch_size = batch_size; + this->counter = batch_size; + switch (party) { + case ALICE: { + for (int i = 0; i < N; i++) { + delete[] h[i]; + delete[] h64[i]; + } + delete[] h; + delete[] h64; + break; + } + case BOB: { + delete[] h[0]; + delete[] h; + delete[] h64[0]; + delete[] h64; + delete[] r_off; + break; + } + } + switch (party) { + case ALICE: + h = new uint8_t *[N]; + h64 = new uint64_t *[N]; + for (int i = 0; i < N; i++) { + h[i] = new uint8_t[precomp_batch_size]; + h64[i] = new uint64_t[precomp_batch_size]; + } + break; + case BOB: + h = new uint8_t *[1]; + h64 = new uint64_t *[1]; + r_off = new uint8_t[precomp_batch_size]; + for (int i = 0; i < 1; i++) { + h[i] = new uint8_t[precomp_batch_size]; + h64[i] = new uint64_t[precomp_batch_size]; + } + break; + } + } + + void setup_send(block128 *in_k0 = nullptr, bool *in_s = nullptr) { + setup = true; + if (in_s != nullptr) { + memcpy(k0, in_k0, lambda * sizeof(block128)); + memcpy(s, in_s, lambda); + block_s = bool_to128(s); + } else { + prg.random_bool(s, lambda); + base_ot->recv(k0, s, lambda); + block_s = bool_to128(s); + } + for (int i = 0; i < lambda; ++i) + G0[i].reseed(&k0[i]); + } + + void setup_recv(block128 *in_k0 = nullptr, block128 *in_k1 = nullptr) { + setup = true; + if (in_k0 != nullptr) { + memcpy(k0, in_k0, lambda * sizeof(block128)); + memcpy(k1, in_k1, lambda * sizeof(block128)); + } else { + prg.random_block(k0, lambda); + prg.random_block(k1, lambda); + base_ot->send(k0, k1, lambda); + } + for (int i = 0; i < lambda; ++i) { + G0[i].reseed(&k0[i]); + G1[i].reseed(&k1[i]); + } + } + + int padded_length(int length) { + return ((length + block_size - 1) / block_size) * block_size; + } + + void send_pre(int length) { + int old_block_size = this->block_size; + this->block_size = + std::min(old_block_size, int(ceil(length / 256.0)) * 256); + length = padded_length(length); + block128 q[block_size]; + qT = new block128[length]; + if (!setup) + setup_send(); + + for (int j = 0; j < length / block_size; ++j) { + for (int i = 0; i < lambda; ++i) { + G0[i].random_data(q + (i * block_size / 128), block_size / 8); + io->recv_data(tmp, block_size / 8); + if (s[i]) + xorBlocks_arr(q + (i * block_size / 128), q + (i * block_size / 128), + tmp, block_size / 128); + } + sse_trans((uint8_t *)(qT + j * block_size), (uint8_t *)q, 128, + block_size); + } + this->block_size = old_block_size; + } + + void recv_pre(bool *r, int length) { + int old_block_size = this->block_size; + this->block_size = + std::min(old_block_size, int(ceil(length / 256.0)) * 256); + int old_length = length; + length = padded_length(length); + block128 t[block_size]; + tT = new block128[length]; + + if (not setup) + setup_recv(); + + bool *r2 = new bool[length]; + prg.random_bool(extended_r, block_size); + memcpy(r2, r, old_length); + memcpy(r2 + old_length, extended_r, length - old_length); + + block128 *block_r = new block128[length / 128]; + for (int i = 0; i < length / 128; ++i) { + block_r[i] = bool_to128(r2 + i * 128); + } + + for (int j = 0; j * block_size < length; ++j) { + for (int i = 0; i < lambda; ++i) { + G0[i].random_data(t + (i * block_size / 128), block_size / 8); + G1[i].random_data(tmp, block_size / 8); + xorBlocks_arr(tmp, t + (i * block_size / 128), tmp, block_size / 128); + xorBlocks_arr(tmp, block_r + (j * block_size / 128), tmp, + block_size / 128); + io->send_data(tmp, block_size / 8); + } + sse_trans((uint8_t *)(tT + j * block_size), (uint8_t *)t, 128, + block_size); + } + + delete[] block_r; + delete[] r2; + + this->block_size = old_block_size; + } + + /********************************************************* + * Online Offline GOT functions * + ********************************************************/ + + void preprocess() { + switch (party) { + case ALICE: { + send_pre(counter); + got_send_offline(counter); + break; + } + case BOB: { + prg.random_data(r_off, counter); + uint8_t mask = N - 1; // N is a power of 2 + for (int i = 0; i < counter; i++) { + r_off[i] &= mask; + } + recv_pre((bool *)r_off, counter); + got_recv_offline(counter); + break; + } + } + counter = 0; + } + + void got_send_offline(int length) { + const int bsize = AES_BATCH_SIZE; + block128 *pad = new block128[2 * bsize]; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = qT[j]; + pad[2 * (j - i) + 1] = xorBlocks(qT[j], block_s); + } + crh.H<2 * bsize>(pad, pad); + for (int j = i; j < i + bsize and j < length; ++j) { + h64[0][j] = ((uint64_t)_mm_extract_epi64(pad[2 * (j - i)], 0)); + h[0][j] = ((uint8_t)_mm_extract_epi8(pad[2 * (j - i)], 0)); + h64[1][j] = ((uint64_t)_mm_extract_epi64(pad[2 * (j - i) + 1], 0)); + h[1][j] = ((uint8_t)_mm_extract_epi8(pad[2 * (j - i) + 1], 0)); + } + } + delete[] qT; + delete[] pad; + } + + void got_recv_offline(int length) { + const int bsize = AES_BATCH_SIZE; + block128 *pad = new block128[2 * bsize]; + for (int i = 0; i < length; i += bsize) { + if (bsize <= length - i) + crh.H<bsize>(pad, tT + i); + else + crh.Hn(pad, tT + i, length - i); + for (int j = 0; j < bsize and j < length - i; ++j) { + h64[0][i + j] = ((uint64_t)_mm_extract_epi64(pad[j], 0)); + h[0][i + j] = ((uint8_t)_mm_extract_epi8(pad[j], 0)); + } + } + delete[] tT; + delete[] pad; + } + + template <typename T> void got_send_online(T **data, int length) { + const int bsize = AES_BATCH_SIZE / 2; + int bits_in_sel_input = 1; + uint32_t y_size = + (uint32_t)ceil((2 * bsize * this->l) / ((float)sizeof(T) * 8)); + uint32_t a_size = (uint32_t)ceil((bsize * bits_in_sel_input) / + ((float)sizeof(uint8_t) * 8)); + uint32_t corrected_bsize, corrected_y_size, corrected_a_size; + ; + T y[y_size]; + uint8_t a_packed[a_size]; + uint8_t a[length]; + T **maskeddata = new T *[bsize]; + for (int i = 0; i < bsize; i++) { + maskeddata[i] = new T[2]; + } + for (int ctr = 0; ctr < length; ctr += bsize) { + corrected_bsize = std::min(bsize, length - ctr); + corrected_y_size = + (uint32_t)ceil((N * corrected_bsize * l) / ((float)sizeof(T) * 8)); + corrected_a_size = (uint32_t)ceil((corrected_bsize * bits_in_sel_input) / + ((float)sizeof(uint8_t) * 8)); + // Receive correction of choice input + io->recv_data(a_packed, sizeof(uint8_t) * corrected_a_size); + unpack_a<uint8_t>(a, a_packed, corrected_bsize, bits_in_sel_input); + + for (uint32_t i = 0; i < corrected_bsize; i++) { + for (int k = 0; k < 2; k++) { + if (sizeof(T) == 8) { + maskeddata[i][k] = (h64[k ^ a[i]][counter] ^ data[ctr + i][k]); + } else if (sizeof(T) == 1) { + maskeddata[i][k] = (h[k ^ a[i]][counter] ^ data[ctr + i][k]); + } else { + throw std::invalid_argument("Not implemented"); + } + } + counter++; + } + pack_messages<T>(y, maskeddata, corrected_y_size, corrected_bsize, l, 2); + io->send_data(y, sizeof(T) * corrected_y_size); + } + for (int i = 0; i < bsize; i++) { + delete[] maskeddata[i]; + } + delete[] maskeddata; + } + + template <typename T> + void got_recv_online(T *data, const uint8_t *r, int length) { + const int bsize = AES_BATCH_SIZE / 2; + int bits_in_sel_input = 1; + uint32_t res_size = + (uint32_t)ceil((2 * bsize * this->l) / ((float)sizeof(T) * 8)); + uint32_t a_size = (uint32_t)ceil((bsize * bits_in_sel_input) / + ((float)sizeof(uint8_t) * 8)); + uint32_t corrected_bsize, corrected_res_size, corrected_a_size; + ; + T res[res_size]; + uint8_t a_unpacked[length]; + uint8_t a[a_size]; + for (int ctr = 0; ctr < length; ctr += bsize) { + corrected_bsize = std::min(bsize, length - ctr); + corrected_res_size = + (uint32_t)ceil((N * corrected_bsize * l) / ((float)sizeof(T) * 8)); + corrected_a_size = (uint32_t)ceil((corrected_bsize * bits_in_sel_input) / + ((float)sizeof(uint8_t) * 8)); + + int counter_memory = counter; + // Send corrected choice inputs + for (uint32_t i = 0; i < corrected_bsize; i++) { + a_unpacked[i] = r_off[counter++] ^ r[ctr + i]; + } + pack_a<uint8_t>(a, a_unpacked, corrected_a_size, corrected_bsize, + bits_in_sel_input); + io->send_data(a, sizeof(uint8_t) * corrected_a_size); + counter = counter_memory; + // Receive OT messages + io->recv_data(res, sizeof(T) * corrected_res_size); + if (sizeof(T) == 8) { + unpack_messages<uint64_t>((uint64_t *)data + ctr, r + ctr, + (uint64_t *)res, h64[0], corrected_bsize, l, + 2, counter); + } else if (sizeof(T) == 1) { + unpack_messages<uint8_t>((uint8_t *)data + ctr, r + ctr, (uint8_t *)res, + h[0], corrected_bsize, l, 2, counter); + } else { + throw std::invalid_argument("Not implemented"); + } + } + } + + /********************************************************* + * Normal GOT functions * + ********************************************************/ + + void got_send_post(const block128 *data0, const block128 *data1, int length) { + const int bsize = AES_BATCH_SIZE / 2; + block128 pad[2 * bsize]; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = qT[j]; + pad[2 * (j - i) + 1] = xorBlocks(qT[j], block_s); + } + crh.H<2 * bsize>(pad, pad); + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = xorBlocks(pad[2 * (j - i)], data0[j]); + pad[2 * (j - i) + 1] = xorBlocks(pad[2 * (j - i) + 1], data1[j]); + } + io->send_data(pad, 2 * sizeof(block128) * std::min(bsize, length - i)); + } + delete[] qT; + } + + void got_recv_post(block128 *data, const bool *r, int length) { + const int bsize = AES_BATCH_SIZE; + block128 res[2 * bsize]; + for (int i = 0; i < length; i += bsize) { + io->recv_data(res, 2 * sizeof(block128) * std::min(bsize, length - i)); + if (bsize <= length - i) + crh.H<bsize>(tT + i, tT + i); + else + crh.Hn(tT + i, tT + i, length - i); + for (int j = 0; j < bsize and j < length - i; ++j) { + data[i + j] = xorBlocks(res[2 * j + r[i + j]], tT[i + j]); + } + } + delete[] tT; + } + + template <typename T> void got_send_post(T **data, int length) { + const int bsize = AES_BATCH_SIZE / 2; + block128 pad[2 * bsize]; + uint32_t y_size = + (uint32_t)ceil((2 * bsize * this->l) / ((float)sizeof(T) * 8)); + uint32_t corrected_y_size, corrected_bsize; + T y[y_size]; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = qT[j]; + pad[2 * (j - i) + 1] = xorBlocks(qT[j], block_s); + } + crh.H<2 * bsize>(pad, pad); + corrected_y_size = (uint32_t)ceil( + (2 * std::min(bsize, length - i) * this->l) / ((float)sizeof(T) * 8)); + corrected_bsize = std::min(bsize, length - i); + if (sizeof(T) == 8) { + pack_ot_messages<uint64_t>((uint64_t *)y, (uint64_t **)data + i, pad, + corrected_y_size, corrected_bsize, this->l, + 2); + } else if (sizeof(T) == 1) { + pack_ot_messages<uint8_t>((uint8_t *)y, (uint8_t **)data + i, pad, + corrected_y_size, corrected_bsize, this->l, + 2); + } else { + throw std::invalid_argument("Not implemented"); + } + io->send_data(y, sizeof(T) * (corrected_y_size)); + } + delete[] qT; + } + + template <typename T> + void got_recv_post(T *data, const uint8_t *r, int length) { + const int bsize = AES_BATCH_SIZE; + uint32_t recvd_size = + (uint32_t)ceil((2 * bsize * this->l) / ((float)sizeof(T) * 8)); + uint32_t corrected_recvd_size, corrected_bsize; + uint64_t recvd[recvd_size]; + + for (int i = 0; i < length; i += bsize) { + corrected_recvd_size = (uint32_t)ceil( + (2 * std::min(bsize, length - i) * this->l) / ((float)sizeof(T) * 8)); + corrected_bsize = std::min(bsize, length - i); + io->recv_data(recvd, sizeof(T) * (corrected_recvd_size)); + if (bsize <= length - i) + crh.H<bsize>(tT + i, tT + i); + else + crh.Hn(tT + i, tT + i, length - i); + if (sizeof(T) == 8) { + unpack_ot_messages<uint64_t>((uint64_t *)data + i, r + i, + (uint64_t *)recvd, tT + i, corrected_bsize, + this->l, 2); + } else if (sizeof(T) == 1) { + unpack_ot_messages<uint8_t>((uint8_t *)data + i, r + i, + (uint8_t *)recvd, tT + i, corrected_bsize, + this->l, 2); + } else { + throw std::invalid_argument("Not implemented"); + } + } + delete[] tT; + } + + // General OT sender with message length > 64 + void send_batched_got(uint64_t *data, int num_ot, int l, + int msgs_per_ot = 1) { + this->l = l; + send_pre(num_ot); + + int dim = num_ot; + uint64_t modulo_mask = (l == 64 ? -1 : ((1ULL << l) - 1)); + int max_num_hashes = ceil((l * msgs_per_ot) / 128.0); + int max_pad_len = dim * max_num_hashes; + block128 *pad = new block128[2 * max_pad_len]; + block128 *y0_per_ot = new block128[msgs_per_ot]; + block128 *y1_per_ot = new block128[msgs_per_ot]; + uint8_t *y0 = + new uint8_t[dim * msgs_per_ot * (sizeof(uint64_t) / sizeof(uint8_t))]; + uint8_t *y1 = + new uint8_t[dim * msgs_per_ot * (sizeof(uint64_t) / sizeof(uint8_t))]; + + int num_hashes = ceil((l * msgs_per_ot) / 128.0); + int bsize = std::min(int(ceil(AES_BATCH_SIZE / double(num_hashes))), dim) * + num_hashes; + for (int j = 0; j < dim; j += (bsize / num_hashes)) { + for (int k = j; k < j + (bsize / num_hashes) and k < dim; k++) { + int ot_idx = k; + int pad1_offset = std::min(bsize / num_hashes, dim - j) * num_hashes; + for (int h = 0; h < num_hashes; h++) { + pad[(k - j) * num_hashes + h] = xorBlocks(qT[ot_idx], toBlock(h)); + pad[pad1_offset + (k - j) * num_hashes + h] = + xorBlocks(pad[(k - j) * num_hashes + h], block_s); + } + } + if (bsize <= (dim - j) * num_hashes) + crh.Hn(pad, pad, 2 * bsize); + else + crh.Hn(pad, pad, 2 * (dim - j) * num_hashes); + + int lnum_ot = std::min(bsize / num_hashes, dim - j); + int32_t ysize_per_ot = ceil(msgs_per_ot * l / (8.0)); + + for (int k = j; k < j + (bsize / num_hashes) and k < dim; k++) { + int ot_idx = k; + int pad1_offset = std::min(bsize / num_hashes, dim - j) * num_hashes; + block128 *pad0_ptr = pad + (k - j) * num_hashes; + block128 *pad1_ptr = pad + pad1_offset + (k - j) * num_hashes; + for (int h = 0; h < msgs_per_ot; h++) { + int msg_idx = ot_idx * msgs_per_ot + h; + writeToPackedArr((uint8_t *)y0_per_ot, ysize_per_ot, h * l, l, + data[msg_idx * 2]); + writeToPackedArr((uint8_t *)y1_per_ot, ysize_per_ot, h * l, l, + data[msg_idx * 2 + 1]); + } + for (int h = 0; h < num_hashes; h++) { + y0_per_ot[h] = xorBlocks(y0_per_ot[h], pad0_ptr[h]); + y1_per_ot[h] = xorBlocks(y1_per_ot[h], pad1_ptr[h]); + } + memcpy(y0 + (ysize_per_ot * (k - j)), y0_per_ot, ysize_per_ot); + memcpy(y1 + (ysize_per_ot * (k - j)), y1_per_ot, ysize_per_ot); + } + io->send_data(y0, sizeof(uint8_t) * ysize_per_ot * lnum_ot); + io->send_data(y1, sizeof(uint8_t) * ysize_per_ot * lnum_ot); + } + delete[] pad; + // delete[] unpacked_pad0; + // delete[] unpacked_pad1; + // delete[] corr_data; + delete[] y0; + delete[] y0_per_ot; + delete[] y1; + delete[] y1_per_ot; + delete[] qT; + + /* + const int bsize = AES_BATCH_SIZE/2; + block128 pad[2*bsize]; + uint32_t y_size = (uint32_t)ceil((2*bsize*l)/(float(64))); + uint32_t corrected_y_size, corrected_bsize; + uint64_t y[y_size]; + for(int i = 0; i < num_ot*msgs_per_ot; i+=bsize) { + for(int j = i; j < i+bsize and j < num_ot*msgs_per_ot; ++j) + { int ot_idx = j/msgs_per_ot; int hash_idx = j % msgs_per_ot; + pad[2*(j-i)] = xorBlocks(qT[ot_idx], + toBlock(hash_idx)); pad[2*(j-i)+1] = xorBlocks(pad[2*(j-i)], block_s); + } + crh.H<2*bsize>(pad, pad); + corrected_y_size = + ceil((2*std::min(bsize,num_ot*msgs_per_ot-i)*l)/(float(64))); + corrected_bsize = std::min(bsize, num_ot*msgs_per_ot-i); + pack_ot_messages<uint64_t>(y, data+i, pad, corrected_y_size, + corrected_bsize, l, 2); io->send_data(y, + sizeof(uint64_t)*(corrected_y_size)); + } + delete[] qT; + */ + } + + // General OT receiver with message length > 64 + void recv_batched_got(uint64_t *data, const uint8_t *r, int num_ot, int l, + int msgs_per_ot = 1) { + this->l = l; + recv_pre((bool *)r, num_ot); + + int dim = num_ot; + uint64_t modulo_mask = (l == 64 ? -1 : ((1ULL << l) - 1)); + + int max_num_hashes = ceil((l * msgs_per_ot) / 128.0); + int max_pad_len = dim * max_num_hashes; + block128 *pad = new block128[max_pad_len]; + uint8_t *y0 = + new uint8_t[dim * msgs_per_ot * (sizeof(uint64_t) / sizeof(uint8_t))]; + uint8_t *y1 = + new uint8_t[dim * msgs_per_ot * (sizeof(uint64_t) / sizeof(uint8_t))]; + + int num_hashes = ceil((l * msgs_per_ot) / 128.0); + int bsize = std::min(int(ceil(AES_BATCH_SIZE / double(num_hashes))), dim) * + num_hashes; + for (int j = 0; j < dim; j += (bsize / num_hashes)) { + int lnum_ot = std::min(bsize / num_hashes, dim - j); + int32_t ysize_per_ot = ceil(msgs_per_ot * l / (8.0)); + + io->recv_data(y0, sizeof(uint8_t) * ysize_per_ot * lnum_ot); + io->recv_data(y1, sizeof(uint8_t) * ysize_per_ot * lnum_ot); + for (int k = j; k < j + (bsize / num_hashes) and k < dim; k++) { + int ot_idx = k; + for (int h = 0; h < num_hashes; h++) { + pad[(k - j) * num_hashes + h] = xorBlocks(tT[ot_idx], toBlock(h)); + } + } + if (bsize <= (dim - j) * num_hashes) + crh.Hn(pad, pad, bsize); + else + crh.Hn(pad, pad, (dim - j) * num_hashes); + for (int k = j; k < j + (bsize / num_hashes) and k < dim; k++) { + int ot_idx = k; + block128 *pad_ptr = pad + (k - j) * num_hashes; + block128 *y0_ptr = (block128 *)(y0 + (ysize_per_ot * (k - j))); + block128 *y1_ptr = (block128 *)(y1 + (ysize_per_ot * (k - j))); + if (r[ot_idx]) { + for (int h = 0; h < num_hashes; h++) { + pad_ptr[h] = xorBlocks(pad_ptr[h], _mm_loadu_si128(y1_ptr + h)); + } + } else { + for (int h = 0; h < num_hashes; h++) { + pad_ptr[h] = xorBlocks(pad_ptr[h], _mm_loadu_si128(y0_ptr + h)); + } + } + for (int h = 0; h < msgs_per_ot; h++) { + int msg_idx = ot_idx * msgs_per_ot + h; + int corr_idx = (k - j) * msgs_per_ot + h; + data[msg_idx] = + readFromPackedArr((uint8_t *)pad_ptr, num_hashes, h * l, l); + } + } + } + delete[] pad; + delete[] y0; + delete[] y1; + delete[] tT; + + /* + const int bsize = AES_BATCH_SIZE; + uint32_t recvd_size = (uint32_t)ceil((2*bsize*l)/(float(64))); + uint32_t corrected_recvd_size, corrected_bsize; + uint64_t recvd[recvd_size]; + block128 pad[bsize]; + uint8_t* r_ext = new uint8_t[num_ot*msgs_per_ot]; + for (int i = 0; i < num_ot; i++) { + memset(r_ext + i*msgs_per_ot, r[i], msgs_per_ot); + } + for(int i = 0; i < num_ot*msgs_per_ot; i+=bsize) { + corrected_recvd_size = + ceil((2*std::min(bsize,num_ot*msgs_per_ot-i)*l)/(float(64))); + corrected_bsize = std::min(bsize, num_ot*msgs_per_ot-i); + io->recv_data(recvd, + sizeof(uint64_t)*(corrected_recvd_size)); for(int j = i; j < i+bsize and j < + num_ot*msgs_per_ot; ++j) { int ot_idx = j/msgs_per_ot; int hash_idx = j % + msgs_per_ot; pad[j-i] = xorBlocks(tT[ot_idx], toBlock(hash_idx)); + } + if (bsize <= num_ot*msgs_per_ot-i) crh.H<bsize>(pad, pad); + else crh.Hn(pad, pad, num_ot*msgs_per_ot-i); + unpack_ot_messages<uint64_t>(data+i, r_ext+i, recvd, pad, + corrected_bsize, l, 2); + } + delete[] tT; + delete[] r_ext; + */ + } + + /********************************************************* + * COT functions * + ********************************************************/ + + void cot_send_post(uint64_t *data0, uint64_t *corr, int length) { + uint64_t modulo_mask = (1ULL << this->l) - 1; + if (this->l == 64) + modulo_mask = -1; + const int bsize = AES_BATCH_SIZE / 2; + block128 pad[2 * bsize]; + uint32_t y_size = (uint32_t)ceil((bsize * this->l) / (float(64))); + uint32_t corrected_y_size, corrected_bsize; + uint64_t y[y_size]; + uint64_t corr_data[bsize]; + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + pad[2 * (j - i)] = qT[j]; + pad[2 * (j - i) + 1] = xorBlocks(qT[j], block_s); + } + crh.H<2 * bsize>(pad, pad); + for (int j = i; j < i + bsize and j < length; ++j) { + data0[j] = _mm_extract_epi64(pad[2 * (j - i)], 0) & modulo_mask; + corr_data[j - i] = + (corr[j] + data0[j] + _mm_extract_epi64(pad[2 * (j - i) + 1], 0)) & + modulo_mask; + } + corrected_y_size = + (uint32_t)ceil((std::min(bsize, length - i) * this->l) / + ((float)sizeof(uint64_t) * 8)); + corrected_bsize = std::min(bsize, length - i); + pack_cot_messages(y, corr_data, corrected_y_size, corrected_bsize, + this->l); + io->send_data(y, sizeof(uint64_t) * (corrected_y_size)); + } + delete[] qT; + } + + void cot_recv_post(uint64_t *data, const bool *r, int length) { + uint64_t modulo_mask = (1ULL << this->l) - 1; + if (this->l == 64) + modulo_mask = -1; + const int bsize = AES_BATCH_SIZE; + uint32_t recvd_size = (uint32_t)ceil((bsize * this->l) / (float(64))); + uint32_t corrected_recvd_size, corrected_bsize; + uint64_t corr_data[bsize]; + uint64_t recvd[recvd_size]; + + for (int i = 0; i < length; i += bsize) { + corrected_recvd_size = + (uint32_t)ceil((std::min(bsize, length - i) * this->l) / (float(64))); + corrected_bsize = std::min(bsize, length - i); + io->recv_data(recvd, sizeof(uint64_t) * corrected_recvd_size); + if (bsize <= length - i) + crh.H<bsize>(tT + i, tT + i); + else + crh.Hn(tT + i, tT + i, length - i); + unpack_cot_messages(corr_data, recvd, corrected_bsize, this->l); + for (int j = i; j < i + bsize and j < length; ++j) { + if (r[j]) + data[j] = + (corr_data[j - i] - _mm_extract_epi64(tT[j], 0)) & modulo_mask; + else + data[j] = _mm_extract_epi64(tT[j], 0) & modulo_mask; + } + } + delete[] tT; + } + + // Batched COT sender with messages of different bitlengths + // msgs_per_ot specifies the number of OTs with same choice bit (to be + // batched) + void send_batched_cot(uint64_t *data0, uint64_t *corr, + std::vector<int> msg_len, int num_ot, + int msgs_per_ot = 1) { + send_pre(num_ot); + + int num_msg_len = msg_len.size(); + // The number of OTs of a particular message bitlength + // Simplifying assumption: Each message bitlength has equal number of OTs + int dim = num_ot / num_msg_len; + uint64_t modulo_mask[num_msg_len]; + for (int bit_idx = 0; bit_idx < num_msg_len; bit_idx++) { + modulo_mask[bit_idx] = + (msg_len[bit_idx] == 64 ? -1 : ((1ULL << msg_len[bit_idx]) - 1)); + } + int max_num_hashes = ceil((64 * msgs_per_ot) / 128.0); + int max_pad_len = dim * max_num_hashes; + block128 *pad = new block128[2 * max_pad_len]; + block128 *y_per_ot = new block128[msgs_per_ot]; + // uint64_t* unpacked_pad0 = new uint64_t[msgs_per_ot]; + // uint64_t* unpacked_pad1 = new uint64_t[msgs_per_ot]; + // uint64_t* corr_data = new uint64_t[dim*msgs_per_ot]; + uint8_t *y = + new uint8_t[dim * msgs_per_ot * (sizeof(uint64_t) / sizeof(uint8_t))]; + for (int i = 0; i < num_ot / dim; i++) { + int bit_idx = i; + int lmsg_len = msg_len[bit_idx]; + uint64_t lmodulo_mask = modulo_mask[bit_idx]; + int num_hashes = ceil((lmsg_len * msgs_per_ot) / 128.0); + int bsize = + std::min(int(ceil(AES_BATCH_SIZE / double(num_hashes))), dim) * + num_hashes; + for (int j = 0; j < dim; j += (bsize / num_hashes)) { + for (int k = j; k < j + (bsize / num_hashes) and k < dim; k++) { + int ot_idx = i * dim + k; + int pad1_offset = std::min(bsize / num_hashes, dim - j) * num_hashes; + for (int h = 0; h < num_hashes; h++) { + pad[(k - j) * num_hashes + h] = xorBlocks(qT[ot_idx], toBlock(h)); + pad[pad1_offset + (k - j) * num_hashes + h] = + xorBlocks(pad[(k - j) * num_hashes + h], block_s); + } + } + if (bsize <= (dim - j) * num_hashes) + crh.Hn(pad, pad, 2 * bsize); + else + crh.Hn(pad, pad, 2 * (dim - j) * num_hashes); + + int lnum_ot = std::min(bsize / num_hashes, dim - j); + int32_t ysize_per_ot = ceil(msgs_per_ot * lmsg_len / (8.0)); + + for (int k = j; k < j + (bsize / num_hashes) and k < dim; k++) { + int ot_idx = i * dim + k; + int pad1_offset = std::min(bsize / num_hashes, dim - j) * num_hashes; + block128 *pad0_ptr = pad + (k - j) * num_hashes; + block128 *pad1_ptr = pad + pad1_offset + (k - j) * num_hashes; + for (int h = 0; h < msgs_per_ot; h++) { + int msg_idx = ot_idx * msgs_per_ot + h; + int32_t corr_idx = (k - j) * msgs_per_ot + h; + uint64_t unpacked_pad0 = readFromPackedArr( + (uint8_t *)pad0_ptr, num_hashes, h * lmsg_len, lmsg_len); + // unpacked_pad1[h] = readFromPackedArr((uint8_t*)pad1_ptr, + // num_hashes, + // h*msg_len[bit_idx], msg_len[bit_idx]); + data0[msg_idx] = unpacked_pad0 & lmodulo_mask; + uint64_t corr_data = (corr[msg_idx] + unpacked_pad0) & lmodulo_mask; + writeToPackedArr((uint8_t *)y_per_ot, ysize_per_ot, h * lmsg_len, + lmsg_len, corr_data); + } + for (int h = 0; h < num_hashes; h++) { + y_per_ot[h] = xorBlocks(y_per_ot[h], pad1_ptr[h]); + } + memcpy(y + (ysize_per_ot * (k - j)), y_per_ot, ysize_per_ot); + } + io->send_data(y, sizeof(uint8_t) * ysize_per_ot * lnum_ot); + } + } + delete[] pad; + // delete[] unpacked_pad0; + // delete[] unpacked_pad1; + // delete[] corr_data; + delete[] y; + delete[] y_per_ot; + delete[] qT; + } + + // Batched COT receiver with messages of different bitlengths + // msgs_per_ot specifies the number of OTs with same choice bit (to be + // batched) + void recv_batched_cot(uint64_t *data, bool *b, std::vector<int> msg_len, + int num_ot, int msgs_per_ot = 1) { + recv_pre(b, num_ot); + + int num_msg_len = msg_len.size(); + // The number of OTs of a particular message bitlength + // Simplifying assumption: Each message bitlength has equal number of OTs + int dim = num_ot / num_msg_len; + uint64_t modulo_mask[num_msg_len]; + for (int bit_idx = 0; bit_idx < num_msg_len; bit_idx++) { + modulo_mask[bit_idx] = + (msg_len[bit_idx] == 64 ? -1 : ((1ULL << msg_len[bit_idx]) - 1)); + } + int max_num_hashes = ceil((64 * msgs_per_ot) / 128.0); + int max_pad_len = dim * max_num_hashes; + block128 *pad = new block128[max_pad_len]; + // uint64_t* unpacked_pad = new uint64_t[msgs_per_ot]; + // uint64_t* corr_data = new uint64_t[dim*msgs_per_ot]; + uint8_t *y = + new uint8_t[dim * msgs_per_ot * (sizeof(uint64_t) / sizeof(uint8_t))]; + for (int i = 0; i < num_ot / dim; i++) { + int bit_idx = i; + int lmsg_len = msg_len[bit_idx]; + int num_hashes = ceil((lmsg_len * msgs_per_ot) / 128.0); + int bsize = + std::min(int(ceil(AES_BATCH_SIZE / double(num_hashes))), dim) * + num_hashes; + for (int j = 0; j < dim; j += (bsize / num_hashes)) { + int lnum_ot = std::min(bsize / num_hashes, dim - j); + int32_t ysize_per_ot = ceil(msgs_per_ot * lmsg_len / (8.0)); + + io->recv_data(y, sizeof(uint8_t) * ysize_per_ot * lnum_ot); + for (int k = j; k < j + (bsize / num_hashes) and k < dim; k++) { + int ot_idx = i * dim + k; + for (int h = 0; h < num_hashes; h++) { + pad[(k - j) * num_hashes + h] = xorBlocks(tT[ot_idx], toBlock(h)); + } + } + if (bsize <= (dim - j) * num_hashes) + crh.Hn(pad, pad, bsize); + else + crh.Hn(pad, pad, (dim - j) * num_hashes); + for (int k = j; k < j + (bsize / num_hashes) and k < dim; k++) { + int ot_idx = i * dim + k; + block128 *pad_ptr = pad + (k - j) * num_hashes; + block128 *y_ptr = (block128 *)(y + (ysize_per_ot * (k - j))); + if (b[ot_idx]) { + for (int h = 0; h < num_hashes; h++) { + pad_ptr[h] = xorBlocks(pad_ptr[h], _mm_loadu_si128(y_ptr + h)); + } + } + for (int h = 0; h < msgs_per_ot; h++) { + int msg_idx = ot_idx * msgs_per_ot + h; + int corr_idx = (k - j) * msgs_per_ot + h; + uint64_t unpacked_pad = readFromPackedArr( + (uint8_t *)pad_ptr, num_hashes, h * lmsg_len, lmsg_len); + data[msg_idx] = unpacked_pad; // & modulo_mask[bit_idx]; + } + } + } + } + delete[] pad; + // delete[] unpacked_pad; + // delete[] corr_data; + delete[] y; + delete[] tT; + } + + /********************************************************* + * Send/Recv wrapper functions * + ********************************************************/ + + void send_impl(const block128 *data0, const block128 *data1, int length) { + send_pre(length); + got_send_post(data0, data1, length); + } + + void recv_impl(block128 *data, const bool *b, int length) { + recv_pre((bool *)b, length); + got_recv_post(data, b, length); + } + + void send_impl(uint64_t **data, int length, int l) { + this->l = l; + if (length <= precomp_batch_size) { + if (length > (precomp_batch_size - counter)) { + preprocess(); + } + got_send_online<uint64_t>(data, length); + } else { + send_pre(length); + got_send_post<uint64_t>(data, length); + } + } + + void recv_impl(uint64_t *data, uint8_t *b, int length, int l) { + this->l = l; + if (length <= precomp_batch_size) { + if (length > (precomp_batch_size - counter)) { + preprocess(); + } + got_recv_online<uint64_t>(data, b, length); + } else { + recv_pre((bool *)b, length); + got_recv_post<uint64_t>(data, b, length); + } + } + + void send_impl(uint8_t **data, int length, int l) { + assert(l <= 8 && l >= 1); + this->l = l; + if (length <= precomp_batch_size) { + if (length > (precomp_batch_size - counter)) { + preprocess(); + } + got_send_online<uint8_t>(data, length); + } else { + send_pre(length); + got_send_post<uint8_t>(data, length); + } + } + + void recv_impl(uint8_t *data, uint8_t *b, int length, int l) { + assert(l <= 8 && l >= 1); + this->l = l; + if (length <= precomp_batch_size) { + if (length > (precomp_batch_size - counter)) { + preprocess(); + } + got_recv_online<uint8_t>(data, b, length); + } else { + recv_pre((bool *)b, length); + got_recv_post<uint8_t>(data, b, length); + } + } + + void send_cot(uint64_t *data0, uint64_t *corr, int length, int l) { + this->l = l; + send_pre(length); + cot_send_post(data0, corr, length); + } + + void recv_cot(uint64_t *data, bool *b, int length, int l) { + this->l = l; + recv_pre(b, length); + cot_recv_post(data, b, length); + } }; -} -#endif// SPLIT_OT_IKNP_H__ +} // namespace sci +#endif // SPLIT_OT_IKNP_H__ diff --git a/SCI/src/OT/split-kkot.h b/SCI/src/OT/split-kkot.h index b2834b69..bc6fd2ca 100644 --- a/SCI/src/OT/split-kkot.h +++ b/SCI/src/OT/split-kkot.h @@ -25,603 +25,580 @@ SOFTWARE. // In split functions, OT is split // into offline and online phase. // The KKOT functions without -// online offline split can +// online offline split can // be found in OT/kkot.h -#include "OT/ot.h" #include "OT/np.h" -#include "OT/split-utils.h" #include "OT/ot-utils.h" +#include "OT/ot.h" +#include "OT/split-utils.h" namespace sci { -template<typename IO> -class SplitKKOT : public OT<SplitKKOT<IO>> -{ +template <typename IO> class SplitKKOT : public OT<SplitKKOT<IO>> { public: - OTNP<IO> * base_ot; - PRG128 prg; - int party; - const int lambda = 256; + OTNP<IO> *base_ot; + PRG128 prg; + int party; + const int lambda = 256; #if __APPLE__ - int block_size = 1024*8; + int block_size = 1024 * 8; #else - int block_size = 1024*16; + int block_size = 1024 * 16; #endif - const int ro_batch_size = 2048; - - // This specifies how much OTs to preprocess in one go. - // 0 means no preprocessing and all everything will be - // run in the online phase. - int precomp_batch_size = 0; - - // counter denotes the number of unused pre-generated OTs. - int counter = precomp_batch_size; - int N = 0, l; - - block256 *k0 = nullptr, *k1 = nullptr, *d = nullptr, *c_AND_s = nullptr, - *qT = nullptr, *tT = nullptr, *tmp = nullptr, block_s; - - // h holds the precomputed hashes which can be used directly - // in the online phase by xoring with the respective OT messages. - uint8_t **h; - uint64_t **h64; - - // r_off is the choice input set used for the offline random OTs. - // This is corrected in the online phase when actual choice_input comes. - uint8_t *r_off; - PRG256 *G0, *G1; - bool *s = nullptr, setup = false; - bool precomp_masks = false; - uint8_t *extended_r = nullptr; - IO *io = nullptr; - - SplitKKOT( - int party, - IO * io, - int N) - { - assert(party == ALICE || party == BOB); - this->party = party; - this->io = io; - assert(N > 0); - this->N = N; - base_ot = new OTNP<IO>(io); - s = new bool[lambda]; - k0 = new block256[lambda]; - k1 = new block256[lambda]; - d = new block256[block_size]; - c_AND_s = new block256[lambda]; - switch (party) { - case ALICE: - h = new uint8_t*[N]; - h64 = new uint64_t*[N]; - for (int i = 0; i < N; i++){ - h[i] = new uint8_t[precomp_batch_size]; - h64[i] = new uint64_t[precomp_batch_size]; - } - break; - case BOB: - h = new uint8_t*[1]; - h64 = new uint64_t*[1]; - r_off = new uint8_t[precomp_batch_size]; - for (int i = 0; i < 1; i++){ - h[i] = new uint8_t[precomp_batch_size]; - h64[i] = new uint64_t[precomp_batch_size]; - } - break; - } - G0 = new PRG256[lambda]; - G1 = new PRG256[lambda]; - tmp = new block256[block_size/256]; - extended_r = new uint8_t[block_size]; - } - - ~SplitKKOT() - { - delete base_ot; - delete[] s; - delete[] k0; - delete[] k1; - delete[] d; - if (precomp_masks) - delete[] c_AND_s; - switch (party) { - case ALICE: - for(int i = 0; i < N; i++){ - delete[] h[i]; - delete[] h64[i]; - } - delete[] h; - delete[] h64; - break; - case BOB: - delete[] h[0]; - delete[] h; - delete[] h64[0]; - delete[] h64; - delete[] r_off; - break; - } - delete[] G0; - delete[] G1; - delete[] tmp; - delete[] extended_r; - } - - void set_precomp_batch_size( - int batch_size) - { - this->precomp_batch_size = batch_size; - this->counter = batch_size; - if (precomp_masks){ - delete[] c_AND_s; - c_AND_s = new block256[lambda]; - precomp_masks = false; - } - switch (party) { - case ALICE: - for(int i = 0; i < N; i++){ - delete[] h[i]; - delete[] h64[i]; - } - delete[] h; - delete[] h64; - break; - case BOB: - delete[] h[0]; - delete[] h; - delete[] h64[0]; - delete[] h64; - delete[] r_off; - break; - } - switch (party) { - case ALICE: - h = new uint8_t*[N]; - h64 = new uint64_t*[N]; - for (int i = 0; i < N; i++){ - h[i] = new uint8_t[precomp_batch_size]; - h64[i] = new uint64_t[precomp_batch_size]; - } - break; - case BOB: - h = new uint8_t*[1]; - h64 = new uint64_t*[1]; - r_off = new uint8_t[precomp_batch_size]; - for (int i = 0; i < 1; i++){ - h[i] = new uint8_t[precomp_batch_size]; - h64[i] = new uint64_t[precomp_batch_size]; - } - break; - } - } - - void setup_send( - block256 * in_k0 = nullptr, - bool * in_s = nullptr) - { - setup = true; - if(in_s != nullptr) { - memcpy(k0, in_k0, lambda*sizeof(block256)); - memcpy(s, in_s, lambda); - block_s = bool_to256(s); - } else { - prg.random_bool(s, lambda); - base_ot->recv(k0, s, lambda); - block_s = bool_to256(s); - } - for(int i = 0; i < lambda; ++i) - G0[i].reseed(&k0[i]); - } - - void setup_recv( - block256 * in_k0 = nullptr, - block256 * in_k1 = nullptr) - { - setup = true; - if(in_k0 !=nullptr) { - memcpy(k0, in_k0, lambda*sizeof(block256)); - memcpy(k1, in_k1, lambda*sizeof(block256)); - } else { - prg.random_block(k0, lambda); - prg.random_block(k1, lambda); - base_ot->send(k0, k1, lambda); - } - for(int i = 0; i < lambda; ++i) { - G0[i].reseed(&k0[i]); - G1[i].reseed(&k1[i]); - } - } - - void precompute_masks() - { - assert(setup == true); - precomp_masks = true; - for(int i = 0; i < N; i++) { - c_AND_s[i] = andBlocks(_mm256_lddqu_si256((const __m256i*) WH_Code[i]), block_s); - } - } - - int padded_length( - int length) - { - return ((length + block_size - 1) / block_size) * block_size; - } - - void preprocess() - { - switch (party) { - case ALICE: - send_pre(counter); - got_send_offline(counter); - break; - case BOB: - prg.random_data(r_off, counter); - uint8_t mask = N - 1; // N is a power of 2 - for (int i = 0; i < counter; i++) { - r_off[i] &= mask; - } - recv_pre(r_off, counter); - got_recv_offline(counter); - break; - } - counter = 0; - } - - void send_pre( - int length) - { - length = padded_length(length); - block256 q[block_size]; - qT = new block256[length]; - if(!setup) setup_send(); - if(!precomp_masks) precompute_masks(); - - for (int j = 0; j < length/block_size; ++j) { - for(int i = 0; i < lambda; ++i) { - G0[i].random_data(q+(i*block_size/256), block_size/8); - io->recv_data(tmp, block_size/8); - if (s[i]) - xorBlocks_arr(q+(i*block_size/256), q+(i*block_size/256), tmp, block_size/256); - } - sse_trans((uint8_t*)(qT+j*block_size), (uint8_t*)q, 256, block_size); - } - } - - void recv_pre( - const uint8_t* r, - int length) - { - int old_length = length; - length = padded_length(length); - block256 t[block_size]; - tT = new block256[length]; - if(not setup) setup_recv(); - - uint8_t* r2 = new uint8_t[length]; - prg.random_data(extended_r, block_size); - memcpy(r2, r, old_length); - memcpy(r2+old_length, extended_r, length - old_length); - - block256* dT = new block256[length]; - for(int i = 0; i < length; i++) - dT[i] = _mm256_lddqu_si256((const __m256i*) WH_Code[r2[i]]); - - for (int j = 0; j * block_size < length; ++j) { - sse_trans((uint8_t*)d, (uint8_t*)(dT+j*block_size), block_size, 256); - for(int i = 0; i < lambda; ++i) { - G0[i].random_data(t+(i*block_size/256), block_size/8); - G1[i].random_data(tmp, block_size/8); - xorBlocks_arr(tmp, t+(i*block_size/256), tmp, block_size/256); - xorBlocks_arr(tmp, d+(i*block_size/256), tmp, block_size/256); - io->send_data(tmp, block_size/8); - } - sse_trans((uint8_t*)(tT+j*block_size), (uint8_t*)t, 256, block_size); - } - - delete[] dT; - delete[] r2; - } - - void got_send_offline( - int length) - { - const int bsize = ro_batch_size; - block256 *key = new block256[N*bsize]; - block128 *pad = new block128[N*bsize]; - - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - for(int k = 0; k < N; k++) { - key[N*(j-i)+k] = xorBlocks(qT[j], c_AND_s[k]); - } - } - CCRF(pad, key, N*bsize); - for(int j = i; j < i+bsize and j < length; ++j) { - for(int k = 0; k < N; k++){ - h[k][j] = ((uint8_t)_mm_extract_epi8(pad[N*(j-i)+k], 0)); - h64[k][j] = ((uint64_t)_mm_extract_epi64(pad[N*(j-i)+k], 0)); - } - } - } - delete[] qT; - delete[] key; - delete[] pad; - } - - void got_recv_offline( - int length) - { - const int bsize = ro_batch_size; - block128 *pad = new block128[N*bsize]; - - for(int i = 0; i < length; i+=bsize) { - if (bsize <= length-i) CCRF(pad, tT+i, bsize); - else CCRF(pad, tT+i, length-i); - for(int j = 0; j < bsize and j < length-i; ++j) { - h[0][i+j] = ((uint8_t)_mm_extract_epi8(pad[j], 0)); - h64[0][i+j] = ((uint64_t)_mm_extract_epi64(pad[j], 0)); - } - } - delete[] tT; - delete[] pad; - } - - template <typename T> - void got_send_online( - T** data, - int length) - { - const int bsize = length;//ro_batch_size; - uint32_t y_size = (uint32_t)ceil((N*bsize*l)/((float)sizeof(T)*8)); - int bits_in_sel_input = sci::bitlen(N); - uint32_t a_size = (uint32_t)ceil((bsize*bits_in_sel_input)/((float)sizeof(uint8_t)*8)); - T y[y_size]; - uint8_t a_packed[a_size]; - uint8_t a[length]; - T **maskeddata = new T*[bsize]; - for(int i=0; i<bsize; i++){ - maskeddata[i] = new T[N]; - } - int32_t corrected_bsize, corrected_y_size, corrected_a_size; - uint8_t mask_a; - mask_a = (1<<bits_in_sel_input)-1; - if(bits_in_sel_input == 8){ - mask_a = -1; - } - - for(int ctr=0; ctr<length; ctr+=bsize){ - corrected_bsize = std::min(bsize, length-ctr); - corrected_y_size = (uint32_t)ceil((N*corrected_bsize*l)/((float)sizeof(T)*8)); - corrected_a_size = (uint32_t)ceil((corrected_bsize*bits_in_sel_input)/((float)sizeof(uint8_t)*8)); - // Receive correction of choice input - io->recv_data(a_packed, sizeof(uint8_t)*corrected_a_size); - unpack_a<uint8_t>(a, a_packed, corrected_bsize, bits_in_sel_input); - if(sizeof(T) == 8){ - for(int i=0; i<corrected_bsize; i++){ - for(int k=0; k<N; k++){ - maskeddata[i][k] = (h64[(k+a[i]) & mask_a][counter] ^ data[ctr+i][k]); - } - counter++; - } - } - else if(sizeof(T) == 1){ - for(int i=0; i<corrected_bsize; i++){ - for(int k=0; k<N; k++){ - maskeddata[i][k] = (h[(k+a[i]) & mask_a][counter] ^ data[ctr+i][k]); - } - counter++; - } - } - else{ - throw std::invalid_argument("Not yet implemented"); - } - pack_messages<T>(y, maskeddata, corrected_y_size, corrected_bsize, l, N); - io->send_data(y, sizeof(T)*corrected_y_size); - } - for(int i=0; i<bsize; i++){ - delete[] maskeddata[i]; - } - delete[] maskeddata; - - } - - template <typename T> - void got_recv_online( - T* data, - const uint8_t* r, - int length) - { - const int bsize = length; - uint32_t res_size = (uint32_t)ceil((N*length*l)/((float)sizeof(T)*8)); - int bits_in_sel_input = sci::bitlen(N); - uint32_t a_size = (uint32_t)ceil((length*bits_in_sel_input)/((float)sizeof(uint8_t)*8)); - T res[res_size]; - uint8_t a_unpacked[length]; - uint8_t a[a_size]; - int32_t corrected_bsize, corrected_res_size, corrected_a_size; - uint8_t mask_a; - mask_a = (1<<bits_in_sel_input)-1; - if(bits_in_sel_input == 8){ - mask_a = -1; - } - - for(int ctr=0; ctr<length; ctr+=bsize){ - corrected_bsize = std::min(bsize, length-ctr); - corrected_res_size = (uint32_t)ceil((N*corrected_bsize*l)/((float)sizeof(T)*8)); - corrected_a_size = (uint32_t)ceil((corrected_bsize*bits_in_sel_input)/((float)sizeof(uint8_t)*8)); - - int counter_memory = counter; - // Send corrected choice inputs - for(int i=0; i<corrected_bsize; i++){ - a_unpacked[i] = (r_off[counter++] - r[ctr+i]) & mask_a; // Replicates neg_mod - } - pack_a<uint8_t>(a, a_unpacked, corrected_a_size, corrected_bsize, bits_in_sel_input); - io->send_data(a, sizeof(uint8_t)*corrected_a_size); - counter = counter_memory; - // Receive OT messages - io->recv_data(res, sizeof(T)*corrected_res_size); - if(sizeof(T) == 8){ - unpack_messages<uint64_t>((uint64_t*)data+ctr, r+ctr, (uint64_t*)res, h64[0], corrected_bsize, l, N, counter); - } - else if(sizeof(T) == 1){ - unpack_messages<uint8_t>((uint8_t*)data+ctr, r+ctr, (uint8_t*)res, h[0], corrected_bsize, l, N, counter); - } - else{ - throw std::invalid_argument("Not yet implemented"); - } - } - } - - template <typename T> - void got_send_post( - T** data, - int length) - { - const int bsize = ro_batch_size; - block256 *key = new block256[N*bsize]; - block128 *pad = new block128[N*bsize]; - uint32_t y_size = (uint32_t)ceil((N*bsize*this->l)/((float)sizeof(T)*8)); - uint32_t corrected_y_size, corrected_bsize; - T y[y_size]; - - for(int i = 0; i < length; i+=bsize) { - for(int j = i; j < i+bsize and j < length; ++j) { - for(int k = 0; k < N; k++) { - key[N*(j-i)+k] = xorBlocks(qT[j], c_AND_s[k]); - } - } - CCRF(pad, key, N*bsize); - corrected_y_size = (uint32_t)ceil((N*std::min(bsize, length-i)*this->l)/((float)sizeof(T)*8)); - corrected_bsize = std::min(bsize, length-i); - if(sizeof(T) == 8){ - pack_ot_messages<uint64_t>((uint64_t*)y, (uint64_t**)data+i, pad, corrected_y_size, corrected_bsize, this->l, this->N); - } - else if(sizeof(T) == 1){ - pack_ot_messages<uint8_t>((uint8_t*)y, (uint8_t**)data+i, pad, corrected_y_size, corrected_bsize, this->l, this->N); - } - else{ - throw std::invalid_argument("Not implemented"); - } - io->send_data(y, sizeof(T)*(corrected_y_size)); - } - delete[] qT; - delete[] key; - delete[] pad; - } - - template <typename T> - void got_recv_post( - T* data, - const uint8_t* r, - int length) - { - const int bsize = ro_batch_size; - block128 *pad = new block128[N*bsize]; - uint32_t recvd_size = (uint32_t)ceil((N*bsize*this->l)/((float)sizeof(T)*8)); - uint32_t corrected_recvd_size, corrected_bsize; - T recvd[recvd_size]; - for(int i = 0; i < length; i+=bsize) { - uint32_t corrected_recvd_size = (uint32_t)ceil((N*std::min(bsize, length-i)*this->l)/((float)sizeof(T)*8)); - corrected_bsize = std::min(bsize, length-i); - io->recv_data(recvd, sizeof(T)*(corrected_recvd_size)); - if (bsize <= length-i) CCRF(pad, tT+i, bsize); - else CCRF(pad, tT+i, length-i); - - if(sizeof(T) == 8){ - unpack_ot_messages<uint64_t>((uint64_t*)data+i, r+i, (uint64_t*)recvd, pad, corrected_bsize, this->l, this->N); - } - else if(sizeof(T) == 1){ - unpack_ot_messages<uint8_t>((uint8_t*)data+i, r+i, (uint8_t*)recvd, pad, corrected_bsize, this->l, this->N); - } - else{ - throw std::invalid_argument("Not implemented"); - } - } - delete[] tT; - delete[] pad; - } - - void send_impl( - uint8_t** data, - int length, - int l) - { - assert(N <= lambda && N >= 2); - assert(l <= 8 && l >= 1); - assert(((N*l*length) % 8) == 0); - this->l = l; - if (length <= precomp_batch_size) { - if (length > (precomp_batch_size - counter)) { - preprocess(); - } - got_send_online<uint8_t>(data, length); - } else { - send_pre(length); - got_send_post<uint8_t>(data, length); - } - } - - void recv_impl( - uint8_t* data, - uint8_t* b, - int length, - int l) - { - assert(N <= lambda && N >= 2); - assert(l <= 8 && l >= 1); - assert(((N*l*length) % 8) == 0); - this->l = l; - if (length <= precomp_batch_size) { - if (length > (precomp_batch_size - counter)) { - preprocess(); - } - got_recv_online<uint8_t>(data, b, length); - } else { - recv_pre(b, length); - got_recv_post<uint8_t>(data, b, length); - } - } - - void send_impl( - uint64_t** data, - int length, - int l) - { - assert(N <= lambda && N >= 2); - assert(l > 8); - this->l = l; - if (length <= precomp_batch_size) { - if (length > (precomp_batch_size - counter)) { - preprocess(); - } - got_send_online<uint64_t>(data, length); - } else { - send_pre(length); - got_send_post<uint64_t>(data, length); - } - } - - void recv_impl( - uint64_t* data, - uint8_t* b, - int length, - int l) - { - assert(N <= lambda && N >= 2); - assert(l > 8); - this->l = l; - if (length <= precomp_batch_size) { - if (length > (precomp_batch_size - counter)) { - preprocess(); - } - got_recv_online<uint64_t>(data, b, length); - } else { - recv_pre(b, length); - got_recv_post<uint64_t>(data, b, length); - } - } - + const int ro_batch_size = 2048; + + // This specifies how much OTs to preprocess in one go. + // 0 means no preprocessing and all everything will be + // run in the online phase. + int precomp_batch_size = 0; + + // counter denotes the number of unused pre-generated OTs. + int counter = precomp_batch_size; + int N = 0, l; + + block256 *k0 = nullptr, *k1 = nullptr, *d = nullptr, *c_AND_s = nullptr, + *qT = nullptr, *tT = nullptr, *tmp = nullptr, block_s; + + // h holds the precomputed hashes which can be used directly + // in the online phase by xoring with the respective OT messages. + uint8_t **h; + uint64_t **h64; + + // r_off is the choice input set used for the offline random OTs. + // This is corrected in the online phase when actual choice_input comes. + uint8_t *r_off; + PRG256 *G0, *G1; + bool *s = nullptr, setup = false; + bool precomp_masks = false; + uint8_t *extended_r = nullptr; + IO *io = nullptr; + + SplitKKOT(int party, IO *io, int N) { + assert(party == ALICE || party == BOB); + this->party = party; + this->io = io; + assert(N > 0); + this->N = N; + base_ot = new OTNP<IO>(io); + s = new bool[lambda]; + k0 = new (std::align_val_t(32)) block256[lambda]; + k1 = new (std::align_val_t(32)) block256[lambda]; + d = new (std::align_val_t(32)) block256[block_size]; + c_AND_s = new (std::align_val_t(32)) block256[lambda]; + switch (party) { + case ALICE: + h = new uint8_t *[N]; + h64 = new uint64_t *[N]; + for (int i = 0; i < N; i++) { + h[i] = new uint8_t[precomp_batch_size]; + h64[i] = new uint64_t[precomp_batch_size]; + } + break; + case BOB: + h = new uint8_t *[1]; + h64 = new uint64_t *[1]; + r_off = new uint8_t[precomp_batch_size]; + for (int i = 0; i < 1; i++) { + h[i] = new uint8_t[precomp_batch_size]; + h64[i] = new uint64_t[precomp_batch_size]; + } + break; + } + G0 = new PRG256[lambda]; + G1 = new PRG256[lambda]; + tmp = new (std::align_val_t(32)) block256[block_size / 256]; + extended_r = new uint8_t[block_size]; + } + + ~SplitKKOT() { + delete base_ot; + delete[] s; + delete[] k0; + delete[] k1; + delete[] d; + if (precomp_masks) + delete[] c_AND_s; + switch (party) { + case ALICE: + for (int i = 0; i < N; i++) { + delete[] h[i]; + delete[] h64[i]; + } + delete[] h; + delete[] h64; + break; + case BOB: + delete[] h[0]; + delete[] h; + delete[] h64[0]; + delete[] h64; + delete[] r_off; + break; + } + delete[] G0; + delete[] G1; + delete[] tmp; + delete[] extended_r; + } + + void set_precomp_batch_size(int batch_size) { + this->precomp_batch_size = batch_size; + this->counter = batch_size; + if (precomp_masks) { + delete[] c_AND_s; + c_AND_s = new (std::align_val_t(32)) block256[lambda]; + precomp_masks = false; + } + switch (party) { + case ALICE: + for (int i = 0; i < N; i++) { + delete[] h[i]; + delete[] h64[i]; + } + delete[] h; + delete[] h64; + break; + case BOB: + delete[] h[0]; + delete[] h; + delete[] h64[0]; + delete[] h64; + delete[] r_off; + break; + } + switch (party) { + case ALICE: + h = new uint8_t *[N]; + h64 = new uint64_t *[N]; + for (int i = 0; i < N; i++) { + h[i] = new uint8_t[precomp_batch_size]; + h64[i] = new uint64_t[precomp_batch_size]; + } + break; + case BOB: + h = new uint8_t *[1]; + h64 = new uint64_t *[1]; + r_off = new uint8_t[precomp_batch_size]; + for (int i = 0; i < 1; i++) { + h[i] = new uint8_t[precomp_batch_size]; + h64[i] = new uint64_t[precomp_batch_size]; + } + break; + } + } + + void setup_send(block256 *in_k0 = nullptr, bool *in_s = nullptr) { + setup = true; + if (in_s != nullptr) { + memcpy(k0, in_k0, lambda * sizeof(block256)); + memcpy(s, in_s, lambda); + block_s = bool_to256(s); + } else { + prg.random_bool(s, lambda); + base_ot->recv(k0, s, lambda); + block_s = bool_to256(s); + } + for (int i = 0; i < lambda; ++i) + G0[i].reseed(&k0[i]); + } + + void setup_recv(block256 *in_k0 = nullptr, block256 *in_k1 = nullptr) { + setup = true; + if (in_k0 != nullptr) { + memcpy(k0, in_k0, lambda * sizeof(block256)); + memcpy(k1, in_k1, lambda * sizeof(block256)); + } else { + prg.random_block(k0, lambda); + prg.random_block(k1, lambda); + base_ot->send(k0, k1, lambda); + } + for (int i = 0; i < lambda; ++i) { + G0[i].reseed(&k0[i]); + G1[i].reseed(&k1[i]); + } + } + + void precompute_masks() { + assert(setup == true); + precomp_masks = true; + for (int i = 0; i < N; i++) { + c_AND_s[i] = + andBlocks(_mm256_lddqu_si256((const __m256i *)WH_Code[i]), block_s); + } + } + + int padded_length(int length) { + return ((length + block_size - 1) / block_size) * block_size; + } + + void preprocess() { + switch (party) { + case ALICE: + send_pre(counter); + got_send_offline(counter); + break; + case BOB: + prg.random_data(r_off, counter); + uint8_t mask = N - 1; // N is a power of 2 + for (int i = 0; i < counter; i++) { + r_off[i] &= mask; + } + recv_pre(r_off, counter); + got_recv_offline(counter); + break; + } + counter = 0; + } + + void send_pre(int length) { + int old_block_size = this->block_size; + this->block_size = + std::min(old_block_size, int(ceil(length / 256.0)) * 256); + length = padded_length(length); + alignas(32) block256 q[block_size]; + qT = new (std::align_val_t(32)) block256[length]; + if (!setup) + setup_send(); + if (!precomp_masks) + precompute_masks(); + + for (int j = 0; j < length / block_size; ++j) { + for (int i = 0; i < lambda; ++i) { + G0[i].random_data(q + (i * block_size / 256), block_size / 8); + io->recv_data(tmp, block_size / 8); + if (s[i]) + xorBlocks_arr(q + (i * block_size / 256), q + (i * block_size / 256), + tmp, block_size / 256); + } + sse_trans((uint8_t *)(qT + j * block_size), (uint8_t *)q, 256, + block_size); + } + this->block_size = old_block_size; + } + + void recv_pre(const uint8_t *r, int length) { + int old_block_size = this->block_size; + this->block_size = + std::min(old_block_size, int(ceil(length / 256.0)) * 256); + int old_length = length; + length = padded_length(length); + alignas(32) block256 t[block_size]; + tT = new (std::align_val_t(32)) block256[length]; + if (not setup) + setup_recv(); + + uint8_t *r2 = new uint8_t[length]; + prg.random_data(extended_r, block_size); + memcpy(r2, r, old_length); + memcpy(r2 + old_length, extended_r, length - old_length); + + block256 *dT = new (std::align_val_t(32)) block256[length]; + for (int i = 0; i < length; i++) + dT[i] = _mm256_lddqu_si256((const __m256i *)WH_Code[r2[i]]); + + for (int j = 0; j * block_size < length; ++j) { + sse_trans((uint8_t *)d, (uint8_t *)(dT + j * block_size), block_size, + 256); + for (int i = 0; i < lambda; ++i) { + G0[i].random_data(t + (i * block_size / 256), block_size / 8); + G1[i].random_data(tmp, block_size / 8); + xorBlocks_arr(tmp, t + (i * block_size / 256), tmp, block_size / 256); + xorBlocks_arr(tmp, d + (i * block_size / 256), tmp, block_size / 256); + io->send_data(tmp, block_size / 8); + } + sse_trans((uint8_t *)(tT + j * block_size), (uint8_t *)t, 256, + block_size); + } + + delete[] dT; + delete[] r2; + + this->block_size = old_block_size; + } + + void got_send_offline(int length) { + const int bsize = ro_batch_size; + block256 *key = new (std::align_val_t(32)) block256[N * bsize]; + block128 *pad = new block128[N * bsize]; + + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + for (int k = 0; k < N; k++) { + key[N * (j - i) + k] = xorBlocks(qT[j], c_AND_s[k]); + } + } + CCRF(pad, key, N * bsize); + for (int j = i; j < i + bsize and j < length; ++j) { + for (int k = 0; k < N; k++) { + h[k][j] = ((uint8_t)_mm_extract_epi8(pad[N * (j - i) + k], 0)); + h64[k][j] = ((uint64_t)_mm_extract_epi64(pad[N * (j - i) + k], 0)); + } + } + } + delete[] qT; + delete[] key; + delete[] pad; + } + + void got_recv_offline(int length) { + const int bsize = ro_batch_size; + block128 *pad = new block128[N * bsize]; + + for (int i = 0; i < length; i += bsize) { + if (bsize <= length - i) + CCRF(pad, tT + i, bsize); + else + CCRF(pad, tT + i, length - i); + for (int j = 0; j < bsize and j < length - i; ++j) { + h[0][i + j] = ((uint8_t)_mm_extract_epi8(pad[j], 0)); + h64[0][i + j] = ((uint64_t)_mm_extract_epi64(pad[j], 0)); + } + } + delete[] tT; + delete[] pad; + } + + template <typename T> void got_send_online(T **data, int length) { + const int bsize = length; // ro_batch_size; + uint32_t y_size = (uint32_t)ceil((N * bsize * l) / ((float)sizeof(T) * 8)); + int bits_in_sel_input = sci::bitlen(N); + uint32_t a_size = (uint32_t)ceil((bsize * bits_in_sel_input) / + ((float)sizeof(uint8_t) * 8)); + T y[y_size]; + uint8_t a_packed[a_size]; + uint8_t a[length]; + T **maskeddata = new T *[bsize]; + for (int i = 0; i < bsize; i++) { + maskeddata[i] = new T[N]; + } + int32_t corrected_bsize, corrected_y_size, corrected_a_size; + uint8_t mask_a; + mask_a = (1 << bits_in_sel_input) - 1; + if (bits_in_sel_input == 8) { + mask_a = -1; + } + + for (int ctr = 0; ctr < length; ctr += bsize) { + corrected_bsize = std::min(bsize, length - ctr); + corrected_y_size = + (uint32_t)ceil((N * corrected_bsize * l) / ((float)sizeof(T) * 8)); + corrected_a_size = (uint32_t)ceil((corrected_bsize * bits_in_sel_input) / + ((float)sizeof(uint8_t) * 8)); + // Receive correction of choice input + io->recv_data(a_packed, sizeof(uint8_t) * corrected_a_size); + unpack_a<uint8_t>(a, a_packed, corrected_bsize, bits_in_sel_input); + if (sizeof(T) == 8) { + for (int i = 0; i < corrected_bsize; i++) { + for (int k = 0; k < N; k++) { + maskeddata[i][k] = + (h64[(k + a[i]) & mask_a][counter] ^ data[ctr + i][k]); + } + counter++; + } + } else if (sizeof(T) == 1) { + for (int i = 0; i < corrected_bsize; i++) { + for (int k = 0; k < N; k++) { + maskeddata[i][k] = + (h[(k + a[i]) & mask_a][counter] ^ data[ctr + i][k]); + } + counter++; + } + } else { + throw std::invalid_argument("Not yet implemented"); + } + pack_messages<T>(y, maskeddata, corrected_y_size, corrected_bsize, l, N); + io->send_data(y, sizeof(T) * corrected_y_size); + } + for (int i = 0; i < bsize; i++) { + delete[] maskeddata[i]; + } + delete[] maskeddata; + } + + template <typename T> + void got_recv_online(T *data, const uint8_t *r, int length) { + const int bsize = length; + uint32_t res_size = + (uint32_t)ceil((N * length * l) / ((float)sizeof(T) * 8)); + int bits_in_sel_input = sci::bitlen(N); + uint32_t a_size = (uint32_t)ceil((length * bits_in_sel_input) / + ((float)sizeof(uint8_t) * 8)); + T res[res_size]; + uint8_t a_unpacked[length]; + uint8_t a[a_size]; + int32_t corrected_bsize, corrected_res_size, corrected_a_size; + uint8_t mask_a; + mask_a = (1 << bits_in_sel_input) - 1; + if (bits_in_sel_input == 8) { + mask_a = -1; + } + + for (int ctr = 0; ctr < length; ctr += bsize) { + corrected_bsize = std::min(bsize, length - ctr); + corrected_res_size = + (uint32_t)ceil((N * corrected_bsize * l) / ((float)sizeof(T) * 8)); + corrected_a_size = (uint32_t)ceil((corrected_bsize * bits_in_sel_input) / + ((float)sizeof(uint8_t) * 8)); + + int counter_memory = counter; + // Send corrected choice inputs + for (int i = 0; i < corrected_bsize; i++) { + a_unpacked[i] = + (r_off[counter++] - r[ctr + i]) & mask_a; // Replicates neg_mod + } + pack_a<uint8_t>(a, a_unpacked, corrected_a_size, corrected_bsize, + bits_in_sel_input); + io->send_data(a, sizeof(uint8_t) * corrected_a_size); + counter = counter_memory; + // Receive OT messages + io->recv_data(res, sizeof(T) * corrected_res_size); + if (sizeof(T) == 8) { + unpack_messages<uint64_t>((uint64_t *)data + ctr, r + ctr, + (uint64_t *)res, h64[0], corrected_bsize, l, + N, counter); + } else if (sizeof(T) == 1) { + unpack_messages<uint8_t>((uint8_t *)data + ctr, r + ctr, (uint8_t *)res, + h[0], corrected_bsize, l, N, counter); + } else { + throw std::invalid_argument("Not yet implemented"); + } + } + } + + template <typename T> void got_send_post(T **data, int length) { + const int bsize = ro_batch_size; + block256 *key = new (std::align_val_t(32)) block256[N * bsize]; + block128 *pad = new block128[N * bsize]; + uint32_t y_size = + (uint32_t)ceil((N * bsize * this->l) / ((float)sizeof(T) * 8)); + uint32_t corrected_y_size, corrected_bsize; + T *y = new T[y_size]; + + for (int i = 0; i < length; i += bsize) { + for (int j = i; j < i + bsize and j < length; ++j) { + for (int k = 0; k < N; k++) { + key[N * (j - i) + k] = xorBlocks(qT[j], c_AND_s[k]); + } + } + CCRF(pad, key, N * bsize); + corrected_y_size = (uint32_t)ceil( + (N * std::min(bsize, length - i) * this->l) / ((float)sizeof(T) * 8)); + corrected_bsize = std::min(bsize, length - i); + if (sizeof(T) == 8) { + pack_ot_messages<uint64_t>((uint64_t *)y, (uint64_t **)data + i, pad, + corrected_y_size, corrected_bsize, this->l, + this->N); + } else if (sizeof(T) == 1) { + pack_ot_messages<uint8_t>((uint8_t *)y, (uint8_t **)data + i, pad, + corrected_y_size, corrected_bsize, this->l, + this->N); + } else { + throw std::invalid_argument("Not implemented"); + } + io->send_data(y, sizeof(T) * (corrected_y_size)); + } + delete[] qT; + delete[] y; + delete[] key; + delete[] pad; + } + + template <typename T> + void got_recv_post(T *data, const uint8_t *r, int length) { + const int bsize = ro_batch_size; + block128 *pad = new block128[N * bsize]; + uint32_t recvd_size = + (uint32_t)ceil((N * bsize * this->l) / ((float)sizeof(T) * 8)); + uint32_t corrected_recvd_size, corrected_bsize; + T *recvd = new T[recvd_size]; + for (int i = 0; i < length; i += bsize) { + uint32_t corrected_recvd_size = (uint32_t)ceil( + (N * std::min(bsize, length - i) * this->l) / ((float)sizeof(T) * 8)); + corrected_bsize = std::min(bsize, length - i); + io->recv_data(recvd, sizeof(T) * (corrected_recvd_size)); + if (bsize <= length - i) + CCRF(pad, tT + i, bsize); + else + CCRF(pad, tT + i, length - i); + + if (sizeof(T) == 8) { + unpack_ot_messages<uint64_t>((uint64_t *)data + i, r + i, + (uint64_t *)recvd, pad, corrected_bsize, + this->l, this->N); + } else if (sizeof(T) == 1) { + unpack_ot_messages<uint8_t>((uint8_t *)data + i, r + i, + (uint8_t *)recvd, pad, corrected_bsize, + this->l, this->N); + } else { + throw std::invalid_argument("Not implemented"); + } + } + delete[] tT; + delete[] pad; + delete[] recvd; + } + + void send_impl(uint8_t **data, int length, int l) { + assert(N <= lambda && N >= 2); + assert(l <= 8 && l >= 1); + // assert(((N*l*length) % 8) == 0); + this->l = l; + if (length <= precomp_batch_size) { + if (length > (precomp_batch_size - counter)) { + preprocess(); + } + got_send_online<uint8_t>(data, length); + } else { + send_pre(length); + got_send_post<uint8_t>(data, length); + } + } + + void recv_impl(uint8_t *data, uint8_t *b, int length, int l) { + assert(N <= lambda && N >= 2); + assert(l <= 8 && l >= 1); + // assert(((N*l*length) % 8) == 0); + this->l = l; + if (length <= precomp_batch_size) { + if (length > (precomp_batch_size - counter)) { + preprocess(); + } + got_recv_online<uint8_t>(data, b, length); + } else { + recv_pre(b, length); + got_recv_post<uint8_t>(data, b, length); + } + } + + void send_impl(uint64_t **data, int length, int l) { + assert(N <= lambda && N >= 2); + // assert(l > 8); + this->l = l; + if (length <= precomp_batch_size) { + if (length > (precomp_batch_size - counter)) { + preprocess(); + } + got_send_online<uint64_t>(data, length); + } else { + send_pre(length); + got_send_post<uint64_t>(data, length); + } + } + + void recv_impl(uint64_t *data, uint8_t *b, int length, int l) { + assert(N <= lambda && N >= 2); + // assert(l > 8); + this->l = l; + if (length <= precomp_batch_size) { + if (length > (precomp_batch_size - counter)) { + preprocess(); + } + got_recv_online<uint64_t>(data, b, length); + } else { + recv_pre(b, length); + got_recv_post<uint64_t>(data, b, length); + } + } }; -} -#endif// SPLIT_OT_KKOT_H__ +} // namespace sci +#endif // SPLIT_OT_KKOT_H__ diff --git a/SCI/src/OT/split-utils.h b/SCI/src/OT/split-utils.h index bbb410a5..5f49ecc4 100644 --- a/SCI/src/OT/split-utils.h +++ b/SCI/src/OT/split-utils.h @@ -1,5 +1,5 @@ /* -Authors: Mayank Rathee +Authors: Mayank Rathee, Deevashwer Rathee Copyright: Copyright (c) 2020 Microsoft Research Permission is hereby granted, free of charge, to any person obtaining a copy @@ -24,191 +24,167 @@ SOFTWARE. #include "OT/ot.h" namespace sci { - template<typename basetype> - void pack_a( - basetype* a, - basetype* a_unpacked, - int asize, - int bsize, - int bitsize) - { - assert(a != nullptr && a_unpacked != nullptr); - uint64_t start_pos = 0; - uint64_t end_pos = 0; - uint64_t start_block = 0; - uint64_t end_block = 0; - basetype temp_bl = 0; - basetype mask = (1<<bitsize)-1; - if(8*sizeof(basetype) == 64){ - mask = (basetype)((1ULL<<bitsize)-1ULL); - } - if(8*sizeof(basetype) == bitsize){ - if(bitsize == 64){ - mask = (basetype)(-1ULL); - } - else{ - mask = (basetype)(-1); - } - } - uint64_t carriersize = 8*(sizeof(basetype)); - for(int i=0; i<asize; i++){ - a[i] = 0; - } - for(int i=0; i<bsize; i++){ - start_pos = i*bitsize; - end_pos = start_pos + bitsize - 1; // inclusive - start_block = start_pos/carriersize; - end_block = end_pos/carriersize; - if(start_block == end_block){ - a[start_block] ^= ((a_unpacked[i] & mask)<<(start_pos % carriersize)); - } - else{ - temp_bl = (a_unpacked[i] & mask); - a[start_block] ^= (temp_bl)<<(start_pos % carriersize); - a[end_block] ^= (temp_bl)>>(carriersize - (start_pos % carriersize)); - } - } - } +template <typename basetype> +void pack_a(basetype *a, basetype *a_unpacked, int asize, int bsize, + int bitsize) { + assert(a != nullptr && a_unpacked != nullptr); + uint64_t start_pos = 0; + uint64_t end_pos = 0; + uint64_t start_block = 0; + uint64_t end_block = 0; + basetype temp_bl = 0; + basetype mask = (1 << bitsize) - 1; + if (8 * sizeof(basetype) == 64) { + mask = (basetype)((1ULL << bitsize) - 1ULL); + } + if (8 * sizeof(basetype) == bitsize) { + if (bitsize == 64) { + mask = (basetype)(-1ULL); + } else { + mask = (basetype)(-1); + } + } + uint64_t carriersize = 8 * (sizeof(basetype)); + for (int i = 0; i < asize; i++) { + a[i] = 0; + } + for (int i = 0; i < bsize; i++) { + start_pos = i * bitsize; + end_pos = start_pos + bitsize - 1; // inclusive + start_block = start_pos / carriersize; + end_block = end_pos / carriersize; + if (start_block == end_block) { + a[start_block] ^= ((a_unpacked[i] & mask) << (start_pos % carriersize)); + } else { + temp_bl = (a_unpacked[i] & mask); + a[start_block] ^= (temp_bl) << (start_pos % carriersize); + a[end_block] ^= (temp_bl) >> (carriersize - (start_pos % carriersize)); + } + } +} + +template <typename basetype> +void unpack_a(basetype *a, basetype *a_packed, int bsize, int bitsize) { + assert(a != nullptr && a_packed != nullptr); + uint64_t start_pos = 0; + uint64_t end_pos = 0; + uint64_t start_block = 0; + uint64_t end_block = 0; + basetype mask = (1 << bitsize) - 1; + if (8 * sizeof(basetype) == 64) { + mask = (basetype)((1ULL << bitsize) - 1ULL); + } + if (8 * sizeof(basetype) == bitsize) { + if (bitsize == 64) { + mask = (basetype)(-1ULL); + } else { + mask = (basetype)(-1); + } + } + uint64_t carriersize = 8 * (sizeof(basetype)); - template<typename basetype> - void unpack_a( - basetype* a, - basetype* a_packed, - int bsize, - int bitsize) - { - assert(a != nullptr && a_packed != nullptr); - uint64_t start_pos = 0; - uint64_t end_pos = 0; - uint64_t start_block = 0; - uint64_t end_block = 0; - basetype mask = (1<<bitsize)-1; - if(8*sizeof(basetype) == 64){ - mask = (basetype)((1ULL<<bitsize)-1ULL); - } - if(8*sizeof(basetype) == bitsize){ - if(bitsize == 64){ - mask = (basetype)(-1ULL); - } - else{ - mask = (basetype)(-1); - } - } - uint64_t carriersize = 8*(sizeof(basetype)); + for (int i = 0; i < bsize; i++) { + start_pos = i * bitsize; + end_pos = start_pos + bitsize - 1; // inclusive + start_block = start_pos / carriersize; + end_block = end_pos / carriersize; + if (start_block == end_block) { + a[i] = (a_packed[start_block] >> (start_pos % carriersize)) & mask; + } else { + a[i] = 0; + a[i] ^= (a_packed[start_block] >> (start_pos % carriersize)); + a[i] ^= + (a_packed[end_block] << (carriersize - (start_pos % carriersize))); + a[i] = a[i] & mask; + } + } +} - for(int i=0; i<bsize; i++){ - start_pos = i*bitsize; - end_pos = start_pos + bitsize - 1; // inclusive - start_block = start_pos/carriersize; - end_block = end_pos/carriersize; - if(start_block == end_block){ - a[i] = (a_packed[start_block]>>(start_pos % carriersize)) & mask; - } - else{ - a[i] = 0; - a[i] ^= (a_packed[start_block]>>(start_pos % carriersize)); - a[i] ^= (a_packed[end_block]<<(carriersize - (start_pos % carriersize))); - a[i] = a[i] & mask; - } - } - } +template <typename basetype> +void pack_messages(basetype *y, basetype **maskeddata, int ysize, int bsize, + int bitsize, int N) { + assert(y != nullptr && maskeddata != nullptr); + uint64_t start_pos = 0; + uint64_t end_pos = 0; + uint64_t start_block = 0; + uint64_t end_block = 0; + basetype temp_bl = 0; + basetype mask = (1 << bitsize) - 1; + if (8 * sizeof(basetype) == 64) { + mask = (basetype)((1ULL << bitsize) - 1ULL); + } + if (8 * sizeof(basetype) == bitsize) { + if (bitsize == 64) { + mask = (basetype)(-1ULL); + } else { + mask = (basetype)(-1); + } + } + uint64_t carriersize = 8 * (sizeof(basetype)); + for (int i = 0; i < ysize; i++) { + y[i] = 0; + } + for (int i = 0; i < bsize; i++) { + for (int k = 0; k < N; k++) { + // OT message k + start_pos = i * N * bitsize + k * bitsize; // inclusive + end_pos = start_pos + bitsize; + end_pos -= 1; // inclusive + start_block = start_pos / carriersize; + end_block = end_pos / carriersize; - template<typename basetype> - void pack_messages(basetype* y, - basetype** maskeddata, - int ysize, - int bsize, - int bitsize, - int N) - { - assert(y != nullptr && maskeddata != nullptr); - uint64_t start_pos = 0; - uint64_t end_pos = 0; - uint64_t start_block = 0; - uint64_t end_block = 0; - basetype temp_bl = 0; - basetype mask = (1<<bitsize)-1; - if(8*sizeof(basetype) == 64){ - mask = (basetype)((1ULL<<bitsize)-1ULL); - } - if(8*sizeof(basetype) == bitsize){ - if(bitsize == 64){ - mask = (basetype)(-1ULL); - } - else{ - mask = (basetype)(-1); - } - } - uint64_t carriersize = 8*(sizeof(basetype)); - for(int i=0; i<ysize; i++){ - y[i] = 0; - } - for(int i=0; i<bsize; i++){ - for(int k=0; k<N; k++){ - // OT message k - start_pos = i*N*bitsize + k*bitsize; //inclusive - end_pos = start_pos + bitsize; - end_pos -= 1; //inclusive - start_block = start_pos/carriersize; - end_block = end_pos/carriersize; + if (start_block == end_block) { + y[start_block] ^= (maskeddata[i][k] & mask) + << (start_pos % carriersize); + } else { + temp_bl = (maskeddata[i][k] & mask); + y[start_block] ^= (temp_bl) << (start_pos % carriersize); + y[end_block] ^= (temp_bl) >> (carriersize - (start_pos % carriersize)); + } + } + } +} - if(start_block == end_block){ - y[start_block] ^= (maskeddata[i][k] & mask)<<(start_pos % carriersize); - } - else{ - temp_bl = (maskeddata[i][k] & mask); - y[start_block] ^= (temp_bl)<<(start_pos % carriersize); - y[end_block] ^= (temp_bl)>>(carriersize - (start_pos % carriersize)); - } - } - } - } +template <typename basetype> +void unpack_messages(basetype *data, const uint8_t *r, basetype *recvd, + basetype *maskhash, int bsize, int bitsize, int N, + int &counter) { + assert(data != nullptr && maskhash != nullptr); + uint64_t start_pos = 0; + uint64_t end_pos = 0; + uint64_t start_block = 0; + uint64_t end_block = 0; + basetype mask = (1 << bitsize) - 1; + if (8 * sizeof(basetype) == 64) { + mask = (basetype)((1ULL << bitsize) - 1ULL); + } + if (8 * sizeof(basetype) == bitsize) { + if (bitsize == 64) { + mask = (basetype)(-1ULL); + } else { + mask = (basetype)(-1); + } + } + uint64_t carriersize = 8 * (sizeof(basetype)); - template<typename basetype> - void unpack_messages(basetype* data, - const uint8_t* r, - basetype* recvd, - basetype* maskhash, - int bsize, - int bitsize, - int N, - int &counter) - { - assert(data != nullptr && maskhash != nullptr); - uint64_t start_pos = 0; - uint64_t end_pos = 0; - uint64_t start_block = 0; - uint64_t end_block = 0; - basetype mask = (1<<bitsize)-1; - if(8*sizeof(basetype) == 64){ - mask = (basetype)((1ULL<<bitsize)-1ULL); - } - if(8*sizeof(basetype) == bitsize){ - if(bitsize == 64){ - mask = (basetype)(-1ULL); - } - else{ - mask = (basetype)(-1); - } - } - uint64_t carriersize = 8*(sizeof(basetype)); - - for(int i=0; i<bsize; i++){ - start_pos = i*N*bitsize + r[i]*bitsize; - end_pos = start_pos + bitsize - 1; //inclusive - start_block = start_pos/carriersize; - end_block = end_pos/carriersize; - if(start_block == end_block){ - data[i] = ((recvd[start_block]>>(start_pos % carriersize)) ^ maskhash[counter]) & mask; - } - else{ - data[i] = 0; - data[i] ^= (recvd[start_block]>>(start_pos % carriersize)); - data[i] ^= (recvd[end_block]<<(carriersize - (start_pos % carriersize))); - data[i] = (data[i] ^ maskhash[counter]) & mask; - } - counter++; - } - } + for (int i = 0; i < bsize; i++) { + start_pos = i * N * bitsize + r[i] * bitsize; + end_pos = start_pos + bitsize - 1; // inclusive + start_block = start_pos / carriersize; + end_block = end_pos / carriersize; + if (start_block == end_block) { + data[i] = ((recvd[start_block] >> (start_pos % carriersize)) ^ + maskhash[counter]) & + mask; + } else { + data[i] = 0; + data[i] ^= (recvd[start_block] >> (start_pos % carriersize)); + data[i] ^= + (recvd[end_block] << (carriersize - (start_pos % carriersize))); + data[i] = (data[i] ^ maskhash[counter]) & mask; + } + counter++; + } } -#endif //SPLIT_UTIL_H__ +} // namespace sci +#endif // SPLIT_UTIL_H__ diff --git a/SCI/src/cleartext_library_fixed.cpp b/SCI/src/cleartext_library_fixed.cpp new file mode 100644 index 00000000..c3f5947f --- /dev/null +++ b/SCI/src/cleartext_library_fixed.cpp @@ -0,0 +1,1224 @@ +/* +Authors: Deevashwer Rathee, G Rahul Kranti Kiran +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "cleartext_library_fixed.h" + +using namespace std; +using namespace sci; + +inline int64_t Saturate(int32_t inp) { return (int64_t)inp; } + +void cleartext_Sigmoid(int64_t *A, int I, int J, int scale_in, int scale_out, + int bwA, int bwB, int64_t *B) { + int32_t sA = log2(scale_in); + int32_t sB = log2(scale_out); + + int64_t *neg_A = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + if (A[i] < 0) { + neg_A[i] = int64_t(A[i]); + } else { + neg_A[i] = (-1LL * int64_t(A[i])); + } + // std::cout << neg_A[i] << std::endl; + } + + int64_t *exp_neg_A = new int64_t[I * J]; + cleartext_Exp_lookup(neg_A, I, J, bwA, scale_in, scale_out, exp_neg_A, 1); + int64_t *sig_neg_A = new int64_t[I * J]; + int64_t *all1 = new int64_t[I * J]; + int64_t *den = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + if (exp_neg_A[i] == (1 << sB)) { + den[i] = (exp_neg_A[i] + (1LL << sB) - 1); + } else { + den[i] = (exp_neg_A[i] + (1LL << sB)); + } + all1[i] = 1; + } + cleartext_div(all1, den, I, J, 1, scale_out, scale_out, sig_neg_A, false); + + int64_t error = 0; + for (int i = 0; i < I * J; i++) { + if (A[i] >= 0) { + B[i] = all1Mask(bwB) & sig_neg_A[i]; + } else { + B[i] = all1Mask(bwB) & ((exp_neg_A[i] * sig_neg_A[i]) >> sB); + } + double flA = (A[i] / double(1LL << sA)); + double sig_A = 1.0 / (1.0 + exp(-1.0 * flA)); + int64_t actualB = sig_A * (1LL << sB); + error += abs(actualB - B[i]); + } + if (party == 2) { + std::cout << "Sigmoid Average Error: " << error / (I * J) << std::endl; + } + + delete[] neg_A; + delete[] exp_neg_A; + delete[] all1; + delete[] sig_neg_A; + delete[] den; + + return; +} + +void cleartext_TanH(int64_t *A, int32_t I, int32_t J, int64_t scale_in, + int64_t scale_out, int32_t bwA, int32_t bwB, int64_t *B) { +#ifdef APPROXIMATE_TANH + for (int i = 0; i < I * J; i++) { + float a = float(A[i]) / scale_in; + float b = a; + + if (b < -1) + b = -1; + else if (b > 1) + b = 1; + B[i] = b * scale_out; + } +#else + int32_t sA = log2(scale_in); + int32_t sB = log2(scale_out); + + int64_t *neg_A = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + if (A[i] < 0) { + neg_A[i] = int64_t(A[i]); + } else { + neg_A[i] = (-1LL * int64_t(A[i])); + } + } + int64_t *exp_neg_2A = new int64_t[I * J]; + // scale_in/2 because we need exp(-2x) + cleartext_Exp_lookup(neg_A, I, J, bwA, scale_in / 2, scale_out, exp_neg_2A, + 1); + int64_t *tanh_neg_A = new int64_t[I * J]; + int64_t *num = new int64_t[I * J]; + int64_t *den = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + if (exp_neg_2A[i] == (1 << sB)) { + den[i] = (exp_neg_2A[i] + (1LL << sB) - 1); + } else { + den[i] = (exp_neg_2A[i] + (1LL << sB)); + } + num[i] = (1LL << sB) - exp_neg_2A[i]; + } + cleartext_div(num, den, I, J, scale_out, scale_out, scale_out, tanh_neg_A, + false); + + int64_t error = 0; + for (int i = 0; i < I * J; i++) { + if (A[i] >= 0) { + B[i] = Saturate(tanh_neg_A[i]); + } else { + B[i] = Saturate(-1 * tanh_neg_A[i]); + } + double flA = (A[i] / double(1LL << sA)); + double tanh_A = tanh(flA); + int64_t actualB = tanh_A * (1LL << sB); + error += abs(actualB - B[i]); + } + if (party == 2) { + std::cout << "TanH Average Error: " << error / (I * J) << std::endl; + } + + delete[] neg_A; + delete[] exp_neg_2A; + delete[] num; + delete[] den; + delete[] tanh_neg_A; + + return; +#endif +} + +void cleartext_MatAdd(int64_t *A, int64_t *B, int64_t *C, int32_t I, int32_t J, + int32_t shrA, int32_t shrB, int32_t shrC, + int32_t demote) { + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t a = (int64_t)A[i * J + j]; + int64_t b = (int64_t)B[i * J + j]; + +#ifdef DIV_RESCALING + a = a / (shrA * shrC); + b = b / (shrB * shrC); +#else + a = a >> (shiftA + shiftC); + b = b >> (shiftB + shiftC); +#endif + + int64_t c = a + b; + +#ifdef DIV_RESCALING + C[i * J + j] = Saturate(c / demote); +#else + C[i * J + j] = Saturate(c >> shift_demote); +#endif + } + } + return; +} + +void cleartext_MatSub(int64_t *A, const int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, int32_t shrC, + int32_t demote) { + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t a = (int64_t)A[i * J + j]; + int64_t b = (int64_t)B[i * J + j]; + +#ifdef DIV_RESCALING + a = a / (shrA * shrC); + b = b / (shrB * shrC); +#else + a = a >> (shiftA + shiftC); + b = b >> (shiftB + shiftC); +#endif + + int64_t c = a - b; + +#ifdef DIV_RESCALING + C[i * J + j] = Saturate(c / demote); +#else + C[i * J + j] = Saturate(c >> shift_demote); +#endif + } + } + return; +} + +void cleartext_MatMul(int64_t *A, int64_t *B, int64_t *C, int64_t *tmp, + int32_t I, int32_t K, int32_t J, int32_t shrA, + int32_t shrB, int32_t H1, int32_t H2, int32_t demote) { + // /* + // int64_t* temp = new int64_t[K]; + int64_t *temp = new int64_t[K]; + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shift_demote = log2(demote); + int depth = ceil(log2(K)); + int32_t shift = shiftA + shiftB + shift_demote + H1 - depth; + + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + for (int k = 0; k < K; k++) { + int64_t a = (int64_t)A[i * K + k]; + int64_t b = (int64_t)B[k * J + j]; + + // int64_t prod = a * b; + int64_t prod = int64_t(a) * int64_t(b); + + temp[k] = prod; + } + // int64_t sum = 0; + int64_t sum = 0; + for (int k = 0; k < K; k++) { + // sum += (temp[k] >> depth); + sum += temp[k]; + } + sum = (sum >> depth); + // C[i * J + j] = Saturate(sum >> (shiftA + shiftB + shift_demote)); + if (shift >= 0) { +#ifdef DIV_RESCALING + C[i * J + j] = Saturate(sum / (1LL << shift)); +#else + C[i * J + j] = Saturate(sum >> shift); +#endif + } else { + C[i * J + j] = Saturate(sum * (1LL << (-1 * shift))); + } + } + } + + delete[] temp; + return; + // */ +} + +void cleartext_MatAddBroadCastA(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, + int32_t shrC, int32_t demote) { + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t a = (int64_t)*A; + int64_t b = (int64_t)B[i * J + j]; + +#ifdef DIV_RESCALING + a = a / (shrA * shrC); + b = b / (shrB * shrC); +#else + a = a >> (shiftA + shiftC); + b = b >> (shiftB + shiftC); +#endif + + int64_t c = a + b; + +#ifdef DIV_RESCALING + C[i * J + j] = Saturate(c / demote); +#else + C[i * J + j] = Saturate(c >> shift_demote); +#endif + } + } + return; +} + +void cleartext_MatAddBroadCastB(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, + int32_t shrC, int32_t demote) { + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t a = (int64_t)A[i * J + j]; + int64_t b = (int64_t)*B; + +#ifdef DIV_RESCALING + a = a / (shrA * shrC); + b = b / (shrB * shrC); +#else + a = a >> (shiftA + shiftC); + b = b >> (shiftB + shiftC); +#endif + + int64_t c = a + b; + +#ifdef DIV_RESCALING + C[i * J + j] = Saturate(c / demote); +#else + C[i * J + j] = Saturate(c >> shift_demote); +#endif + } + } + return; +} + +void cleartext_MatSubBroadCastA(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, + int32_t shrC, int32_t demote) { + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t a = (int64_t)*A; + int64_t b = (int64_t)B[i * J + j]; + +#ifdef DIV_RESCALING + a = a / (shrA * shrC); + b = (-1 * b) / (shrB * shrC); +#else + a = a >> (shiftA + shiftC); + b = (-1 * b) >> (shiftB + shiftC); +#endif + + int64_t c = a + b; + +#ifdef DIV_RESCALING + C[i * J + j] = Saturate(c / demote); +#else + C[i * J + j] = Saturate(c >> shift_demote); +#endif + } + } + return; +} + +void cleartext_MatSubBroadCastB(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, + int32_t shrC, int32_t demote) { + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t a = (int64_t)A[i * J + j]; + int64_t b = (int64_t)*B; + +#ifdef DIV_RESCALING + a = a / (shrA * shrC); + b = (-1 * b) / (shrB * shrC); +#else + a = a >> (shiftA + shiftC); + b = (-1 * b) >> (shiftB + shiftC); +#endif + + int64_t c = a + b; + +#ifdef DIV_RESCALING + C[i * J + j] = Saturate(c / demote); +#else + C[i * J + j] = Saturate(c >> shift_demote); +#endif + } + } + return; +} + +void cleartext_ScalarMul(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, int demote) { + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shift_demote = log2(demote); + int64_t a = (int64_t)*A; + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t b = (int64_t)B[i * J + j]; + + int64_t prod = a * b; + +#ifdef DIV_RESCALING + C[i * J + j] = Saturate(prod / (shrA * shrB * demote)); +#else + C[i * J + j] = Saturate(prod >> (shiftA + shiftB + shift_demote)); +#endif + } + } + + return; +} + +void cleartext_MulCir(int64_t *A, int64_t *B, int64_t *C, int32_t I, int32_t J, + int32_t shrA, int32_t shrB, int32_t demote) { + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shift_demote = log2(demote); + + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t a = (int64_t)A[i * J + j]; + int64_t b = (int64_t)B[i * J + j]; + + int64_t prod = a * b; + +#ifdef DIV_RESCALING + C[i * J + j] = Saturate(prod / (shrA * shrB * demote)); +#else + C[i * J + j] = Saturate(prod >> (shiftA + shiftB + shift_demote)); +#endif + } + } + return; +} + +void cleartext_sqrt(int64_t *A, int32_t I, int32_t J, int32_t shrA, + int32_t shrB, int32_t bwA, int32_t bwB, int64_t *B, + bool inverse) { + int32_t sA = log2(shrA); + int32_t sB = log2(shrB); + int32_t m, iters; + if (sB <= 14) { + m = ceil(sB / 2.0); + iters = 1; + } else { + m = ceil((ceil(sB / 2.0)) / 2.0); + iters = 2; + } + assert(m <= KKOT_LIMIT); + assert(sA >= m); + + int64_t m_mask = (1LL << m) - 1; + int64_t error = 0; + for (int i = 0; i < I * J; i++) { + assert(A[i] >= 0); + int32_t msnzb = floor(log2(int64_t(A[i]))); + int32_t adjust_amt = bwA - 2 - msnzb; + int64_t adjust = (1LL << adjust_amt); + int64_t sqrt_adjust_scale = + (inverse ? floor((bwA - 1 - sA) / 2.0) : floor((sA + 1) / 2.0)); + int64_t sqrt_adjust; + if (inverse) { + sqrt_adjust = + (1LL << int(floor((sA - msnzb + 1) / 2.0) + sqrt_adjust_scale)); + } else { + sqrt_adjust = (1LL << int(floor((msnzb - sA) / 2.0) + sqrt_adjust_scale)); + } + int64_t exp_parity = ((msnzb - sA) & 1); + // shifted_A: bw = bwA - 1, scale = bwA - 2 + int64_t shifted_A = int64_t(A[i]) * adjust; + + // Top m bits of shifted_A excluding MSB, which is always 1 + // A_m: bw = m, scale = m + int64_t A_m = (int64_t(shifted_A) >> (bwA - 2 - m)) & m_mask; + // Y: bw = m + SQRT_LOOKUP_SCALE + 1, scale = m + SQRT_LOOKUP_SCALE + int64_t Y = lookup_sqrt(A_m, m, exp_parity); + + // X = (exp_parity ? 2 * shifted_A : shifted_A); scale = bwA - 2 + // X: bw = bwA + int64_t X = (exp_parity ? 2 * shifted_A : shifted_A); + + int64_t x_prev; + if (inverse) { + // x_prev : bw = m + SQRT_LOOKUP_SCALE + 1, scale = m + SQRT_LOOKUP_SCALE + // x_prev \approx 0.5 < 1/sqrt(X) < 1 + x_prev = Y; + } else { + // x_prev : bw = sB + 1, scale = sB + // x_prev \approx 1 < sqrt(X) < 2 + x_prev = (X * Y); + if (bwA - 2 + m + SQRT_LOOKUP_SCALE > sB) { + x_prev = x_prev >> (bwA - 2 + m + SQRT_LOOKUP_SCALE - sB); + } else { + x_prev = x_prev << (sB - bwA + 2 - m - SQRT_LOOKUP_SCALE); + } + } + // b_prev_scale = sB + int64_t b_prev = X; + if (bwA - 2 > sB) { + b_prev = b_prev >> (bwA - 2 - sB); + } else { + b_prev = b_prev << (sB + 2 - bwA); + } + // Y_prev_scale = m + 1 + int64_t Y_prev = Y; + int64_t x_curr, b_curr, Y_curr; + for (int j = 0; j < iters; j++) { + int64_t Y_sq = Y_prev * Y_prev; + if (j == 0) { + // b_curr: bw = sB + 2, scale = sB + b_curr = (Y_sq * b_prev) >> (2 * m + 2 * SQRT_LOOKUP_SCALE); + } else { + Y_sq = Y_sq >> (sB + 2); + // b_curr: bw = sB + 2, scale = sB + b_curr = (Y_sq * b_prev) >> sB; + } + // Y_curr: bw = sB + 2, scale = sB + 1 + // Y_curr = (3 - b_curr)/2 + Y_curr = (1.5 * (1LL << (sB + 1))) - b_curr; + x_curr = x_prev * Y_curr; + if (inverse && (j == 0)) { + // x_curr: bw = sB + 1, scale = sB + x_curr = x_curr >> (m + SQRT_LOOKUP_SCALE + 1); + } else { + // x_curr: bw = sB + 1, scale = sB + x_curr = x_curr >> (sB + 1); + } + x_prev = x_curr; + b_prev = b_curr; + Y_prev = Y_curr; + } + int64_t res; + if (iters > 0 || (!inverse)) { + res = x_curr * sqrt_adjust; + res = res >> sqrt_adjust_scale; + } else { + // Scale of x_curr is m + 1 if iters == 0 and sB = m + res = x_curr * sqrt_adjust; + res = res >> (sqrt_adjust_scale + SQRT_LOOKUP_SCALE); + } + B[i] = Saturate(res); + + double flA = (A[i] / double(1LL << sA)); + double sqrt_A = (inverse ? 1.0 / sqrt(flA) : sqrt(flA)); + int64_t actualB = sqrt_A * (1LL << sB); + error += abs(actualB - B[i]); + } + if (party == 2) { + std::cout << "Sqrt Average Error: " << error / (I * J) << std::endl; + } + + return; +} + +void cleartext_div(int64_t *A, int64_t *B, int32_t I, int32_t J, int32_t shrA, + int32_t shrB, int32_t shrC, int64_t *C, bool compute_msnzb) { + int32_t bwA = sizeof(int64_t) * 8; + int32_t bwB = sizeof(int64_t) * 8; + int32_t bwC = sizeof(int64_t) * 8; + int32_t sA = log2(shrA); + int32_t sB = log2(shrB); + int32_t sC = log2(shrC); + int32_t m, iters; + m = (sC <= 18 ? ceil((sC - 2) / 2.0) : ceil((ceil(sC / 2.0) - 2) / 2.0)); + iters = (sC <= 18 ? 0 : 1); + assert(m <= KKOT_LIMIT); + assert(sB >= m); + + int64_t m_mask = (1LL << m) - 1; + uint64_t s_min_m_mask = (1ULL << (sB - m)) - 1; + int64_t error = 0; + for (int i = 0; i < I * J; i++) { + int32_t tmp_sB; + int32_t msnzb, s_adjust; + int64_t adjust, tmpB; + if (compute_msnzb) { + msnzb = floor(log2(int64_t(A[i]))); + tmp_sB = bwB - 1; + s_adjust = bwB - 1 - sB; + int32_t adjust_amt = bwB - 1 - msnzb; + adjust = (1LL << adjust_amt); + tmpB = (adjust * int64_t(B[i])); + } else { + assert((B[i] >= (1LL << sB)) && (B[i] < (2LL << sB))); + tmpB = int64_t(B[i]); + tmp_sB = sB; + } + int64_t B_m = (tmpB >> (tmp_sB - m)) & m_mask; + int64_t A0 = lookup_div_A0(B_m, m); + int64_t A1 = lookup_div_A1(B_m, m); + int64_t Q = tmpB & s_min_m_mask; + int64_t A0_Q = A0 * Q; + // reciprocal approximation of B with precision sC + int64_t Y = ((A1 << (tmp_sB + 1 - m)) - A0_Q) >> (tmp_sB + m + 3 - sC); + int64_t a0 = (int64_t(A[i]) * Y) >> sA; + if (compute_msnzb) { + a0 = (a0 * adjust) >> s_adjust; + } + if (iters > 0) { + int64_t e = (tmpB * Y) >> sB; + // e0 = 1 - e + int64_t e0 = (1LL << sC) - e; + int64_t a_prev = a0, e_prev = e0, a_curr, e_curr; + for (int j = 0; j < iters - 1; j++) { + e_curr = (e_prev * e_prev) >> sC; + a_curr = (a_prev * ((1LL << sC) + e_prev)) >> sC; + a_prev = a_curr; + e_prev = e_curr; + } + a0 = (a_prev * ((1LL << sC) + e_prev)) >> sC; + } + C[i] = Saturate(a0); + + double flA = (A[i] / double(1LL << sA)); + double flB = (B[i] / double(1LL << sB)); + double A_by_B = flA / flB; + int64_t actualC = A_by_B * (1LL << sC); + error += abs(actualC - C[i]); + } + if (party == 2) { + std::cout << "Div Average Error: " << error / (I * J) << std::endl; + } + + return; +} + +void cleartext_Exp_lookup(int64_t *A, int32_t I, int32_t J, int bwA, + int32_t shrA, int32_t shrB, int64_t *B, + int32_t demote) { + int32_t sA = log2(shrA); + int32_t sB = log2(shrB); + int32_t s_demote = log2(demote); + int32_t LUT_size = KKOT_LIMIT; + + int digit_size = LUT_size; + int num_digits = ceil(double(bwA) / digit_size); + int last_digit_size = bwA - (num_digits - 1) * digit_size; + int64_t digit_mask = (digit_size == 64 ? -1 : (1LL << digit_size) - 1); + int64_t A_digits[num_digits]; + int64_t error = 0; + for (int i = 0; i < I * J; i++) { + assert(A[i] <= 0); + int64_t neg_A = -1LL * (A[i]); + for (int j = 0; j < num_digits; j++) { + A_digits[j] = (neg_A >> (j * digit_size)) & digit_mask; + A_digits[j] = lookup_neg_exp(A_digits[j], sA - digit_size * j, sB); + } + for (int j = 1; j < num_digits; j *= 2) { + for (int k = 0; k < num_digits and k + j < num_digits; k += 2 * j) { + A_digits[k] = (A_digits[k + j] * A_digits[k]) >> sB; + } + } + B[i] = Saturate(A_digits[0] >> s_demote); + double flA = (A[i] / double(1LL << sA)); + double expA = exp(flA); + int64_t actualB = expA * (1LL << sB); + error += abs(actualB - B[i]); + } + if (party == 2) { + std::cout << "Exp Average Error: " << error / (I * J) << std::endl; + } + + return; +} + +void cleartext_ArgMax(int64_t *A, int32_t I, int32_t J, int32_t *index) { + int64_t max = A[0]; + int32_t maxIndex = 0, counter = 0; + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t x = A[i * J + j]; + + if (max < x) { + maxIndex = counter; + max = x; + } + + counter++; + } + } + + *index = maxIndex; + + return; +} + +void cleartext_Convolution(int64_t *A, int64_t *B, int64_t *C, int64_t *tmp, + int32_t N, int32_t H, int32_t W, int32_t CIN, + int32_t HF, int32_t WF, int32_t CINF, int32_t COUTF, + int32_t HOUT, int32_t WOUT, int32_t HPADL, + int32_t HPADR, int32_t WPADL, int32_t WPADR, + int32_t HSTR, int32_t WSTR, int32_t HDL, int32_t WDL, + int32_t G, int32_t shrA, int32_t shrB, int32_t H1, + int32_t H2, int32_t demote) { + int32_t HOffsetL = HDL * (HF / 2) - HPADL; + int32_t WOffsetL = WDL * (WF / 2) - WPADL; + int32_t HOffsetR = HDL * (HF / 2) - HPADR; + int32_t WOffsetR = WDL * (WF / 2) - WPADR; + + int K = HF * WF * CINF; + int64_t *temp = new int64_t[K]; + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shift_demote = log2(demote); + int depth = ceil(log2(K)); + int32_t shift = shiftA + shiftB + shift_demote + H1 - depth; + + for (int32_t n = 0; n < N; n++) { + for (int32_t h = HOffsetL, hout = 0; h < H - HOffsetR; h += HSTR, hout++) { + for (int32_t w = WOffsetL, wout = 0; w < W - WOffsetR; + w += WSTR, wout++) { + for (int32_t g = 0; g < G; g++) { + for (int32_t co = 0; co < COUTF; co++) { + + int32_t counter = 0; + for (int32_t hf = -(HF / 2); hf <= HF / 2; hf++) { + for (int32_t wf = -(WF / 2); wf <= WF / 2; wf++) { + for (int32_t ci = 0; ci < CINF; ci++) { + + int64_t a = + (int64_t)(((h + HDL * hf) < 0) || ((h + HDL * hf) >= H) || + ((w + WDL * wf) < 0) || ((w + WDL * wf) >= W)) + ? 0 + : A[n * H * W * CIN + (h + HDL * hf) * W * CIN + + (w + WDL * wf) * CIN + (ci + g * CINF)]; + + int64_t b = (int64_t) + B[g * HF * WF * CINF * COUTF + + (hf + HF / 2) * WF * CINF * COUTF + + (wf + WF / 2) * CINF * COUTF + ci * COUTF + co]; + + // tmp[counter] = a * b; + int64_t prod = int64_t(a) * int64_t(b); + temp[counter] = prod; + counter++; + } + } + } + + int64_t sum = 0; + for (int k = 0; k < K; k++) { + sum += temp[k]; + } + sum = (sum >> depth); + int C_idx = n * HOUT * WOUT * (COUTF * G) + + hout * WOUT * (COUTF * G) + wout * (COUTF * G) + + (co + g * COUTF); + if (shift >= 0) { +#ifdef DIV_RESCALING + C[C_idx] = Saturate(sum / (1LL << shift)); +#else + C[C_idx] = Saturate(sum >> shift); +#endif + } else { + C[C_idx] = Saturate(sum * (1LL << (-1 * shift))); + } + // C[n * HOUT * WOUT * (COUTF * G) + hout * WOUT * (COUTF * G) + + // wout * (COUTF * G) + (co + g * COUTF)] = Saturate(((tmp[0] / + // shrA) / shrB) / demote); + } + } + } + } + } + delete[] temp; +} + +void cleartext_AddOrSubCir4D(int64_t *A, int64_t *B, int64_t *X, int32_t N, + int32_t H, int32_t W, int32_t C, int32_t shrA, + int32_t shrB, int32_t shrC, bool add, + int32_t demote) { + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + + for (int n = 0; n < N; n++) { + for (int h = 0; h < H; h++) { + for (int w = 0; w < W; w++) { + for (int c = 0; c < C; c++) { + int64_t a = (int64_t)A[n * H * W * C + h * W * C + w * C + c]; + int64_t b = (int64_t)B[c]; +#ifdef DIV_RESCALING + a = a / (shrA * shrC); + b = b / (shrB * shrC); +#else + a = a >> (shiftA + shiftC); + b = b >> (shiftB + shiftC); +#endif + + int64_t res; + if (add) + res = a + b; + else + res = a - b; + +#ifdef DIV_RESCALING + X[n * H * W * C + h * W * C + w * C + c] = Saturate(res / demote); +#else + X[n * H * W * C + h * W * C + w * C + c] = + Saturate(res >> shift_demote); +#endif + } + } + } + } + return; +} + +void cleartext_Relu6(int64_t *A, int64_t *B, int32_t N, int32_t H, int32_t W, + int32_t C, int64_t six, int32_t div) { + int32_t shift_div = log2(div); + + for (int n = 0; n < N; n++) { + for (int h = 0; h < H; h++) { + for (int w = 0; w < W; w++) { + for (int c = 0; c < C; c++) { + int64_t a = A[n * H * W * C + h * W * C + w * C + c]; + if (a < 0) + a = 0; + if (a > six) + a = six; +#ifdef DIV_RESCALING + B[n * H * W * C + h * W * C + w * C + c] = (int64_t)(a / div); +#else + B[n * H * W * C + h * W * C + w * C + c] = (int64_t)(a >> shift_div); +#endif + } + } + } + } + return; +} + +void cleartext_BNorm(int64_t *A, int64_t *BNW, int64_t *BNB, int64_t *B, + int32_t I, int32_t J, int32_t shA, int32_t shBNB, + int32_t shB) { + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + int64_t a = (int64_t)A[i * J + j]; + int64_t bn_b = (int64_t)BNB[j]; + int64_t bn_w = (int64_t)BNW[j]; + + // sh = +ve : right shift + // sh = -ve : left shift + if (shA <= 0) { + a = (a * (1LL << (-1 * shA))); + } else { +#ifdef DIV_RESCALING + a = a / (1LL << shA); +#else + a = a >> shA; +#endif + } + if (shBNB <= 0) { + bn_b = (bn_b * (1LL << (-1 * shBNB))); + } else { +#ifdef DIV_RESCALING + bn_b = bn_b / (1LL << shBNB); +#else + bn_b = bn_b >> shBNB; +#endif + } + + int64_t b = (a + bn_b) * bn_w; + + if (shB <= 0) { + B[i * J + j] = Saturate(b * (1LL << (-1 * shB))); + } else { +#ifdef DIV_RESCALING + B[i * J + j] = Saturate(b / (1LL << shB)); +#else + B[i * J + j] = Saturate(b >> shB); +#endif + } + } + } + return; +} + +void cleartext_MBConv(int64_t *A, int64_t *F1, int64_t *BN1W, int64_t *BN1B, + int64_t *F2, int64_t *BN2W, int64_t *BN2B, int64_t *F3, + int64_t *BN3W, int64_t *BN3B, int64_t *C, int64_t *X, + int64_t *T, int64_t *U, int32_t N, int32_t H, int32_t W, + int32_t Cin, int32_t Ct, int32_t HF, int32_t WF, + int32_t Cout, int32_t Hout, int32_t Wout, int32_t HPADL, + int32_t HPADR, int32_t WPADL, int32_t WPADR, int32_t HSTR, + int32_t WSTR, int32_t D1, int32_t D2, int32_t D3, + int64_t SIX_1, int64_t SIX_2, int64_t shr1, int64_t shr2, + int64_t shr3, int64_t shr4, int64_t shr5, int64_t shr6, + int64_t shr7, int64_t shr8, int64_t shr9, int64_t shl1, + int64_t shl2, int64_t shl3, int64_t shl4, int64_t shl5, + int64_t shl6, int64_t shl7, int64_t shl8, int64_t shl9) { + int32_t HOffsetL = (HF / 2) - HPADL; + int32_t WOffsetL = (WF / 2) - WPADL; + int32_t HOffsetR = (HF / 2) - HPADR; + int32_t WOffsetR = (WF / 2) - WPADR; + + bool del_X = false; + if (X == nullptr) { + X = new int64_t[H * W * Ct]; + del_X = true; + } + + bool del_T = false; + if (T == nullptr) { + T = new int64_t[Ct]; + del_T = true; + } + + bool del_U = false; + if (U == nullptr) { + U = new int64_t[Cin + HF * WF + Ct]; + del_U = true; + } + + int32_t shift1 = log2(shr1); + int32_t shift2 = log2(shr2); + int32_t shift3 = log2(shr3); + int32_t shift4 = log2(shr4); + int32_t shift5 = log2(shr5); + int32_t shift6 = log2(shr6); + int32_t shift7 = log2(shr7); + int32_t shift8 = log2(shr8); + int32_t shift9 = log2(shr9); + + for (int32_t n = 0; n < N; n++) { + int32_t margin = + HOffsetL + (HF / 2 + 1) - HSTR > 0 ? HOffsetL + (HF / 2 + 1) - HSTR : 0; + int32_t nstart = HOffsetL - (HF / 2) < 0 ? 0 : HOffsetL - (HF / 2); + for (int32_t i = nstart; i < margin; i++) { + for (int32_t j = 0; j < W; j++) { + for (int32_t k = 0; k < Ct; k++) { + int64_t tmpU = 0; + for (int32_t l = 0; l < Cin; l++) { + tmpU += ((int64_t)A[n * H * W * Cin + i * W * Cin + j * Cin + l]) * + ((int64_t)F1[l * Ct + k]); + } + tmpU = tmpU >> D1; + + // std::cout << i << "\t" << tmpU << std::endl; +#ifdef DIV_RESCALING + int64_t x = (((int64_t)((int64_t(tmpU) * shl1) / shr1 + + (BN1B[k] * shl2) / shr2)) * + ((int64_t)BN1W[k])); +#else + int64_t x = (((int64_t)(((int64_t(tmpU) * shl1) >> shift1) + + ((BN1B[k] * shl2) >> shift2))) * + ((int64_t)BN1W[k])); +#endif + x = x < 0 ? 0 : x; + x = x > SIX_1 ? SIX_1 : x; +#ifdef DIV_RESCALING + X[i * W * Ct + j * Ct + k] = Saturate((x * shl3) / shr3); +#else + X[i * W * Ct + j * Ct + k] = Saturate((x * shl3) >> shift3); +#endif + // std::cout << i << "\t" << X[i * W * Ct + j * Ct + k] << std::endl; + } + } + } + + for (int32_t h = HOffsetL, hout = 0; h < H - HOffsetR; hout++, h += HSTR) { + + for (int32_t i = 0; i < HSTR; i++) { + for (int32_t j = 0; j < W; j++) { + for (int32_t k = 0; k < Ct; k++) { + int32_t iRed = (i + margin + hout * HSTR) % HF, + iFull = i + margin + hout * HSTR; + X[iRed * W * Ct + j * Ct + k] = 0; + int64_t tmpU = 0; + for (int32_t l = 0; l < Cin; l++) { + int64_t a = + iFull < H ? A[n * H * W * Cin + iFull * W * Cin + j * Cin + l] + : 0; + tmpU += ((int64_t)a) * ((int64_t)F1[l * Ct + k]); + } + tmpU = tmpU >> D1; + + // std::cout << iFull << "\t" << tmpU << std::endl; +#ifdef DIV_RESCALING + int64_t x = (((int64_t)((int64_t(tmpU) * shl1) / shr1 + + (BN1B[k] * shl2) / shr2)) * + ((int64_t)BN1W[k])); +#else + int64_t x = (((int64_t)(((int64_t(tmpU) * shl1) >> shift1) + + ((BN1B[k] * shl2) >> shift2))) * + ((int64_t)BN1W[k])); +#endif + x = x < 0 ? 0 : x; + x = x > SIX_1 ? SIX_1 : x; +#ifdef DIV_RESCALING + X[iRed * W * Ct + j * Ct + k] = Saturate((x * shl3) / shr3); +#else + X[iRed * W * Ct + j * Ct + k] = Saturate((x * shl3) >> shift3); +#endif + // std::cout << iFull << "\t" << X[iRed * W * Ct + j * Ct + k] << + // std::endl; + } + } + } + + for (int32_t w = WOffsetL, wout = 0; w < W - WOffsetR; + w += WSTR, wout++) { + for (int32_t g = 0; g < Ct; g++) { + int32_t counter = 0; + int64_t tmpU = 0; + for (int32_t hf = -(HF / 2); hf <= (HF / 2); hf++) { + for (int32_t wf = -(WF / 2); wf <= (WF / 2); wf++) { + int64_t x = (((h + hf) < 0) || ((h + hf) >= H) || + ((w + wf) < 0) || ((w + wf) >= W)) + ? 0 + : X[((h + hf) % HF) * W * Ct + (w + wf) * Ct + g]; + int64_t b = F2[g * HF * WF + (hf + HF / 2) * WF + (wf + WF / 2)]; + tmpU += ((int64_t)x) * ((int64_t)b); + counter++; + } + } + tmpU = tmpU >> D2; + + // std::cout << tmpU << std::endl; + +#ifdef DIV_RESCALING + int64_t x = (((int64_t)((int64_t(tmpU) * shl4) / shr4 + + (BN2B[g] * shl5) / shr5)) * + ((int64_t)BN2W[g])); +#else + int64_t x = (((int64_t)(((int64_t(tmpU) * shl4) >> shift4) + + ((BN2B[g] * shl5) >> shift5))) * + ((int64_t)BN2W[g])); +#endif + x = x < 0 ? 0 : x; + x = x > SIX_2 ? SIX_2 : x; +#ifdef DIV_RESCALING + T[g] = Saturate((x * shl6) / shr6); +#else + T[g] = Saturate((x * shl6) >> shift6); +#endif + } + + for (int32_t i = 0; i < Cout; i++) { + int64_t tmpU = 0; + for (int32_t g = 0; g < Ct; g++) { + tmpU += T[g] * F3[g * Cout + i]; + } + tmpU = tmpU >> D3; + +#ifdef DIV_RESCALING + C[n * Hout * Wout * Cout + hout * Wout * Cout + wout * Cout + i] = + Saturate(((((int64_t)((tmpU * shl7) / shr7 + + (BN3B[i] * shl8) / shr8)) * + ((int64_t)BN3W[i])) * + shl9) / + shr9); +#else + C[n * Hout * Wout * Cout + hout * Wout * Cout + wout * Cout + i] = + Saturate(((((int64_t)(((tmpU * shl7) >> shift7) + + ((BN3B[i] * shl8) >> shift8))) * + ((int64_t)BN3W[i])) * + shl9) >> + shift9); +#endif + } + } + } + } + + if (del_X) + delete[] X; + if (del_T) + delete[] T; + if (del_U) + delete[] U; +} + +void cleartext_NormaliseL2(int64_t *A, int64_t *B, int32_t N, int32_t H, + int32_t W, int32_t C, int32_t scaleA, int32_t shrA, + int32_t bwA, int32_t bwB) { + int32_t scale_in = -1 * scaleA; + int32_t scale_out = -1 * (scaleA + 1); + int32_t shrAdiv = (1 << shrA); + int64_t *sumSquare = new int64_t[N * H * W]; + int64_t *inverseNorm = new int64_t[N * H * W]; + for (int32_t i = 0; i < N * H * W; i++) { + // calculate the sum square + sumSquare[i] = 0; + for (int32_t j = 0; j < C; j++) { + int64_t tmp = A[i * C + j]; + sumSquare[i] += int64_t((tmp * tmp) >> (2 * shrA)); + } + } + cleartext_sqrt(sumSquare, N * H * W, 1, 1 << (2 * (scale_in - shrA)), + 1 << (scale_out - scale_in + shrA), bwA, bwB, inverseNorm, + true); + /* + for(int i = 0; i < N*H*W; i++) { + std::cout << double(sumSquare[i])/(1LL << (2*(scale_in-shrA))) << "\t" << + double(inverseNorm[i])/(1LL << (scale_out-scale_in+shrA)) << std::endl; + } + */ + + for (int32_t i = 0; i < N * H * W; i++) { + // multiply all elements by the 1/sqrt(sumSquare) + for (int32_t j = 0; j < C; j++) { +#ifdef DIV_RESCALING + B[i * C + j] = + (int64_t(A[i * C + j]) * int64_t(inverseNorm[i])) / (shrAdiv); +#else + B[i * C + j] = (int64_t(A[i * C + j]) * int64_t(inverseNorm[i])) >> shrA; +#endif + } + } + delete[] sumSquare; + delete[] inverseNorm; + + return; +} + +void cleartext_NormaliseL2_seedot(int64_t *A, int64_t *B, int32_t N, int32_t H, + int32_t W, int32_t C, int32_t scaleA, + int32_t shrA) { + for (int32_t n = 0; n < N; n++) { + for (int32_t h = 0; h < H; h++) { + for (int32_t w = 0; w < W; w++) { + + // calculate the sum square + int32_t sumSquare = 0; + int32_t shrAdiv = (1 << shrA); + + for (int32_t c = 0; c < C; c++) { +#ifdef FASTAPPROX + int32_t tmp = (A[n * H * W * C + h * W * C + w * C + c] / shrAdiv); + sumSquare += tmp * tmp; +#else + int32_t tmp = A[n * H * W * C + h * W * C + w * C + c]; + sumSquare += (((tmp * tmp) / shrAdiv) / shrAdiv); +#endif + } + + // calculate the inverse square root of sumSquare + int32_t yLow = 1; + + // yHigh: A number of length shrA with all 1s in binary representation + // e.g. for shrA=8 --> y_high = 0b11111111 + int32_t yHigh = ((1 << shrA) - 1); + + // one: value of 1 with same scale as y*y*sumSquare + // scale of sumSquare = 2*scale_in + 2*shrA + // since we assume scale of y = 1 - shrA + // scale of y*y*sumSquare = 2*scale_in + 2*shrA + 2(1-shrA) = + // 2*scale_in + 2 + int32_t one = (1 << (-(2 * scaleA + 2))); + + // binary search for the inverse square root + while (yLow + 1 < yHigh) { + + // using int32_t sotherwise (y*y*sumSquare) will overflow + int32_t yMid = ((yHigh + yLow) >> 1); + + int64_t cmpValue = (int64_t)sumSquare * yMid * yMid; + + if (cmpValue > one) { + yHigh = yMid; + } else { + yLow = yMid; + } + } + int32_t inverseNorm = yLow; + + // multiply all elements by the 1/sqrt(sumSquare) + for (int32_t c = 0; c < C; c++) { + B[n * H * W * C + h * W * C + w * C + c] = + (A[n * H * W * C + h * W * C + w * C + c] / shrAdiv) * + inverseNorm; + } + } + } + } + return; +} + +void cleartext_AdjustScaleShr(int64_t *A, int32_t I, int32_t J, int32_t scale) { + int32_t shift_scale = ceil(log2(scale)); + for (int32_t i = 0; i < I; i++) { + for (int32_t j = 0; j < J; j++) { + int64_t a = A[i * J + j]; +#ifdef DIV_RESCALING + A[i * J + j] = a / scale; +#else + A[i * J + j] = a >> shift_scale; +#endif + } + } + return; +} + +void cleartext_MaxPool2D(int64_t *A, int32_t I, int32_t J, int64_t *B) { + int32_t counter = 0; + bool verbose = false; + for (int i = 0; i < I; i++) { + int64_t max = A[i * J + 0]; + for (int j = 0; j < J; j++) { + int64_t x = max - A[i * J + j]; + int64_t diff = signed_val_cleartext(x, sizeof(int64_t) * 8); + + if (verbose) { + std::cout << "max: " << max << " | cur: " << A[i * J + j] << " | diff:\ + " + << diff << std::endl; + } + + if (diff <= 0) { + max = A[i * J + j]; + } + } + verbose = false; + B[i] = (int64_t)max; + } + + return; +} diff --git a/SCI/src/cleartext_library_fixed.h b/SCI/src/cleartext_library_fixed.h new file mode 100644 index 00000000..44c956b5 --- /dev/null +++ b/SCI/src/cleartext_library_fixed.h @@ -0,0 +1,180 @@ +/* +Authors: Deevashwer Rathee, G Rahul Kranti Kiran +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef CLEARTEXT_LIBRARY_FIXED_H__ +#define CLEARTEXT_LIBRARY_FIXED_H__ + +#include "defines.h" +#include "globals.h" +#include <cassert> +#include <cmath> + +#define KKOT_LIMIT 8 +#define SQRT_LOOKUP_SCALE 2 + +static inline int64_t signed_val_cleartext(uint64_t x, int bw_x) { + uint64_t pow_x = (bw_x == 64 ? 0ULL : (1ULL << bw_x)); + uint64_t mask_x = pow_x - 1; + x = x & mask_x; + return int64_t(x - ((x >= (pow_x / 2)) * pow_x)); +} + +static int64_t lookup_sqrt(int32_t index, int m, int exp_parity) { + int32_t k = 1 << m; + double u = (1.0 + (double(index) / double(k))) * (1 << exp_parity); + double Y = 1.0 / sqrt(u); + int32_t scale = m + SQRT_LOOKUP_SCALE; + int64_t val = (Y * (1ULL << scale)); + return val; +} + +// A0 \in (1/4, 1) +static int64_t lookup_div_A0(int64_t index, int m) { + int32_t k = 1 << m; + double p = 1 + (double(index) / double(k)); + double A1 = 1.0 / (p * (p + 1.0 / double(k))); + int32_t scale = m + 3; + int64_t val = (A1 * (1LL << scale)); + return val; +} + +// A1 \in (1/2, 1) +static int64_t lookup_div_A1(int64_t index, int m) { + int32_t k = 1 << m; + double p = 1 + (double(index) / double(k)); + double z = (p * (p + (1.0 / double(k)))); + double A1 = ((1.0 / double(k * 2)) + sqrt(z)) / z; + int32_t scale = 2 * m + 2; + int64_t val = (A1 * (1LL << scale)); + return val; +} + +static int64_t lookup_neg_exp(int64_t val_in, int32_t s_in, int32_t s_out) { + if (s_in < 0) { + s_in *= -1; + val_in *= (1 << (s_in)); + s_in = 0; + } + int64_t res_val = exp(-1.0 * (val_in / double(1LL << s_in))) * (1LL << s_out); + return res_val; +} + +void cleartext_Sigmoid(int64_t *A, int I, int J, int scale_in, int scale_out, + int bwA, int bwB, int64_t *B); + +void cleartext_TanH(int64_t *A, int I, int J, int64_t scale_in, + int64_t scale_out, int bwA, int bwB, int64_t *B); + +void cleartext_MatAdd(int64_t *A, int64_t *B, int64_t *C, int32_t I, int32_t J, + int32_t shrA, int32_t shrB, int32_t shrC, int32_t demote); + +void cleartext_MatSub(int64_t *A, const int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, int32_t shrC, + int32_t demote); + +void cleartext_MatMul(int64_t *A, int64_t *B, int64_t *C, int64_t *tmp, + int32_t I, int32_t K, int32_t J, int32_t shrA, + int32_t shrB, int32_t H1, int32_t H2, int32_t demote); + +void cleartext_MatAddBroadCastA(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, + int32_t shrC, int32_t demote); + +void cleartext_MatAddBroadCastB(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, + int32_t shrC, int32_t demote); + +void cleartext_MatSubBroadCastA(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, + int32_t shrC, int32_t demote); + +void cleartext_MatSubBroadCastB(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, + int32_t shrC, int32_t demote); + +void cleartext_ScalarMul(int64_t *A, int64_t *B, int64_t *C, int32_t I, + int32_t J, int32_t shrA, int32_t shrB, int demote); + +void cleartext_MulCir(int64_t *A, int64_t *B, int64_t *C, int32_t I, int32_t J, + int32_t shrA, int32_t shrB, int32_t demote); + +void cleartext_sqrt(int64_t *A, int32_t I, int32_t J, int32_t shrA, + int32_t shrB, int32_t bwA, int32_t bwB, int64_t *B, + bool inverse = false); + +void cleartext_div(int64_t *A, int64_t *B, int32_t I, int32_t J, int32_t shrA, + int32_t shrB, int32_t shrC, int64_t *C, + bool compute_msnzb = false); + +void cleartext_Exp_lookup(int64_t *A, int32_t I, int32_t J, int bwA, + int32_t shrA, int32_t shrB, int64_t *B, + int32_t demote); + +void cleartext_ArgMax(int64_t *A, int32_t I, int32_t J, int32_t *index); + +void cleartext_Convolution(int64_t *A, int64_t *B, int64_t *C, int64_t *tmp, + int32_t N, int32_t H, int32_t W, int32_t CIN, + int32_t HF, int32_t WF, int32_t CINF, int32_t COUTF, + int32_t HOUT, int32_t WOUT, int32_t HPADL, + int32_t HPADR, int32_t WPADL, int32_t WPADR, + int32_t HSTR, int32_t WSTR, int32_t HDL, int32_t WDL, + int32_t G, int32_t shrA, int32_t shrB, int32_t H1, + int32_t H2, int32_t demote); + +void cleartext_AddOrSubCir4D(int64_t *A, int64_t *B, int64_t *X, int32_t N, + int32_t H, int32_t W, int32_t C, int32_t shrA, + int32_t shrB, int32_t shrC, bool add, + int32_t demote); + +void cleartext_Relu6(int64_t *A, int64_t *B, int32_t N, int32_t H, int32_t W, + int32_t C, int64_t six, int32_t div); + +void cleartext_BNorm(int64_t *A, int64_t *BNW, int64_t *BNB, int64_t *B, + int32_t I, int32_t J, int32_t shA, int32_t shBNB, + int32_t shB); + +void cleartext_MBConv(int64_t *A, int64_t *F1, int64_t *BN1W, int64_t *BN1B, + int64_t *F2, int64_t *BN2W, int64_t *BN2B, int64_t *F3, + int64_t *BN3W, int64_t *BN3B, int64_t *C, int64_t *X, + int64_t *T, int64_t *U, int32_t N, int32_t H, int32_t W, + int32_t Cin, int32_t Ct, int32_t HF, int32_t WF, + int32_t Cout, int32_t Hout, int32_t Wout, int32_t HPADL, + int32_t HPADR, int32_t WPADL, int32_t WPADR, int32_t HSTR, + int32_t WSTR, int32_t D1, int32_t D2, int32_t D3, + int64_t SIX_1, int64_t SIX_2, int64_t shr1, int64_t shr2, + int64_t shr3, int64_t shr4, int64_t shr5, int64_t shr6, + int64_t shr7, int64_t shr8, int64_t shr9, int64_t shl1, + int64_t shl2, int64_t shl3, int64_t shl4, int64_t shl5, + int64_t shl6, int64_t shl7, int64_t shl8, int64_t shl9); + +void cleartext_NormaliseL2(int64_t *A, int64_t *B, int32_t N, int32_t H, + int32_t W, int32_t C, int32_t scaleA, int32_t shrA, + int32_t bwA, int32_t bwB); + +void cleartext_NormaliseL2_seedot(int64_t *A, int64_t *B, int32_t N, int32_t H, + int32_t W, int32_t C, int32_t scaleA, + int32_t shrA); + +void cleartext_AdjustScaleShr(int64_t *A, int32_t I, int32_t J, int32_t scale); + +void cleartext_MaxPool2D(int64_t *A, int32_t I, int32_t J, int64_t *B); + +#endif diff --git a/SCI/src/cleartext_library_fixed_uniform.h b/SCI/src/cleartext_library_fixed_uniform.h new file mode 100644 index 00000000..d080f421 --- /dev/null +++ b/SCI/src/cleartext_library_fixed_uniform.h @@ -0,0 +1,3061 @@ +/* +Authors: Nishant Kumar, Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef CLEARTEXT_LIBRARY_FIXED_CSF_H__ +#define CLEARTEXT_LIBRARY_FIXED_CSF_H__ + +#include <Eigen/Dense> +#include <cassert> +#include <cstdlib> +#include <fstream> +#include <iostream> +#include <math.h> +#include <vector> + +extern uint64_t prime_mod; +extern uint64_t moduloMask; +extern uint64_t moduloMidPt; + +typedef std::vector<uint64_t> uint64_1D; +typedef std::vector<std::vector<uint64_t>> uint64_2D; +typedef std::vector<std::vector<std::vector<uint64_t>>> uint64_3D; +typedef std::vector<std::vector<std::vector<std::vector<uint64_t>>>> uint64_4D; +typedef std::vector< + std::vector<std::vector<std::vector<std::vector<uint64_t>>>>> + uint64_5D; + +#if defined(SCI_OT) + +void div_floor(int64_t a, int64_t b, int64_t &quot, int64_t &rem) { + assert(b > 0); + int64_t q = a / b; + int64_t r = a % b; + int64_t corr = ((r != 0) && (r < 0)); + quot = q - corr; + rem = (r + b) % b; +} + +inline int64_t getSignedVal(uint64_t x) { + assert(x < prime_mod); + int64_t sx = x; + if (x >= moduloMidPt) + sx = x - prime_mod; + return sx; +} + +inline uint64_t getRingElt(int64_t x) { return ((uint64_t)x) & moduloMask; } + +inline uint64_t PublicAdd(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + return (x + y) & moduloMask; +} + +inline uint64_t PublicSub(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + return (x - y) & moduloMask; +} + +inline uint64_t PublicMult(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + return (x * y) & moduloMask; // This works because its a two-power ring +} + +inline bool PublicGT(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + return (sx > sy); +} + +inline bool PublicGTE(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + return (sx >= sy); +} + +inline bool PublicLT(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + return (sx < sy); +} + +inline bool PublicLTE(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + return (sx <= sy); +} + +uint64_t PublicDiv(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + int64_t q, r; + div_floor(sx, sy, q, r); + return getRingElt(q); +} + +uint64_t PublicMod(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + int64_t q, r; + div_floor(sx, sy, q, r); + return r; +} + +inline uint64_t PublicRShiftA(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + int64_t sx = getSignedVal(x); + int64_t ans = sx >> y; + return getRingElt(ans); +} + +inline uint64_t PublicRShiftL(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + return (x >> y); +} + +inline uint64_t PublicLShift(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + return (x << y) & moduloMask; +} + +#else + +// Assumption at some places in the following code is that 2*mod < (1<<64) +// which allows things like (x+y)%(1<<64). +uint64_t moduloMult(uint64_t a, uint64_t b, uint64_t mod) { + uint64_t res = 0; + a %= mod; + while (b) { + if (b & 1) + res = (res + a) % mod; + a = (2 * a) % mod; + b >>= 1; + } + return res; +} + +void div_floor(int64_t a, int64_t b, int64_t &quot, int64_t &rem) { + assert(b > 0); + int64_t q = a / b; + int64_t r = a % b; + int64_t corr = ((r != 0) && (r < 0)); + quot = q - corr; + rem = (r + b) % b; +} + +int64_t getSignedVal(uint64_t x) { + assert(x < prime_mod); + bool xPos; + if (prime_mod & 1) + xPos = (x <= (prime_mod / 2)); + else + xPos = (x < (prime_mod / 2)); + int64_t sx = x; + if (!xPos) + sx = x - prime_mod; + return sx; +} + +uint64_t getRingElt(int64_t x) { + if (x > 0) + return x % prime_mod; + else { + int64_t y = -x; + int64_t temp = prime_mod - y; + int64_t temp1 = temp % ((int64_t)prime_mod); + uint64_t ans = (temp1 + prime_mod) % prime_mod; + return ans; + } +} + +uint64_t PublicAdd(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + return (x + y) % prime_mod; +} + +uint64_t PublicSub(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + uint64_t ans; + if (x >= y) + ans = (x - y) % prime_mod; + else + ans = ((x + prime_mod) - y) % prime_mod; + return ans; +} + +uint64_t PublicMult(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); +#ifdef __SIZEOF_INT128__ + __int128 ix = x; + __int128 iy = y; + __int128 iz = ix * iy; + + return iz % prime_mod; +#else + return moduloMult(x, y, prime_mod); +#endif +} + +bool PublicGT(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + return (sx > sy); +} + +bool PublicGTE(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + return (sx >= sy); +} + +bool PublicLT(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + return (sx < sy); +} + +bool PublicLTE(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + return (sx <= sy); +} + +uint64_t PublicDiv(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + int64_t q, r; + div_floor(sx, sy, q, r); + return getRingElt(q); +} + +uint64_t PublicMod(uint64_t x, uint64_t y) { + int64_t sx = getSignedVal(x); + int64_t sy = getSignedVal(y); + int64_t q, r; + div_floor(sx, sy, q, r); + return r; +} + +uint64_t PublicRShiftA(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + int64_t sx = getSignedVal(x); + int64_t ans = sx >> y; + return getRingElt(ans); +} + +uint64_t PublicRShiftL(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + return (x >> y); +} + +uint64_t PublicLShift(uint64_t x, uint64_t y) { + assert((x < prime_mod) && (y < prime_mod)); + return (x << y) % prime_mod; +} + +#endif + +using namespace std; + +uint32_t public_lrshift(uint32_t x, uint32_t y) { return (x >> y); } + +int32_t public_lrshift(int32_t x, uint32_t y) { + return ((int32_t)(((uint32_t)x) >> y)); +} + +uint64_t public_lrshift(uint64_t x, uint64_t y) { return (x >> y); } + +int64_t public_lrshift(int64_t x, uint64_t y) { + return ((int64_t)(((uint64_t)x) >> y)); +} + +template <typename T> vector<T> make_vector(size_t size) { + return std::vector<T>(size); +} + +template <typename T, typename... Args> +auto make_vector(size_t first, Args... sizes) { + auto inner = make_vector<T>(sizes...); + return vector<decltype(inner)>(first, inner); +} + +template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) { + for (auto it = v.begin(); it != v.end(); ++it) { + os << *it << endl; + } + return os; +} + +void MatMul2DEigen_pt(int64_t i, int64_t j, int64_t k, uint64_2D &A, + uint64_2D &B, uint64_2D &C, int64_t consSF) { + Eigen::Matrix<__int128, Eigen::Dynamic, Eigen::Dynamic> eigen_a(i, j); + Eigen::Matrix<__int128, Eigen::Dynamic, Eigen::Dynamic> eigen_b(j, k); + Eigen::Matrix<__int128, Eigen::Dynamic, Eigen::Dynamic> eigen_c(i, k); + + for (int i0 = 0; i0 < i; ++i0) { + for (int i1 = 0; i1 < j; ++i1) { + eigen_a(i0, i1) = A[i0][i1]; + } + } + + for (int i0 = 0; i0 < j; ++i0) { + for (int i1 = 0; i1 < k; ++i1) { + eigen_b(i0, i1) = B[i0][i1]; + } + } + + eigen_c = eigen_a * eigen_b; // No overflows since running in __int128 + + for (int i0 = 0; i0 < i; ++i0) { + for (int i1 = 0; i1 < k; ++i1) { + if (bitlength == 64) { + C[i0][i1] = eigen_c(i0, i1); + } else { + C[i0][i1] = (eigen_c(i0, i1)) % prime_mod; + } + } + } +} + +void MatMul2D_pt(uint64_t i, uint64_t j, uint64_t k, uint64_2D &A, uint64_2D &B, + uint64_2D &C, uint64_t consSF) { + MatMul2DEigen_pt(i, j, k, A, B, C, consSF); +} + +void ArgMax_pt(uint64_t s1, uint64_t s2, uint64_2D &inArr, uint64_1D &outArr) { + for (uint64_t od = (int32_t)0; od < s1; od++) { + + uint64_t maxi = inArr[od][(int32_t)0]; + + uint64_t maxiIdx = (int64_t)0; + for (uint64_t i = (int32_t)0; i < s2; i++) { + + uint64_t iL = i; + maxiIdx = (PublicGT(inArr[od][i], maxi)) ? iL : maxiIdx; + maxi = (PublicGT(inArr[od][i], maxi)) ? inArr[od][i] : maxi; + } + outArr[od] = maxiIdx; + } +} + +void Relu_pt(uint64_t s1, uint64_1D &inArr, uint64_1D &outArr, uint64_t sf, + uint64_t doTruncation) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + outArr[i1] = (PublicGT(inArr[i1], (int64_t)0)) ? inArr[i1] : (int64_t)0; + } + if (doTruncation) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + outArr[i1] = (PublicRShiftA(outArr[i1], sf)); + } + } +} + +void Floor_pt(uint64_t s1, uint64_1D &inArr, uint64_1D &outArr, uint64_t sf) { + + uint64_t mask = ~(PublicSub((PublicLShift((int32_t)1, sf)), (int32_t)1)); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + outArr[i1] = (inArr[i1] & mask); + } +} + +void MaxPool_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t C, uint64_t ksizeH, + uint64_t ksizeW, uint64_t zPadHLeft, uint64_t zPadHRight, + uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, + uint64_t strideW, uint64_t N1, uint64_t imgH, uint64_t imgW, + uint64_t C1, + std::vector<std::vector<std::vector<uint64_1D>>> &inArr, + std::vector<std::vector<std::vector<uint64_1D>>> &outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t c = (int32_t)0; c < C; c++) { + + uint64_t leftTopCornerH = (PublicSub((int32_t)0, zPadHLeft)); + + uint64_t extremeRightBottomCornerH = + (PublicAdd((PublicSub(imgH, (int32_t)1)), zPadHRight)); + + uint64_t ctH = (int32_t)0; + while ((PublicLTE( + (PublicSub((PublicAdd(leftTopCornerH, ksizeH)), (int32_t)1)), + extremeRightBottomCornerH))) { + + uint64_t leftTopCornerW = (PublicSub((int32_t)0, zPadWLeft)); + + uint64_t extremeRightBottomCornerW = + (PublicAdd((PublicSub(imgW, (int32_t)1)), zPadWRight)); + + uint64_t ctW = (int32_t)0; + while ((PublicLTE( + (PublicSub((PublicAdd(leftTopCornerW, ksizeW)), (int32_t)1)), + extremeRightBottomCornerW))) { + + uint64_t maxi = (int64_t)0; + if ((((PublicLT(leftTopCornerH, (int32_t)0)) || + (PublicGTE(leftTopCornerH, imgH))) || + ((PublicLT(leftTopCornerW, (int32_t)0)) || + (PublicGTE(leftTopCornerW, imgW))))) { + maxi = (int64_t)0; + } else { + maxi = inArr[n][leftTopCornerH][leftTopCornerW][c]; + } + for (uint64_t fh = (int32_t)0; fh < ksizeH; fh++) { + for (uint64_t fw = (int32_t)0; fw < ksizeW; fw++) { + + uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); + + uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); + + uint64_t temp = (int64_t)0; + if ((((PublicLT(curPosH, (int32_t)0)) || + (PublicGTE(curPosH, imgH))) || + ((PublicLT(curPosW, (int32_t)0)) || + (PublicGTE(curPosW, imgW))))) { + temp = (int64_t)0; + } else { + temp = inArr[n][curPosH][curPosW][c]; + } + // maxi = (PublicLT(maxi, temp)) ? temp : maxi; + maxi = (getSignedVal(PublicSub(maxi, temp)) < 0) ? temp : maxi; + } + } + outArr[n][ctH][ctW][c] = maxi; + leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); + ctW = (PublicAdd(ctW, (int32_t)1)); + } + + leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); + ctH = (PublicAdd(ctH, (int32_t)1)); + } + } + } +} + +void AvgPool_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t C, uint64_t ksizeH, + uint64_t ksizeW, uint64_t zPadHLeft, uint64_t zPadHRight, + uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, + uint64_t strideW, uint64_t N1, uint64_t imgH, uint64_t imgW, + uint64_t C1, + std::vector<std::vector<std::vector<uint64_1D>>> &inArr, + std::vector<std::vector<std::vector<uint64_1D>>> &outArr) { + + uint64_t rows = (PublicMult((PublicMult((PublicMult(N, C)), H)), W)); + + auto filterAvg = make_vector<uint64_t>(rows); + + uint64_t rowIdx = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t c = (int32_t)0; c < C; c++) { + + uint64_t leftTopCornerH = (PublicSub((int32_t)0, zPadHLeft)); + + uint64_t extremeRightBottomCornerH = + (PublicAdd((PublicSub(imgH, (int32_t)1)), zPadHRight)); + + uint64_t ctH = (int32_t)0; + while ((PublicLTE( + (PublicSub((PublicAdd(leftTopCornerH, ksizeH)), (int32_t)1)), + extremeRightBottomCornerH))) { + + uint64_t leftTopCornerW = (PublicSub((int32_t)0, zPadWLeft)); + + uint64_t extremeRightBottomCornerW = + (PublicAdd((PublicSub(imgW, (int32_t)1)), zPadWRight)); + + uint64_t ctW = (int32_t)0; + while ((PublicLTE( + (PublicSub((PublicAdd(leftTopCornerW, ksizeW)), (int32_t)1)), + extremeRightBottomCornerW))) { + + uint64_t curFilterSum = (int64_t)0; + for (uint64_t fh = (int32_t)0; fh < ksizeH; fh++) { + for (uint64_t fw = (int32_t)0; fw < ksizeW; fw++) { + + uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); + + uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); + + uint64_t temp = (int64_t)0; + if ((((PublicLT(curPosH, (int32_t)0)) || + (PublicGTE(curPosH, imgH))) || + ((PublicLT(curPosW, (int32_t)0)) || + (PublicGTE(curPosW, imgW))))) { + temp = (int64_t)0; + } else { + temp = inArr[n][curPosH][curPosW][c]; + } + curFilterSum = (PublicAdd(curFilterSum, temp)); + } + } + + uint64_t ksizeH64 = ksizeH; + + uint64_t ksizeW64 = ksizeW; + + uint64_t filterSz64 = (PublicMult(ksizeH64, ksizeW64)); + + uint64_t curFilterAvg = (PublicDiv(curFilterSum, filterSz64)); + filterAvg[rowIdx] = curFilterAvg; + rowIdx = (PublicAdd(rowIdx, (int32_t)1)); + leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); + ctW = (PublicAdd(ctW, (int32_t)1)); + } + + leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); + ctH = (PublicAdd(ctH, (int32_t)1)); + } + } + } + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t c = (int32_t)0; c < C; c++) { + for (uint64_t h = (int32_t)0; h < H; h++) { + for (uint64_t w = (int32_t)0; w < W; w++) { + outArr[n][h][w][c] = filterAvg[(PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(n, C)), H)), W)), + (PublicMult((PublicMult(c, H)), W)))), + (PublicMult(h, W)))), + w))]; + } + } + } + } +} + +void ElemWiseSecretSharedVectorMult_pt(uint64_t s1, uint64_1D &arr1, + uint64_1D &arr2, uint64_1D &outArr) { + for (uint64_t ii = (int32_t)0; ii < s1; ii++) { + outArr[ii] = (PublicMult(arr1[ii], arr2[ii])); + } +} + +void ElemWiseActModelVectorMult_pt(uint64_t s1, uint64_1D &arr1, + uint64_1D &arr2, uint64_1D &outArr) { + ElemWiseSecretSharedVectorMult_pt(s1, arr1, arr2, outArr); +} + +void ElemWiseVectorPublicDiv_pt(uint64_t s1, uint64_1D &arr1, uint64_t divisor, + uint64_1D &outArr) { + + uint64_t divisor64 = divisor; + for (uint64_t ii = (int32_t)0; ii < s1; ii++) { + outArr[ii] = (PublicDiv(arr1[ii], divisor64)); + } +} + +void ScaleUp_pt(uint64_t s1, uint64_1D &arr, uint64_t sf) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + arr[i] = (PublicLShift(arr[i], sf)); + } +} + +void ScaleDown_pt(uint64_t s1, uint64_1D &arr, uint64_t sf) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + arr[i1] = (PublicRShiftA(arr[i1], sf)); + } +} + +void ClearMemSecret1_pt(uint64_t s1, uint64_1D &arr) { return; } + +void ClearMemSecret2_pt(uint64_t s1, uint64_t s2, uint64_2D &arr) { return; } + +void ClearMemSecret3_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_3D &arr) { + return; +} + +void ClearMemSecret4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &arr) { + return; +} + +void ClearMemSecret5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t s5, uint64_5D &arr) { + return; +} + +void ClearMemPublic_pt(uint64_t x) { return; } + +void ClearMemPublic1_pt(uint64_t s, uint64_1D &x) { return; } + +void ClearMemPublic2_pt(uint64_t s1, uint64_t s2, uint64_2D &arr) { return; } + +void ClearMemPublic3_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_3D &arr) { + return; +} + +void ClearMemPublic4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &arr) { + return; +} + +void ClearMemPublic5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t s5, uint64_5D &arr) { + return; +} + +void StartComputation_pt() { return; } + +void EndComputation_pt() { return; } + +void MatAddBroadCast2_pt(uint64_t s1, uint64_t s2, uint64_2D &A, uint64_1D &B, + uint64_2D &outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + outArr[i1][i2] = (PublicAdd(A[i1][i2], B[i2])); + } + } +} + +void MatAdd2_pt(uint64_t s1, uint64_t s2, uint64_2D &A, uint64_2D &B, + uint64_2D &outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + outArr[i1][i2] = (PublicAdd(A[i1][i2], B[i1][i2])); + } + } +} + +void MatAddBroadCast4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &A, uint64_1D &B, uint64_4D &outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + outArr[i1][i2][i3][i4] = (PublicAdd(A[i1][i2][i3][i4], B[i4])); + } + } + } + } +} + +void MatAdd4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &A, uint64_4D &B, uint64_4D &outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + outArr[i1][i2][i3][i4] = + (PublicAdd(A[i1][i2][i3][i4], B[i1][i2][i3][i4])); + } + } + } + } +} + +void MatAddBroadCast5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t s5, uint64_5D &A, uint64_1D &B, + uint64_5D &outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + outArr[i1][i2][i3][i4][i5] = + (PublicAdd(A[i1][i2][i3][i4][i5], B[i5])); + } + } + } + } + } +} + +void MatAdd5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, + uint64_5D &A, uint64_5D &B, uint64_5D &outArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + outArr[i1][i2][i3][i4][i5] = + (PublicAdd(A[i1][i2][i3][i4][i5], B[i1][i2][i3][i4][i5])); + } + } + } + } + } +} + +void CreateTensor1_pt(uint64_t s1, uint64_t val, uint64_1D &arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + arr[i1] = val; + } +} + +void CreateTensor2_pt(uint64_t s1, uint64_t s2, uint64_t val, uint64_2D &arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + arr[i1][i2] = val; + } + } +} + +void CreateTensor3_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t val, + uint64_3D &arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + arr[i1][i2][i3] = val; + } + } + } +} + +void CreateTensor4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t val, uint64_4D &arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + arr[i1][i2][i3][i4] = val; + } + } + } + } +} + +void CreateTensor5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t s5, uint64_t val, uint64_5D &arr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + arr[i1][i2][i3][i4][i5] = val; + } + } + } + } + } +} + +void CopyTensor1_pt(uint64_t s1, uint64_1D &targetArr, uint64_1D &fromArr, + uint64_1D &ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + targetArr[i1] = fromArr[i1]; + } +} + +void CopyTensor2_pt(uint64_t s1, uint64_t s2, uint64_2D &targetArr, + uint64_2D &fromArr, uint64_2D &ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + targetArr[i1][i2] = fromArr[i1][i2]; + } + } +} + +void CopyTensor3_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_3D &targetArr, + uint64_3D &fromArr, uint64_3D &ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + targetArr[i1][i2][i3] = fromArr[i1][i2][i3]; + } + } + } +} + +void CopyTensor4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &targetArr, uint64_4D &fromArr, + uint64_4D &ignore) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + targetArr[i1][i2][i3][i4] = fromArr[i1][i2][i3][i4]; + } + } + } + } +} + +void CreateIdentity11_pt(uint64_t s1, uint64_1D &fromArr, uint64_1D &newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + newArr[i1] = fromArr[i1]; + } +} + +void CreateIdentity22_pt(uint64_t s1, uint64_t s2, uint64_2D &fromArr, + uint64_2D &newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + newArr[i1][i2] = fromArr[i1][i2]; + } + } +} + +void CreateIdentity33_pt(uint64_t s1, uint64_t s2, uint64_t s3, + uint64_3D &fromArr, uint64_3D &newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + newArr[i1][i2][i3] = fromArr[i1][i2][i3]; + } + } + } +} + +void CreateIdentity44_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &fromArr, uint64_4D &newArr) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + newArr[i1][i2][i3][i4] = fromArr[i1][i2][i3][i4]; + } + } + } + } +} + +void CreateCopy2211_pt(uint64_t s1, uint64_t s2, uint64_t inps1, uint64_t inps2, + uint64_2D &inArr, uint64_t perDimSize, + uint64_1D &beginIdx, uint64_1D &sizeIdx, + uint64_2D &outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + outArr[i][j] = inArr[(PublicAdd(beginIdx[(int32_t)0], i))] + [(PublicAdd(beginIdx[(int32_t)1], j))]; + } + } +} + +void CreateCopy5511_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t s5, uint64_t inps1, uint64_t inps2, + uint64_t inps3, uint64_t inps4, uint64_t inps5, + uint64_5D &inArr, uint64_t perDimSize, + uint64_1D &beginIdx, uint64_1D &sizeIdx, + uint64_5D &outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + outArr[i][j][k][l][m] = inArr[(PublicAdd(beginIdx[(int32_t)0], i))] + [(PublicAdd(beginIdx[(int32_t)1], j))] + [(PublicAdd(beginIdx[(int32_t)2], k))] + [(PublicAdd(beginIdx[(int32_t)3], l))] + [(PublicAdd(beginIdx[(int32_t)4], m))]; + } + } + } + } + } +} + +void Concat2T222_pt(uint64_t s1, uint64_t s2, uint64_t inp1s1, uint64_t inp1s2, + uint64_2D &inp1, uint64_t inp2s1, uint64_t inp2s2, + uint64_2D &inp2, uint64_t axis, uint64_2D &outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + if (axis == (int32_t)0) { + if ((PublicLT(i1, inp1s1))) { + outp[i1][i2] = inp1[i1][i2]; + } else { + outp[i1][i2] = inp2[(PublicSub(i1, inp1s1))][i2]; + } + } else { + if ((PublicLT(i2, inp1s2))) { + outp[i1][i2] = inp1[i1][i2]; + } else { + outp[i1][i2] = inp2[i1][(PublicSub(i2, inp1s2))]; + } + } + } + } +} + +void Concat2T444_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t inp1s1, uint64_t inp1s2, uint64_t inp1s3, + uint64_t inp1s4, uint64_4D &inp1, uint64_t inp2s1, + uint64_t inp2s2, uint64_t inp2s3, uint64_t inp2s4, + uint64_4D &inp2, uint64_t axis, uint64_4D &outp) { + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + if (axis == (int32_t)0) { + if ((PublicLT(i1, inp1s1))) { + outp[i1][i2][i3][i4] = inp1[i1][i2][i3][i4]; + } else { + outp[i1][i2][i3][i4] = inp2[(PublicSub(i1, inp1s1))][i2][i3][i4]; + } + } else { + if (axis == (int32_t)1) { + if ((PublicLT(i2, inp1s2))) { + outp[i1][i2][i3][i4] = inp1[i1][i2][i3][i4]; + } else { + outp[i1][i2][i3][i4] = + inp2[i1][(PublicSub(i2, inp1s2))][i3][i4]; + } + } else { + if (axis == (int32_t)2) { + if ((PublicLT(i3, inp1s3))) { + outp[i1][i2][i3][i4] = inp1[i1][i2][i3][i4]; + } else { + outp[i1][i2][i3][i4] = + inp2[i1][i2][(PublicSub(i3, inp1s3))][i4]; + } + } else { + if ((PublicLT(i4, inp1s4))) { + outp[i1][i2][i3][i4] = inp1[i1][i2][i3][i4]; + } else { + outp[i1][i2][i3][i4] = + inp2[i1][i2][i3][(PublicSub(i4, inp1s4))]; + } + } + } + } + } + } + } + } +} + +void Split44_pt(uint64_t O1, uint64_t O2, uint64_t O3, uint64_t O4, uint64_t I1, + uint64_t I2, uint64_t I3, uint64_t I4, uint64_4D &inp, + uint64_t axis, uint64_t curCount, uint64_t total, + uint64_4D &out) { + for (uint64_t o1 = (int32_t)0; o1 < O1; o1++) { + for (uint64_t o2 = (int32_t)0; o2 < O2; o2++) { + for (uint64_t o3 = (int32_t)0; o3 < O3; o3++) { + for (uint64_t o4 = (int32_t)0; o4 < O4; o4++) { + + uint64_t i1 = o1; + + uint64_t i2 = o2; + + uint64_t i3 = o3; + + uint64_t i4 = o4; + if (axis == (int32_t)0) { + i1 = + (PublicAdd((PublicMult((PublicDiv(I1, total)), curCount)), o1)); + } + if (axis == (int32_t)1) { + i2 = + (PublicAdd((PublicMult((PublicDiv(I2, total)), curCount)), o2)); + } + if (axis == (int32_t)2) { + i3 = + (PublicAdd((PublicMult((PublicDiv(I3, total)), curCount)), o3)); + } + if (axis == (int32_t)3) { + i4 = + (PublicAdd((PublicMult((PublicDiv(I4, total)), curCount)), o4)); + } + out[o1][o2][o3][o4] = inp[i1][i2][i3][i4]; + } + } + } + } +} + +void Conv2DReshapeFilter_pt(uint64_t FH, uint64_t FW, uint64_t CI, uint64_t CO, + uint64_4D &inputArr, uint64_2D &outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t linIdx = + (PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CI)), + (PublicMult(fw, CI)))), + ci)); + outputArr[co][linIdx] = inputArr[fh][fw][ci][co]; + } + } + } + } +} + +void Conv2DReshapeMatMulOP_pt(uint64_t N, uint64_t finalH, uint64_t finalW, + uint64_t CO, uint64_2D &inputArr, + uint64_4D &outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + outputArr[n][h][w][co] = inputArr[co][(PublicAdd( + (PublicAdd((PublicMult((PublicMult(n, finalH)), finalW)), + (PublicMult(h, finalW)))), + w))]; + } + } + } + } +} + +void Conv2DReshapeInput_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, + uint64_t FH, uint64_t FW, uint64_t zPadHLeft, + uint64_t zPadHRight, uint64_t zPadWLeft, + uint64_t zPadWRight, uint64_t strideH, + uint64_t strideW, uint64_t RRows, uint64_t RCols, + uint64_4D &inputArr, uint64_2D &outputArr) { + + uint64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + uint64_t leftTopCornerH = (PublicSub((int32_t)0, zPadHLeft)); + + uint64_t extremeRightBottomCornerH = + (PublicAdd((PublicSub(H, (int32_t)1)), zPadHRight)); + while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), + extremeRightBottomCornerH))) { + + uint64_t leftTopCornerW = (PublicSub((int32_t)0, zPadWLeft)); + + uint64_t extremeRightBottomCornerW = + (PublicAdd((PublicSub(W, (int32_t)1)), zPadWRight)); + while ( + (PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), + extremeRightBottomCornerW))) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); + + uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); + + uint64_t val = (int64_t)0; + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((PublicLT(curPosH, (int32_t)0)) || + (PublicGTE(curPosH, H))) || + ((PublicLT(curPosW, (int32_t)0)) || + (PublicGTE(curPosW, W))))) { + val = (int64_t)0; + } else { + val = inputArr[n][curPosH][curPosW][ci]; + } + outputArr[( + PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CI)), + (PublicMult(fw, CI)))), + ci))][linIdxFilterMult] = val; + } + } + } + linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); + leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); + } + + leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); + } + } +} + +void Conv2D_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, + uint64_t FW, uint64_t CO, uint64_t zPadHLeft, + uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, + uint64_t strideH, uint64_t strideW, uint64_4D &inputArr, + uint64_4D &filterArr, uint64_4D &outArr) { + + uint64_t reshapedFilterRows = CO; + + uint64_t reshapedFilterCols = (PublicMult((PublicMult(FH, FW)), CI)); + + uint64_t reshapedIPRows = (PublicMult((PublicMult(FH, FW)), CI)); + + uint64_t newH = (PublicAdd( + (PublicDiv( + (PublicSub((PublicAdd(H, (PublicAdd(zPadHLeft, zPadHRight)))), FH)), + strideH)), + (int32_t)1)); + + uint64_t newW = (PublicAdd( + (PublicDiv( + (PublicSub((PublicAdd(W, (PublicAdd(zPadWLeft, zPadWRight)))), FW)), + strideW)), + (int32_t)1)); + + uint64_t reshapedIPCols = (PublicMult((PublicMult(N, newH)), newW)); + + auto filterReshaped = + make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); + + auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); + + auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); + Conv2DReshapeFilter_pt(FH, FW, CI, CO, filterArr, filterReshaped); + Conv2DReshapeInput_pt(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, reshapedIPRows, + reshapedIPCols, inputArr, inputReshaped); + MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOP_pt(N, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv2DLoopInner_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, + uint64_t FH, uint64_t FW, uint64_t CO, + uint64_t zPadHLeft, uint64_t zPadHRight, + uint64_t zPadWLeft, uint64_t zPadWRight, + uint64_t strideH, uint64_t strideW, uint64_t outH, + uint64_t outW, uint64_t G, uint64_4D &inputArr, + uint64_4D &filterArr, uint64_4D &outArr) { + + uint64_t GIS = (PublicDiv(CI, G)); + + uint64_t GOS = (PublicDiv(CO, G)); + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t cog = (int32_t)0; cog < GOS; cog++) { + for (uint64_t cig = (int32_t)0; cig < GIS; cig++) { + for (uint64_t g = (int32_t)0; g < G; g++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + + uint64_t val = (int64_t)0; + + uint64_t ci = (PublicAdd((PublicMult(GIS, g)), cig)); + + uint64_t co = (PublicAdd((PublicMult(GOS, g)), cog)); + + uint64_t curPosH = + (PublicSub((PublicMult(strideH, h)), zPadHLeft)); + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + + uint64_t curPosW = + (PublicSub((PublicMult(strideW, w)), zPadWLeft)); + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + if (((((PublicGTE(curPosH, (int32_t)0)) && + (PublicGTE(curPosW, (int32_t)0))) && + (PublicLT(curPosH, H))) && + (PublicLT(curPosW, W)))) { + val = (PublicAdd( + val, (PublicMult( + inputArr[n][curPosH][curPosW][ci], + filterArr[fh][fw][(PublicDiv(ci, G))][co])))); + } + curPosW = (PublicAdd(curPosW, (int32_t)1)); + } + curPosH = (PublicAdd(curPosH, (int32_t)1)); + } + outArr[n][h][w][co] = (PublicAdd(outArr[n][h][w][co], val)); + } + } + } + } + } + } +} + +void Conv2DLoop_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, + uint64_t FW, uint64_t CO, uint64_t zPadHLeft, + uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, + uint64_t strideH, uint64_t strideW, uint64_t G, + uint64_4D &inputArr, uint64_4D &filterArr, + uint64_4D &outArr) { + + uint64_t outH = + (PublicAdd((PublicDiv((PublicAdd((PublicSub(H, FH)), + (PublicAdd(zPadHLeft, zPadHRight)))), + strideH)), + (int32_t)1)); + + uint64_t outW = + (PublicAdd((PublicDiv((PublicAdd((PublicSub(W, FW)), + (PublicAdd(zPadWLeft, zPadWRight)))), + strideW)), + (int32_t)1)); + Conv2DLoopInner_pt(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, outH, outW, G, inputArr, + filterArr, outArr); +} + +void Conv2DReshapeFilterGroup_pt(uint64_t FH, uint64_t FW, uint64_t CI, + uint64_t CO, uint64_t g, uint64_t G, + uint64_4D &inputArr, uint64_2D &outputArr) { + + uint64_t CIG = (PublicDiv(CI, G)); + + uint64_t COG = (PublicDiv(CO, G)); + + uint64_t startCO = (PublicMult(g, COG)); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + + uint64_t linIdx = + (PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CIG)), + (PublicMult(fw, CIG)))), + ci)); + outputArr[co][linIdx] = + inputArr[fh][fw][ci][(PublicAdd(co, startCO))]; + } + } + } + } +} + +void Conv2DReshapeMatMulOPGroup_pt(uint64_t N, uint64_t finalH, uint64_t finalW, + uint64_t CO, uint64_t g, uint64_t G, + uint64_2D &inputArr, uint64_4D &outputArr) { + + uint64_t COG = (PublicDiv(CO, G)); + + uint64_t startCO = (PublicMult(g, COG)); + for (uint64_t co = (int32_t)0; co < COG; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + outputArr[n][h][w][(PublicAdd(co, startCO))] = + inputArr[co][(PublicAdd( + (PublicAdd((PublicMult((PublicMult(n, finalH)), finalW)), + (PublicMult(h, finalW)))), + w))]; + } + } + } + } +} + +void Conv2DReshapeInputGroup_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, + uint64_t FH, uint64_t FW, uint64_t zPadHLeft, + uint64_t zPadHRight, uint64_t zPadWLeft, + uint64_t zPadWRight, uint64_t strideH, + uint64_t strideW, uint64_t g, uint64_t G, + uint64_t RRows, uint64_t RCols, + uint64_4D &inputArr, uint64_2D &outputArr) { + + uint64_t linIdxFilterMult = (int32_t)0; + + uint64_t CIG = (PublicDiv(CI, G)); + for (uint64_t n = (int32_t)0; n < N; n++) { + + uint64_t leftTopCornerH = (PublicSub((int32_t)0, zPadHLeft)); + + uint64_t extremeRightBottomCornerH = + (PublicAdd((PublicSub(H, (int32_t)1)), zPadHRight)); + while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), + extremeRightBottomCornerH))) { + + uint64_t leftTopCornerW = (PublicSub((int32_t)0, zPadWLeft)); + + uint64_t extremeRightBottomCornerW = + (PublicAdd((PublicSub(W, (int32_t)1)), zPadWRight)); + while ( + (PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), + extremeRightBottomCornerW))) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); + + uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); + + uint64_t val = (int64_t)0; + + uint64_t startCI = (PublicMult(g, CIG)); + for (uint64_t ci = (int32_t)0; ci < CIG; ci++) { + if ((((PublicLT(curPosH, (int32_t)0)) || + (PublicGTE(curPosH, H))) || + ((PublicLT(curPosW, (int32_t)0)) || + (PublicGTE(curPosW, W))))) { + val = (int64_t)0; + } else { + val = inputArr[n][curPosH][curPosW][(PublicAdd(ci, startCI))]; + } + outputArr[( + PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CIG)), + (PublicMult(fw, CIG)))), + ci))][linIdxFilterMult] = val; + } + } + } + linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); + leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); + } + + leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); + } + } +} + +void Conv2DGroup_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, + uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadHLeft, + uint64_t zPadHRight, uint64_t zPadWLeft, + uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, + uint64_t G, uint64_4D &inputArr, uint64_4D &filterArr, + uint64_4D &outArr) { + + uint64_t CIG = (PublicDiv(CI, G)); + + uint64_t reshapedFilterRows = (PublicDiv(CO, G)); + + uint64_t reshapedFilterCols = (PublicMult((PublicMult(FH, FW)), CIG)); + + uint64_t reshapedIPRows = (PublicMult((PublicMult(FH, FW)), CIG)); + + uint64_t outH = (PublicAdd( + (PublicDiv( + (PublicSub((PublicAdd(H, (PublicAdd(zPadHLeft, zPadHRight)))), FH)), + strideH)), + (int32_t)1)); + + uint64_t outW = (PublicAdd( + (PublicDiv( + (PublicSub((PublicAdd(W, (PublicAdd(zPadWLeft, zPadWRight)))), FW)), + strideW)), + (int32_t)1)); + + uint64_t reshapedIPCols = (PublicMult((PublicMult(N, outH)), outW)); + for (uint64_t g = (int32_t)0; g < G; g++) { + + auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); + + auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); + + auto filterReshaped = + make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); + Conv2DReshapeFilterGroup_pt(FH, FW, CI, CO, g, G, filterArr, + filterReshaped); + Conv2DReshapeInputGroup_pt(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, + zPadWLeft, zPadWRight, strideH, strideW, g, G, + reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOPGroup_pt(N, outH, outW, CO, g, G, matmulOP, outArr); + ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); + } +} + +void Conv3DReshapeFilter_pt(uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CI, + uint64_t CO, uint64_5D &inputArr, + uint64_2D &outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd((PublicMult( + (PublicMult((PublicMult(fd, FH)), FW)), CI)), + (PublicMult((PublicMult(fh, FW)), CI)))), + (PublicMult(fw, CI)))), + ci)); + outputArr[co][linIdx] = inputArr[fd][fh][fw][ci][co]; + } + } + } + } + } +} + +void Conv3DReshapeMatMulOP_pt(uint64_t N, uint64_t finalD, uint64_t finalH, + uint64_t finalW, uint64_t CO, uint64_2D &inputArr, + uint64_5D &outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t d = (int32_t)0; d < finalD; d++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + outputArr[n][d][h][w][co] = inputArr[co][(PublicAdd( + (PublicAdd( + (PublicAdd((PublicMult((PublicMult((PublicMult(n, finalD)), + finalH)), + finalW)), + (PublicMult((PublicMult(d, finalH)), finalW)))), + (PublicMult(h, finalW)))), + w))]; + } + } + } + } + } +} + +void Conv3DReshapeInput_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, + uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, + uint64_t zPadDLeft, uint64_t zPadDRight, + uint64_t zPadHLeft, uint64_t zPadHRight, + uint64_t zPadWLeft, uint64_t zPadWRight, + int64_t strideD, uint64_t strideH, uint64_t strideW, + uint64_t RRows, uint64_t RCols, uint64_5D &inputArr, + uint64_2D &outputArr) { + + uint64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + uint64_t leftTopCornerD = (PublicSub((int32_t)0, zPadDLeft)); + + uint64_t extremeRightBottomCornerD = + (PublicAdd((PublicSub(D, (int32_t)1)), zPadDRight)); + while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerD, FD)), (int32_t)1)), + extremeRightBottomCornerD))) { + + uint64_t leftTopCornerH = (PublicSub((int32_t)0, zPadHLeft)); + + uint64_t extremeRightBottomCornerH = + (PublicAdd((PublicSub(H, (int32_t)1)), zPadHRight)); + while ( + (PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), + extremeRightBottomCornerH))) { + + uint64_t leftTopCornerW = (PublicSub((int32_t)0, zPadWLeft)); + + uint64_t extremeRightBottomCornerW = + (PublicAdd((PublicSub(W, (int32_t)1)), zPadWRight)); + while ( + (PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), + extremeRightBottomCornerW))) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + uint64_t curPosD = (PublicAdd(leftTopCornerD, fd)); + + uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); + + uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); + + uint64_t val = (int64_t)0; + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((PublicLT(curPosD, (int32_t)0)) || + (PublicGTE(curPosD, D))) || + ((PublicLT(curPosH, (int32_t)0)) || + (PublicGTE(curPosH, H)))) || + ((PublicLT(curPosW, (int32_t)0)) || + (PublicGTE(curPosW, W))))) { + val = (int64_t)0; + } else { + val = inputArr[n][curPosD][curPosH][curPosW][ci]; + } + outputArr[(PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult( + (PublicMult((PublicMult(fd, FH)), FW)), CI)), + (PublicMult((PublicMult(fh, FW)), CI)))), + (PublicMult(fw, CI)))), + ci))][linIdxFilterMult] = val; + } + } + } + } + linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); + leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); + } + + leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); + } + + leftTopCornerD = (PublicAdd(leftTopCornerD, strideD)); + } + } +} + +void Conv3D_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, uint64_t CI, + uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, + uint64_t zPadDLeft, uint64_t zPadDRight, uint64_t zPadHLeft, + uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, + uint64_t strideD, uint64_t strideH, uint64_t strideW, + uint64_5D &inputArr, uint64_5D &filterArr, uint64_5D &outArr) { + + uint64_t reshapedFilterRows = CO; + + uint64_t reshapedFilterCols = + (PublicMult((PublicMult((PublicMult(FD, FH)), FW)), CI)); + + uint64_t reshapedIPRows = + (PublicMult((PublicMult((PublicMult(FD, FH)), FW)), CI)); + + uint64_t newD = (PublicAdd( + (PublicDiv( + (PublicSub((PublicAdd(D, (PublicAdd(zPadDLeft, zPadDRight)))), FD)), + strideD)), + (int32_t)1)); + + uint64_t newH = (PublicAdd( + (PublicDiv( + (PublicSub((PublicAdd(H, (PublicAdd(zPadHLeft, zPadHRight)))), FH)), + strideH)), + (int32_t)1)); + + uint64_t newW = (PublicAdd( + (PublicDiv( + (PublicSub((PublicAdd(W, (PublicAdd(zPadWLeft, zPadWRight)))), FW)), + strideW)), + (int32_t)1)); + + uint64_t reshapedIPCols = + (PublicMult((PublicMult((PublicMult(N, newD)), newH)), newW)); + + auto filterReshaped = + make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); + + auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); + + auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); + Conv3DReshapeFilter_pt(FD, FH, FW, CI, CO, filterArr, filterReshaped); + Conv3DReshapeInput_pt(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, reshapedIPRows, reshapedIPCols, + inputArr, inputReshaped); + MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP_pt(N, newD, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv3DLoopInner_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, + uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, + uint64_t CO, uint64_t zPadDLeft, uint64_t zPadDRight, + uint64_t zPadHLeft, uint64_t zPadHRight, + uint64_t zPadWLeft, uint64_t zPadWRight, + uint64_t strideD, uint64_t strideH, uint64_t strideW, + uint64_t outD, uint64_t outH, uint64_t outW, + uint64_5D &inputArr, uint64_5D &filterArr, + uint64_5D &outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = (int64_t)0; + for (uint64_t fd = (PublicMult(d, strideD)); + fd < (PublicAdd((PublicMult(d, strideD)), FD)); fd++) { + for (uint64_t fh = (PublicMult(h, strideH)); + fh < (PublicAdd((PublicMult(h, strideH)), FH)); fh++) { + for (uint64_t fw = (PublicMult(w, strideW)); + fw < (PublicAdd((PublicMult(w, strideW)), FW)); fw++) { + + uint64_t curPosD = (PublicSub(fd, zPadDLeft)); + + uint64_t curPosH = (PublicSub(fh, zPadHLeft)); + + uint64_t curPosW = (PublicSub(fw, zPadWLeft)); + if (((((((PublicGTE(curPosD, (int32_t)0)) && + (PublicGTE(curPosH, (int32_t)0))) && + (PublicGTE(curPosW, (int32_t)0))) && + (PublicLT(curPosD, D))) && + (PublicLT(curPosH, H))) && + (PublicLT(curPosW, W)))) { + + uint64_t curFilterPosD = + (PublicSub(fd, (PublicMult(d, strideD)))); + + uint64_t curFilterPosH = + (PublicSub(fh, (PublicMult(h, strideH)))); + + uint64_t curFilterPosW = + (PublicSub(fw, (PublicMult(w, strideW)))); + val = (PublicAdd( + val, (PublicMult( + inputArr[n][curPosD][curPosH][curPosW][ci], + filterArr[curFilterPosD][curFilterPosH] + [curFilterPosW][ci][co])))); + } + } + } + } + outArr[n][d][h][w][co] = (PublicAdd(outArr[n][d][h][w][co], val)); + } + } + } + } + } + } +} + +void Conv3DLoop_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, uint64_t CI, + uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, + uint64_t zPadDLeft, uint64_t zPadDRight, uint64_t zPadHLeft, + uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, + uint64_t strideD, uint64_t strideH, uint64_t strideW, + uint64_5D &inputArr, uint64_5D &filterArr, + uint64_5D &outArr) { + + uint64_t outD = + (PublicAdd((PublicDiv((PublicAdd((PublicSub(D, FD)), + (PublicAdd(zPadDLeft, zPadDRight)))), + strideD)), + (int32_t)1)); + + uint64_t outH = + (PublicAdd((PublicDiv((PublicAdd((PublicSub(H, FH)), + (PublicAdd(zPadHLeft, zPadHRight)))), + strideH)), + (int32_t)1)); + + uint64_t outW = + (PublicAdd((PublicDiv((PublicAdd((PublicSub(W, FW)), + (PublicAdd(zPadWLeft, zPadWRight)))), + strideW)), + (int32_t)1)); + Conv3DLoopInner_pt(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, + zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, + strideH, strideW, outD, outH, outW, inputArr, filterArr, + outArr); +} + +void ConvTranspose2DReshapeMatMulOP_pt(uint64_t N, uint64_t finalH, + uint64_t finalW, uint64_t CO, + uint64_2D &inputArr, + uint64_4D &outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t h = (int32_t)0; h < finalH; h++) { + for (uint64_t w = (int32_t)0; w < finalW; w++) { + outputArr[n][h][w][co] = inputArr[co][(PublicAdd( + (PublicAdd((PublicMult((PublicMult(n, finalH)), finalW)), + (PublicMult(h, finalW)))), + w))]; + } + } + } + } +} + +void ConvTranspose2DReshapeFilter_pt(uint64_t FH, uint64_t FW, uint64_t CO, + uint64_t CI, uint64_4D &inputArr, + uint64_2D &outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t linIdx = + (PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CI)), + (PublicMult(fw, CI)))), + ci)); + outputArr[co][linIdx] = + inputArr[(PublicSub((PublicSub(FH, (int32_t)1)), fh))] + [(PublicSub((PublicSub(FW, (int32_t)1)), fw))][co][ci]; + } + } + } + } +} + +void ConvTranspose2DReshapeInput_pt(uint64_t N, uint64_t HPrime, + uint64_t WPrime, uint64_t CI, uint64_t FH, + uint64_t FW, uint64_t zPadTrHLeft, + uint64_t zPadTrHRight, uint64_t zPadTrWLeft, + uint64_t zPadTrWRight, uint64_t strideH, + uint64_t strideW, uint64_t RRows, + uint64_t RCols, uint64_4D &inputArr, + uint64_2D &outputArr) { + + uint64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + uint64_t leftTopCornerH = (PublicSub((int32_t)0, zPadTrHLeft)); + + uint64_t HPrimeTilde = + (PublicAdd(HPrime, (PublicMult((PublicSub(HPrime, (int32_t)1)), + (PublicSub(strideH, (int32_t)1)))))); + + uint64_t extremeRightBottomCornerH = + (PublicAdd((PublicSub(HPrimeTilde, (int32_t)1)), zPadTrHRight)); + while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), + extremeRightBottomCornerH))) { + + uint64_t leftTopCornerW = (PublicSub((int32_t)0, zPadTrWLeft)); + + uint64_t WPrimeTilde = + (PublicAdd(WPrime, (PublicMult((PublicSub(WPrime, (int32_t)1)), + (PublicSub(strideW, (int32_t)1)))))); + + uint64_t extremeRightBottomCornerW = + (PublicAdd((PublicSub(WPrimeTilde, (int32_t)1)), zPadTrWRight)); + while ( + (PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), + extremeRightBottomCornerW))) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); + + uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); + + uint64_t val = (int64_t)0; + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if ((((PublicLT(curPosH, (int32_t)0)) || + (PublicGTE(curPosH, HPrimeTilde))) || + ((PublicLT(curPosW, (int32_t)0)) || + (PublicGTE(curPosW, WPrimeTilde))))) { + val = (int64_t)0; + } else { + if (((PublicMod(curPosH, strideH)) == (int32_t)0) && + ((PublicMod(curPosW, strideW)) == (int32_t)0)) { + + uint64_t idxInputH = (PublicDiv(curPosH, strideH)); + + uint64_t idxInputW = (PublicDiv(curPosW, strideW)); + val = inputArr[n][idxInputH][idxInputW][ci]; + } else { + val = (int64_t)0; + } + } + outputArr[( + PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CI)), + (PublicMult(fw, CI)))), + ci))][linIdxFilterMult] = val; + } + } + } + linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); + leftTopCornerW = (PublicAdd(leftTopCornerW, (int32_t)1)); + } + + leftTopCornerH = (PublicAdd(leftTopCornerH, (int32_t)1)); + } + } +} + +void ConvTranspose2D_pt(uint64_t N, uint64_t HPrime, uint64_t WPrime, + uint64_t CI, uint64_t FH, uint64_t FW, uint64_t CO, + uint64_t H, uint64_t W, uint64_t zPadTrHLeft, + uint64_t zPadTrHRight, uint64_t zPadTrWLeft, + uint64_t zPadTrWRight, uint64_t strideH, + uint64_t strideW, uint64_4D &inputArr, + uint64_4D &filterArr, uint64_4D &outArr) { + + uint64_t reshapedFilterRows = CO; + + uint64_t reshapedFilterCols = (PublicMult((PublicMult(FH, FW)), CI)); + + uint64_t reshapedIPRows = (PublicMult((PublicMult(FH, FW)), CI)); + + uint64_t reshapedIPCols = (PublicMult((PublicMult(N, H)), W)); + + auto filterReshaped = + make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); + + auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); + + auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); + ConvTranspose2DReshapeFilter_pt(FH, FW, CO, CI, filterArr, filterReshaped); + ConvTranspose2DReshapeInput_pt(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, + zPadTrHRight, zPadTrWLeft, zPadTrWRight, + strideH, strideW, reshapedIPRows, + reshapedIPCols, inputArr, inputReshaped); + MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + ConvTranspose2DReshapeMatMulOP_pt(N, H, W, CO, matmulOP, outArr); + ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DReshapeFilter_pt(uint64_t FD, uint64_t FH, uint64_t FW, + uint64_t CO, uint64_t CI, + uint64_5D &inputArr, + uint64_2D &outputArr) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd((PublicMult( + (PublicMult((PublicMult(fd, FH)), FW)), CI)), + (PublicMult((PublicMult(fh, FW)), CI)))), + (PublicMult(fw, CI)))), + ci)); + outputArr[co][linIdx] = + inputArr[(PublicSub((PublicSub(FD, (int32_t)1)), fd))] + [(PublicSub((PublicSub(FH, (int32_t)1)), fh))] + [(PublicSub((PublicSub(FW, (int32_t)1)), fw))][co][ci]; + } + } + } + } + } +} + +void ConvTranspose3DReshapeInput_pt( + uint64_t N, uint64_t DPrime, uint64_t HPrime, uint64_t WPrime, uint64_t CI, + uint64_t FD, uint64_t FH, uint64_t FW, uint64_t zPadTrDLeft, + uint64_t zPadTrDRight, uint64_t zPadTrHLeft, uint64_t zPadTrHRight, + uint64_t zPadTrWLeft, uint64_t zPadTrWRight, uint64_t strideD, + uint64_t strideH, uint64_t strideW, uint64_t RRows, uint64_t RCols, + uint64_5D &inputArr, uint64_2D &outputArr) { + + uint64_t linIdxFilterMult = (int32_t)0; + for (uint64_t n = (int32_t)0; n < N; n++) { + + uint64_t leftTopCornerD = (PublicSub((int32_t)0, zPadTrDLeft)); + + uint64_t DPrimeTilde = + (PublicAdd(DPrime, (PublicMult((PublicSub(DPrime, (int32_t)1)), + (PublicSub(strideD, (int32_t)1)))))); + + uint64_t extremeRightBottomCornerD = + (PublicAdd((PublicSub(DPrimeTilde, (int32_t)1)), zPadTrDRight)); + while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerD, FD)), (int32_t)1)), + extremeRightBottomCornerD))) { + + uint64_t leftTopCornerH = (PublicSub((int32_t)0, zPadTrHLeft)); + + uint64_t HPrimeTilde = + (PublicAdd(HPrime, (PublicMult((PublicSub(HPrime, (int32_t)1)), + (PublicSub(strideH, (int32_t)1)))))); + + uint64_t extremeRightBottomCornerH = + (PublicAdd((PublicSub(HPrimeTilde, (int32_t)1)), zPadTrHRight)); + while ( + (PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), + extremeRightBottomCornerH))) { + + uint64_t leftTopCornerW = (PublicSub((int32_t)0, zPadTrWLeft)); + + uint64_t WPrimeTilde = + (PublicAdd(WPrime, (PublicMult((PublicSub(WPrime, (int32_t)1)), + (PublicSub(strideW, (int32_t)1)))))); + + uint64_t extremeRightBottomCornerW = + (PublicAdd((PublicSub(WPrimeTilde, (int32_t)1)), zPadTrWRight)); + while ( + (PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), + extremeRightBottomCornerW))) { + for (uint64_t fd = (int32_t)0; fd < FD; fd++) { + for (uint64_t fh = (int32_t)0; fh < FH; fh++) { + for (uint64_t fw = (int32_t)0; fw < FW; fw++) { + + uint64_t curPosD = (PublicAdd(leftTopCornerD, fd)); + + uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); + + uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); + + uint64_t val = (int64_t)0; + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + if (((((PublicLT(curPosD, (int32_t)0)) || + (PublicGTE(curPosD, DPrimeTilde))) || + ((PublicLT(curPosH, (int32_t)0)) || + (PublicGTE(curPosH, HPrimeTilde)))) || + ((PublicLT(curPosW, (int32_t)0)) || + (PublicGTE(curPosW, WPrimeTilde))))) { + val = (int64_t)0; + } else { + if ((((PublicMod(curPosD, strideD)) == (int32_t)0) && + ((PublicMod(curPosH, strideH)) == (int32_t)0)) && + ((PublicMod(curPosW, strideW)) == (int32_t)0)) { + + uint64_t idxInputD = (PublicDiv(curPosD, strideD)); + + uint64_t idxInputH = (PublicDiv(curPosH, strideH)); + + uint64_t idxInputW = (PublicDiv(curPosW, strideW)); + val = inputArr[n][idxInputD][idxInputH][idxInputW][ci]; + } else { + val = (int64_t)0; + } + } + outputArr[(PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult( + (PublicMult((PublicMult(fd, FH)), FW)), CI)), + (PublicMult((PublicMult(fh, FW)), CI)))), + (PublicMult(fw, CI)))), + ci))][linIdxFilterMult] = val; + } + } + } + } + linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); + leftTopCornerW = (PublicAdd(leftTopCornerW, (int32_t)1)); + } + + leftTopCornerH = (PublicAdd(leftTopCornerH, (int32_t)1)); + } + + leftTopCornerD = (PublicAdd(leftTopCornerD, (int32_t)1)); + } + } +} + +void ConvTranspose3D_pt(uint64_t N, uint64_t DPrime, uint64_t HPrime, + uint64_t WPrime, uint64_t CI, uint64_t FD, uint64_t FH, + uint64_t FW, uint64_t CO, uint64_t D, uint64_t H, + uint64_t W, uint64_t zPadTrDLeft, uint64_t zPadTrDRight, + uint64_t zPadTrHLeft, uint64_t zPadTrHRight, + uint64_t zPadTrWLeft, uint64_t zPadTrWRight, + uint64_t strideD, uint64_t strideH, uint64_t strideW, + uint64_5D &inputArr, uint64_5D &filterArr, + uint64_5D &outArr) { + + uint64_t reshapedFilterRows = CO; + + uint64_t reshapedFilterCols = + (PublicMult((PublicMult((PublicMult(FD, FH)), FW)), CI)); + + uint64_t reshapedIPRows = + (PublicMult((PublicMult((PublicMult(FD, FH)), FW)), CI)); + + uint64_t reshapedIPCols = + (PublicMult((PublicMult((PublicMult(N, D)), H)), W)); + + auto filterReshaped = + make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); + + auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); + + auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); + ConvTranspose3DReshapeFilter_pt(FD, FH, FW, CO, CI, filterArr, + filterReshaped); + ConvTranspose3DReshapeInput_pt( + N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, + zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, + strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); + MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv3DReshapeMatMulOP_pt(N, D, H, W, CO, matmulOP, outArr); + ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void ConvTranspose3DLoopInner_pt( + uint64_t N, uint64_t D, uint64_t H, uint64_t W, uint64_t CI, uint64_t FD, + uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadDLeft, + uint64_t zPadDRight, uint64_t zPadHLeft, uint64_t zPadHRight, + uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideD, uint64_t strideH, + uint64_t strideW, uint64_t outD, uint64_t outH, uint64_t outW, + uint64_5D &inputArr, uint64_5D &filterArr, uint64_5D &outArr) { + for (uint64_t n = (int32_t)0; n < N; n++) { + for (uint64_t co = (int32_t)0; co < CO; co++) { + for (uint64_t d = (int32_t)0; d < outD; d++) { + for (uint64_t h = (int32_t)0; h < outH; h++) { + for (uint64_t w = (int32_t)0; w < outW; w++) { + for (uint64_t ci = (int32_t)0; ci < CI; ci++) { + + uint64_t val = (int64_t)0; + for (uint64_t fd = d; fd < (PublicAdd(d, FD)); fd++) { + for (uint64_t fh = h; fh < (PublicAdd(h, FH)); fh++) { + for (uint64_t fw = w; fw < (PublicAdd(w, FW)); fw++) { + + uint64_t curPosD = + (PublicDiv((PublicSub(fd, zPadDLeft)), strideD)); + + uint64_t curPosH = + (PublicDiv((PublicSub(fh, zPadHLeft)), strideD)); + + uint64_t curPosW = + (PublicDiv((PublicSub(fw, zPadWLeft)), strideD)); + if (((((((((PublicGTE(curPosD, (int32_t)0)) && + (PublicGTE(curPosH, (int32_t)0))) && + (PublicGTE(curPosW, (int32_t)0))) && + (PublicLT(curPosD, D))) && + (PublicLT(curPosH, H))) && + (PublicLT(curPosW, W))) && + ((PublicMod((PublicSub(fd, zPadDLeft)), strideD)) == + (int32_t)0)) && + ((PublicMod((PublicSub(fh, zPadHLeft)), strideH)) == + (int32_t)0)) && + ((PublicMod((PublicSub(fw, zPadWLeft)), strideW)) == + (int32_t)0)) { + + uint64_t curFilterPosD = (PublicSub( + (PublicSub((PublicAdd(FD, d)), fd)), (int32_t)1)); + + uint64_t curFilterPosH = (PublicSub( + (PublicSub((PublicAdd(FH, h)), fh)), (int32_t)1)); + + uint64_t curFilterPosW = (PublicSub( + (PublicSub((PublicAdd(FW, w)), fw)), (int32_t)1)); + val = (PublicAdd( + val, (PublicMult( + inputArr[n][curPosD][curPosH][curPosW][ci], + filterArr[curFilterPosD][curFilterPosH] + [curFilterPosW][co][ci])))); + } + } + } + } + outArr[n][d][h][w][co] = (PublicAdd(outArr[n][d][h][w][co], val)); + } + } + } + } + } + } +} + +void ConvTranspose3DLoop_pt( + uint64_t N, uint64_t DPrime, uint64_t HPrime, uint64_t WPrime, uint64_t CI, + uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t D, uint64_t H, + uint64_t W, uint64_t zPadTrDLeft, uint64_t zPadTrDRight, + uint64_t zPadTrHLeft, uint64_t zPadTrHRight, uint64_t zPadTrWLeft, + uint64_t zPadTrWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, + uint64_5D &inputArr, uint64_5D &filterArr, uint64_5D &outArr) { + ConvTranspose3DLoopInner_pt( + N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, + zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, + strideW, D, H, W, inputArr, filterArr, outArr); +} + +void Transpose2_pt(uint64_t s1, uint64_t s2, uint64_2D &inArr, + uint64_2D &outArr) { + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + outArr[i][j] = inArr[j][i]; + } + } +} + +void Pad442_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t inps1, uint64_t inps2, uint64_t inps3, uint64_t inps4, + uint64_4D &inpArr, uint64_t pads1, uint64_t pads2, + uint64_2D &paddings, uint64_4D &outArr) { + + uint64_t lbounds1 = paddings[(int32_t)0][(int32_t)0]; + + uint64_t rbounds1excl = (PublicSub(s1, paddings[(int32_t)0][(int32_t)1])); + + uint64_t lbounds2 = paddings[(int32_t)1][(int32_t)0]; + + uint64_t rbounds2excl = (PublicSub(s2, paddings[(int32_t)1][(int32_t)1])); + + uint64_t lbounds3 = paddings[(int32_t)2][(int32_t)0]; + + uint64_t rbounds3excl = (PublicSub(s3, paddings[(int32_t)2][(int32_t)1])); + + uint64_t lbounds4 = paddings[(int32_t)3][(int32_t)0]; + + uint64_t rbounds4excl = (PublicSub(s4, paddings[(int32_t)3][(int32_t)1])); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + if (((((((((PublicGTE(i, lbounds1)) && (PublicLT(i, rbounds1excl))) && + (PublicGTE(j, lbounds2))) && + (PublicLT(j, rbounds2excl))) && + (PublicGTE(k, lbounds3))) && + (PublicLT(k, rbounds3excl))) && + (PublicGTE(l, lbounds4))) && + (PublicLT(l, rbounds4excl)))) { + outArr[i][j][k][l] = + inpArr[(PublicSub(i, paddings[(int32_t)0][(int32_t)0]))] + [(PublicSub(j, paddings[(int32_t)1][(int32_t)0]))] + [(PublicSub(k, paddings[(int32_t)2][(int32_t)0]))] + [(PublicSub(l, paddings[(int32_t)3][(int32_t)0]))]; + } else { + outArr[i][j][k][l] = (int64_t)0; + } + } + } + } + } +} + +void Pad552_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, + uint64_t inps1, uint64_t inps2, uint64_t inps3, uint64_t inps4, + uint64_t inps5, uint64_5D &inpArr, uint64_t pads1, + uint64_t pads2, uint64_2D &paddings, uint64_5D &outArr) { + + uint64_t lbounds1 = paddings[(int32_t)0][(int32_t)0]; + + uint64_t rbounds1excl = (PublicSub(s1, paddings[(int32_t)0][(int32_t)1])); + + uint64_t lbounds2 = paddings[(int32_t)1][(int32_t)0]; + + uint64_t rbounds2excl = (PublicSub(s2, paddings[(int32_t)1][(int32_t)1])); + + uint64_t lbounds3 = paddings[(int32_t)2][(int32_t)0]; + + uint64_t rbounds3excl = (PublicSub(s3, paddings[(int32_t)2][(int32_t)1])); + + uint64_t lbounds4 = paddings[(int32_t)3][(int32_t)0]; + + uint64_t rbounds4excl = (PublicSub(s4, paddings[(int32_t)3][(int32_t)1])); + + uint64_t lbounds5 = paddings[(int32_t)4][(int32_t)0]; + + uint64_t rbounds5excl = (PublicSub(s5, paddings[(int32_t)4][(int32_t)1])); + for (uint64_t i = (int32_t)0; i < s1; i++) { + for (uint64_t j = (int32_t)0; j < s2; j++) { + for (uint64_t k = (int32_t)0; k < s3; k++) { + for (uint64_t l = (int32_t)0; l < s4; l++) { + for (uint64_t m = (int32_t)0; m < s5; m++) { + if (((((((((((PublicGTE(i, lbounds1)) && + (PublicLT(i, rbounds1excl))) && + (PublicGTE(j, lbounds2))) && + (PublicLT(j, rbounds2excl))) && + (PublicGTE(k, lbounds3))) && + (PublicLT(k, rbounds3excl))) && + (PublicGTE(l, lbounds4))) && + (PublicLT(l, rbounds4excl))) && + (PublicGTE(m, lbounds5))) && + (PublicLT(m, rbounds5excl)))) { + outArr[i][j][k][l][m] = + inpArr[(PublicSub(i, paddings[(int32_t)0][(int32_t)0]))] + [(PublicSub(j, paddings[(int32_t)1][(int32_t)0]))] + [(PublicSub(k, paddings[(int32_t)2][(int32_t)0]))] + [(PublicSub(l, paddings[(int32_t)3][(int32_t)0]))] + [(PublicSub(m, paddings[(int32_t)4][(int32_t)0]))]; + } else { + outArr[i][j][k][l][m] = (int64_t)0; + } + } + } + } + } + } +} + +void PadONNX441_pt(uint64_t o1, uint64_t o2, uint64_t o3, uint64_t o4, + uint64_t i1, uint64_t i2, uint64_t i3, uint64_t i4, + uint64_4D &inpArr, uint64_t pads, uint64_1D &paddings, + uint64_4D &outArr) { + + uint64_t lbounds1 = paddings[(int32_t)0]; + + uint64_t rbounds1excl = (PublicSub(o1, paddings[(int32_t)4])); + + uint64_t lbounds2 = paddings[(int32_t)1]; + + uint64_t rbounds2excl = (PublicSub(o2, paddings[(int32_t)5])); + + uint64_t lbounds3 = paddings[(int32_t)2]; + + uint64_t rbounds3excl = (PublicSub(o3, paddings[(int32_t)6])); + + uint64_t lbounds4 = paddings[(int32_t)3]; + + uint64_t rbounds4excl = (PublicSub(o4, paddings[(int32_t)7])); + for (uint64_t i = (int32_t)0; i < o1; i++) { + for (uint64_t j = (int32_t)0; j < o2; j++) { + for (uint64_t k = (int32_t)0; k < o3; k++) { + for (uint64_t l = (int32_t)0; l < o4; l++) { + if (((((((((PublicGTE(i, lbounds1)) && (PublicLT(i, rbounds1excl))) && + (PublicGTE(j, lbounds2))) && + (PublicLT(j, rbounds2excl))) && + (PublicGTE(k, lbounds3))) && + (PublicLT(k, rbounds3excl))) && + (PublicGTE(l, lbounds4))) && + (PublicLT(l, rbounds4excl)))) { + outArr[i][j][k][l] = inpArr[(PublicSub(i, paddings[(int32_t)0]))] + [(PublicSub(j, paddings[(int32_t)1]))] + [(PublicSub(k, paddings[(int32_t)2]))] + [(PublicSub(l, paddings[(int32_t)3]))]; + } else { + outArr[i][j][k][l] = (int64_t)0; + } + } + } + } + } +} + +void Squeeze24_pt(uint64_t s1, uint64_t s2, uint64_t dim1, uint64_t dim2, + uint64_t ins1, uint64_t ins2, uint64_t ins3, uint64_t ins4, + uint64_4D &inArr, uint64_2D &outArr) { + for (uint64_t i = (int32_t)0; i < ins1; i++) { + for (uint64_t j = (int32_t)0; j < ins2; j++) { + for (uint64_t k = (int32_t)0; k < ins3; k++) { + for (uint64_t l = (int32_t)0; l < ins4; l++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i, ins2)), ins3)), + ins4)), + (PublicMult((PublicMult(j, ins3)), ins4)))), + (PublicMult(k, ins4)))), + l)); + + uint64_t outIdx1 = (PublicDiv(linIdx, s2)); + + uint64_t outIdx2 = (PublicMod(linIdx, s2)); + outArr[outIdx1][outIdx2] = inArr[i][j][k][l]; + } + } + } + } +} + +void FusedBatchNorm4411_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &inArr, uint64_1D &multArr, + uint64_1D &biasArr, uint64_t multExprScaleDownSf, + uint64_t biasExprScaleUpSf, uint64_4D &outputArr) { + + uint64_t inpSize = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); + + auto inArrReshaped = make_vector<uint64_t>(inpSize); + + auto multArrReshaped = make_vector<uint64_t>(inpSize); + + auto multExprAns = make_vector<uint64_t>(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + inArrReshaped[linIdx] = inArr[i1][i2][i3][i4]; + multArrReshaped[linIdx] = multArr[i4]; + } + } + } + } + ElemWiseActModelVectorMult_pt(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((PublicGT(multExprScaleDownSf, (int32_t)0))) { + ScaleDown_pt(inpSize, multExprAns, multExprScaleDownSf); + } + + auto biasArrScaledUp = make_vector<uint64_t>(s4); + for (uint64_t ii = (int32_t)0; ii < s4; ii++) { + biasArrScaledUp[ii] = biasArr[ii]; + } + if ((PublicGT(biasExprScaleUpSf, (int32_t)0))) { + ScaleUp_pt(s4, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + outputArr[i1][i2][i3][i4] = + (PublicAdd(multExprAns[linIdx], biasArrScaledUp[i4])); + } + } + } + } + ClearMemSecret1_pt(inpSize, inArrReshaped); + ClearMemSecret1_pt(inpSize, multArrReshaped); + ClearMemSecret1_pt(inpSize, multExprAns); + ClearMemSecret1_pt(s4, biasArrScaledUp); +} + +void FusedBatchNorm5511_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t s5, uint64_5D &inArr, uint64_1D &multArr, + uint64_1D &biasArr, uint64_t multExprScaleDownSf, + uint64_t biasExprScaleUpSf, uint64_5D &outputArr) { + + uint64_t inpSize = (PublicMult( + (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)), s5)); + + auto inArrReshaped = make_vector<uint64_t>(inpSize); + + auto multArrReshaped = make_vector<uint64_t>(inpSize); + + auto multExprAns = make_vector<uint64_t>(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult( + (PublicMult( + (PublicMult((PublicMult(i1, s2)), s3)), + s4)), + s5)), + (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), + s5)))), + (PublicMult((PublicMult(i3, s4)), s5)))), + (PublicMult(i4, s5)))), + i5)); + inArrReshaped[linIdx] = inArr[i1][i2][i3][i4][i5]; + multArrReshaped[linIdx] = multArr[i5]; + } + } + } + } + } + ElemWiseActModelVectorMult_pt(inpSize, inArrReshaped, multArrReshaped, + multExprAns); + if ((PublicGT(multExprScaleDownSf, (int32_t)0))) { + ScaleDown_pt(inpSize, multExprAns, multExprScaleDownSf); + } + + auto biasArrScaledUp = make_vector<uint64_t>(s5); + for (uint64_t ii = (int32_t)0; ii < s5; ii++) { + biasArrScaledUp[ii] = biasArr[ii]; + } + if ((PublicGT(biasExprScaleUpSf, (int32_t)0))) { + ScaleUp_pt(s5, biasArrScaledUp, biasExprScaleUpSf); + } + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult( + (PublicMult( + (PublicMult((PublicMult(i1, s2)), s3)), + s4)), + s5)), + (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), + s5)))), + (PublicMult((PublicMult(i3, s4)), s5)))), + (PublicMult(i4, s5)))), + i5)); + outputArr[i1][i2][i3][i4][i5] = + (PublicAdd(multExprAns[linIdx], biasArrScaledUp[i5])); + } + } + } + } + } + ClearMemSecret1_pt(inpSize, inArrReshaped); + ClearMemSecret1_pt(inpSize, multArrReshaped); + ClearMemSecret1_pt(inpSize, multExprAns); + ClearMemSecret1_pt(s5, biasArrScaledUp); +} + +void ElemWiseMul2_pt(uint64_t s1, uint64_t s2, uint64_2D &arr1, uint64_2D &arr2, + uint64_2D &outArr) { + + uint64_t inpSize = (PublicMult(s1, s2)); + + auto arr1Reshaped = make_vector<uint64_t>(inpSize); + + auto arr2Reshaped = make_vector<uint64_t>(inpSize); + + auto outArrReshaped = make_vector<uint64_t>(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + arr1Reshaped[linIdx] = arr1[i1][i2]; + arr2Reshaped[linIdx] = arr2[i1][i2]; + } + } + ElemWiseSecretSharedVectorMult_pt(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + outArr[i1][i2] = outArrReshaped[linIdx]; + } + } + ClearMemSecret1_pt(inpSize, arr1Reshaped); + ClearMemSecret1_pt(inpSize, arr2Reshaped); + ClearMemSecret1_pt(inpSize, outArrReshaped); +} + +void ElemWiseMul4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &arr1, uint64_4D &arr2, uint64_4D &outArr) { + + uint64_t inpSize = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); + + auto arr1Reshaped = make_vector<uint64_t>(inpSize); + + auto arr2Reshaped = make_vector<uint64_t>(inpSize); + + auto outArrReshaped = make_vector<uint64_t>(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + arr1Reshaped[linIdx] = arr1[i1][i2][i3][i4]; + arr2Reshaped[linIdx] = arr2[i1][i2][i3][i4]; + } + } + } + } + ElemWiseSecretSharedVectorMult_pt(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + outArr[i1][i2][i3][i4] = outArrReshaped[linIdx]; + } + } + } + } + ClearMemSecret1_pt(inpSize, arr1Reshaped); + ClearMemSecret1_pt(inpSize, arr2Reshaped); + ClearMemSecret1_pt(inpSize, outArrReshaped); +} + +void ElemWiseMul5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_t s5, uint64_5D &arr1, uint64_5D &arr2, + uint64_5D &outArr) { + + uint64_t inpSize = (PublicMult( + (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)), s5)); + + auto arr1Reshaped = make_vector<uint64_t>(inpSize); + + auto arr2Reshaped = make_vector<uint64_t>(inpSize); + + auto outArrReshaped = make_vector<uint64_t>(inpSize); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult( + (PublicMult( + (PublicMult((PublicMult(i1, s2)), s3)), + s4)), + s5)), + (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), + s5)))), + (PublicMult((PublicMult(i3, s4)), s5)))), + (PublicMult(i4, s5)))), + i5)); + arr1Reshaped[linIdx] = arr1[i1][i2][i3][i4][i5]; + arr2Reshaped[linIdx] = arr2[i1][i2][i3][i4][i5]; + } + } + } + } + } + ElemWiseSecretSharedVectorMult_pt(inpSize, arr1Reshaped, arr2Reshaped, + outArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult( + (PublicMult( + (PublicMult((PublicMult(i1, s2)), s3)), + s4)), + s5)), + (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), + s5)))), + (PublicMult((PublicMult(i3, s4)), s5)))), + (PublicMult(i4, s5)))), + i5)); + outArr[i1][i2][i3][i4][i5] = outArrReshaped[linIdx]; + } + } + } + } + } + ClearMemSecret1_pt(inpSize, arr1Reshaped); + ClearMemSecret1_pt(inpSize, arr2Reshaped); + ClearMemSecret1_pt(inpSize, outArrReshaped); +} + +void ReduceMean24_pt(uint64_t outS1, uint64_t outS2, uint64_t inS1, + uint64_t inS2, uint64_t inS3, uint64_t inS4, + uint64_4D &inputArr, uint64_1D &axes, + uint64_2D &outputArr) { + + uint64_t divisor = (PublicMult(inS2, inS3)); + + uint64_t outputSize = (PublicMult(outS1, outS2)); + + auto sumArr = make_vector<uint64_t>(outputSize); + + auto outputArrReshaped = make_vector<uint64_t>(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = (int64_t)0; + for (uint64_t i = (int32_t)0; i < inS2; i++) { + for (uint64_t j = (int32_t)0; j < inS3; j++) { + summ = (PublicAdd(summ, inputArr[i1][i][j][i2])); + } + } + sumArr[(PublicAdd((PublicMult(i1, outS2)), i2))] = summ; + } + } + ElemWiseVectorPublicDiv_pt(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + outputArr[i1][i2] = + outputArrReshaped[(PublicAdd((PublicMult(i1, outS2)), i2))]; + } + } + ClearMemSecret1_pt(outputSize, sumArr); + ClearMemSecret1_pt(outputSize, outputArrReshaped); +} + +void ReduceMeanONNX24_pt(uint64_t outS1, uint64_t outS2, uint64_t inS1, + uint64_t inS2, uint64_t inS3, uint64_t inS4, + uint64_4D &inputArr, uint64_t axis1, uint64_t axis2, + uint64_2D &outputArr) { + + uint64_t divisor = (PublicMult(inS3, inS4)); + + uint64_t outputSize = (PublicMult(outS1, outS2)); + + auto sumArr = make_vector<uint64_t>(outputSize); + + auto outputArrReshaped = make_vector<uint64_t>(outputSize); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + + uint64_t summ = (int64_t)0; + for (uint64_t i = (int32_t)0; i < inS3; i++) { + for (uint64_t j = (int32_t)0; j < inS4; j++) { + summ = (PublicAdd(summ, inputArr[i1][i2][i][j])); + } + } + sumArr[(PublicAdd((PublicMult(i1, outS2)), i2))] = summ; + } + } + ElemWiseVectorPublicDiv_pt(outputSize, sumArr, divisor, outputArrReshaped); + for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++) { + outputArr[i1][i2] = + outputArrReshaped[(PublicAdd((PublicMult(i1, outS2)), i2))]; + } + } + ClearMemSecret1_pt(outputSize, sumArr); + ClearMemSecret1_pt(outputSize, outputArrReshaped); +} + +void ArgMax1_pt(uint64_t outArrS1, uint64_t inArrS1, uint64_t inArrS2, + uint64_2D &inArr, uint64_t dim, uint64_1D &outArr) { + ArgMax_pt(inArrS1, inArrS2, inArr, outArr); +} + +void ArgMax3_pt(uint64_t outs1, uint64_t outs2, uint64_t outs3, uint64_t ins1, + uint64_t ins2, uint64_t ins3, uint64_t ins4, uint64_4D &inArr, + uint64_t dim, uint64_3D &outArr) { + + uint64_t size = (PublicMult((PublicMult(ins1, ins2)), ins3)); + + auto reshapedInArr = make_vector<uint64_t>(size, ins4); + + auto reshapedOutArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++) { + + uint64_t linIdx = + (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, ins2)), ins3)), + (PublicMult(i2, ins3)))), + i3)); + reshapedInArr[linIdx][i4] = inArr[i1][i2][i3][i4]; + } + } + } + } + ArgMax_pt(size, ins4, reshapedInArr, reshapedOutArr); + for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++) { + + uint64_t linIdx = + (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, ins2)), ins3)), + (PublicMult(i2, ins3)))), + i3)); + outArr[i1][i2][i3] = reshapedOutArr[linIdx]; + } + } + } + ClearMemSecret2_pt(size, ins4, reshapedInArr); + ClearMemSecret1_pt(size, reshapedOutArr); +} + +void Relu2_pt(uint64_t s1, uint64_t s2, uint64_2D &inArr, uint64_2D &outArr, + uint64_t sf, uint64_t doTruncation) { + + uint64_t size = (PublicMult(s1, s2)); + + auto reshapedInArr = make_vector<uint64_t>(size); + + auto reshapedOutArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + reshapedInArr[linIdx] = inArr[i1][i2]; + } + } + Relu_pt(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + outArr[i1][i2] = reshapedOutArr[linIdx]; + } + } + ClearMemSecret1_pt(size, reshapedInArr); + ClearMemSecret1_pt(size, reshapedOutArr); +} + +void Relu4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &inArr, uint64_4D &outArr, uint64_t sf, + uint64_t doTruncation) { + + uint64_t size = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); + + auto reshapedInArr = make_vector<uint64_t>(size); + + auto reshapedOutArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + reshapedInArr[linIdx] = inArr[i1][i2][i3][i4]; + } + } + } + } + Relu_pt(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + outArr[i1][i2][i3][i4] = reshapedOutArr[linIdx]; + } + } + } + } + ClearMemSecret1_pt(size, reshapedInArr); + ClearMemSecret1_pt(size, reshapedOutArr); +} + +void Relu5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, + uint64_5D &inArr, uint64_5D &outArr, uint64_t sf, + uint64_t doTruncation) { + + uint64_t size = (PublicMult( + (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)), s5)); + + auto reshapedInArr = make_vector<uint64_t>(size); + + auto reshapedOutArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult( + (PublicMult( + (PublicMult((PublicMult(i1, s2)), s3)), + s4)), + s5)), + (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), + s5)))), + (PublicMult((PublicMult(i3, s4)), s5)))), + (PublicMult(i4, s5)))), + i5)); + reshapedInArr[linIdx] = inArr[i1][i2][i3][i4][i5]; + } + } + } + } + } + Relu_pt(size, reshapedInArr, reshapedOutArr, sf, doTruncation); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + for (uint64_t i5 = (int32_t)0; i5 < s5; i5++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult( + (PublicMult( + (PublicMult((PublicMult(i1, s2)), s3)), + s4)), + s5)), + (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), + s5)))), + (PublicMult((PublicMult(i3, s4)), s5)))), + (PublicMult(i4, s5)))), + i5)); + outArr[i1][i2][i3][i4][i5] = reshapedOutArr[linIdx]; + } + } + } + } + } + ClearMemSecret1_pt(size, reshapedInArr); + ClearMemSecret1_pt(size, reshapedOutArr); +} + +void Floor2_pt(uint64_t s1, uint64_t s2, uint64_2D &inArr, uint64_2D &outArr, + uint64_t sf) { + + uint64_t size = (PublicMult(s1, s2)); + + auto reshapedInArr = make_vector<uint64_t>(size); + + auto reshapedOutArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + reshapedInArr[linIdx] = inArr[i1][i2]; + } + } + Floor_pt(size, reshapedInArr, reshapedOutArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + outArr[i1][i2] = reshapedOutArr[linIdx]; + } + } + ClearMemSecret1_pt(size, reshapedInArr); + ClearMemSecret1_pt(size, reshapedOutArr); +} + +void ScaleUp1_pt(uint64_t s1, uint64_1D &arr, uint64_t sf) { + ScaleUp_pt(s1, arr, sf); +} + +void ScaleUp2_pt(uint64_t s1, uint64_t s2, uint64_2D &arr, uint64_t sf) { + + uint64_t size = (PublicMult(s1, s2)); + + auto reshapedArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + reshapedArr[linIdx] = arr[i1][i2]; + } + } + ScaleUp_pt(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + arr[i1][i2] = reshapedArr[linIdx]; + } + } + ClearMemSecret1_pt(size, reshapedArr); +} + +void ScaleUp3_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_3D &arr, + uint64_t sf) { + + uint64_t size = (PublicMult((PublicMult(s1, s2)), s3)); + + auto reshapedArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + uint64_t linIdx = + (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, s2)), s3)), + (PublicMult(i2, s3)))), + i3)); + reshapedArr[linIdx] = arr[i1][i2][i3]; + } + } + } + ScaleUp_pt(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + uint64_t linIdx = + (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, s2)), s3)), + (PublicMult(i2, s3)))), + i3)); + arr[i1][i2][i3] = reshapedArr[linIdx]; + } + } + } + ClearMemSecret1_pt(size, reshapedArr); +} + +void ScaleUp4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &arr, uint64_t sf) { + + uint64_t size = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); + + auto reshapedArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + reshapedArr[linIdx] = arr[i1][i2][i3][i4]; + } + } + } + } + ScaleUp_pt(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + arr[i1][i2][i3][i4] = reshapedArr[linIdx]; + } + } + } + } + ClearMemSecret1_pt(size, reshapedArr); +} + +void ScaleDown1_pt(uint64_t s1, uint64_1D &arr, uint64_t sf) { + ScaleDown_pt(s1, arr, sf); +} + +void ScaleDown2_pt(uint64_t s1, uint64_t s2, uint64_2D &arr, uint64_t sf) { + + uint64_t size = (PublicMult(s1, s2)); + + auto reshapedArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + reshapedArr[linIdx] = arr[i1][i2]; + } + } + ScaleDown_pt(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + + uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); + arr[i1][i2] = reshapedArr[linIdx]; + } + } + ClearMemSecret1_pt(size, reshapedArr); +} + +void ScaleDown3_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_3D &arr, + uint64_t sf) { + + uint64_t size = (PublicMult((PublicMult(s1, s2)), s3)); + + auto reshapedArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + uint64_t linIdx = + (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, s2)), s3)), + (PublicMult(i2, s3)))), + i3)); + reshapedArr[linIdx] = arr[i1][i2][i3]; + } + } + } + ScaleDown_pt(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + + uint64_t linIdx = + (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, s2)), s3)), + (PublicMult(i2, s3)))), + i3)); + arr[i1][i2][i3] = reshapedArr[linIdx]; + } + } + } + ClearMemSecret1_pt(size, reshapedArr); +} + +void ScaleDown4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, + uint64_4D &arr, uint64_t sf) { + + uint64_t size = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); + + auto reshapedArr = make_vector<uint64_t>(size); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + reshapedArr[linIdx] = arr[i1][i2][i3][i4]; + } + } + } + } + ScaleDown_pt(size, reshapedArr, sf); + for (uint64_t i1 = (int32_t)0; i1 < s1; i1++) { + for (uint64_t i2 = (int32_t)0; i2 < s2; i2++) { + for (uint64_t i3 = (int32_t)0; i3 < s3; i3++) { + for (uint64_t i4 = (int32_t)0; i4 < s4; i4++) { + + uint64_t linIdx = (PublicAdd( + (PublicAdd( + (PublicAdd( + (PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), + (PublicMult((PublicMult(i2, s3)), s4)))), + (PublicMult(i3, s4)))), + i4)); + arr[i1][i2][i3][i4] = reshapedArr[linIdx]; + } + } + } + } + ClearMemSecret1_pt(size, reshapedArr); +} + +void Conv2DWrapper_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, + uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadHLeft, + uint64_t zPadHRight, uint64_t zPadWLeft, + uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, + uint64_4D &inputArr, uint64_4D &filterArr, + uint64_4D &outArr) { + Conv2D_pt(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, inputArr, filterArr, outArr); +} + +void Conv3DWrapper_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, + uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, + uint64_t CO, uint64_t zPadDLeft, uint64_t zPadDRight, + uint64_t zPadHLeft, uint64_t zPadHRight, + uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideD, + uint64_t strideH, uint64_t strideW, uint64_5D &inputArr, + uint64_5D &filterArr, uint64_5D &outArr) { + Conv3D_pt(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, + zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, + inputArr, filterArr, outArr); +} + +void Conv2DGroupWrapper_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, + uint64_t FH, uint64_t FW, uint64_t CO, + uint64_t zPadHLeft, uint64_t zPadHRight, + uint64_t zPadWLeft, uint64_t zPadWRight, + uint64_t strideH, uint64_t strideW, uint64_t G, + uint64_4D &inputArr, uint64_4D &filterArr, + uint64_4D &outArr) { + Conv2DGroup_pt(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, G, inputArr, filterArr, outArr); +} + +void ConvTranspose2DWrapper_pt(uint64_t N, uint64_t HPrime, uint64_t WPrime, + uint64_t CI, uint64_t FH, uint64_t FW, + uint64_t CO, uint64_t H, uint64_t W, + uint64_t zPadTrHLeft, uint64_t zPadTrHRight, + uint64_t zPadTrWLeft, uint64_t zPadTrWRight, + uint64_t strideH, uint64_t strideW, + uint64_4D &inputArr, uint64_4D &filterArr, + uint64_4D &outArr) { + ConvTranspose2D_pt(N, HPrime, WPrime, CI, FH, FW, CO, H, W, zPadTrHLeft, + zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, + inputArr, filterArr, outArr); +} + +void ConvTranspose3DWrapper_pt( + uint64_t N, uint64_t DPrime, uint64_t HPrime, uint64_t WPrime, uint64_t CI, + uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t D, uint64_t H, + uint64_t W, uint64_t zPadTrDLeft, uint64_t zPadTrDRight, + uint64_t zPadTrHLeft, uint64_t zPadTrHRight, uint64_t zPadTrWLeft, + uint64_t zPadTrWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, + uint64_5D &inputArr, uint64_5D &filterArr, uint64_5D &outArr) { + ConvTranspose3D_pt(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, D, H, W, + zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, + zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, + inputArr, filterArr, outArr); +} + +#endif diff --git a/SCI/src/defines.h b/SCI/src/defines.h new file mode 100644 index 00000000..92d098b5 --- /dev/null +++ b/SCI/src/defines.h @@ -0,0 +1,54 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef DEFINES_H___ +#define DEFINES_H___ + +#define LOG_LAYERWISE +#define VERIFY_LAYERWISE +#define USE_EIGEN +#define WRITE_LOG +// #define APPROXIMATE_SIGMOID +// #define APPROXIMATE_TANH +#define THREADING_MIN_CHUNK_SIZE 128 + +#define DIV_RESCALING +#ifndef DIV_RESCALING +#define TRUNCATION_RESCALING +#endif + +#include <fstream> +#include <stdint.h> +#include <string> + +#define RESET "\033[0m" +#define RED "\033[31m" /* Red */ +#define GREEN "\033[32m" /* Green */ + +const int SERVER = 1; +const int CLIENT = 2; + +extern int party; +extern std::string address; +extern int port; +extern int num_threads; + +#endif diff --git a/SCI/src/defines_uniform.h b/SCI/src/defines_uniform.h new file mode 100644 index 00000000..10b49264 --- /dev/null +++ b/SCI/src/defines_uniform.h @@ -0,0 +1,84 @@ +/* +Authors: Nishant Kumar +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef DEFINES_UNIFORM_H___ +#define DEFINES_UNIFORM_H___ + +#include "defines.h" +#include <cassert> +#include <chrono> //Keep the local repo based headers below, once constants are defined +#include <cstdint> //Only keep standard headers over here +#include <iostream> +#include <map> +#include <thread> + +typedef uint64_t intType; +typedef int64_t signedIntType; + +extern int32_t bitlength; +extern uint64_t prime_mod; + +// #define NDEBUG //This must come first -- so that this marco is used +// throughout code +// Defining this will disable all asserts throughout code +#define USE_LINEAR_UNIFORM +#define RUNOPTI +#ifdef RUNOPTI +#define MULTITHREADED_MATMUL +#define MULTITHREADED_NONLIN +#define MULTITHREADED_TRUNC +#define MULTITHREADED_DOTPROD +#endif + +#if defined(SCI_HE) +const bool isNativeRing = false; +#elif defined(SCI_OT) +const bool isNativeRing = true; +#endif + +/* +Bitlength 32 prime: 4293918721 +Bitlength 33 prime: 8589475841 +Bitlength 34 prime: 17179672577 +Bitlength 35 prime: 34359410689 +Bitlength 36 prime: 68718428161 +Bitlength 37 prime: 137438822401 +Bitlength 38 prime: 274876334081 +Bitlength 39 prime: 549755486209 +Bitlength 40 prime: 1099510054913 +Bitlength 41 prime: 2199023190017 +*/ + +static void checkIfUsingEigen() { +#ifdef USE_EIGEN + std::cout << "Using Eigen for Matmul" << std::endl; +#else + std::cout << "Using normal Matmul" << std::endl; +#endif +} + +static void assertFieldRun() { + assert(sizeof(intType) == sizeof(uint64_t)); + assert(sizeof(signedIntType) == sizeof(int64_t)); + assert(bitlength >= 32 && bitlength <= 41); +} + +#endif // DEFINES_UNIFORM_H__ diff --git a/SCI/src/functionalities.h b/SCI/src/functionalities.h deleted file mode 100644 index d6d944ad..00000000 --- a/SCI/src/functionalities.h +++ /dev/null @@ -1,1023 +0,0 @@ -/* -Authors: Nishant Kumar -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#ifndef FUNCTIONALITIES_H__ -#define FUNCTIONALITIES_H__ - -#include "globals.h" -#include <cmath> - -void funcLocalTruncate(int s, intType* arr, int consSF){ - if (party==SERVER){ - for(int i=0;i<s;i++){ - arr[i] = static_cast<intType>((static_cast<signedIntType>(arr[i]))>>consSF); - } - } - else if (party==CLIENT){ - for(int i=0;i<s;i++){ - arr[i] = -static_cast<intType>((static_cast<signedIntType>(-arr[i]))>>consSF); - } - } - else{ - assert(false); - } -} - -signedIntType getAnyRingSignedVal(intType x){ - signedIntType ans = x; - if (x > (prime_mod/2)){ - ans = (x - prime_mod); - } - return ans; -} - -intType funcSSCons(int32_t x){ - /* - Secret share public value x between the two parties. - Corresponding ezpc statement would be int32_al x = 0; - Set one party share as x and other party's share as 0. - */ - if (party==SERVER){ - return x; - } - else{ - return 0; - } -} - -intType funcSSCons(int64_t x){ - /* - Secret share public value x between the two parties. - Corresponding ezpc statement would be int32_al x = 0; - Set one party share as x and other party's share as 0. - */ - if (party==SERVER){ - return x; - } - else{ - return 0; - } -} - -inline intType getFieldMsb(intType x){ - return (x > (prime_mod/2)); -} - -void funcReconstruct2PCCons(signedIntType* y, intType* x, int len){ - intType temp = 0; - signedIntType ans = 0; - if (party==SERVER){ - io->send_data(x, len*sizeof(intType)); - } - else if (party==CLIENT){ - io->recv_data(y, len*sizeof(intType)); - for (int i = 0; i < len; i++) { - temp = y[i] + x[i]; - if (!isNativeRing){ - temp = sci::neg_mod(temp,(int64_t)prime_mod); //cast temp to signed int and then take a proper modulo p - y[i] = getAnyRingSignedVal(temp); - } - else{ - temp = temp & (prime_mod - 1); - if (temp >= (prime_mod/2)) y[i] = temp - prime_mod; - else y[i] = temp; - } - } - } - return; -} - -signedIntType funcReconstruct2PCCons(intType x, int revealParty){ - assert(revealParty == 2 && "Reveal to only client is supported right now."); - intType temp = 0; - signedIntType ans = 0; - static const uint64_t moduloMask = sci::all1Mask(bitlength); - if (party==SERVER){ - io->send_data(&x, sizeof(intType)); - } - else if (party==CLIENT){ - io->recv_data(&temp, sizeof(intType)); - temp = temp + x; - if (!isNativeRing){ - temp = sci::neg_mod(temp,(int64_t)prime_mod); //cast temp to signed int and then take a proper modulo p - ans = getAnyRingSignedVal(temp); - } - else{ - ans = temp & moduloMask; - } - } - return ans; -} - -signedIntType div_floor(signedIntType a, signedIntType b){ - signedIntType q = a/b; - signedIntType r = a%b; - signedIntType corr = ((r!=0) && (r<0)); - return q-corr; -} - -void funcTruncationIdeal(int size, intType* arr, int consSF){ - if (party==SERVER){ - io->send_data(arr, sizeof(intType)*size); - for(int i=0;i<size;i++){ - arr[i] = 0; - } - } - else{ - intType* arrOther = new intType[size]; - io->recv_data(arrOther, sizeof(intType)*size); - for(int i=0;i<size;i++){ - signedIntType ans; - intType temp = arr[i]+arrOther[i]; - if (!isNativeRing){ - temp = sci::neg_mod(temp,(int64_t)prime_mod); - ans = getAnyRingSignedVal(temp); - ans = div_floor(ans,1ULL<<consSF); - } - else{ - uint64_t moduloMask = (1ULL<<bitlength)-1; - if (bitlength==64) moduloMask = -1; - temp = temp & moduloMask; - ans = ((signedIntType)temp)>>consSF; - } - arr[i] = ans; - } - } -} - -void printAllReconstructedValuesSigned(int size, intType* arr){ - if (party==SERVER){ - io->send_data(arr, sizeof(intType)*size); - } - else{ - intType* arrOther = new intType[size]; - io->recv_data(arrOther, sizeof(intType)*size); - for(int i=0;i<size;i++){ - signedIntType ans; - intType temp = arr[i]+arrOther[i]; - if (!isNativeRing){ - temp = sci::neg_mod(temp,(int64_t)prime_mod); - ans = getAnyRingSignedVal(temp); - } - else{ - ans = temp; - } - std::cout<<ans<<std::endl; - } - } -} - -intType funcSigendDivIdeal(intType x, uint32_t y){ - if (party==SERVER){ - io->send_data(&x,sizeof(intType)); - return 0; - } - else{ - intType temp; - io->recv_data(&temp,sizeof(intType)); - temp += x; - return (((signedIntType)temp)/y); - } -} - -void funcReLUThread(int tid, intType* outp, intType* inp, int numRelu, uint8_t* drelu_res=nullptr, bool skip_ot=false) { - reluImplArr[tid]->relu(outp, inp, numRelu, drelu_res, skip_ot); -} - -void funcMaxpoolThread(int tid, int rows, int cols, intType* inpArr, intType* maxi, intType* maxiIdx) { - maxpoolImplArr[tid]->funcMaxMPC(rows, cols, inpArr, maxi, maxiIdx); -} - -void funcMatmulThread(int tid, int N, int s1, int s2, int s3, const intType* A, const intType* B, intType* C, - int partyWithAInAB_mul) -{ - assert(tid>=0); - int s2StartIdx = tid*(s2/N); //Inclusive - int s2EndIdx = ((tid==N-1) ? s2 : ((tid+1)*(s2/N))); //Exclusive - intType* APtr = new intType[s1*(s2EndIdx - s2StartIdx)]; - for(int i=0;i<s1;i++){ - for(int j=s2StartIdx;j<s2EndIdx;j++){ - Arr2DIdxRowM(APtr,s1,(s2EndIdx - s2StartIdx),i,(j - s2StartIdx)) = Arr2DIdxRowM(A,s1,s2,i,j); - } - } - intType* BPtr = B + s2StartIdx*s3; - /* - Case 1: If Alice has A and Bob has B - Then for even threads, Bob (holding B) acts as receiver and Alice (holding A) acts as sender - For odd threads, Bob (holding B) acts as sender and Alice (holding A) acts as receiver - - Case 2: If Alice has B and Bob has A - Then for even threads, Bob (holding A) acts as receiver and Alice (holding B) as sender - For odd threads, Bob (holding A) acts as sender and Alice (holding B) as receiver - - Note that for even threads, Bob is always the receiver and Alice is always the sender - and for odd threads, Bob is always the sender and Alice the receiver - This makes sure that the matmul and otinstances (indexed by tid) are always used by with the same - sender-receiver pair. - */ - - bool useBobAsSender = tid&1; - if (partyWithAInAB_mul==sci::BOB) useBobAsSender = !useBobAsSender; - if (useBobAsSender){ - // Odd tid, use Bob (holding B) as sender and Alice (holding A) as receiver - if (party==partyWithAInAB_mul){ - matmulInstanceArr[tid]->funcOTReceiverInputA(s1,(s2EndIdx - s2StartIdx),s3,APtr,C,otInstanceArr[tid]); - } - else{ - matmulInstanceArr[tid]->funcOTSenderInputB(s1,(s2EndIdx - s2StartIdx),s3,BPtr,C,otInstanceArr[tid]); - } - } - else{ - // Even tid, use Bob (holding B) as receiver and Alice (holding A) as sender - if (party==partyWithAInAB_mul){ - matmulInstanceArr[tid]->funcOTSenderInputA(s1,(s2EndIdx - s2StartIdx),s3,APtr,C,otInstanceArr[tid]); - } - else{ - matmulInstanceArr[tid]->funcOTReceiverInputB(s1,(s2EndIdx - s2StartIdx),s3,BPtr,C,otInstanceArr[tid]); - } - } - delete[] APtr; -} - -void funcDotProdThread(int tid, int N, int size, const intType* inArr, intType* outArr) -{ - assert(tid>=0); - if (tid & 1){ - //tid is odd -- acc to convention in the rest of the code, Alice is recv and Bob is sender - if (::party==sci::ALICE){ - matmulInstanceArr[tid]->funcDotProdOTReceiver(size, inArr, outArr, otInstanceArr[tid]); - } - else{ - matmulInstanceArr[tid]->funcDotProdOTSender(size, inArr, outArr, otInstanceArr[tid]); - } - } - else{ - //tid is even -- acc to convention in the rest of the code, Alice is sender and Bob is recv - if (::party==sci::ALICE){ - matmulInstanceArr[tid]->funcDotProdOTSender(size, inArr, outArr, otInstanceArr[tid]); - } - else{ - matmulInstanceArr[tid]->funcDotProdOTReceiver(size, inArr, outArr, otInstanceArr[tid]); - } - } -} - -/* - Note this assumes 1 <= s < ell - More optimizations that could be done for this function: - - The call to 1oo4 KKOT and 1oo2 IKNP results in 4 rounds. Round compression can potentially be done - to reduce rounds to 2. - The interface can also potentially be cleaned up to use only otpack. However, currently the COT required - to be used is present in IKNP - so keeping that too in the interface. -*/ -void funcTruncateTwoPowerRing(int curParty, - sci::NetIO* curio, sci::OTPack<sci::NetIO>* curotpack, - sci::IKNP<sci::NetIO>* curiknp, - ReLUProtocol<sci::NetIO, intType>* curReluImpl, - sci::PRG128* curPrgInstance, - int size, const intType* inp, intType* outp, - int consSF, uint8_t* msbShare, - bool doCarryBitCalculation = true - ) -{ - assert(size%8==0); - static const int rightShiftForMsb = bitlength - 1; - uint64_t* carryBitCompArr; - uint8_t* carryBitCompAns; - uint64_t moduloMask = sci::all1Mask(bitlength); - - for(int i=0;i<size;i++){ - assert(inp[i] <= moduloMask); - } - - if (doCarryBitCalculation){ - carryBitCompArr = new uint64_t[size]; - carryBitCompAns = new uint8_t[size]; - for(int i=0;i<size;i++){ - carryBitCompArr[i] = (inp[i] & sci::all1Mask(consSF)); - if (curParty==sci::BOB){ - carryBitCompArr[i] = (sci::all1Mask(consSF)) - carryBitCompArr[i]; - } - } - MillionaireProtocol millionaire(curParty,consSF,baseForRelu,curio,curotpack); - millionaire.compare(carryBitCompAns,carryBitCompArr,size); - } - - bool createdMsbSharesHere = false; - if (msbShare==nullptr){ - msbShare = new uint8_t[size]; - curReluImpl->relu(nullptr, inp, size, msbShare, true); - createdMsbSharesHere = true; - } - - if (curParty==sci::ALICE){ - uint64_t** otMessages1oo4 = new uint64_t*[size]; - intType* otMessages1oo2Data = new intType[size]; - intType* otMessages1oo2Corr= new intType[size]; - intType* localShare1oo4 = new intType[size]; - curPrgInstance->random_data(localShare1oo4, sizeof(intType)*size); - - for(int i=0;i<size;i++){ - otMessages1oo4[i] = new uint64_t[4]; - uint8_t localShareMSB = ((uint8_t)(inp[i]>>rightShiftForMsb)); - intType r = -localShare1oo4[i]; - for(int j=0;j<4;j++){ - uint8_t b0 = j&1; - uint8_t b1 = (j>>1)&1; //b1,b0 is the bit representation of j = [msb(a)]_1, msb(a_1) - uint8_t temp = ((msbShare[i]+b1+localShareMSB)&1)&((msbShare[i]+b1+b0)&1); - intType curMsg = r; - if (temp & (localShareMSB==0)){ - //msb(a_0)=0, msb(a_1)=0, msb(a)=1 - curMsg -= 1; - } - else if (temp & (localShareMSB==1)){ - //msb(a_0)=1, msb(a_1)=1, msb(a)=0 - curMsg += 1; - } - //In other cases, extra term is 0 - otMessages1oo4[i][j] = (uint64_t)curMsg; - } - if (doCarryBitCalculation){ - otMessages1oo2Corr[i] = ((intType)carryBitCompAns[i]); - } - } - - curotpack->kkot_4->send_impl(otMessages1oo4, size, bitlength); - if (doCarryBitCalculation){ - curiknp->send_cot_moduloAdd<intType>(otMessages1oo2Data, otMessages1oo2Corr, size); - } - - for(int i=0;i<size;i++){ - intType shareTerm1 = ((intType)((getAnyRingSignedVal(inp[i]))>>consSF)); - intType shareTerm2 = (localShare1oo4[i]<<(bitlength-consSF)); - outp[i] = shareTerm1 + shareTerm2; - if (doCarryBitCalculation){ - intType curCarryShare = -otMessages1oo2Data[i]; - outp[i] = outp[i] + ((intType)carryBitCompAns[i]) - 2*curCarryShare; - } - outp[i] = outp[i] & moduloMask; - delete[] otMessages1oo4[i]; - } - - delete[] otMessages1oo4; - delete[] otMessages1oo2Data; - delete[] otMessages1oo2Corr; - delete[] localShare1oo4; - } - else{ - uint64_t* otRecvMsg1oo4 = new uint64_t[size]; - uint8_t* choiceBits = new uint8_t[size]; - intType* otRecvMsg1oo2 = new intType[size]; - uint8_t* choiceBits1oo2OT = new uint8_t[size]; - for(int i=0;i<size;i++){ - uint8_t localShareMSB = ((uint8_t)(inp[i]>>rightShiftForMsb)); - choiceBits[i] = (msbShare[i]<<1)+localShareMSB; - if (doCarryBitCalculation){ - choiceBits1oo2OT[i] = carryBitCompAns[i]; - } - } - - curotpack->kkot_4->recv_impl(otRecvMsg1oo4, choiceBits, size, bitlength); - if (doCarryBitCalculation){ - curiknp->recv_cot_moduloAdd<intType>(otRecvMsg1oo2,choiceBits1oo2OT,size); - } - for(int i=0;i<size;i++){ - intType G1 = (intType)otRecvMsg1oo4[i]; - intType shareTerm1 = (getAnyRingSignedVal(inp[i]))>>consSF; - intType shareTerm2 = (G1<<(bitlength-consSF)); - outp[i] = shareTerm1 + shareTerm2; - if (doCarryBitCalculation){ - outp[i] = outp[i] + ((intType)carryBitCompAns[i]) - 2*otRecvMsg1oo2[i]; - } - outp[i] = outp[i] & moduloMask; - } - - delete[] otRecvMsg1oo4; - delete[] choiceBits; - delete[] otRecvMsg1oo2; - delete[] choiceBits1oo2OT; - } - - if (doCarryBitCalculation){ - delete[] carryBitCompArr; - delete[] carryBitCompAns; - } - - if (createdMsbSharesHere){ - delete[] msbShare; - } -} - -void funcTruncateTwoPowerRingWrapper(int size, const intType* inp, intType* outp, - int consSF, uint8_t* msbShare, bool doCarryBitCalculation=true) -{ - assert(size%8==0); -#ifdef MULTITHREADED_TRUNC - std::thread truncThreads[numThreads]; - int chunk_size = (size/(8*numThreads))*8; - for (int i = 0; i < numThreads; i++) { - int offset = i*chunk_size; - int curSize; - if (i == (numThreads - 1)) { - curSize = size - offset; - } - else { - curSize = chunk_size; - } - int curParty = party; - if (i & 1) curParty = 3 - curParty; - uint8_t* msbShareArg = msbShare; - if (msbShare!=nullptr) msbShareArg = msbShareArg+offset; - truncThreads[i] = std::thread(funcTruncateTwoPowerRing, - curParty, ioArr[i], otpackArr[i], otInstanceArr[i], - reluImplArr[i], prgInstanceArr[i], - curSize, inp+offset, outp+offset, consSF, msbShareArg, doCarryBitCalculation - ); - } - for (int i = 0; i < numThreads; ++i) { - truncThreads[i].join(); - } -#else - funcTruncateTwoPowerRing(party, io, otpack, iknpOT, kkot, reluImpl, prg128Instance, //Global variables - size, inp, outp, consSF, msbShare, doCarryBitCalculation - ); -#endif -} - -/* - More optimizations that could be done for this function: - - Currently if bitsForA + bitlength > 64, then the function resorts to using block128 based 1oo4 KKOT, - skipping packing. This could be optimized to do ideal packing even in this case. - - The last COT being performed is also not using packing for bitlenth != 32/64. -*/ -void funcAvgPoolTwoPowerRing(int curParty, - sci::NetIO* curio, sci::OTPack<sci::NetIO>* curotpack, - sci::IKNP<sci::NetIO>* curiknp, sci::KKOT<sci::NetIO>* curkkot, - ReLUProtocol<sci::NetIO, intType>* curReluImpl, - sci::PRG128* curPrgInstance, - int size, const intType* inp, intType* outp, intType divisor) -{ - assert(inp!=outp && "Assumption is there is a separate array for input and output"); - assert(size%8==0 && "pad size to multiple of 8 and pass"); - assert(divisor>0 && "working with positive divisor"); - static const int rightShiftForMsb = bitlength-1; - assert(sci::all1Mask(bitlength) > (6*divisor-1)); // 2^l-1 > 6d-1 => 2^l > 6d - intType ringRem, ringQuot; - if (bitlength==64){ - ringRem = ((intType)(-divisor))%divisor; //(2^l-d)%d = 2^l%d - ringQuot = (((intType)(-divisor))/divisor)+1; //((2^l-d)/d)+1 = 2^l/d - } - else{ - ringRem = prime_mod%divisor; - ringQuot = prime_mod/divisor; - } - uint8_t* msbShare = new uint8_t[size]; - uint64_t moduloMask = sci::all1Mask(bitlength); - - for(int i=0;i<size;i++){ - assert(inp[i] <= moduloMask); - intType shareTerm1 = div_floor(getAnyRingSignedVal(inp[i]), divisor); - intType localShareMSB = (inp[i]>>rightShiftForMsb); - intType shareTerm2 = div_floor((signedIntType)((inp[i]%divisor)-localShareMSB*ringRem), divisor); - outp[i] = shareTerm1 - shareTerm2; - if (curParty == sci::ALICE) outp[i] += 1; - } - - curReluImpl->relu(nullptr, inp, size, msbShare, true); - - const uint64_t bitsForA = std::ceil(std::log2(6*divisor)); - uint64_t totalRandomBytesForLargeRing = sci::ceil_val(bitlength*size,8); - uint8_t* localShareCorrPacked = new uint8_t[totalRandomBytesForLargeRing]; - intType* localShareCorr = new intType[size]; - int totalRandomBytesForSmallRing = sci::ceil_val(bitsForA*size,8); - uint8_t* localShareCorrSmallRingPacked = new uint8_t[totalRandomBytesForSmallRing]; - uint64_t* localShareCorrSmallRing = new uint64_t[size]; - intType* otMsgCorrRing = new intType[4*size]; - intType* otMsgCorrSmallRing = new intType[4*size]; - - bool OT1oo4FitsIn64Bits = ((bitsForA + bitlength) <= 64); - if (curParty == sci::ALICE){ - curPrgInstance->random_data(localShareCorrPacked, totalRandomBytesForLargeRing); - curPrgInstance->random_data(localShareCorrSmallRingPacked, totalRandomBytesForSmallRing); - for(int i=0;i<size;i++){ - localShareCorr[i] = sci::readFromPackedArr(localShareCorrPacked, totalRandomBytesForLargeRing, i*(bitlength), bitlength); - localShareCorrSmallRing[i] = sci::readFromPackedArr(localShareCorrSmallRingPacked, totalRandomBytesForSmallRing, - i*bitsForA, bitsForA); - uint8_t localShareMSB = ((uint8_t)(inp[i]>>rightShiftForMsb)); - for(int j=0;j<4;j++){ - uint8_t b0 = j&1; - uint8_t b1 = (j>>1)&1; //b1,b0 is the bit representation of j = [msb(a)]_1, msb(a_1) - uint8_t temp = ((msbShare[i]+b1+localShareMSB)&1)&((msbShare[i]+b1+b0)&1); - intType curMsg = -localShareCorr[i]; - intType curMsgSmallRing = -localShareCorrSmallRing[i]; - if (temp & (localShareMSB==0)){ - //msb(a_0)=0, msb(a_1)=0, msb(a)=1 - curMsg -= 1; - curMsgSmallRing -= 1; - } - else if (temp & (localShareMSB==1)){ - //msb(a_0)=1, msb(a_1)=1, msb(a)=0 - curMsg += 1; - curMsgSmallRing += 1; - } - curMsg = curMsg & moduloMask; - curMsgSmallRing = curMsgSmallRing & sci::all1Mask(bitsForA); - otMsgCorrRing[i*4+j] = curMsg; - otMsgCorrSmallRing[i*4+j] = curMsgSmallRing; - } - } - - if (OT1oo4FitsIn64Bits){ - uint64_t** otMessages1oo4 = new uint64_t*[size]; - for(int i=0;i<size;i++){ - otMessages1oo4[i] = new uint64_t[4]; - for(int j=0;j<4;j++) otMessages1oo4[i][j] = (((uint64_t)otMsgCorrSmallRing[i*4+j])<<bitlength) + ((uint64_t)otMsgCorrRing[i*4+j]); - } - curotpack->kkot_4->send_impl(otMessages1oo4, size, (bitlength+bitsForA)); - for(int i=0;i<size;i++){ - delete[] otMessages1oo4[i]; - } - delete otMessages1oo4; - } - else{ - sci::block128** otMessages1oo4 = new sci::block128*[size]; - for(int i=0;i<size;i++){ - otMessages1oo4[i] = new sci::block128[4]; - for(int j=0;j<4;j++) otMessages1oo4[i][j] = _mm_set_epi64x(otMsgCorrSmallRing[i*4+j], otMsgCorrRing[i*4+j]); - } - curkkot->send_impl(otMessages1oo4, size, 4); - for(int i=0;i<size;i++){ - delete[] otMessages1oo4[i]; - } - delete otMessages1oo4; - } - for(int i=0;i<size;i++){ - outp[i] += (localShareCorr[i]*ringQuot); - } - } - else{ - uint8_t* choiceBits = new uint8_t[size]; - for(int i=0;i<size;i++){ - uint8_t localShareMSB = ((uint8_t)(inp[i]>>rightShiftForMsb)); - choiceBits[i] = (msbShare[i]<<1)+localShareMSB; - } - - if (OT1oo4FitsIn64Bits){ - uint64_t* otRecvMsg1oo4 = new uint64_t[size]; - curotpack->kkot_4->recv_impl(otRecvMsg1oo4, choiceBits, size, (bitlength + bitsForA)); - for(int i=0;i<size;i++){ - otMsgCorrRing[i] = otRecvMsg1oo4[i] & sci::all1Mask(bitlength); - otMsgCorrSmallRing[i] = otRecvMsg1oo4[i] >> bitlength; - } - delete[] otRecvMsg1oo4; - } - else{ - sci::block128* otRecvMsg1oo4 = new sci::block128[size]; - curkkot->recv_impl(otRecvMsg1oo4, choiceBits, size, 4); - for(int i=0;i<size;i++){ - uint64_t temp = _mm_extract_epi64(otRecvMsg1oo4[i], 0); - otMsgCorrRing[i] = temp; - temp = _mm_extract_epi64(otRecvMsg1oo4[i], 1); - otMsgCorrSmallRing[i] = temp; - } - delete[] otRecvMsg1oo4; - } - - for(int i=0;i<size;i++){ - localShareCorr[i] = otMsgCorrRing[i]; - localShareCorrSmallRing[i] = otMsgCorrSmallRing[i]; - outp[i] += (localShareCorr[i]*ringQuot); - } - - delete[] choiceBits; - } - - intType* localShareA_all3 = new intType[3*size]; - uint8_t* localShareA_all3_drelu = new uint8_t[3*size]; - uint64_t bitsAmask = sci::all1Mask(bitsForA); - uint64_t bitsAMinusOneMask = sci::all1Mask((bitsForA-1)); - uint64_t* radixCompValues = new uint64_t[3*size]; - uint8_t* carryBit = new uint8_t[3*size]; - - // Optimization to reduce comparions to 2 - int totalComp = 3*size; - int compPerElt = 3; - if (2*ringRem < divisor){ - //A+d<0 becomes moot - totalComp = 2*size; - compPerElt = 2; - } - - for(int i=0;i<size;i++){ - intType localShareA = ((inp[i]%divisor) - ((inp[i]>>rightShiftForMsb) - localShareCorrSmallRing[i])*ringRem)&bitsAmask; - for(int j=0;j<compPerElt;j++){ - localShareA_all3[compPerElt*i+j] = localShareA; - } - - if (curParty == sci::ALICE){ - if (compPerElt==3){ - localShareA_all3[3*i] = (localShareA_all3[3*i]-divisor)&bitsAmask; - localShareA_all3[3*i+2] = (localShareA_all3[3*i+2]+divisor)&bitsAmask; - } - else{ - localShareA_all3[2*i] = (localShareA_all3[2*i]-divisor)&bitsAmask; - } - } - - for(int j=0;j<compPerElt;j++){ - radixCompValues[compPerElt*i+j] = (localShareA_all3[compPerElt*i+j]&bitsAMinusOneMask); - localShareA_all3_drelu[compPerElt*i+j] = (localShareA_all3[compPerElt*i+j]>>(bitsForA-1)); - if (curParty==sci::BOB){ - radixCompValues[compPerElt*i+j] = bitsAMinusOneMask - radixCompValues[compPerElt*i+j]; - } - } - } - - MillionaireProtocol millionaire(curParty,bitsForA-1,baseForRelu,curio,curotpack); - millionaire.compare(carryBit,radixCompValues,totalComp); - for(int i=0;i<totalComp;i++){ - localShareA_all3_drelu[i] = (localShareA_all3_drelu[i] + carryBit[i])&1; - } - - if (curParty == sci::ALICE){ - intType* cotData = new intType[totalComp]; - intType* cotCorr = new intType[totalComp]; - for(int i=0;i<totalComp;i++){ - cotCorr[i] = (intType)localShareA_all3_drelu[i]; - } - curiknp->send_cot_moduloAdd<intType>(cotData, cotCorr, totalComp); - for(int i=0;i<size;i++){ - intType curCTermShare = 0; - for(int j=0;j<compPerElt;j++){ - intType curMultTermShare = -cotData[compPerElt*i+j]; - intType curDReluAns = (intType)localShareA_all3_drelu[compPerElt*i+j] - 2*curMultTermShare; - curCTermShare += curDReluAns; - } - outp[i] -= curCTermShare; - } - delete[] cotData; - delete[] cotCorr; - } - else{ - intType* cotDataRecvd = new intType[totalComp]; - curiknp->recv_cot_moduloAdd<intType>(cotDataRecvd,localShareA_all3_drelu,totalComp); - for(int i=0;i<size;i++){ - intType curCTermShare = 0; - for(int j=0;j<compPerElt;j++){ - intType curMultTermShare = cotDataRecvd[compPerElt*i+j]; - intType curDReluAns = (intType)localShareA_all3_drelu[compPerElt*i+j] - 2*curMultTermShare; - curCTermShare += curDReluAns; - } - outp[i] -= curCTermShare; - } - delete[] cotDataRecvd; - } - - for(int i=0;i<size;i++){ - outp[i] = outp[i] & moduloMask; - } - - delete[] msbShare; - delete[] localShareCorr; - delete[] localShareCorrSmallRingPacked; - delete[] localShareCorrSmallRing; - delete[] otMsgCorrRing; - delete[] otMsgCorrSmallRing; - delete[] localShareA_all3; - delete[] localShareA_all3_drelu; - delete[] radixCompValues; - delete[] carryBit; -} - -void funcAvgPoolTwoPowerRingWrapper(int size, const intType* inp, intType* outp, intType divisor) -{ - assert(size%8==0); -#ifdef MULTITHREADED_TRUNC - std::thread truncThreads[numThreads]; - int chunk_size = (size/(8*numThreads))*8; - for (int i = 0; i < numThreads; i++) { - int offset = i*chunk_size; - int curSize; - if (i == (numThreads - 1)) { - curSize = size - offset; - } - else { - curSize = chunk_size; - } - int curParty = party; - if (i & 1) curParty = 3 - curParty; - truncThreads[i] = std::thread(funcAvgPoolTwoPowerRing, - curParty, ioArr[i], otpackArr[i], otInstanceArr[i], kkotInstanceArr[i], - reluImplArr[i], prgInstanceArr[i], - curSize, inp+offset, outp+offset, divisor - ); - } - for (int i = 0; i < numThreads; ++i) { - truncThreads[i].join(); - } -#else - funcAvgPoolTwoPowerRing(party, io, otpack, iknpOT, kkot, reluImpl, prg128Instance, - size, inp, outp, divisor); -#endif -} - -/* - Assume uint64_t for fields - More optimizations that could be performed for this function: - - The 1oo4 KKOT being performed resorts to using block128 and no packing when fieldBits + bitsForA > 64. This - can be optimized to use ideal packing even in this case. - - The last OT being performed is a COT, but is being done using an OT with no packing. -*/ -template<typename intType> -void funcFieldDiv(int curParty, - sci::NetIO* curio, sci::OTPack<sci::NetIO>* curotpack, - sci::IKNP<sci::NetIO>* curiknp, sci::KKOT<sci::NetIO>* curkkot, - ReLUProtocol<sci::NetIO, intType>* curReluImpl, - sci::PRG128* curPrgInstance, - int size, const intType* inp, intType* outp, - intType divisor, uint8_t* msbShare) -{ - assert(inp!=outp && "Assumption is there is a separate array for input and output"); - assert(size%8==0 && "pad size to multiple of 8 and pass"); - assert((divisor>0) && (divisor<prime_mod) && "working with positive divisor"); - assert(prime_mod > 6*divisor); - const intType ringRem = prime_mod%divisor; - const intType ringQuot = prime_mod/divisor; - bool doMSBComputation = (msbShare==nullptr); - if (doMSBComputation) msbShare = new uint8_t[size]; - - for(int i=0;i<size;i++){ - assert(inp[i]<prime_mod && "input is not a valid share modulo prime_mod"); - signedIntType shareTerm1 = div_floor((signedIntType)getAnyRingSignedVal(inp[i]), divisor); - intType localShareMSB = getFieldMsb(inp[i]); - signedIntType shareTerm2 = div_floor((signedIntType)((inp[i]%divisor)-localShareMSB*ringRem), divisor); - signedIntType temp = shareTerm1 - shareTerm2; - if (curParty == sci::BOB) temp += 1; - outp[i] = sci::neg_mod(temp,(int64_t)prime_mod); - } - - if (doMSBComputation){ - curReluImpl->relu(nullptr, inp, size, msbShare, true); - } - - static const int fieldBits = std::ceil(std::log2(prime_mod)); - const uint64_t bitsForA = std::ceil(std::log2(6*divisor)); - const uint64_t totalBitlen = fieldBits + bitsForA; - bool OT1oo4FitsIn64Bits = (totalBitlen <= 64); - - intType* localShareCorr = new intType[size]; - int totalRandomBytesForSmallRing = sci::ceil_val(bitsForA*size,8); - uint8_t* localShareCorrSmallRingPacked = new uint8_t[totalRandomBytesForSmallRing]; - uint64_t* localShareCorrSmallRing = new uint64_t[size]; - intType* otMsgCorrField = new intType[4*size]; - intType* otMsgCorrSmallRing = new intType[4*size]; - - if (curParty==sci::ALICE){ - curPrgInstance->random_mod_p<intType>(localShareCorr, size, prime_mod); - curPrgInstance->random_data(localShareCorrSmallRingPacked, totalRandomBytesForSmallRing); - for(int i=0;i<size;i++){ - localShareCorrSmallRing[i] = sci::readFromPackedArr(localShareCorrSmallRingPacked, totalRandomBytesForSmallRing, - i*bitsForA, bitsForA); - uint8_t localShareMSB = getFieldMsb(inp[i]); - for(int j=0;j<4;j++){ - uint8_t b0 = j&1; - uint8_t b1 = (j>>1)&1; //b1,b0 is the bit representation of j = [msb(a)]_1, msb(a_1) - uint8_t temp = ((msbShare[i]+b1+localShareMSB)&1)&((msbShare[i]+b1+b0)&1); - signedIntType curMsg = -localShareCorr[i]; - intType curMsgSmallRing = -localShareCorrSmallRing[i]; - if (temp & (localShareMSB==0)){ - //msb(a_0)=0, msb(a_1)=0, msb(a)=1 - curMsg -= 1; - curMsgSmallRing -= 1; - } - else if (temp & (localShareMSB==1)){ - //msb(a_0)=1, msb(a_1)=1, msb(a)=0 - curMsg += 1; - curMsgSmallRing += 1; - } - intType curMsgField = sci::neg_mod(curMsg,(int64_t)prime_mod); - curMsgSmallRing = curMsgSmallRing & sci::all1Mask(bitsForA); - otMsgCorrField[i*4+j] = curMsgField; - otMsgCorrSmallRing[i*4+j] = curMsgSmallRing; - } - } - if (OT1oo4FitsIn64Bits){ - uint64_t** otMessages1oo4 = new uint64_t*[size]; - for(int i=0;i<size;i++){ - otMessages1oo4[i] = new uint64_t[4]; - for(int j=0;j<4;j++) otMessages1oo4[i][j] = (((uint64_t)otMsgCorrSmallRing[i*4+j])<<fieldBits) + ((uint64_t)otMsgCorrField[i*4+j]); - } - curotpack->kkot_4->send_impl(otMessages1oo4, size, totalBitlen); - for(int i=0;i<size;i++){ - delete[] otMessages1oo4[i]; - } - delete otMessages1oo4; - } - else{ - sci::block128** otMessages1oo4 = new sci::block128*[size]; - for(int i=0;i<size;i++){ - otMessages1oo4[i] = new sci::block128[4]; - for(int j=0;j<4;j++) otMessages1oo4[i][j] = _mm_set_epi64x(otMsgCorrSmallRing[i*4+j], otMsgCorrField[i*4+j]); - } - curkkot->send_impl(otMessages1oo4, size, 4); - for(int i=0;i<size;i++){ - delete[] otMessages1oo4[i]; - } - delete otMessages1oo4; - } - for(int i=0;i<size;i++){ -#ifdef __SIZEOF_INT128__ - intType temp = (((__int128)localShareCorr[i])*((__int128)ringQuot)) % prime_mod; -#else - intType temp = sci::moduloMult(localShareCorr[i],ringQuot,prime_mod); -#endif - outp[i] = sci::neg_mod(outp[i] + temp, (int64_t)prime_mod); - } - } - else{ - uint8_t* choiceBits = new uint8_t[size]; - for(int i=0;i<size;i++){ - uint8_t localShareMSB = getFieldMsb(inp[i]); - choiceBits[i] = (msbShare[i]<<1)+localShareMSB; - } - - if (OT1oo4FitsIn64Bits){ - uint64_t* otRecvMsg1oo4 = new uint64_t[size]; - curotpack->kkot_4->recv_impl(otRecvMsg1oo4, choiceBits, size, totalBitlen); - for(int i=0;i<size;i++){ - otMsgCorrField[i] = otRecvMsg1oo4[i] & sci::all1Mask(fieldBits); - otMsgCorrSmallRing[i] = otRecvMsg1oo4[i] >> fieldBits; - } - delete[] otRecvMsg1oo4; - } - else{ - sci::block128* otRecvMsg1oo4 = new sci::block128[size]; - curkkot->recv_impl(otRecvMsg1oo4, choiceBits, size, 4); - for(int i=0;i<size;i++){ - uint64_t temp = _mm_extract_epi64(otRecvMsg1oo4[i], 0); - otMsgCorrField[i] = temp; - temp = _mm_extract_epi64(otRecvMsg1oo4[i], 1); - otMsgCorrSmallRing[i] = temp; - } - delete[] otRecvMsg1oo4; - } - - for(int i=0;i<size;i++){ - localShareCorr[i] = otMsgCorrField[i]; - localShareCorrSmallRing[i] = otMsgCorrSmallRing[i]; -#ifdef __SIZEOF_INT128__ - intType temp = (((__int128)localShareCorr[i])*((__int128)ringQuot)) % prime_mod; -#else - intType temp = sci::moduloMult(localShareCorr[i],ringQuot,prime_mod); -#endif - outp[i] = sci::neg_mod(outp[i] + temp, (int64_t)prime_mod); - } - - delete[] choiceBits; - } - - int totalComp = 3*size; - int compPerElt = 3; - if (2*ringRem < divisor){ - //A+d<0 becomes moot - totalComp = 2*size; - compPerElt = 2; - } - - intType* localShareA_all3 = new intType[3*size]; - uint8_t* localShareA_all3_drelu = new uint8_t[3*size]; - uint64_t bitsAmask = sci::all1Mask(bitsForA); - uint64_t bitsAMinusOneMask = sci::all1Mask((bitsForA-1)); - uint64_t* radixCompValues = new uint64_t[3*size]; - uint8_t* carryBit = new uint8_t[3*size]; - for(int i=0;i<size;i++){ - intType localShareA = (inp[i]%divisor) - (getFieldMsb(inp[i]) - localShareCorrSmallRing[i])*ringRem; - for(int j=0;j<compPerElt;j++){ - localShareA_all3[compPerElt*i+j] = localShareA; - } - - if (curParty==sci::ALICE){ - if (compPerElt==3){ - localShareA_all3[3*i] = (localShareA_all3[3*i]-divisor)&bitsAmask; - localShareA_all3[3*i+2] = (localShareA_all3[3*i+2]+divisor)&bitsAmask; - } - else{ - localShareA_all3[2*i] = (localShareA_all3[2*i]-divisor)&bitsAmask; - } - } - for(int j=0;j<compPerElt;j++){ - radixCompValues[compPerElt*i+j] = (localShareA_all3[compPerElt*i+j]&bitsAMinusOneMask); - localShareA_all3_drelu[compPerElt*i+j] = (localShareA_all3[compPerElt*i+j]>>(bitsForA-1)); - if (curParty==sci::BOB){ - radixCompValues[compPerElt*i+j] = bitsAMinusOneMask - radixCompValues[compPerElt*i+j]; - } - } - } - - MillionaireProtocol millionaire(curParty,bitsForA-1,baseForRelu,curio,curotpack); - millionaire.compare(carryBit,radixCompValues,totalComp); - for(int i=0;i<totalComp;i++){ - localShareA_all3_drelu[i] = (localShareA_all3_drelu[i] + carryBit[i])&1; - } - - if (curParty==sci::ALICE){ - uint64_t** otMsg = new uint64_t*[totalComp]; - intType* localShareDRelu = new intType[totalComp]; - curPrgInstance->random_mod_p<intType>(localShareDRelu, totalComp, prime_mod); - for(int i=0;i<totalComp;i++){ - otMsg[i] = new uint64_t[2]; - otMsg[i][0] = sci::neg_mod(-localShareDRelu[i] + (localShareA_all3_drelu[i]), (int64_t)prime_mod); - otMsg[i][1] = sci::neg_mod(-localShareDRelu[i] + ((localShareA_all3_drelu[i]+1)&1), (int64_t)prime_mod); - } - curiknp->send_impl(otMsg, totalComp, fieldBits); - for(int i=0;i<size;i++){ - intType curCTermShare = 0; - for(int j=0;j<compPerElt;j++){ - curCTermShare = sci::neg_mod(curCTermShare + localShareDRelu[compPerElt*i+j],(int64_t)prime_mod); - } - outp[i] = sci::neg_mod(outp[i] - curCTermShare,(int64_t)prime_mod); - delete[] otMsg[i]; - } - delete[] otMsg; - delete[] localShareDRelu; - } - else{ - uint64_t* otDataRecvd = new uint64_t[totalComp]; - curiknp->recv_impl(otDataRecvd,localShareA_all3_drelu,totalComp,fieldBits); - for(int i=0;i<size;i++){ - intType curCTermShare = 0; - for(int j=0;j<compPerElt;j++){ - uint64_t curDReluAns = otDataRecvd[compPerElt*i+j]; - curCTermShare = sci::neg_mod(curCTermShare + curDReluAns, (int64_t)prime_mod); - } - outp[i] = sci::neg_mod(outp[i] - curCTermShare,(int64_t)prime_mod); - } - delete[] otDataRecvd; - } - - if (doMSBComputation) delete[] msbShare; - delete[] localShareCorr; - delete[] localShareCorrSmallRingPacked; - delete[] localShareCorrSmallRing; - delete[] otMsgCorrField; - delete[] otMsgCorrSmallRing; - delete[] localShareA_all3; - delete[] localShareA_all3_drelu; - delete[] radixCompValues; - delete[] carryBit; -} - -template<typename intType> -void funcFieldDivWrapper(int size, const intType* inp, intType* outp, intType divisor, uint8_t* msbShare) -{ - assert(size%8==0); -#ifdef MULTITHREADED_TRUNC - std::thread truncThreads[numThreads]; - int chunk_size = (size/(8*numThreads))*8; - for (int i = 0; i < numThreads; i++) { - int offset = i*chunk_size; - int curSize; - if (i == (numThreads - 1)) { - curSize = size - offset; - } - else { - curSize = chunk_size; - } - int curParty = party; - if (i & 1) curParty = 3 - curParty; - uint8_t* msbShareArg = msbShare; - if (msbShare!=nullptr) msbShareArg = msbShareArg+offset; - truncThreads[i] = std::thread(funcFieldDiv<intType>, - curParty, ioArr[i], otpackArr[i], otInstanceArr[i], kkotInstanceArr[i], - reluImplArr[i], prgInstanceArr[i], - curSize, inp+offset, outp+offset, divisor, msbShareArg - ); - } - for (int i = 0; i < numThreads; ++i) { - truncThreads[i].join(); - } -#else - funcFieldDiv<intType>(party, io, otpack, iknpOT, kkot, reluImpl, prg128Instance, - size, inp, outp, divisor, msbShare); -#endif -} - -#endif //FUNCTIONALITIES_H__ diff --git a/SCI/src/functionalities_pt.h b/SCI/src/functionalities_pt.h deleted file mode 100644 index 2dd2f39e..00000000 --- a/SCI/src/functionalities_pt.h +++ /dev/null @@ -1,2312 +0,0 @@ -/* -Authors: Nishant Kumar, Deevashwer Rathee -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#include<vector> -#include<math.h> -#include<cstdlib> -#include<iostream> -#include<fstream> -#include<cassert> -#include <Eigen/Dense> - -#if defined(SCI_OT) - - const uint64_t modulo = prime_mod; - const uint64_t moduloMask = prime_mod - 1; - const uint64_t moduloMidPt = prime_mod/2; - - void div_floor(int64_t a, int64_t b, int64_t& quot, int64_t& rem){ - assert(b>0); - int64_t q = a/b; - int64_t r = a%b; - int64_t corr = ((r!=0) && (r<0)); - quot = q-corr; - rem = (r+b)%b; - } - - inline int64_t getSignedVal(uint64_t x){ - x = x & moduloMask; - assert(x < modulo); - int64_t sx = x; - if (x >= moduloMidPt) sx = x - modulo; - return sx; - } - - inline uint64_t getRingElt(int64_t x){ - return ((uint64_t)x) & moduloMask; - } - - inline uint64_t PublicAdd(uint64_t x, uint64_t y){ - assert((x < modulo) && (y < modulo)); - return (x+y) & moduloMask; - } - - inline uint64_t PublicSub(uint64_t x, uint64_t y){ - assert((x < modulo) && (y < modulo)); - return (x-y) & moduloMask; - } - - inline uint64_t PublicMult(uint64_t x, uint64_t y){ - assert((x < modulo) && (y < modulo)); - return (x*y) & moduloMask; //This works because its a two-power ring - } - - inline bool PublicGT(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - return (sx > sy); - } - - inline bool PublicGTE(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - return (sx >= sy); - } - - inline bool PublicLT(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - return (sx < sy); - } - - inline bool PublicLTE(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - return (sx <= sy); - } - - uint64_t PublicDiv(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - int64_t q,r; - div_floor(sx,sy,q,r); - return getRingElt(q); - } - - uint64_t PublicMod(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - int64_t q,r; - div_floor(sx,sy,q,r); - return r; - } - - inline uint64_t PublicRShiftA(uint64_t x, uint64_t y){ - assert((x<modulo) && (y<modulo)); - int64_t sx = getSignedVal(x); - int64_t ans = sx >> y; - return getRingElt(ans); - } - - inline uint64_t PublicRShiftL(uint64_t x, uint64_t y){ - assert((x<modulo) && (y<modulo)); - return (x>>y); - } - - inline uint64_t PublicLShift(uint64_t x, uint64_t y){ - assert((x<modulo) && (y<modulo)); - return (x<<y) & moduloMask; - } - -#else - - //Assumption at some places in the following code is that 2*mod < (1<<64) - // which allows things like (x+y)%(1<<64). - const uint64_t modulo = prime_mod; - uint64_t moduloMult(uint64_t a, uint64_t b, uint64_t mod){ - uint64_t res = 0; - a %= mod; - while (b) - { - if (b & 1) res = (res + a) % mod; - a = (2 * a) % mod; - b >>= 1; - } - return res; - } - - void div_floor(int64_t a, int64_t b, int64_t& quot, int64_t& rem){ - assert(b>0); - int64_t q = a/b; - int64_t r = a%b; - int64_t corr = ((r!=0) && (r<0)); - quot = q-corr; - rem = (r+b)%b; - } - - int64_t getSignedVal(uint64_t x){ - assert(x < modulo); - bool xPos; - if (modulo&1) xPos = (x <= (modulo/2)); - else xPos = (x < (modulo/2)); - int64_t sx = x; - if (!xPos) sx = x - modulo; - return sx; - } - - uint64_t getRingElt(int64_t x){ - if (x > 0) - return x%modulo; - else{ - int64_t y = -x; - int64_t temp = modulo - y; - int64_t temp1 = temp % ((int64_t)modulo); - uint64_t ans = (temp1 + modulo)%modulo; - return ans; - } - } - - uint64_t PublicAdd(uint64_t x, uint64_t y){ - assert((x < modulo) && (y < modulo)); - return (x+y)%modulo; - } - - uint64_t PublicSub(uint64_t x, uint64_t y){ - assert((x < modulo) && (y < modulo)); - uint64_t ans; - if (x>=y) ans = (x-y)%modulo; - else ans = ((x + modulo) - y)%modulo; - return ans; - } - - uint64_t PublicMult(uint64_t x, uint64_t y){ - assert((x < modulo) && (y < modulo)); - #ifdef __SIZEOF_INT128__ - __int128 ix = x; - __int128 iy = y; - __int128 iz = ix*iy; - - return iz % modulo; - #else - return moduloMult(x,y,modulo); - #endif - } - - bool PublicGT(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - return (sx > sy); - } - - bool PublicGTE(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - return (sx >= sy); - } - - bool PublicLT(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - return (sx < sy); - } - - bool PublicLTE(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - return (sx <= sy); - } - - uint64_t PublicDiv(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - int64_t q,r; - div_floor(sx,sy,q,r); - return getRingElt(q); - } - - uint64_t PublicMod(uint64_t x, uint64_t y){ - int64_t sx = getSignedVal(x); - int64_t sy = getSignedVal(y); - int64_t q,r; - div_floor(sx,sy,q,r); - return r; - } - - uint64_t PublicRShiftA(uint64_t x, uint64_t y){ - assert((x<modulo) && (y<modulo)); - int64_t sx = getSignedVal(x); - int64_t ans = sx >> y; - return getRingElt(ans); - } - - uint64_t PublicRShiftL(uint64_t x, uint64_t y){ - assert((x<modulo) && (y<modulo)); - return (x>>y); - } - - uint64_t PublicLShift(uint64_t x, uint64_t y){ - assert((x<modulo) && (y<modulo)); - return (x<<y)%modulo; - } - -#endif - - -using namespace std; - -uint32_t public_lrshift(uint32_t x, uint32_t y){ -return (x >> y); -} - -int32_t public_lrshift(int32_t x, uint32_t y){ -return ((int32_t)(((uint32_t)x) >> y)); -} - -uint64_t public_lrshift(uint64_t x, uint64_t y){ -return (x >> y); -} - -int64_t public_lrshift(int64_t x, uint64_t y){ -return ((int64_t)(((uint64_t)x) >> y)); -} - -template<typename T> -vector<T> make_vector(size_t size) { -return std::vector<T>(size); -} - -template <typename T, typename... Args> -auto make_vector(size_t first, Args... sizes) -{ -auto inner = make_vector<T>(sizes...); -return vector<decltype(inner)>(first, inner); -} - -template<typename T> -ostream& operator<< (ostream &os, const vector<T> &v) -{ -for(auto it = v.begin (); it != v.end (); ++it) { -os << *it << endl; -} -return os; -} - - -void MatMul2DEigen_pt(int64_t i, int64_t j, int64_t k, auto& A, auto& B, auto& C, int64_t consSF){ - Eigen::Matrix<__int128, Eigen::Dynamic, Eigen::Dynamic> eigen_a(i, j); - Eigen::Matrix<__int128, Eigen::Dynamic, Eigen::Dynamic> eigen_b(j, k); - Eigen::Matrix<__int128, Eigen::Dynamic, Eigen::Dynamic> eigen_c(i, k); - - for (int i0 = 0; i0 < i; ++i0){ - for (int i1 = 0; i1 < j; ++i1){ - eigen_a(i0, i1) = A[i0][i1]; - } - } - - for (int i0 = 0; i0 < j; ++i0){ - for (int i1 = 0; i1 < k; ++i1){ - eigen_b(i0, i1) = B[i0][i1]; - } - } - - eigen_c = eigen_a * eigen_b; //No overflows since running in __int128 - - for (int i0 = 0; i0 < i; ++i0){ - for (int i1 = 0; i1 < k; ++i1){ - if (bitlength == 64) { - C[i0][i1] = eigen_c(i0, i1); - } else { - C[i0][i1] = (eigen_c(i0, i1))%modulo; - } - } - } -} - -void MatMul2D_pt(uint64_t i, uint64_t j, uint64_t k, auto& A, auto& B, auto& C, uint64_t consSF){ - MatMul2DEigen_pt(i,j,k,A,B,C,consSF); -} - -void ArgMax_pt(uint64_t s1, uint64_t s2, auto& inArr, auto& outArr){ -for (uint64_t od = (int32_t)0; od < s1; od++){ - -uint64_t maxi = inArr[od][ (int32_t)0]; - -uint64_t maxiIdx = (int64_t)0; -for (uint64_t i = (int32_t)0; i < s2; i++){ - -uint64_t iL = i; -maxiIdx = (PublicGT(inArr[od][i], maxi)) ? iL : maxiIdx; -maxi = (PublicGT(inArr[od][i], maxi)) ? inArr[od][i] : maxi; -} -outArr[od] = maxiIdx; -} -} - -void Relu_pt(uint64_t s1, auto& inArr, auto& outArr, uint64_t sf, uint64_t doTruncation){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -outArr[i1] = (PublicGT(inArr[i1], (int64_t)0)) ? inArr[i1] : (int64_t)0; -} -if (doTruncation) { -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -outArr[i1] = (PublicRShiftA(outArr[i1], sf)); -} -} -} - -void Floor_pt(uint64_t s1, auto& inArr, auto& outArr, uint64_t sf){ - -uint64_t mask = ~ (PublicSub((PublicLShift( (int32_t)1, sf)), (int32_t)1)); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -outArr[i1] = (inArr[i1] & mask); -} -} - -void MaxPool_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t C, uint64_t ksizeH, uint64_t ksizeW, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, uint64_t N1, uint64_t imgH, uint64_t imgW, uint64_t C1, auto& inArr, auto& outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t c = (int32_t)0; c < C; c++){ - -uint64_t leftTopCornerH = (PublicSub( (int32_t)0, zPadHLeft)); - -uint64_t extremeRightBottomCornerH = (PublicAdd((PublicSub(imgH, (int32_t)1)), zPadHRight)); - -uint64_t ctH = (int32_t)0; -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, ksizeH)), (int32_t)1)), extremeRightBottomCornerH))) { - -uint64_t leftTopCornerW = (PublicSub( (int32_t)0, zPadWLeft)); - -uint64_t extremeRightBottomCornerW = (PublicAdd((PublicSub(imgW, (int32_t)1)), zPadWRight)); - -uint64_t ctW = (int32_t)0; -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerW, ksizeW)), (int32_t)1)), extremeRightBottomCornerW))) { - -uint64_t maxi = (int64_t)0; -if ((((PublicLT(leftTopCornerH, (int32_t)0)) || (PublicGTE(leftTopCornerH, imgH))) || ((PublicLT(leftTopCornerW, (int32_t)0)) || (PublicGTE(leftTopCornerW, imgW))))) { -maxi = (int64_t)0; -} else { -maxi = inArr[n][leftTopCornerH][leftTopCornerW][c]; -} -for (uint64_t fh = (int32_t)0; fh < ksizeH; fh++){ -for (uint64_t fw = (int32_t)0; fw < ksizeW; fw++){ - -uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); - -uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); - -uint64_t temp = (int64_t)0; -if ((((PublicLT(curPosH, (int32_t)0)) || (PublicGTE(curPosH, imgH))) || ((PublicLT(curPosW, (int32_t)0)) || (PublicGTE(curPosW, imgW))))) { -temp = (int64_t)0; -} else { -temp = inArr[n][curPosH][curPosW][c]; -} -maxi = (getSignedVal(PublicSub(maxi, temp)) < 0) ? temp : maxi; -} -} -outArr[n][ctH][ctW][c] = maxi; -leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); -ctW = (PublicAdd(ctW, (int32_t)1)); -} - -leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); -ctH = (PublicAdd(ctH, (int32_t)1)); -} - -} -} -} - -void AvgPool_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t C, uint64_t ksizeH, uint64_t ksizeW, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, uint64_t N1, uint64_t imgH, uint64_t imgW, uint64_t C1, auto& inArr, auto& outArr){ - -uint64_t rows = (PublicMult((PublicMult((PublicMult(N, C)), H)), W)); - -auto filterAvg = make_vector<uint64_t>(rows); - -uint64_t rowIdx = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t c = (int32_t)0; c < C; c++){ - -uint64_t leftTopCornerH = (PublicSub( (int32_t)0, zPadHLeft)); - -uint64_t extremeRightBottomCornerH = (PublicAdd((PublicSub(imgH, (int32_t)1)), zPadHRight)); - -uint64_t ctH = (int32_t)0; -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, ksizeH)), (int32_t)1)), extremeRightBottomCornerH))) { - -uint64_t leftTopCornerW = (PublicSub( (int32_t)0, zPadWLeft)); - -uint64_t extremeRightBottomCornerW = (PublicAdd((PublicSub(imgW, (int32_t)1)), zPadWRight)); - -uint64_t ctW = (int32_t)0; -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerW, ksizeW)), (int32_t)1)), extremeRightBottomCornerW))) { - -uint64_t curFilterSum = (int64_t)0; -for (uint64_t fh = (int32_t)0; fh < ksizeH; fh++){ -for (uint64_t fw = (int32_t)0; fw < ksizeW; fw++){ - -uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); - -uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); - -uint64_t temp = (int64_t)0; -if ((((PublicLT(curPosH, (int32_t)0)) || (PublicGTE(curPosH, imgH))) || ((PublicLT(curPosW, (int32_t)0)) || (PublicGTE(curPosW, imgW))))) { -temp = (int64_t)0; -} else { -temp = inArr[n][curPosH][curPosW][c]; -} -curFilterSum = (PublicAdd(curFilterSum, temp)); -} -} - -uint64_t ksizeH64 = ksizeH; - -uint64_t ksizeW64 = ksizeW; - -uint64_t filterSz64 = (PublicMult(ksizeH64, ksizeW64)); - -uint64_t curFilterAvg = (PublicDiv(curFilterSum, filterSz64)); -filterAvg[rowIdx] = curFilterAvg; -rowIdx = (PublicAdd(rowIdx, (int32_t)1)); -leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); -ctW = (PublicAdd(ctW, (int32_t)1)); -} - -leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); -ctH = (PublicAdd(ctH, (int32_t)1)); -} - -} -} -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t c = (int32_t)0; c < C; c++){ -for (uint64_t h = (int32_t)0; h < H; h++){ -for (uint64_t w = (int32_t)0; w < W; w++){ -outArr[n][h][w][c] = filterAvg[(PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(n, C)), H)), W)), (PublicMult((PublicMult(c, H)), W)))), (PublicMult(h, W)))), w))]; -} -} -} -} -} - -void ElemWiseSecretSharedVectorMult_pt(uint64_t s1, auto& arr1, auto& arr2, auto& outArr){ -for (uint64_t ii = (int32_t)0; ii < s1; ii++){ -outArr[ii] = (PublicMult(arr1[ii], arr2[ii])); -} -} - -void ElemWiseActModelVectorMult_pt(uint64_t s1, auto& arr1, auto& arr2, auto& outArr){ -ElemWiseSecretSharedVectorMult_pt(s1, arr1, arr2, outArr); -} - -void ElemWiseVectorPublicDiv_pt(uint64_t s1, auto& arr1, uint64_t divisor, auto& outArr){ - -uint64_t divisor64 = divisor; -for (uint64_t ii = (int32_t)0; ii < s1; ii++){ -outArr[ii] = (PublicDiv(arr1[ii], divisor64)); -} -} - -void ScaleUp_pt(uint64_t s1, auto& arr, uint64_t sf){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -arr[i] = (PublicLShift(arr[i], sf)); -} -} - -void ScaleDown_pt(uint64_t s1, auto& arr, uint64_t sf){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -arr[i1] = (PublicRShiftA(arr[i1], sf)); -} -} - -void ClearMemSecret1_pt(uint64_t s1, auto& arr){ -return ; -} - -void ClearMemSecret2_pt(uint64_t s1, uint64_t s2, auto& arr){ -return ; -} - -void ClearMemSecret3_pt(uint64_t s1, uint64_t s2, uint64_t s3, auto& arr){ -return ; -} - -void ClearMemSecret4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& arr){ -return ; -} - -void ClearMemSecret5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, auto& arr){ -return ; -} - -void ClearMemPublic_pt(uint64_t x){ -return ; -} - -void ClearMemPublic1_pt(uint64_t s, auto& x){ -return ; -} - -void ClearMemPublic2_pt(uint64_t s1, uint64_t s2, auto& arr){ -return ; -} - -void ClearMemPublic3_pt(uint64_t s1, uint64_t s2, uint64_t s3, auto& arr){ -return ; -} - -void ClearMemPublic4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& arr){ -return ; -} - -void ClearMemPublic5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, auto& arr){ -return ; -} - -void StartComputation_pt(){ -return ; -} - -void EndComputation_pt(){ -return ; -} - -void MatAddBroadCast2_pt(uint64_t s1, uint64_t s2, auto& A, auto& B, auto& outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -outArr[i1][i2] = (PublicAdd(A[i1][i2], B[i2])); -} -} -} - -void MatAdd2_pt(uint64_t s1, uint64_t s2, auto& A, auto& B, auto& outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -outArr[i1][i2] = (PublicAdd(A[i1][i2], B[i1][i2])); -} -} -} - -void MatAddBroadCast4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& A, auto& B, auto& outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -outArr[i1][i2][i3][i4] = (PublicAdd(A[i1][i2][i3][i4], B[i4])); -} -} -} -} -} - -void MatAdd4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& A, auto& B, auto& outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -outArr[i1][i2][i3][i4] = (PublicAdd(A[i1][i2][i3][i4], B[i1][i2][i3][i4])); -} -} -} -} -} - -void MatAddBroadCast5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, auto& A, auto& B, auto& outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -outArr[i1][i2][i3][i4][i5] = (PublicAdd(A[i1][i2][i3][i4][i5], B[i5])); -} -} -} -} -} -} - -void MatAdd5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, auto& A, auto& B, auto& outArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -outArr[i1][i2][i3][i4][i5] = (PublicAdd(A[i1][i2][i3][i4][i5], B[i1][i2][i3][i4][i5])); -} -} -} -} -} -} - -void CreateTensor1_pt(uint64_t s1, uint64_t val, auto& arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -arr[i1] = val; -} -} - -void CreateTensor2_pt(uint64_t s1, uint64_t s2, uint64_t val, auto& arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -arr[i1][i2] = val; -} -} -} - -void CreateTensor3_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t val, auto& arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -arr[i1][i2][i3] = val; -} -} -} -} - -void CreateTensor4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t val, auto& arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -arr[i1][i2][i3][i4] = val; -} -} -} -} -} - -void CreateTensor5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, uint64_t val, auto& arr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ -arr[i1][i2][i3][i4][i5] = val; -} -} -} -} -} -} - -void CopyTensor1_pt(uint64_t s1, auto& targetArr, auto& fromArr, auto& ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -targetArr[i1] = fromArr[i1]; -} -} - -void CopyTensor2_pt(uint64_t s1, uint64_t s2, auto& targetArr, auto& fromArr, auto& ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -targetArr[i1][i2] = fromArr[i1][i2]; -} -} -} - -void CopyTensor3_pt(uint64_t s1, uint64_t s2, uint64_t s3, auto& targetArr, auto& fromArr, auto& ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -targetArr[i1][i2][i3] = fromArr[i1][i2][i3]; -} -} -} -} - -void CopyTensor4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& targetArr, auto& fromArr, auto& ignore){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -targetArr[i1][i2][i3][i4] = fromArr[i1][i2][i3][i4]; -} -} -} -} -} - -void CreateIdentity11_pt(uint64_t s1, auto& fromArr, auto& newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -newArr[i1] = fromArr[i1]; -} -} - -void CreateIdentity22_pt(uint64_t s1, uint64_t s2, auto& fromArr, auto& newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -newArr[i1][i2] = fromArr[i1][i2]; -} -} -} - -void CreateIdentity33_pt(uint64_t s1, uint64_t s2, uint64_t s3, auto& fromArr, auto& newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -newArr[i1][i2][i3] = fromArr[i1][i2][i3]; -} -} -} -} - -void CreateIdentity44_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& fromArr, auto& newArr){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -newArr[i1][i2][i3][i4] = fromArr[i1][i2][i3][i4]; -} -} -} -} -} - -void CreateCopy2211_pt(uint64_t s1, uint64_t s2, uint64_t inps1, uint64_t inps2, auto& inArr, uint64_t perDimSize, auto& beginIdx, auto& sizeIdx, auto& outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -outArr[i][j] = inArr[(PublicAdd(beginIdx[ (int32_t)0], i))][(PublicAdd(beginIdx[ (int32_t)1], j))]; -} -} -} - -void CreateCopy5511_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, uint64_t inps1, uint64_t inps2, uint64_t inps3, uint64_t inps4, uint64_t inps5, auto& inArr, uint64_t perDimSize, auto& beginIdx, auto& sizeIdx, auto& outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -outArr[i][j][k][l][m] = inArr[(PublicAdd(beginIdx[ (int32_t)0], i))][(PublicAdd(beginIdx[ (int32_t)1], j))][(PublicAdd(beginIdx[ (int32_t)2], k))][(PublicAdd(beginIdx[ (int32_t)3], l))][(PublicAdd(beginIdx[ (int32_t)4], m))]; -} -} -} -} -} -} - -void Concat2T222_pt(uint64_t s1, uint64_t s2, uint64_t inp1s1, uint64_t inp1s2, auto& inp1, uint64_t inp2s1, uint64_t inp2s2, auto& inp2, uint64_t axis, auto& outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -if ((axis == (int32_t)0)) { -if ((PublicLT(i1, inp1s1))) { -outp[i1][i2] = inp1[i1][i2]; -} else { -outp[i1][i2] = inp2[(PublicSub(i1, inp1s1))][i2]; -} -} else { -if ((PublicLT(i2, inp1s2))) { -outp[i1][i2] = inp1[i1][i2]; -} else { -outp[i1][i2] = inp2[i1][(PublicSub(i2, inp1s2))]; -} -} -} -} -} - -void Concat2T444_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t inp1s1, uint64_t inp1s2, uint64_t inp1s3, uint64_t inp1s4, auto& inp1, uint64_t inp2s1, uint64_t inp2s2, uint64_t inp2s3, uint64_t inp2s4, auto& inp2, uint64_t axis, auto& outp){ -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -if ((axis == (int32_t)0)) { -if ((PublicLT(i1, inp1s1))) { -outp[i1][i2][i3][i4] = inp1[i1][i2][i3][i4]; -} else { -outp[i1][i2][i3][i4] = inp2[(PublicSub(i1, inp1s1))][i2][i3][i4]; -} -} else { -if ((axis == (int32_t)1)) { -if ((PublicLT(i2, inp1s2))) { -outp[i1][i2][i3][i4] = inp1[i1][i2][i3][i4]; -} else { -outp[i1][i2][i3][i4] = inp2[i1][(PublicSub(i2, inp1s2))][i3][i4]; -} -} else { -if ((axis == (int32_t)2)) { -if ((PublicLT(i3, inp1s3))) { -outp[i1][i2][i3][i4] = inp1[i1][i2][i3][i4]; -} else { -outp[i1][i2][i3][i4] = inp2[i1][i2][(PublicSub(i3, inp1s3))][i4]; -} -} else { -if ((PublicLT(i4, inp1s4))) { -outp[i1][i2][i3][i4] = inp1[i1][i2][i3][i4]; -} else { -outp[i1][i2][i3][i4] = inp2[i1][i2][i3][(PublicSub(i4, inp1s4))]; -} -} -} -} -} -} -} -} -} - -void Split44_pt(uint64_t O1, uint64_t O2, uint64_t O3, uint64_t O4, uint64_t I1, uint64_t I2, uint64_t I3, uint64_t I4, auto& inp, uint64_t axis, uint64_t curCount, uint64_t total, auto& out){ -for (uint64_t o1 = (int32_t)0; o1 < O1; o1++){ -for (uint64_t o2 = (int32_t)0; o2 < O2; o2++){ -for (uint64_t o3 = (int32_t)0; o3 < O3; o3++){ -for (uint64_t o4 = (int32_t)0; o4 < O4; o4++){ - -uint64_t i1 = o1; - -uint64_t i2 = o2; - -uint64_t i3 = o3; - -uint64_t i4 = o4; -if ((axis == (int32_t)0)) { -i1 = (PublicAdd((PublicMult((PublicDiv(I1, total)), curCount)), o1)); -} -if ((axis == (int32_t)1)) { -i2 = (PublicAdd((PublicMult((PublicDiv(I2, total)), curCount)), o2)); -} -if ((axis == (int32_t)2)) { -i3 = (PublicAdd((PublicMult((PublicDiv(I3, total)), curCount)), o3)); -} -if ((axis == (int32_t)3)) { -i4 = (PublicAdd((PublicMult((PublicDiv(I4, total)), curCount)), o4)); -} -out[o1][o2][o3][o4] = inp[i1][i2][i3][i4]; -} -} -} -} -} - -void Conv2DReshapeFilter_pt(uint64_t FH, uint64_t FW, uint64_t CI, uint64_t CO, auto& inputArr, auto& outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CI)), (PublicMult(fw, CI)))), ci)); -outputArr[co][linIdx] = inputArr[fh][fw][ci][co]; -} -} -} -} -} - -void Conv2DReshapeMatMulOP_pt(uint64_t N, uint64_t finalH, uint64_t finalW, uint64_t CO, auto& inputArr, auto& outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -outputArr[n][h][w][co] = inputArr[co][(PublicAdd((PublicAdd((PublicMult((PublicMult(n, finalH)), finalW)), (PublicMult(h, finalW)))), w))]; -} -} -} -} -} - -void Conv2DReshapeInput_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, uint64_t RRows, uint64_t RCols, auto& inputArr, auto& outputArr){ - -uint64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -uint64_t leftTopCornerH = (PublicSub( (int32_t)0, zPadHLeft)); - -uint64_t extremeRightBottomCornerH = (PublicAdd((PublicSub(H, (int32_t)1)), zPadHRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), extremeRightBottomCornerH))) { - -uint64_t leftTopCornerW = (PublicSub( (int32_t)0, zPadWLeft)); - -uint64_t extremeRightBottomCornerW = (PublicAdd((PublicSub(W, (int32_t)1)), zPadWRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), extremeRightBottomCornerW))) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); - -uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); - -uint64_t val = (int64_t)0; -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((PublicLT(curPosH, (int32_t)0)) || (PublicGTE(curPosH, H))) || ((PublicLT(curPosW, (int32_t)0)) || (PublicGTE(curPosW, W))))) { -val = (int64_t)0; -} else { -val = inputArr[n][curPosH][curPosW][ci]; -} -outputArr[(PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CI)), (PublicMult(fw, CI)))), ci))][linIdxFilterMult] = val; -} -} -} -linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); -leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); -} - -leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); -} - -} -} - -void Conv2D_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ - -uint64_t reshapedFilterRows = CO; - -uint64_t reshapedFilterCols = (PublicMult((PublicMult(FH, FW)), CI)); - -uint64_t reshapedIPRows = (PublicMult((PublicMult(FH, FW)), CI)); - -uint64_t newH = (PublicAdd((PublicDiv((PublicSub((PublicAdd(H, (PublicAdd(zPadHLeft, zPadHRight)))), FH)), strideH)), (int32_t)1)); - -uint64_t newW = (PublicAdd((PublicDiv((PublicSub((PublicAdd(W, (PublicAdd(zPadWLeft, zPadWRight)))), FW)), strideW)), (int32_t)1)); - -uint64_t reshapedIPCols = (PublicMult((PublicMult(N, newH)), newW)); - -auto filterReshaped = make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); - -auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); - -auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); -Conv2DReshapeFilter_pt(FH, FW, CI, CO, filterArr, filterReshaped); -Conv2DReshapeInput_pt(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOP_pt(N, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv2DLoopInner_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, uint64_t outH, uint64_t outW, uint64_t G, auto& inputArr, auto& filterArr, auto& outArr){ - -uint64_t GIS = (PublicDiv(CI, G)); - -uint64_t GOS = (PublicDiv(CO, G)); -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t cog = (int32_t)0; cog < GOS; cog++){ -for (uint64_t cig = (int32_t)0; cig < GIS; cig++){ -for (uint64_t g = (int32_t)0; g < G; g++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ - -uint64_t val = (int64_t)0; - -uint64_t ci = (PublicAdd((PublicMult(GIS, g)), cig)); - -uint64_t co = (PublicAdd((PublicMult(GOS, g)), cog)); - -uint64_t curPosH = (PublicSub((PublicMult(strideH, h)), zPadHLeft)); -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ - -uint64_t curPosW = (PublicSub((PublicMult(strideW, w)), zPadWLeft)); -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -if (((((PublicGTE(curPosH, (int32_t)0)) && (PublicGTE(curPosW, (int32_t)0))) && (PublicLT(curPosH, H))) && (PublicLT(curPosW, W)))) { -val = (PublicAdd(val, (PublicMult(inputArr[n][curPosH][curPosW][ci], filterArr[fh][fw][(PublicDiv(ci, G))][co])))); -} -curPosW = (PublicAdd(curPosW, (int32_t)1)); -} -curPosH = (PublicAdd(curPosH, (int32_t)1)); -} -outArr[n][h][w][co] = (PublicAdd(outArr[n][h][w][co], val)); -} -} -} -} -} -} -} - -void Conv2DLoop_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, uint64_t G, auto& inputArr, auto& filterArr, auto& outArr){ - -uint64_t outH = (PublicAdd((PublicDiv((PublicAdd((PublicSub(H, FH)), (PublicAdd(zPadHLeft, zPadHRight)))), strideH)), (int32_t)1)); - -uint64_t outW = (PublicAdd((PublicDiv((PublicAdd((PublicSub(W, FW)), (PublicAdd(zPadWLeft, zPadWRight)))), strideW)), (int32_t)1)); -Conv2DLoopInner_pt(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, outH, outW, G, inputArr, filterArr, outArr); -} - -void Conv2DReshapeFilterGroup_pt(uint64_t FH, uint64_t FW, uint64_t CI, uint64_t CO, uint64_t g, uint64_t G, auto& inputArr, auto& outputArr){ - -uint64_t CIG = (PublicDiv(CI, G)); - -uint64_t COG = (PublicDiv(CO, G)); - -uint64_t startCO = (PublicMult(g, COG)); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CIG)), (PublicMult(fw, CIG)))), ci)); -outputArr[co][linIdx] = inputArr[fh][fw][ci][(PublicAdd(co, startCO))]; -} -} -} -} -} - -void Conv2DReshapeMatMulOPGroup_pt(uint64_t N, uint64_t finalH, uint64_t finalW, uint64_t CO, uint64_t g, uint64_t G, auto& inputArr, auto& outputArr){ - -uint64_t COG = (PublicDiv(CO, G)); - -uint64_t startCO = (PublicMult(g, COG)); -for (uint64_t co = (int32_t)0; co < COG; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -outputArr[n][h][w][(PublicAdd(co, startCO))] = inputArr[co][(PublicAdd((PublicAdd((PublicMult((PublicMult(n, finalH)), finalW)), (PublicMult(h, finalW)))), w))]; -} -} -} -} -} - -void Conv2DReshapeInputGroup_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, uint64_t g, uint64_t G, uint64_t RRows, uint64_t RCols, auto& inputArr, auto& outputArr){ - -uint64_t linIdxFilterMult = (int32_t)0; - -uint64_t CIG = (PublicDiv(CI, G)); -for (uint64_t n = (int32_t)0; n < N; n++){ - -uint64_t leftTopCornerH = (PublicSub( (int32_t)0, zPadHLeft)); - -uint64_t extremeRightBottomCornerH = (PublicAdd((PublicSub(H, (int32_t)1)), zPadHRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), extremeRightBottomCornerH))) { - -uint64_t leftTopCornerW = (PublicSub( (int32_t)0, zPadWLeft)); - -uint64_t extremeRightBottomCornerW = (PublicAdd((PublicSub(W, (int32_t)1)), zPadWRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), extremeRightBottomCornerW))) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); - -uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); - -uint64_t val = (int64_t)0; - -uint64_t startCI = (PublicMult(g, CIG)); -for (uint64_t ci = (int32_t)0; ci < CIG; ci++){ -if ((((PublicLT(curPosH, (int32_t)0)) || (PublicGTE(curPosH, H))) || ((PublicLT(curPosW, (int32_t)0)) || (PublicGTE(curPosW, W))))) { -val = (int64_t)0; -} else { -val = inputArr[n][curPosH][curPosW][(PublicAdd(ci, startCI))]; -} -outputArr[(PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CIG)), (PublicMult(fw, CIG)))), ci))][linIdxFilterMult] = val; -} -} -} -linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); -leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); -} - -leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); -} - -} -} - -void Conv2DGroup_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, uint64_t G, auto& inputArr, auto& filterArr, auto& outArr){ - -uint64_t CIG = (PublicDiv(CI, G)); - -uint64_t reshapedFilterRows = (PublicDiv(CO, G)); - -uint64_t reshapedFilterCols = (PublicMult((PublicMult(FH, FW)), CIG)); - -uint64_t reshapedIPRows = (PublicMult((PublicMult(FH, FW)), CIG)); - -uint64_t outH = (PublicAdd((PublicDiv((PublicSub((PublicAdd(H, (PublicAdd(zPadHLeft, zPadHRight)))), FH)), strideH)), (int32_t)1)); - -uint64_t outW = (PublicAdd((PublicDiv((PublicSub((PublicAdd(W, (PublicAdd(zPadWLeft, zPadWRight)))), FW)), strideW)), (int32_t)1)); - -uint64_t reshapedIPCols = (PublicMult((PublicMult(N, outH)), outW)); -for (uint64_t g = (int32_t)0; g < G; g++){ - -auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); - -auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); - -auto filterReshaped = make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); -Conv2DReshapeFilterGroup_pt(FH, FW, CI, CO, g, G, filterArr, filterReshaped); -Conv2DReshapeInputGroup_pt(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, g, G, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv2DReshapeMatMulOPGroup_pt(N, outH, outW, CO, g, G, matmulOP, outArr); -ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); -} -} - -void Conv3DReshapeFilter_pt(uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CI, uint64_t CO, auto& inputArr, auto& outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(fd, FH)), FW)), CI)), (PublicMult((PublicMult(fh, FW)), CI)))), (PublicMult(fw, CI)))), ci)); -outputArr[co][linIdx] = inputArr[fd][fh][fw][ci][co]; -} -} -} -} -} -} - -void Conv3DReshapeMatMulOP_pt(uint64_t N, uint64_t finalD, uint64_t finalH, uint64_t finalW, uint64_t CO, auto& inputArr, auto& outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t d = (int32_t)0; d < finalD; d++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -outputArr[n][d][h][w][co] = inputArr[co][(PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(n, finalD)), finalH)), finalW)), (PublicMult((PublicMult(d, finalH)), finalW)))), (PublicMult(h, finalW)))), w))]; -} -} -} -} -} -} - -void Conv3DReshapeInput_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t zPadDLeft, uint64_t zPadDRight, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, uint64_t RRows, uint64_t RCols, auto& inputArr, auto& outputArr){ - -uint64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -uint64_t leftTopCornerD = (PublicSub( (int32_t)0, zPadDLeft)); - -uint64_t extremeRightBottomCornerD = (PublicAdd((PublicSub(D, (int32_t)1)), zPadDRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerD, FD)), (int32_t)1)), extremeRightBottomCornerD))) { - -uint64_t leftTopCornerH = (PublicSub( (int32_t)0, zPadHLeft)); - -uint64_t extremeRightBottomCornerH = (PublicAdd((PublicSub(H, (int32_t)1)), zPadHRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), extremeRightBottomCornerH))) { - -uint64_t leftTopCornerW = (PublicSub( (int32_t)0, zPadWLeft)); - -uint64_t extremeRightBottomCornerW = (PublicAdd((PublicSub(W, (int32_t)1)), zPadWRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), extremeRightBottomCornerW))) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -uint64_t curPosD = (PublicAdd(leftTopCornerD, fd)); - -uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); - -uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); - -uint64_t val = (int64_t)0; -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((PublicLT(curPosD, (int32_t)0)) || (PublicGTE(curPosD, D))) || ((PublicLT(curPosH, (int32_t)0)) || (PublicGTE(curPosH, H)))) || ((PublicLT(curPosW, (int32_t)0)) || (PublicGTE(curPosW, W))))) { -val = (int64_t)0; -} else { -val = inputArr[n][curPosD][curPosH][curPosW][ci]; -} -outputArr[(PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(fd, FH)), FW)), CI)), (PublicMult((PublicMult(fh, FW)), CI)))), (PublicMult(fw, CI)))), ci))][linIdxFilterMult] = val; -} -} -} -} -linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); -leftTopCornerW = (PublicAdd(leftTopCornerW, strideW)); -} - -leftTopCornerH = (PublicAdd(leftTopCornerH, strideH)); -} - -leftTopCornerD = (PublicAdd(leftTopCornerD, strideD)); -} - -} -} - -void Conv3D_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadDLeft, uint64_t zPadDRight, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ - -uint64_t reshapedFilterRows = CO; - -uint64_t reshapedFilterCols = (PublicMult((PublicMult((PublicMult(FD, FH)), FW)), CI)); - -uint64_t reshapedIPRows = (PublicMult((PublicMult((PublicMult(FD, FH)), FW)), CI)); - -uint64_t newD = (PublicAdd((PublicDiv((PublicSub((PublicAdd(D, (PublicAdd(zPadDLeft, zPadDRight)))), FD)), strideD)), (int32_t)1)); - -uint64_t newH = (PublicAdd((PublicDiv((PublicSub((PublicAdd(H, (PublicAdd(zPadHLeft, zPadHRight)))), FH)), strideH)), (int32_t)1)); - -uint64_t newW = (PublicAdd((PublicDiv((PublicSub((PublicAdd(W, (PublicAdd(zPadWLeft, zPadWRight)))), FW)), strideW)), (int32_t)1)); - -uint64_t reshapedIPCols = (PublicMult((PublicMult((PublicMult(N, newD)), newH)), newW)); - -auto filterReshaped = make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); - -auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); - -auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); -Conv3DReshapeFilter_pt(FD, FH, FW, CI, CO, filterArr, filterReshaped); -Conv3DReshapeInput_pt(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP_pt(N, newD, newH, newW, CO, matmulOP, outArr); -ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void Conv3DLoopInner_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadDLeft, uint64_t zPadDRight, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, uint64_t outD, uint64_t outH, uint64_t outW, auto& inputArr, auto& filterArr, auto& outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = (int64_t)0; -for (uint64_t fd = (PublicMult(d, strideD)); fd < (PublicAdd((PublicMult(d, strideD)), FD)); fd++){ -for (uint64_t fh = (PublicMult(h, strideH)); fh < (PublicAdd((PublicMult(h, strideH)), FH)); fh++){ -for (uint64_t fw = (PublicMult(w, strideW)); fw < (PublicAdd((PublicMult(w, strideW)), FW)); fw++){ - -uint64_t curPosD = (PublicSub(fd, zPadDLeft)); - -uint64_t curPosH = (PublicSub(fh, zPadHLeft)); - -uint64_t curPosW = (PublicSub(fw, zPadWLeft)); -if (((((((PublicGTE(curPosD, (int32_t)0)) && (PublicGTE(curPosH, (int32_t)0))) && (PublicGTE(curPosW, (int32_t)0))) && (PublicLT(curPosD, D))) && (PublicLT(curPosH, H))) && (PublicLT(curPosW, W)))) { - -uint64_t curFilterPosD = (PublicSub(fd, (PublicMult(d, strideD)))); - -uint64_t curFilterPosH = (PublicSub(fh, (PublicMult(h, strideH)))); - -uint64_t curFilterPosW = (PublicSub(fw, (PublicMult(w, strideW)))); -val = (PublicAdd(val, (PublicMult(inputArr[n][curPosD][curPosH][curPosW][ci], filterArr[curFilterPosD][curFilterPosH][curFilterPosW][ci][co])))); -} -} -} -} -outArr[n][d][h][w][co] = (PublicAdd(outArr[n][d][h][w][co], val)); -} -} -} -} -} -} -} - -void Conv3DLoop_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadDLeft, uint64_t zPadDRight, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ - -uint64_t outD = (PublicAdd((PublicDiv((PublicAdd((PublicSub(D, FD)), (PublicAdd(zPadDLeft, zPadDRight)))), strideD)), (int32_t)1)); - -uint64_t outH = (PublicAdd((PublicDiv((PublicAdd((PublicSub(H, FH)), (PublicAdd(zPadHLeft, zPadHRight)))), strideH)), (int32_t)1)); - -uint64_t outW = (PublicAdd((PublicDiv((PublicAdd((PublicSub(W, FW)), (PublicAdd(zPadWLeft, zPadWRight)))), strideW)), (int32_t)1)); -Conv3DLoopInner_pt(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, outD, outH, outW, inputArr, filterArr, outArr); -} - -void ConvTranspose2DReshapeMatMulOP_pt(uint64_t N, uint64_t finalH, uint64_t finalW, uint64_t CO, auto& inputArr, auto& outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t h = (int32_t)0; h < finalH; h++){ -for (uint64_t w = (int32_t)0; w < finalW; w++){ -outputArr[n][h][w][co] = inputArr[co][(PublicAdd((PublicAdd((PublicMult((PublicMult(n, finalH)), finalW)), (PublicMult(h, finalW)))), w))]; -} -} -} -} -} - -void ConvTranspose2DReshapeFilter_pt(uint64_t FH, uint64_t FW, uint64_t CO, uint64_t CI, auto& inputArr, auto& outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CI)), (PublicMult(fw, CI)))), ci)); -outputArr[co][linIdx] = inputArr[(PublicSub((PublicSub(FH, (int32_t)1)), fh))][(PublicSub((PublicSub(FW, (int32_t)1)), fw))][co][ci]; -} -} -} -} -} - -void ConvTranspose2DReshapeInput_pt(uint64_t N, uint64_t HPrime, uint64_t WPrime, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t zPadTrHLeft, uint64_t zPadTrHRight, uint64_t zPadTrWLeft, uint64_t zPadTrWRight, uint64_t strideH, uint64_t strideW, uint64_t RRows, uint64_t RCols, auto& inputArr, auto& outputArr){ - -uint64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -uint64_t leftTopCornerH = (PublicSub( (int32_t)0, zPadTrHLeft)); - -uint64_t HPrimeTilde = (PublicAdd(HPrime, (PublicMult((PublicSub(HPrime, (int32_t)1)), (PublicSub(strideH, (int32_t)1)))))); - -uint64_t extremeRightBottomCornerH = (PublicAdd((PublicSub(HPrimeTilde, (int32_t)1)), zPadTrHRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), extremeRightBottomCornerH))) { - -uint64_t leftTopCornerW = (PublicSub( (int32_t)0, zPadTrWLeft)); - -uint64_t WPrimeTilde = (PublicAdd(WPrime, (PublicMult((PublicSub(WPrime, (int32_t)1)), (PublicSub(strideW, (int32_t)1)))))); - -uint64_t extremeRightBottomCornerW = (PublicAdd((PublicSub(WPrimeTilde, (int32_t)1)), zPadTrWRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), extremeRightBottomCornerW))) { -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); - -uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); - -uint64_t val = (int64_t)0; -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if ((((PublicLT(curPosH, (int32_t)0)) || (PublicGTE(curPosH, HPrimeTilde))) || ((PublicLT(curPosW, (int32_t)0)) || (PublicGTE(curPosW, WPrimeTilde))))) { -val = (int64_t)0; -} else { -if ((((PublicMod(curPosH, strideH)) == (int32_t)0) && ((PublicMod(curPosW, strideW)) == (int32_t)0))) { - -uint64_t idxInputH = (PublicDiv(curPosH, strideH)); - -uint64_t idxInputW = (PublicDiv(curPosW, strideW)); -val = inputArr[n][idxInputH][idxInputW][ci]; -} else { -val = (int64_t)0; -} -} -outputArr[(PublicAdd((PublicAdd((PublicMult((PublicMult(fh, FW)), CI)), (PublicMult(fw, CI)))), ci))][linIdxFilterMult] = val; -} -} -} -linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); -leftTopCornerW = (PublicAdd(leftTopCornerW, (int32_t)1)); -} - -leftTopCornerH = (PublicAdd(leftTopCornerH, (int32_t)1)); -} - -} -} - -void ConvTranspose2D_pt(uint64_t N, uint64_t HPrime, uint64_t WPrime, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t H, uint64_t W, uint64_t zPadTrHLeft, uint64_t zPadTrHRight, uint64_t zPadTrWLeft, uint64_t zPadTrWRight, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ - -uint64_t reshapedFilterRows = CO; - -uint64_t reshapedFilterCols = (PublicMult((PublicMult(FH, FW)), CI)); - -uint64_t reshapedIPRows = (PublicMult((PublicMult(FH, FW)), CI)); - -uint64_t reshapedIPCols = (PublicMult((PublicMult(N, H)), W)); - -auto filterReshaped = make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); - -auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); - -auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); -ConvTranspose2DReshapeFilter_pt(FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose2DReshapeInput_pt(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -ConvTranspose2DReshapeMatMulOP_pt(N, H, W, CO, matmulOP, outArr); -ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DReshapeFilter_pt(uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t CI, auto& inputArr, auto& outputArr){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(fd, FH)), FW)), CI)), (PublicMult((PublicMult(fh, FW)), CI)))), (PublicMult(fw, CI)))), ci)); -outputArr[co][linIdx] = inputArr[(PublicSub((PublicSub(FD, (int32_t)1)), fd))][(PublicSub((PublicSub(FH, (int32_t)1)), fh))][(PublicSub((PublicSub(FW, (int32_t)1)), fw))][co][ci]; -} -} -} -} -} -} - -void ConvTranspose3DReshapeInput_pt(uint64_t N, uint64_t DPrime, uint64_t HPrime, uint64_t WPrime, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t zPadTrDLeft, uint64_t zPadTrDRight, uint64_t zPadTrHLeft, uint64_t zPadTrHRight, uint64_t zPadTrWLeft, uint64_t zPadTrWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, uint64_t RRows, uint64_t RCols, auto& inputArr, auto& outputArr){ - -uint64_t linIdxFilterMult = (int32_t)0; -for (uint64_t n = (int32_t)0; n < N; n++){ - -uint64_t leftTopCornerD = (PublicSub( (int32_t)0, zPadTrDLeft)); - -uint64_t DPrimeTilde = (PublicAdd(DPrime, (PublicMult((PublicSub(DPrime, (int32_t)1)), (PublicSub(strideD, (int32_t)1)))))); - -uint64_t extremeRightBottomCornerD = (PublicAdd((PublicSub(DPrimeTilde, (int32_t)1)), zPadTrDRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerD, FD)), (int32_t)1)), extremeRightBottomCornerD))) { - -uint64_t leftTopCornerH = (PublicSub( (int32_t)0, zPadTrHLeft)); - -uint64_t HPrimeTilde = (PublicAdd(HPrime, (PublicMult((PublicSub(HPrime, (int32_t)1)), (PublicSub(strideH, (int32_t)1)))))); - -uint64_t extremeRightBottomCornerH = (PublicAdd((PublicSub(HPrimeTilde, (int32_t)1)), zPadTrHRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerH, FH)), (int32_t)1)), extremeRightBottomCornerH))) { - -uint64_t leftTopCornerW = (PublicSub( (int32_t)0, zPadTrWLeft)); - -uint64_t WPrimeTilde = (PublicAdd(WPrime, (PublicMult((PublicSub(WPrime, (int32_t)1)), (PublicSub(strideW, (int32_t)1)))))); - -uint64_t extremeRightBottomCornerW = (PublicAdd((PublicSub(WPrimeTilde, (int32_t)1)), zPadTrWRight)); -while ((PublicLTE((PublicSub((PublicAdd(leftTopCornerW, FW)), (int32_t)1)), extremeRightBottomCornerW))) { -for (uint64_t fd = (int32_t)0; fd < FD; fd++){ -for (uint64_t fh = (int32_t)0; fh < FH; fh++){ -for (uint64_t fw = (int32_t)0; fw < FW; fw++){ - -uint64_t curPosD = (PublicAdd(leftTopCornerD, fd)); - -uint64_t curPosH = (PublicAdd(leftTopCornerH, fh)); - -uint64_t curPosW = (PublicAdd(leftTopCornerW, fw)); - -uint64_t val = (int64_t)0; -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ -if (((((PublicLT(curPosD, (int32_t)0)) || (PublicGTE(curPosD, DPrimeTilde))) || ((PublicLT(curPosH, (int32_t)0)) || (PublicGTE(curPosH, HPrimeTilde)))) || ((PublicLT(curPosW, (int32_t)0)) || (PublicGTE(curPosW, WPrimeTilde))))) { -val = (int64_t)0; -} else { -if (((((PublicMod(curPosD, strideD)) == (int32_t)0) && ((PublicMod(curPosH, strideH)) == (int32_t)0)) && ((PublicMod(curPosW, strideW)) == (int32_t)0))) { - -uint64_t idxInputD = (PublicDiv(curPosD, strideD)); - -uint64_t idxInputH = (PublicDiv(curPosH, strideH)); - -uint64_t idxInputW = (PublicDiv(curPosW, strideW)); -val = inputArr[n][idxInputD][idxInputH][idxInputW][ci]; -} else { -val = (int64_t)0; -} -} -outputArr[(PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(fd, FH)), FW)), CI)), (PublicMult((PublicMult(fh, FW)), CI)))), (PublicMult(fw, CI)))), ci))][linIdxFilterMult] = val; -} -} -} -} -linIdxFilterMult = (PublicAdd(linIdxFilterMult, (int32_t)1)); -leftTopCornerW = (PublicAdd(leftTopCornerW, (int32_t)1)); -} - -leftTopCornerH = (PublicAdd(leftTopCornerH, (int32_t)1)); -} - -leftTopCornerD = (PublicAdd(leftTopCornerD, (int32_t)1)); -} - -} -} - -void ConvTranspose3D_pt(uint64_t N, uint64_t DPrime, uint64_t HPrime, uint64_t WPrime, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t D, uint64_t H, uint64_t W, uint64_t zPadTrDLeft, uint64_t zPadTrDRight, uint64_t zPadTrHLeft, uint64_t zPadTrHRight, uint64_t zPadTrWLeft, uint64_t zPadTrWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ - -uint64_t reshapedFilterRows = CO; - -uint64_t reshapedFilterCols = (PublicMult((PublicMult((PublicMult(FD, FH)), FW)), CI)); - -uint64_t reshapedIPRows = (PublicMult((PublicMult((PublicMult(FD, FH)), FW)), CI)); - -uint64_t reshapedIPCols = (PublicMult((PublicMult((PublicMult(N, D)), H)), W)); - -auto filterReshaped = make_vector<uint64_t>(reshapedFilterRows, reshapedFilterCols); - -auto inputReshaped = make_vector<uint64_t>(reshapedIPRows, reshapedIPCols); - -auto matmulOP = make_vector<uint64_t>(reshapedFilterRows, reshapedIPCols); -ConvTranspose3DReshapeFilter_pt(FD, FH, FW, CO, CI, filterArr, filterReshaped); -ConvTranspose3DReshapeInput_pt(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped); -MatMul2D_pt(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, filterReshaped, inputReshaped, matmulOP, 1); -Conv3DReshapeMatMulOP_pt(N, D, H, W, CO, matmulOP, outArr); -ClearMemSecret2_pt(reshapedFilterRows, reshapedFilterCols, filterReshaped); -ClearMemSecret2_pt(reshapedIPRows, reshapedIPCols, inputReshaped); -ClearMemSecret2_pt(reshapedFilterRows, reshapedIPCols, matmulOP); -} - -void ConvTranspose3DLoopInner_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadDLeft, uint64_t zPadDRight, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, uint64_t outD, uint64_t outH, uint64_t outW, auto& inputArr, auto& filterArr, auto& outArr){ -for (uint64_t n = (int32_t)0; n < N; n++){ -for (uint64_t co = (int32_t)0; co < CO; co++){ -for (uint64_t d = (int32_t)0; d < outD; d++){ -for (uint64_t h = (int32_t)0; h < outH; h++){ -for (uint64_t w = (int32_t)0; w < outW; w++){ -for (uint64_t ci = (int32_t)0; ci < CI; ci++){ - -uint64_t val = (int64_t)0; -for (uint64_t fd = d; fd < (PublicAdd(d, FD)); fd++){ -for (uint64_t fh = h; fh < (PublicAdd(h, FH)); fh++){ -for (uint64_t fw = w; fw < (PublicAdd(w, FW)); fw++){ - -uint64_t curPosD = (PublicDiv((PublicSub(fd, zPadDLeft)), strideD)); - -uint64_t curPosH = (PublicDiv((PublicSub(fh, zPadHLeft)), strideD)); - -uint64_t curPosW = (PublicDiv((PublicSub(fw, zPadWLeft)), strideD)); -if ((((((((((PublicGTE(curPosD, (int32_t)0)) && (PublicGTE(curPosH, (int32_t)0))) && (PublicGTE(curPosW, (int32_t)0))) && (PublicLT(curPosD, D))) && (PublicLT(curPosH, H))) && (PublicLT(curPosW, W))) && ((PublicMod((PublicSub(fd, zPadDLeft)), strideD)) == (int32_t)0)) && ((PublicMod((PublicSub(fh, zPadHLeft)), strideH)) == (int32_t)0)) && ((PublicMod((PublicSub(fw, zPadWLeft)), strideW)) == (int32_t)0))) { - -uint64_t curFilterPosD = (PublicSub((PublicSub((PublicAdd(FD, d)), fd)), (int32_t)1)); - -uint64_t curFilterPosH = (PublicSub((PublicSub((PublicAdd(FH, h)), fh)), (int32_t)1)); - -uint64_t curFilterPosW = (PublicSub((PublicSub((PublicAdd(FW, w)), fw)), (int32_t)1)); -val = (PublicAdd(val, (PublicMult(inputArr[n][curPosD][curPosH][curPosW][ci], filterArr[curFilterPosD][curFilterPosH][curFilterPosW][co][ci])))); -} -} -} -} -outArr[n][d][h][w][co] = (PublicAdd(outArr[n][d][h][w][co], val)); -} -} -} -} -} -} -} - -void ConvTranspose3DLoop_pt(uint64_t N, uint64_t DPrime, uint64_t HPrime, uint64_t WPrime, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t D, uint64_t H, uint64_t W, uint64_t zPadTrDLeft, uint64_t zPadTrDRight, uint64_t zPadTrHLeft, uint64_t zPadTrHRight, uint64_t zPadTrWLeft, uint64_t zPadTrWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ -ConvTranspose3DLoopInner_pt(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, D, H, W, inputArr, filterArr, outArr); -} - -void Transpose2_pt(uint64_t s1, uint64_t s2, auto& inArr, auto& outArr){ -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -outArr[i][j] = inArr[j][i]; -} -} -} - -void Pad442_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t inps1, uint64_t inps2, uint64_t inps3, uint64_t inps4, auto& inpArr, uint64_t pads1, uint64_t pads2, auto& paddings, auto& outArr){ - -uint64_t lbounds1 = paddings[ (int32_t)0][ (int32_t)0]; - -uint64_t rbounds1excl = (PublicSub(s1, paddings[ (int32_t)0][ (int32_t)1])); - -uint64_t lbounds2 = paddings[ (int32_t)1][ (int32_t)0]; - -uint64_t rbounds2excl = (PublicSub(s2, paddings[ (int32_t)1][ (int32_t)1])); - -uint64_t lbounds3 = paddings[ (int32_t)2][ (int32_t)0]; - -uint64_t rbounds3excl = (PublicSub(s3, paddings[ (int32_t)2][ (int32_t)1])); - -uint64_t lbounds4 = paddings[ (int32_t)3][ (int32_t)0]; - -uint64_t rbounds4excl = (PublicSub(s4, paddings[ (int32_t)3][ (int32_t)1])); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -if (((((((((PublicGTE(i, lbounds1)) && (PublicLT(i, rbounds1excl))) && (PublicGTE(j, lbounds2))) && (PublicLT(j, rbounds2excl))) && (PublicGTE(k, lbounds3))) && (PublicLT(k, rbounds3excl))) && (PublicGTE(l, lbounds4))) && (PublicLT(l, rbounds4excl)))) { -outArr[i][j][k][l] = inpArr[(PublicSub(i, paddings[ (int32_t)0][ (int32_t)0]))][(PublicSub(j, paddings[ (int32_t)1][ (int32_t)0]))][(PublicSub(k, paddings[ (int32_t)2][ (int32_t)0]))][(PublicSub(l, paddings[ (int32_t)3][ (int32_t)0]))]; -} else { -outArr[i][j][k][l] = (int64_t)0; -} -} -} -} -} -} - -void Pad552_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, uint64_t inps1, uint64_t inps2, uint64_t inps3, uint64_t inps4, uint64_t inps5, auto& inpArr, uint64_t pads1, uint64_t pads2, auto& paddings, auto& outArr){ - -uint64_t lbounds1 = paddings[ (int32_t)0][ (int32_t)0]; - -uint64_t rbounds1excl = (PublicSub(s1, paddings[ (int32_t)0][ (int32_t)1])); - -uint64_t lbounds2 = paddings[ (int32_t)1][ (int32_t)0]; - -uint64_t rbounds2excl = (PublicSub(s2, paddings[ (int32_t)1][ (int32_t)1])); - -uint64_t lbounds3 = paddings[ (int32_t)2][ (int32_t)0]; - -uint64_t rbounds3excl = (PublicSub(s3, paddings[ (int32_t)2][ (int32_t)1])); - -uint64_t lbounds4 = paddings[ (int32_t)3][ (int32_t)0]; - -uint64_t rbounds4excl = (PublicSub(s4, paddings[ (int32_t)3][ (int32_t)1])); - -uint64_t lbounds5 = paddings[ (int32_t)4][ (int32_t)0]; - -uint64_t rbounds5excl = (PublicSub(s5, paddings[ (int32_t)4][ (int32_t)1])); -for (uint64_t i = (int32_t)0; i < s1; i++){ -for (uint64_t j = (int32_t)0; j < s2; j++){ -for (uint64_t k = (int32_t)0; k < s3; k++){ -for (uint64_t l = (int32_t)0; l < s4; l++){ -for (uint64_t m = (int32_t)0; m < s5; m++){ -if (((((((((((PublicGTE(i, lbounds1)) && (PublicLT(i, rbounds1excl))) && (PublicGTE(j, lbounds2))) && (PublicLT(j, rbounds2excl))) && (PublicGTE(k, lbounds3))) && (PublicLT(k, rbounds3excl))) && (PublicGTE(l, lbounds4))) && (PublicLT(l, rbounds4excl))) && (PublicGTE(m, lbounds5))) && (PublicLT(m, rbounds5excl)))) { -outArr[i][j][k][l][m] = inpArr[(PublicSub(i, paddings[ (int32_t)0][ (int32_t)0]))][(PublicSub(j, paddings[ (int32_t)1][ (int32_t)0]))][(PublicSub(k, paddings[ (int32_t)2][ (int32_t)0]))][(PublicSub(l, paddings[ (int32_t)3][ (int32_t)0]))][(PublicSub(m, paddings[ (int32_t)4][ (int32_t)0]))]; -} else { -outArr[i][j][k][l][m] = (int64_t)0; -} -} -} -} -} -} -} - -void PadONNX441_pt(uint64_t o1, uint64_t o2, uint64_t o3, uint64_t o4, uint64_t i1, uint64_t i2, uint64_t i3, uint64_t i4, auto& inpArr, uint64_t pads, auto& paddings, auto& outArr){ - -uint64_t lbounds1 = paddings[ (int32_t)0]; - -uint64_t rbounds1excl = (PublicSub(o1, paddings[ (int32_t)4])); - -uint64_t lbounds2 = paddings[ (int32_t)1]; - -uint64_t rbounds2excl = (PublicSub(o2, paddings[ (int32_t)5])); - -uint64_t lbounds3 = paddings[ (int32_t)2]; - -uint64_t rbounds3excl = (PublicSub(o3, paddings[ (int32_t)6])); - -uint64_t lbounds4 = paddings[ (int32_t)3]; - -uint64_t rbounds4excl = (PublicSub(o4, paddings[ (int32_t)7])); -for (uint64_t i = (int32_t)0; i < o1; i++){ -for (uint64_t j = (int32_t)0; j < o2; j++){ -for (uint64_t k = (int32_t)0; k < o3; k++){ -for (uint64_t l = (int32_t)0; l < o4; l++){ -if (((((((((PublicGTE(i, lbounds1)) && (PublicLT(i, rbounds1excl))) && (PublicGTE(j, lbounds2))) && (PublicLT(j, rbounds2excl))) && (PublicGTE(k, lbounds3))) && (PublicLT(k, rbounds3excl))) && (PublicGTE(l, lbounds4))) && (PublicLT(l, rbounds4excl)))) { -outArr[i][j][k][l] = inpArr[(PublicSub(i, paddings[ (int32_t)0]))][(PublicSub(j, paddings[ (int32_t)1]))][(PublicSub(k, paddings[ (int32_t)2]))][(PublicSub(l, paddings[ (int32_t)3]))]; -} else { -outArr[i][j][k][l] = (int64_t)0; -} -} -} -} -} -} - -void Squeeze24_pt(uint64_t s1, uint64_t s2, uint64_t dim1, uint64_t dim2, uint64_t ins1, uint64_t ins2, uint64_t ins3, uint64_t ins4, auto& inArr, auto& outArr){ -for (uint64_t i = (int32_t)0; i < ins1; i++){ -for (uint64_t j = (int32_t)0; j < ins2; j++){ -for (uint64_t k = (int32_t)0; k < ins3; k++){ -for (uint64_t l = (int32_t)0; l < ins4; l++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i, ins2)), ins3)), ins4)), (PublicMult((PublicMult(j, ins3)), ins4)))), (PublicMult(k, ins4)))), l)); - -uint64_t outIdx1 = (PublicDiv(linIdx, s2)); - -uint64_t outIdx2 = (PublicMod(linIdx, s2)); -outArr[outIdx1][outIdx2] = inArr[i][j][k][l]; -} -} -} -} -} - -void FusedBatchNorm4411_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& inArr, auto& multArr, auto& biasArr, uint64_t multExprScaleDownSf, uint64_t biasExprScaleUpSf, auto& outputArr){ - -uint64_t inpSize = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); - -auto inArrReshaped = make_vector<uint64_t>(inpSize); - -auto multArrReshaped = make_vector<uint64_t>(inpSize); - -auto multExprAns = make_vector<uint64_t>(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -inArrReshaped[linIdx] = inArr[i1][i2][i3][i4]; -multArrReshaped[linIdx] = multArr[i4]; -} -} -} -} -ElemWiseActModelVectorMult_pt(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((PublicGT(multExprScaleDownSf, (int32_t)0))) { -ScaleDown_pt(inpSize, multExprAns, multExprScaleDownSf); -} - -auto biasArrScaledUp = make_vector<uint64_t>(s4); -for (uint64_t ii = (int32_t)0; ii < s4; ii++){ -biasArrScaledUp[ii] = biasArr[ii]; -} -if ((PublicGT(biasExprScaleUpSf, (int32_t)0))) { -ScaleUp_pt(s4, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -outputArr[i1][i2][i3][i4] = (PublicAdd(multExprAns[linIdx], biasArrScaledUp[i4])); -} -} -} -} -ClearMemSecret1_pt(inpSize, inArrReshaped); -ClearMemSecret1_pt(inpSize, multArrReshaped); -ClearMemSecret1_pt(inpSize, multExprAns); -ClearMemSecret1_pt(s4, biasArrScaledUp); -} - -void FusedBatchNorm5511_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, auto& inArr, auto& multArr, auto& biasArr, uint64_t multExprScaleDownSf, uint64_t biasExprScaleUpSf, auto& outputArr){ - -uint64_t inpSize = (PublicMult((PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)), s5)); - -auto inArrReshaped = make_vector<uint64_t>(inpSize); - -auto multArrReshaped = make_vector<uint64_t>(inpSize); - -auto multExprAns = make_vector<uint64_t>(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), s5)), (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), s5)))), (PublicMult((PublicMult(i3, s4)), s5)))), (PublicMult(i4, s5)))), i5)); -inArrReshaped[linIdx] = inArr[i1][i2][i3][i4][i5]; -multArrReshaped[linIdx] = multArr[i5]; -} -} -} -} -} -ElemWiseActModelVectorMult_pt(inpSize, inArrReshaped, multArrReshaped, multExprAns); -if ((PublicGT(multExprScaleDownSf, (int32_t)0))) { -ScaleDown_pt(inpSize, multExprAns, multExprScaleDownSf); -} - -auto biasArrScaledUp = make_vector<uint64_t>(s5); -for (uint64_t ii = (int32_t)0; ii < s5; ii++){ -biasArrScaledUp[ii] = biasArr[ii]; -} -if ((PublicGT(biasExprScaleUpSf, (int32_t)0))) { -ScaleUp_pt(s5, biasArrScaledUp, biasExprScaleUpSf); -} -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), s5)), (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), s5)))), (PublicMult((PublicMult(i3, s4)), s5)))), (PublicMult(i4, s5)))), i5)); -outputArr[i1][i2][i3][i4][i5] = (PublicAdd(multExprAns[linIdx], biasArrScaledUp[i5])); -} -} -} -} -} -ClearMemSecret1_pt(inpSize, inArrReshaped); -ClearMemSecret1_pt(inpSize, multArrReshaped); -ClearMemSecret1_pt(inpSize, multExprAns); -ClearMemSecret1_pt(s5, biasArrScaledUp); -} - -void ElemWiseMul2_pt(uint64_t s1, uint64_t s2, auto& arr1, auto& arr2, auto& outArr){ - -uint64_t inpSize = (PublicMult(s1, s2)); - -auto arr1Reshaped = make_vector<uint64_t>(inpSize); - -auto arr2Reshaped = make_vector<uint64_t>(inpSize); - -auto outArrReshaped = make_vector<uint64_t>(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -arr1Reshaped[linIdx] = arr1[i1][i2]; -arr2Reshaped[linIdx] = arr2[i1][i2]; -} -} -ElemWiseSecretSharedVectorMult_pt(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -outArr[i1][i2] = outArrReshaped[linIdx]; -} -} -ClearMemSecret1_pt(inpSize, arr1Reshaped); -ClearMemSecret1_pt(inpSize, arr2Reshaped); -ClearMemSecret1_pt(inpSize, outArrReshaped); -} - -void ElemWiseMul4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& arr1, auto& arr2, auto& outArr){ - -uint64_t inpSize = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); - -auto arr1Reshaped = make_vector<uint64_t>(inpSize); - -auto arr2Reshaped = make_vector<uint64_t>(inpSize); - -auto outArrReshaped = make_vector<uint64_t>(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -arr1Reshaped[linIdx] = arr1[i1][i2][i3][i4]; -arr2Reshaped[linIdx] = arr2[i1][i2][i3][i4]; -} -} -} -} -ElemWiseSecretSharedVectorMult_pt(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -outArr[i1][i2][i3][i4] = outArrReshaped[linIdx]; -} -} -} -} -ClearMemSecret1_pt(inpSize, arr1Reshaped); -ClearMemSecret1_pt(inpSize, arr2Reshaped); -ClearMemSecret1_pt(inpSize, outArrReshaped); -} - -void ElemWiseMul5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, auto& arr1, auto& arr2, auto& outArr){ - -uint64_t inpSize = (PublicMult((PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)), s5)); - -auto arr1Reshaped = make_vector<uint64_t>(inpSize); - -auto arr2Reshaped = make_vector<uint64_t>(inpSize); - -auto outArrReshaped = make_vector<uint64_t>(inpSize); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), s5)), (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), s5)))), (PublicMult((PublicMult(i3, s4)), s5)))), (PublicMult(i4, s5)))), i5)); -arr1Reshaped[linIdx] = arr1[i1][i2][i3][i4][i5]; -arr2Reshaped[linIdx] = arr2[i1][i2][i3][i4][i5]; -} -} -} -} -} -ElemWiseSecretSharedVectorMult_pt(inpSize, arr1Reshaped, arr2Reshaped, outArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), s5)), (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), s5)))), (PublicMult((PublicMult(i3, s4)), s5)))), (PublicMult(i4, s5)))), i5)); -outArr[i1][i2][i3][i4][i5] = outArrReshaped[linIdx]; -} -} -} -} -} -ClearMemSecret1_pt(inpSize, arr1Reshaped); -ClearMemSecret1_pt(inpSize, arr2Reshaped); -ClearMemSecret1_pt(inpSize, outArrReshaped); -} - -void ReduceMean24_pt(uint64_t outS1, uint64_t outS2, uint64_t inS1, uint64_t inS2, uint64_t inS3, uint64_t inS4, auto& inputArr, auto& axes, auto& outputArr){ - -uint64_t divisor = (PublicMult(inS2, inS3)); - -uint64_t outputSize = (PublicMult(outS1, outS2)); - -auto sumArr = make_vector<uint64_t>(outputSize); - -auto outputArrReshaped = make_vector<uint64_t>(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = (int64_t)0; -for (uint64_t i = (int32_t)0; i < inS2; i++){ -for (uint64_t j = (int32_t)0; j < inS3; j++){ -summ = (PublicAdd(summ, inputArr[i1][i][j][i2])); -} -} -sumArr[(PublicAdd((PublicMult(i1, outS2)), i2))] = summ; -} -} -ElemWiseVectorPublicDiv_pt(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -outputArr[i1][i2] = outputArrReshaped[(PublicAdd((PublicMult(i1, outS2)), i2))]; -} -} -ClearMemSecret1_pt(outputSize, sumArr); -ClearMemSecret1_pt(outputSize, outputArrReshaped); -} - -void ReduceMeanONNX24_pt(uint64_t outS1, uint64_t outS2, uint64_t inS1, uint64_t inS2, uint64_t inS3, uint64_t inS4, auto& inputArr, uint64_t axis1, uint64_t axis2, auto& outputArr){ - -uint64_t divisor = (PublicMult(inS3, inS4)); - -uint64_t outputSize = (PublicMult(outS1, outS2)); - -auto sumArr = make_vector<uint64_t>(outputSize); - -auto outputArrReshaped = make_vector<uint64_t>(outputSize); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ - -uint64_t summ = (int64_t)0; -for (uint64_t i = (int32_t)0; i < inS3; i++){ -for (uint64_t j = (int32_t)0; j < inS4; j++){ -summ = (PublicAdd(summ, inputArr[i1][i2][i][j])); -} -} -sumArr[(PublicAdd((PublicMult(i1, outS2)), i2))] = summ; -} -} -ElemWiseVectorPublicDiv_pt(outputSize, sumArr, divisor, outputArrReshaped); -for (uint64_t i1 = (int32_t)0; i1 < outS1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < outS2; i2++){ -outputArr[i1][i2] = outputArrReshaped[(PublicAdd((PublicMult(i1, outS2)), i2))]; -} -} -ClearMemSecret1_pt(outputSize, sumArr); -ClearMemSecret1_pt(outputSize, outputArrReshaped); -} - -void ArgMax1_pt(uint64_t outArrS1, uint64_t inArrS1, uint64_t inArrS2, auto& inArr, uint64_t dim, auto& outArr){ -ArgMax(inArrS1, inArrS2, inArr, outArr); -} - -void ArgMax3_pt(uint64_t outs1, uint64_t outs2, uint64_t outs3, uint64_t ins1, uint64_t ins2, uint64_t ins3, uint64_t ins4, auto& inArr, uint64_t dim, auto& outArr){ - -uint64_t size = (PublicMult((PublicMult(ins1, ins2)), ins3)); - -auto reshapedInArr = make_vector<uint64_t>(size, ins4); - -auto reshapedOutArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < ins4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, ins2)), ins3)), (PublicMult(i2, ins3)))), i3)); -reshapedInArr[linIdx][i4] = inArr[i1][i2][i3][i4]; -} -} -} -} -ArgMax_pt(size, ins4, reshapedInArr, reshapedOutArr); -for (uint64_t i1 = (int32_t)0; i1 < ins1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < ins2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < ins3; i3++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, ins2)), ins3)), (PublicMult(i2, ins3)))), i3)); -outArr[i1][i2][i3] = reshapedOutArr[linIdx]; -} -} -} -ClearMemSecret2_pt(size, ins4, reshapedInArr); -ClearMemSecret1_pt(size, reshapedOutArr); -} - -void Relu2_pt(uint64_t s1, uint64_t s2, auto& inArr, auto& outArr, uint64_t sf, uint64_t doTruncation){ - -uint64_t size = (PublicMult(s1, s2)); - -auto reshapedInArr = make_vector<uint64_t>(size); - -auto reshapedOutArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -reshapedInArr[linIdx] = inArr[i1][i2]; -} -} -Relu_pt(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -outArr[i1][i2] = reshapedOutArr[linIdx]; -} -} -ClearMemSecret1_pt(size, reshapedInArr); -ClearMemSecret1_pt(size, reshapedOutArr); -} - -void Relu4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& inArr, auto& outArr, uint64_t sf, uint64_t doTruncation){ - -uint64_t size = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); - -auto reshapedInArr = make_vector<uint64_t>(size); - -auto reshapedOutArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -reshapedInArr[linIdx] = inArr[i1][i2][i3][i4]; -} -} -} -} -Relu_pt(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -outArr[i1][i2][i3][i4] = reshapedOutArr[linIdx]; -} -} -} -} -ClearMemSecret1_pt(size, reshapedInArr); -ClearMemSecret1_pt(size, reshapedOutArr); -} - -void Relu5_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, uint64_t s5, auto& inArr, auto& outArr, uint64_t sf, uint64_t doTruncation){ - -uint64_t size = (PublicMult((PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)), s5)); - -auto reshapedInArr = make_vector<uint64_t>(size); - -auto reshapedOutArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), s5)), (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), s5)))), (PublicMult((PublicMult(i3, s4)), s5)))), (PublicMult(i4, s5)))), i5)); -reshapedInArr[linIdx] = inArr[i1][i2][i3][i4][i5]; -} -} -} -} -} -Relu_pt(size, reshapedInArr, reshapedOutArr, sf, doTruncation); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ -for (uint64_t i5 = (int32_t)0; i5 < s5; i5++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), s5)), (PublicMult((PublicMult((PublicMult(i2, s3)), s4)), s5)))), (PublicMult((PublicMult(i3, s4)), s5)))), (PublicMult(i4, s5)))), i5)); -outArr[i1][i2][i3][i4][i5] = reshapedOutArr[linIdx]; -} -} -} -} -} -ClearMemSecret1_pt(size, reshapedInArr); -ClearMemSecret1_pt(size, reshapedOutArr); -} - -void Floor2_pt(uint64_t s1, uint64_t s2, auto& inArr, auto& outArr, uint64_t sf){ - -uint64_t size = (PublicMult(s1, s2)); - -auto reshapedInArr = make_vector<uint64_t>(size); - -auto reshapedOutArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -reshapedInArr[linIdx] = inArr[i1][i2]; -} -} -Floor_pt(size, reshapedInArr, reshapedOutArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -outArr[i1][i2] = reshapedOutArr[linIdx]; -} -} -ClearMemSecret1_pt(size, reshapedInArr); -ClearMemSecret1_pt(size, reshapedOutArr); -} - -void ScaleUp1_pt(uint64_t s1, auto& arr, uint64_t sf){ -ScaleUp_pt(s1, arr, sf); -} - -void ScaleUp2_pt(uint64_t s1, uint64_t s2, auto& arr, uint64_t sf){ - -uint64_t size = (PublicMult(s1, s2)); - -auto reshapedArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -reshapedArr[linIdx] = arr[i1][i2]; -} -} -ScaleUp_pt(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -arr[i1][i2] = reshapedArr[linIdx]; -} -} -ClearMemSecret1_pt(size, reshapedArr); -} - -void ScaleUp3_pt(uint64_t s1, uint64_t s2, uint64_t s3, auto& arr, uint64_t sf){ - -uint64_t size = (PublicMult((PublicMult(s1, s2)), s3)); - -auto reshapedArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, s2)), s3)), (PublicMult(i2, s3)))), i3)); -reshapedArr[linIdx] = arr[i1][i2][i3]; -} -} -} -ScaleUp_pt(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, s2)), s3)), (PublicMult(i2, s3)))), i3)); -arr[i1][i2][i3] = reshapedArr[linIdx]; -} -} -} -ClearMemSecret1_pt(size, reshapedArr); -} - -void ScaleUp4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& arr, uint64_t sf){ - -uint64_t size = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); - -auto reshapedArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -reshapedArr[linIdx] = arr[i1][i2][i3][i4]; -} -} -} -} -ScaleUp_pt(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -arr[i1][i2][i3][i4] = reshapedArr[linIdx]; -} -} -} -} -ClearMemSecret1_pt(size, reshapedArr); -} - -void ScaleDown1_pt(uint64_t s1, auto& arr, uint64_t sf){ -ScaleDown_pt(s1, arr, sf); -} - -void ScaleDown2_pt(uint64_t s1, uint64_t s2, auto& arr, uint64_t sf){ - -uint64_t size = (PublicMult(s1, s2)); - -auto reshapedArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -reshapedArr[linIdx] = arr[i1][i2]; -} -} -ScaleDown_pt(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ - -uint64_t linIdx = (PublicAdd((PublicMult(i1, s2)), i2)); -arr[i1][i2] = reshapedArr[linIdx]; -} -} -ClearMemSecret1_pt(size, reshapedArr); -} - -void ScaleDown3_pt(uint64_t s1, uint64_t s2, uint64_t s3, auto& arr, uint64_t sf){ - -uint64_t size = (PublicMult((PublicMult(s1, s2)), s3)); - -auto reshapedArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, s2)), s3)), (PublicMult(i2, s3)))), i3)); -reshapedArr[linIdx] = arr[i1][i2][i3]; -} -} -} -ScaleDown_pt(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicMult((PublicMult(i1, s2)), s3)), (PublicMult(i2, s3)))), i3)); -arr[i1][i2][i3] = reshapedArr[linIdx]; -} -} -} -ClearMemSecret1_pt(size, reshapedArr); -} - -void ScaleDown4_pt(uint64_t s1, uint64_t s2, uint64_t s3, uint64_t s4, auto& arr, uint64_t sf){ - -uint64_t size = (PublicMult((PublicMult((PublicMult(s1, s2)), s3)), s4)); - -auto reshapedArr = make_vector<uint64_t>(size); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -reshapedArr[linIdx] = arr[i1][i2][i3][i4]; -} -} -} -} -ScaleDown_pt(size, reshapedArr, sf); -for (uint64_t i1 = (int32_t)0; i1 < s1; i1++){ -for (uint64_t i2 = (int32_t)0; i2 < s2; i2++){ -for (uint64_t i3 = (int32_t)0; i3 < s3; i3++){ -for (uint64_t i4 = (int32_t)0; i4 < s4; i4++){ - -uint64_t linIdx = (PublicAdd((PublicAdd((PublicAdd((PublicMult((PublicMult((PublicMult(i1, s2)), s3)), s4)), (PublicMult((PublicMult(i2, s3)), s4)))), (PublicMult(i3, s4)))), i4)); -arr[i1][i2][i3][i4] = reshapedArr[linIdx]; -} -} -} -} -ClearMemSecret1_pt(size, reshapedArr); -} - -void Conv2DWrapper_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ -Conv2D_pt(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, inputArr, filterArr, outArr); -} - -void Conv3DWrapper_pt(uint64_t N, uint64_t D, uint64_t H, uint64_t W, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadDLeft, uint64_t zPadDRight, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ -Conv3D_pt(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD, strideH, strideW, inputArr, filterArr, outArr); -} - -void Conv2DGroupWrapper_pt(uint64_t N, uint64_t H, uint64_t W, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t zPadHLeft, uint64_t zPadHRight, uint64_t zPadWLeft, uint64_t zPadWRight, uint64_t strideH, uint64_t strideW, uint64_t G, auto& inputArr, auto& filterArr, auto& outArr){ -Conv2DGroup_pt(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, G, inputArr, filterArr, outArr); -} - -void ConvTranspose2DWrapper_pt(uint64_t N, uint64_t HPrime, uint64_t WPrime, uint64_t CI, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t H, uint64_t W, uint64_t zPadTrHLeft, uint64_t zPadTrHRight, uint64_t zPadTrWLeft, uint64_t zPadTrWRight, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ -ConvTranspose2D_pt(N, HPrime, WPrime, CI, FH, FW, CO, H, W, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH, strideW, inputArr, filterArr, outArr); -} - -void ConvTranspose3DWrapper_pt(uint64_t N, uint64_t DPrime, uint64_t HPrime, uint64_t WPrime, uint64_t CI, uint64_t FD, uint64_t FH, uint64_t FW, uint64_t CO, uint64_t D, uint64_t H, uint64_t W, uint64_t zPadTrDLeft, uint64_t zPadTrDRight, uint64_t zPadTrHLeft, uint64_t zPadTrHRight, uint64_t zPadTrWLeft, uint64_t zPadTrWRight, uint64_t strideD, uint64_t strideH, uint64_t strideW, auto& inputArr, auto& filterArr, auto& outArr){ -ConvTranspose3D_pt(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO, D, H, W, zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW, inputArr, filterArr, outArr); -} diff --git a/SCI/src/functionalities_uniform.h b/SCI/src/functionalities_uniform.h new file mode 100644 index 00000000..d499c4e6 --- /dev/null +++ b/SCI/src/functionalities_uniform.h @@ -0,0 +1,1105 @@ +/* +Authors: Nishant Kumar +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef FUNCTIONALITIES_UNIFORM_H__ +#define FUNCTIONALITIES_UNIFORM_H__ + +#include "globals.h" +#include <cmath> + +void funcLocalTruncate(int s, intType *arr, int consSF) { + if (party == SERVER) { + for (int i = 0; i < s; i++) { + arr[i] = + static_cast<intType>((static_cast<signedIntType>(arr[i])) >> consSF); + } + } else if (party == CLIENT) { + for (int i = 0; i < s; i++) { + arr[i] = -static_cast<intType>((static_cast<signedIntType>(-arr[i])) >> + consSF); + } + } else { + assert(false); + } +} + +signedIntType getAnyRingSignedVal(intType x) { + signedIntType ans = x; + if (x > (prime_mod / 2)) { + ans = (x - prime_mod); + } + return ans; +} + +intType funcSSCons(int32_t x) { + /* + Secret share public value x between the two parties. + Corresponding ezpc statement would be int32_al x = 0; + Set one party share as x and other party's share as 0. + */ + if (party == SERVER) { + return x; + } else { + return 0; + } +} + +intType funcSSCons(int64_t x) { + /* + Secret share public value x between the two parties. + Corresponding ezpc statement would be int32_al x = 0; + Set one party share as x and other party's share as 0. + */ + if (party == SERVER) { + return x; + } else { + return 0; + } +} + +inline intType getFieldMsb(intType x) { return (x > (prime_mod / 2)); } + +void funcReconstruct2PCCons(signedIntType *y, const intType *x, int len) { + intType temp = 0; + signedIntType ans = 0; + if (party == SERVER) { + io->send_data(x, len * sizeof(intType)); + } else if (party == CLIENT) { + io->recv_data(y, len * sizeof(intType)); + for (int i = 0; i < len; i++) { + temp = y[i] + x[i]; + if (!isNativeRing) { + temp = sci::neg_mod(temp, + (int64_t)prime_mod); // cast temp to signed int and + // then take a proper modulo p + y[i] = getAnyRingSignedVal(temp); + } else { + temp = temp & (prime_mod - 1); + if (temp >= (prime_mod / 2)) + y[i] = temp - prime_mod; + else + y[i] = temp; + } + } + } + return; +} + +signedIntType funcReconstruct2PCCons(intType x, int revealParty) { + assert(revealParty == 2 && "Reveal to only client is supported right now."); + intType temp = 0; + signedIntType ans = 0; + static const uint64_t moduloMask = sci::all1Mask(bitlength); + if (party == SERVER) { + io->send_data(&x, sizeof(intType)); + } else if (party == CLIENT) { + io->recv_data(&temp, sizeof(intType)); + temp = temp + x; + if (!isNativeRing) { + temp = + sci::neg_mod(temp, (int64_t)prime_mod); // cast temp to signed int and + // then take a proper modulo p + ans = getAnyRingSignedVal(temp); + } else { + ans = temp & moduloMask; + } + } + return ans; +} + +signedIntType div_floor(signedIntType a, signedIntType b) { + signedIntType q = a / b; + signedIntType r = a % b; + signedIntType corr = ((r != 0) && (r < 0)); + return q - corr; +} + +void funcTruncationIdeal(int size, intType *arr, int consSF) { + if (party == SERVER) { + io->send_data(arr, sizeof(intType) * size); + for (int i = 0; i < size; i++) { + arr[i] = 0; + } + } else { + intType *arrOther = new intType[size]; + io->recv_data(arrOther, sizeof(intType) * size); + for (int i = 0; i < size; i++) { + signedIntType ans; + intType temp = arr[i] + arrOther[i]; + if (!isNativeRing) { + temp = sci::neg_mod(temp, (int64_t)prime_mod); + ans = getAnyRingSignedVal(temp); + ans = div_floor(ans, 1ULL << consSF); + } else { + uint64_t moduloMask = (1ULL << bitlength) - 1; + if (bitlength == 64) + moduloMask = -1; + temp = temp & moduloMask; + ans = ((signedIntType)temp) >> consSF; + } + arr[i] = ans; + } + } +} + +void printAllReconstructedValuesSigned(int size, intType *arr) { + if (party == SERVER) { + io->send_data(arr, sizeof(intType) * size); + } else { + intType *arrOther = new intType[size]; + io->recv_data(arrOther, sizeof(intType) * size); + for (int i = 0; i < size; i++) { + signedIntType ans; + intType temp = arr[i] + arrOther[i]; + if (!isNativeRing) { + temp = sci::neg_mod(temp, (int64_t)prime_mod); + ans = getAnyRingSignedVal(temp); + } else { + ans = temp; + } + std::cout << ans << std::endl; + } + } +} + +intType funcSigendDivIdeal(intType x, uint32_t y) { + if (party == SERVER) { + io->send_data(&x, sizeof(intType)); + return 0; + } else { + intType temp; + io->recv_data(&temp, sizeof(intType)); + temp += x; + return (((signedIntType)temp) / y); + } +} + +void funcReLUThread(int tid, intType *outp, intType *inp, int numRelu, + uint8_t *drelu_res = nullptr, bool skip_ot = false) { + reluArr[tid]->relu(outp, inp, numRelu, drelu_res, skip_ot); +} + +void funcMaxpoolThread(int tid, int rows, int cols, intType *inpArr, + intType *maxi, intType *maxiIdx) { + maxpoolArr[tid]->funcMaxMPC(rows, cols, inpArr, maxi, maxiIdx); +} + +#ifdef SCI_OT +void funcMatmulThread(int tid, int N, int s1, int s2, int s3, intType *A, + intType *B, intType *C, int partyWithAInAB_mul) { + assert(tid >= 0); + int s2StartIdx = tid * ceil(s2 / double(N)); // Inclusive + int s2EndIdx = ((tid + 1) * ceil(s2 / double(N))); // Exclusive + s2StartIdx = std::min(s2StartIdx, s2); + s2EndIdx = std::min(s2EndIdx, s2); + intType *APtr = new intType[s1 * (s2EndIdx - s2StartIdx)]; + for (int i = 0; i < s1; i++) { + for (int j = s2StartIdx; j < s2EndIdx; j++) { + Arr2DIdxRowM(APtr, s1, (s2EndIdx - s2StartIdx), i, (j - s2StartIdx)) = + Arr2DIdxRowM(A, s1, s2, i, j); + } + } + intType *BPtr = B + s2StartIdx * s3; + /* + Case 1: If Alice has A and Bob has B + Then for even threads, Bob (holding B) acts as receiver and Alice + (holding A) acts as sender For odd threads, Bob (holding B) acts as sender + and Alice (holding A) acts as receiver Case 2: If Alice has B and Bob has A + Then for even threads, Bob (holding A) acts as receiver and Alice + (holding B) as sender For odd threads, Bob (holding A) acts as sender and + Alice (holding B) as receiver Note that for even threads, Bob is always the + receiver and Alice is always the sender and for odd threads, Bob is always + the sender and Alice the receiver This makes sure that the matmul and + otinstances (indexed by tid) are always used by with the same + sender-receiver pair. + */ + +#ifdef USE_LINEAR_UNIFORM + assert(s2EndIdx > s2StartIdx); + bool useBobAsSender = tid & 1; + if (partyWithAInAB_mul == sci::BOB) + useBobAsSender = !useBobAsSender; + if (useBobAsSender) { + // Odd tid, use Bob (holding B) as sender and Alice (holding A) as receiver + if (party == partyWithAInAB_mul) { + multUniformArr[tid]->funcOTReceiverInputA(s1, (s2EndIdx - s2StartIdx), s3, + APtr, C, otInstanceArr[tid]); + } else { + multUniformArr[tid]->funcOTSenderInputB(s1, (s2EndIdx - s2StartIdx), s3, + BPtr, C, otInstanceArr[tid]); + } + } else { + // Even tid, use Bob (holding B) as receiver and Alice (holding A) as sender + if (party == partyWithAInAB_mul) { + multUniformArr[tid]->funcOTSenderInputA(s1, (s2EndIdx - s2StartIdx), s3, + APtr, C, otInstanceArr[tid]); + } else { + multUniformArr[tid]->funcOTReceiverInputB(s1, (s2EndIdx - s2StartIdx), s3, + BPtr, C, otInstanceArr[tid]); + } + } +#else // USE_LINEAR_UNIFORM + MultMode mode; + if (tid & 1) { + if (partyWithAInAB_mul == sci::ALICE) + mode = MultMode::Bob_has_A; + else + mode = MultMode::Bob_has_B; + } else { + if (partyWithAInAB_mul == sci::ALICE) + mode = MultMode::Alice_has_A; + else + mode = MultMode::Alice_has_B; + } + if (s2EndIdx > s2StartIdx) { + multArr[tid]->matmul_cross_terms(s1, (s2EndIdx - s2StartIdx), s3, APtr, + BPtr, C, bitlength, bitlength, bitlength, + true, mode); + } else { + memset(C, 0, s1 * s3 * sizeof(intType)); + } +#endif // USE_LINEAR_UNIFORM + delete[] APtr; +} + +void funcDotProdThread(int tid, int N, int size, intType *multiplyArr, + intType *inArr, intType *outArr, + bool both_cross_terms = false) { + if (size == 0) + return; + assert(tid >= 0); + if (tid & 1) { + MultMode mode = (both_cross_terms ? MultMode::None : MultMode::Bob_has_A); + multArr[tid]->hadamard_cross_terms(size, multiplyArr, inArr, outArr, + bitlength, bitlength, bitlength, mode); + } else { + MultMode mode = (both_cross_terms ? MultMode::None : MultMode::Alice_has_A); + multArr[tid]->hadamard_cross_terms(size, multiplyArr, inArr, outArr, + bitlength, bitlength, bitlength, mode); + } +} +#endif + +/* + Note this assumes 1 <= s < ell + More optimizations that could be done for this function: + - The call to 1oo4 KKOT and 1oo2 IKNP results in 4 rounds. Round + compression can potentially be done to reduce rounds to 2. The interface can + also potentially be cleaned up to use only otpack. However, currently the COT + required to be used is present in IKNP - so keeping that too in the + interface. +*/ +void funcTruncateTwoPowerRing(int curParty, sci::NetIO *curio, + sci::OTPack<sci::NetIO> *curotpack, + sci::IKNP<sci::NetIO> *curiknp, + ReLUProtocol<sci::NetIO, intType> *curReluImpl, + sci::PRG128 *curPrgInstance, int size, + intType *inp, intType *outp, int consSF, + uint8_t *msbShare, + bool doCarryBitCalculation = true) { + assert(size % 8 == 0); + static const int rightShiftForMsb = bitlength - 1; + uint64_t *carryBitCompArr; + uint8_t *carryBitCompAns; + uint64_t moduloMask = sci::all1Mask(bitlength); + + for (int i = 0; i < size; i++) { + assert(inp[i] <= moduloMask); + } + + if (doCarryBitCalculation) { + carryBitCompArr = new uint64_t[size]; + carryBitCompAns = new uint8_t[size]; + for (int i = 0; i < size; i++) { + carryBitCompArr[i] = (inp[i] & sci::all1Mask(consSF)); + if (curParty == sci::BOB) { + carryBitCompArr[i] = (sci::all1Mask(consSF)) - carryBitCompArr[i]; + } + } + MillionaireProtocol millionaire(curParty, curio, curotpack); + millionaire.compare(carryBitCompAns, carryBitCompArr, size, consSF); + } + + bool createdMsbSharesHere = false; + if (msbShare == nullptr) { + msbShare = new uint8_t[size]; + curReluImpl->relu(nullptr, inp, size, msbShare, true); + createdMsbSharesHere = true; + } + + if (curParty == sci::ALICE) { + uint64_t **otMessages1oo4 = new uint64_t *[size]; + intType *otMessages1oo2Data = new intType[size]; + intType *otMessages1oo2Corr = new intType[size]; + intType *localShare1oo4 = new intType[size]; + curPrgInstance->random_data(localShare1oo4, sizeof(intType) * size); + + for (int i = 0; i < size; i++) { + otMessages1oo4[i] = new uint64_t[4]; + uint8_t localShareMSB = ((uint8_t)(inp[i] >> rightShiftForMsb)); + intType r = -localShare1oo4[i]; + for (int j = 0; j < 4; j++) { + uint8_t b0 = j & 1; + uint8_t b1 = + (j >> 1) & + 1; // b1,b0 is the bit representation of j = [msb(a)]_1, msb(a_1) + uint8_t temp = ((msbShare[i] + b1 + localShareMSB) & 1) & + ((msbShare[i] + b1 + b0) & 1); + intType curMsg = r; + if (temp & (localShareMSB == 0)) { + // msb(a_0)=0, msb(a_1)=0, msb(a)=1 + curMsg -= 1; + } else if (temp & (localShareMSB == 1)) { + // msb(a_0)=1, msb(a_1)=1, msb(a)=0 + curMsg += 1; + } + // In other cases, extra term is 0 + otMessages1oo4[i][j] = (uint64_t)curMsg; + } + if (doCarryBitCalculation) { + otMessages1oo2Corr[i] = ((intType)carryBitCompAns[i]); + } + } + + curotpack->kkot[1]->send_impl(otMessages1oo4, size, bitlength); + if (doCarryBitCalculation) { + curiknp->send_cot_moduloAdd<intType>(otMessages1oo2Data, + otMessages1oo2Corr, size); + } + + for (int i = 0; i < size; i++) { + intType shareTerm1 = ((intType)((getAnyRingSignedVal(inp[i])) >> consSF)); + intType shareTerm2 = (localShare1oo4[i] << (bitlength - consSF)); + outp[i] = shareTerm1 + shareTerm2; + if (doCarryBitCalculation) { + intType curCarryShare = -otMessages1oo2Data[i]; + outp[i] = outp[i] + ((intType)carryBitCompAns[i]) - 2 * curCarryShare; + } + outp[i] = outp[i] & moduloMask; + delete[] otMessages1oo4[i]; + } + + delete[] otMessages1oo4; + delete[] otMessages1oo2Data; + delete[] otMessages1oo2Corr; + delete[] localShare1oo4; + } else { + uint64_t *otRecvMsg1oo4 = new uint64_t[size]; + uint8_t *choiceBits = new uint8_t[size]; + intType *otRecvMsg1oo2 = new intType[size]; + uint8_t *choiceBits1oo2OT = new uint8_t[size]; + for (int i = 0; i < size; i++) { + uint8_t localShareMSB = ((uint8_t)(inp[i] >> rightShiftForMsb)); + choiceBits[i] = (msbShare[i] << 1) + localShareMSB; + if (doCarryBitCalculation) { + choiceBits1oo2OT[i] = carryBitCompAns[i]; + } + } + + curotpack->kkot[1]->recv_impl(otRecvMsg1oo4, choiceBits, size, bitlength); + if (doCarryBitCalculation) { + curiknp->recv_cot_moduloAdd<intType>(otRecvMsg1oo2, choiceBits1oo2OT, + size); + } + for (int i = 0; i < size; i++) { + intType G1 = (intType)otRecvMsg1oo4[i]; + intType shareTerm1 = (getAnyRingSignedVal(inp[i])) >> consSF; + intType shareTerm2 = (G1 << (bitlength - consSF)); + outp[i] = shareTerm1 + shareTerm2; + if (doCarryBitCalculation) { + outp[i] = + outp[i] + ((intType)carryBitCompAns[i]) - 2 * otRecvMsg1oo2[i]; + } + outp[i] = outp[i] & moduloMask; + } + + delete[] otRecvMsg1oo4; + delete[] choiceBits; + delete[] otRecvMsg1oo2; + delete[] choiceBits1oo2OT; + } + + if (doCarryBitCalculation) { + delete[] carryBitCompArr; + delete[] carryBitCompAns; + } + + if (createdMsbSharesHere) { + delete[] msbShare; + } +} + +void funcTruncateTwoPowerRingWrapper(int size, intType *inp, intType *outp, + int consSF, uint8_t *msbShare, + bool doCarryBitCalculation = true) { + assert(size % 8 == 0); +#ifdef MULTITHREADED_TRUNC + std::thread truncThreads[num_threads]; + int chunk_size = (size / (8 * num_threads)) * 8; + for (int i = 0; i < num_threads; i++) { + int offset = i * chunk_size; + int curSize; + if (i == (num_threads - 1)) { + curSize = size - offset; + } else { + curSize = chunk_size; + } + int curParty = party; + if (i & 1) + curParty = 3 - curParty; + uint8_t *msbShareArg = msbShare; + if (msbShare != nullptr) + msbShareArg = msbShareArg + offset; + truncThreads[i] = std::thread( + funcTruncateTwoPowerRing, curParty, ioArr[i], otpackArr[i], + otInstanceArr[i], reluArr[i], prgInstanceArr[i], curSize, inp + offset, + outp + offset, consSF, msbShareArg, doCarryBitCalculation); + } + for (int i = 0; i < num_threads; ++i) { + truncThreads[i].join(); + } +#else + funcTruncateTwoPowerRing( + party, io, otpack, iknpOT, kkot, relu, prg128Instance, // Global variables + size, inp, outp, consSF, msbShare, doCarryBitCalculation); +#endif +} + +/* + More optimizations that could be done for this function: + - Currently if bitsForA + bitlength > 64, then the function resorts to + using block128 based 1oo4 KKOT, skipping packing. This could be optimized to + do ideal packing even in this case. + - The last COT being performed is also not using packing for bitlenth != + 32/64. +*/ +void funcAvgPoolTwoPowerRing(int curParty, sci::NetIO *curio, + sci::OTPack<sci::NetIO> *curotpack, + sci::IKNP<sci::NetIO> *curiknp, + sci::KKOT<sci::NetIO> *curkkot, + ReLUProtocol<sci::NetIO, intType> *curReluImpl, + sci::PRG128 *curPrgInstance, int size, + intType *inp, intType *outp, intType divisor) { + assert(inp != outp && + "Assumption is there is a separate array for input and output"); + assert(size % 8 == 0 && "pad size to multiple of 8 and pass"); + assert(divisor > 0 && "working with positive divisor"); + static const int rightShiftForMsb = bitlength - 1; + assert(sci::all1Mask(bitlength) > + (6 * divisor - 1)); // 2^l-1 > 6d-1 => 2^l > 6d + intType ringRem, ringQuot; + if (bitlength == 64) { + ringRem = ((intType)(-divisor)) % divisor; //(2^l-d)%d = 2^l%d + ringQuot = (((intType)(-divisor)) / divisor) + 1; //((2^l-d)/d)+1 = 2^l/d + } else { + ringRem = prime_mod % divisor; + ringQuot = prime_mod / divisor; + } + uint8_t *msbShare = new uint8_t[size]; + uint64_t moduloMask = sci::all1Mask(bitlength); + + for (int i = 0; i < size; i++) { + inp[i] = inp[i] & moduloMask; + intType shareTerm1 = div_floor(getAnyRingSignedVal(inp[i]), divisor); + intType localShareMSB = (inp[i] >> rightShiftForMsb); + intType shareTerm2 = div_floor( + (signedIntType)((inp[i] % divisor) - localShareMSB * ringRem), divisor); + outp[i] = shareTerm1 - shareTerm2; + if (curParty == sci::ALICE) + outp[i] += 1; + } + + curReluImpl->relu(nullptr, inp, size, msbShare, true); + + const uint64_t bitsForA = std::ceil(std::log2(6 * divisor)); + uint64_t totalRandomBytesForLargeRing = sci::ceil_val(bitlength * size, 8); + uint8_t *localShareCorrPacked = new uint8_t[totalRandomBytesForLargeRing]; + intType *localShareCorr = new intType[size]; + int totalRandomBytesForSmallRing = sci::ceil_val(bitsForA * size, 8); + uint8_t *localShareCorrSmallRingPacked = + new uint8_t[totalRandomBytesForSmallRing]; + uint64_t *localShareCorrSmallRing = new uint64_t[size]; + intType *otMsgCorrRing = new intType[4 * size]; + intType *otMsgCorrSmallRing = new intType[4 * size]; + + bool OT1oo4FitsIn64Bits = ((bitsForA + bitlength) <= 64); + if (curParty == sci::ALICE) { + curPrgInstance->random_data(localShareCorrPacked, + totalRandomBytesForLargeRing); + curPrgInstance->random_data(localShareCorrSmallRingPacked, + totalRandomBytesForSmallRing); + for (int i = 0; i < size; i++) { + localShareCorr[i] = sci::readFromPackedArr(localShareCorrPacked, + totalRandomBytesForLargeRing, + i * (bitlength), bitlength); + localShareCorrSmallRing[i] = sci::readFromPackedArr( + localShareCorrSmallRingPacked, totalRandomBytesForSmallRing, + i * bitsForA, bitsForA); + uint8_t localShareMSB = ((uint8_t)(inp[i] >> rightShiftForMsb)); + for (int j = 0; j < 4; j++) { + uint8_t b0 = j & 1; + uint8_t b1 = + (j >> 1) & + 1; // b1,b0 is the bit representation of j = [msb(a)]_1, msb(a_1) + uint8_t temp = ((msbShare[i] + b1 + localShareMSB) & 1) & + ((msbShare[i] + b1 + b0) & 1); + intType curMsg = -localShareCorr[i]; + intType curMsgSmallRing = -localShareCorrSmallRing[i]; + if (temp & (localShareMSB == 0)) { + // msb(a_0)=0, msb(a_1)=0, msb(a)=1 + curMsg -= 1; + curMsgSmallRing -= 1; + } else if (temp & (localShareMSB == 1)) { + // msb(a_0)=1, msb(a_1)=1, msb(a)=0 + curMsg += 1; + curMsgSmallRing += 1; + } + curMsg = curMsg & moduloMask; + curMsgSmallRing = curMsgSmallRing & sci::all1Mask(bitsForA); + otMsgCorrRing[i * 4 + j] = curMsg; + otMsgCorrSmallRing[i * 4 + j] = curMsgSmallRing; + } + } + + if (OT1oo4FitsIn64Bits) { + uint64_t **otMessages1oo4 = new uint64_t *[size]; + for (int i = 0; i < size; i++) { + otMessages1oo4[i] = new uint64_t[4]; + for (int j = 0; j < 4; j++) + otMessages1oo4[i][j] = + (((uint64_t)otMsgCorrSmallRing[i * 4 + j]) << bitlength) + + ((uint64_t)otMsgCorrRing[i * 4 + j]); + } + curotpack->kkot[1]->send_impl(otMessages1oo4, size, + (bitlength + bitsForA)); + for (int i = 0; i < size; i++) { + delete[] otMessages1oo4[i]; + } + delete[] otMessages1oo4; + } else { + sci::block128 **otMessages1oo4 = new sci::block128 *[size]; + for (int i = 0; i < size; i++) { + otMessages1oo4[i] = new sci::block128[4]; + for (int j = 0; j < 4; j++) + otMessages1oo4[i][j] = _mm_set_epi64x(otMsgCorrSmallRing[i * 4 + j], + otMsgCorrRing[i * 4 + j]); + } + curkkot->send_impl(otMessages1oo4, size, 4); + for (int i = 0; i < size; i++) { + delete[] otMessages1oo4[i]; + } + delete[] otMessages1oo4; + } + for (int i = 0; i < size; i++) { + outp[i] += (localShareCorr[i] * ringQuot); + } + } else { + uint8_t *choiceBits = new uint8_t[size]; + for (int i = 0; i < size; i++) { + uint8_t localShareMSB = ((uint8_t)(inp[i] >> rightShiftForMsb)); + choiceBits[i] = (msbShare[i] << 1) + localShareMSB; + } + + if (OT1oo4FitsIn64Bits) { + uint64_t *otRecvMsg1oo4 = new uint64_t[size]; + curotpack->kkot[1]->recv_impl(otRecvMsg1oo4, choiceBits, size, + (bitlength + bitsForA)); + for (int i = 0; i < size; i++) { + otMsgCorrRing[i] = otRecvMsg1oo4[i] & sci::all1Mask(bitlength); + otMsgCorrSmallRing[i] = otRecvMsg1oo4[i] >> bitlength; + } + delete[] otRecvMsg1oo4; + } else { + sci::block128 *otRecvMsg1oo4 = new sci::block128[size]; + curkkot->recv_impl(otRecvMsg1oo4, choiceBits, size, 4); + for (int i = 0; i < size; i++) { + uint64_t temp = _mm_extract_epi64(otRecvMsg1oo4[i], 0); + otMsgCorrRing[i] = temp; + temp = _mm_extract_epi64(otRecvMsg1oo4[i], 1); + otMsgCorrSmallRing[i] = temp; + } + delete[] otRecvMsg1oo4; + } + + for (int i = 0; i < size; i++) { + localShareCorr[i] = otMsgCorrRing[i]; + localShareCorrSmallRing[i] = otMsgCorrSmallRing[i]; + outp[i] += (localShareCorr[i] * ringQuot); + } + + delete[] choiceBits; + } + + intType *localShareA_all3 = new intType[3 * size]; + uint8_t *localShareA_all3_drelu = new uint8_t[3 * size]; + uint64_t bitsAmask = sci::all1Mask(bitsForA); + uint64_t bitsAMinusOneMask = sci::all1Mask((bitsForA - 1)); + uint64_t *radixCompValues = new uint64_t[3 * size]; + uint8_t *carryBit = new uint8_t[3 * size]; + + // Optimization to reduce comparions to 2 + int totalComp = 3 * size; + int compPerElt = 3; + if (2 * ringRem < divisor) { + // A+d<0 becomes moot + totalComp = 2 * size; + compPerElt = 2; + } + + for (int i = 0; i < size; i++) { + intType localShareA = ((inp[i] % divisor) - ((inp[i] >> rightShiftForMsb) - + localShareCorrSmallRing[i]) * + ringRem) & + bitsAmask; + for (int j = 0; j < compPerElt; j++) { + localShareA_all3[compPerElt * i + j] = localShareA; + } + + if (curParty == sci::ALICE) { + if (compPerElt == 3) { + localShareA_all3[3 * i] = + (localShareA_all3[3 * i] - divisor) & bitsAmask; + localShareA_all3[3 * i + 2] = + (localShareA_all3[3 * i + 2] + divisor) & bitsAmask; + } else { + localShareA_all3[2 * i] = + (localShareA_all3[2 * i] - divisor) & bitsAmask; + } + } + + for (int j = 0; j < compPerElt; j++) { + radixCompValues[compPerElt * i + j] = + (localShareA_all3[compPerElt * i + j] & bitsAMinusOneMask); + localShareA_all3_drelu[compPerElt * i + j] = + (localShareA_all3[compPerElt * i + j] >> (bitsForA - 1)); + if (curParty == sci::BOB) { + radixCompValues[compPerElt * i + j] = + bitsAMinusOneMask - radixCompValues[compPerElt * i + j]; + } + } + } + + MillionaireProtocol millionaire(curParty, curio, curotpack); + millionaire.compare(carryBit, radixCompValues, totalComp, bitsForA - 1); + for (int i = 0; i < totalComp; i++) { + localShareA_all3_drelu[i] = (localShareA_all3_drelu[i] + carryBit[i]) & 1; + } + + if (curParty == sci::ALICE) { + intType *cotData = new intType[totalComp]; + intType *cotCorr = new intType[totalComp]; + for (int i = 0; i < totalComp; i++) { + cotCorr[i] = (intType)localShareA_all3_drelu[i]; + } + curiknp->send_cot_moduloAdd<intType>(cotData, cotCorr, totalComp); + for (int i = 0; i < size; i++) { + intType curCTermShare = 0; + for (int j = 0; j < compPerElt; j++) { + intType curMultTermShare = -cotData[compPerElt * i + j]; + intType curDReluAns = + (intType)localShareA_all3_drelu[compPerElt * i + j] - + 2 * curMultTermShare; + curCTermShare += curDReluAns; + } + outp[i] -= curCTermShare; + } + delete[] cotData; + delete[] cotCorr; + } else { + intType *cotDataRecvd = new intType[totalComp]; + curiknp->recv_cot_moduloAdd<intType>(cotDataRecvd, localShareA_all3_drelu, + totalComp); + for (int i = 0; i < size; i++) { + intType curCTermShare = 0; + for (int j = 0; j < compPerElt; j++) { + intType curMultTermShare = cotDataRecvd[compPerElt * i + j]; + intType curDReluAns = + (intType)localShareA_all3_drelu[compPerElt * i + j] - + 2 * curMultTermShare; + curCTermShare += curDReluAns; + } + outp[i] -= curCTermShare; + } + delete[] cotDataRecvd; + } + + for (int i = 0; i < size; i++) { + outp[i] = outp[i] & moduloMask; + } + + delete[] msbShare; + delete[] localShareCorr; + delete[] localShareCorrSmallRingPacked; + delete[] localShareCorrSmallRing; + delete[] otMsgCorrRing; + delete[] otMsgCorrSmallRing; + delete[] localShareA_all3; + delete[] localShareA_all3_drelu; + delete[] radixCompValues; + delete[] carryBit; +} + +void funcAvgPoolTwoPowerRingWrapper(int size, intType *inp, intType *outp, + intType divisor) { + assert(size % 8 == 0); +#ifdef MULTITHREADED_TRUNC + std::thread truncThreads[num_threads]; + int chunk_size = (size / (8 * num_threads)) * 8; + for (int i = 0; i < num_threads; i++) { + int offset = i * chunk_size; + int curSize; + if (i == (num_threads - 1)) { + curSize = size - offset; + } else { + curSize = chunk_size; + } + int curParty = party; + if (i & 1) + curParty = 3 - curParty; + truncThreads[i] = std::thread( + funcAvgPoolTwoPowerRing, curParty, ioArr[i], otpackArr[i], + otInstanceArr[i], kkotInstanceArr[i], reluArr[i], prgInstanceArr[i], + curSize, inp + offset, outp + offset, divisor); + } + for (int i = 0; i < num_threads; ++i) { + truncThreads[i].join(); + } +#else + funcAvgPoolTwoPowerRing(party, io, otpack, iknpOT, kkot, relu, prg128Instance, + size, inp, outp, divisor); +#endif +} + +/* + Assume uint64_t for fields + More optimizations that could be performed for this function: + - The 1oo4 KKOT being performed resorts to using block128 and no packing + when fieldBits + bitsForA > 64. This can be optimized to use ideal packing + even in this case. + - The last OT being performed is a COT, but is being done using an OT + with no packing. +*/ +template <typename intType> +void funcFieldDiv(int curParty, sci::NetIO *curio, + sci::OTPack<sci::NetIO> *curotpack, + sci::IKNP<sci::NetIO> *curiknp, + sci::KKOT<sci::NetIO> *curkkot, + ReLUProtocol<sci::NetIO, intType> *curReluImpl, + sci::PRG128 *curPrgInstance, int size, intType *inp, + intType *outp, intType divisor, uint8_t *msbShare) { + assert(inp != outp && + "Assumption is there is a separate array for input and output"); + assert(size % 8 == 0 && "pad size to multiple of 8 and pass"); + assert((divisor > 0) && (divisor < prime_mod) && + "working with positive divisor"); + assert(prime_mod > 6 * divisor); + const intType ringRem = prime_mod % divisor; + const intType ringQuot = prime_mod / divisor; + bool doMSBComputation = (msbShare == nullptr); + if (doMSBComputation) + msbShare = new uint8_t[size]; + + for (int i = 0; i < size; i++) { + assert(inp[i] < prime_mod && "input is not a valid share modulo prime_mod"); + signedIntType shareTerm1 = + div_floor((signedIntType)getAnyRingSignedVal(inp[i]), divisor); + intType localShareMSB = getFieldMsb(inp[i]); + signedIntType shareTerm2 = div_floor( + (signedIntType)((inp[i] % divisor) - localShareMSB * ringRem), divisor); + signedIntType temp = shareTerm1 - shareTerm2; + if (curParty == sci::BOB) + temp += 1; + outp[i] = sci::neg_mod(temp, (int64_t)prime_mod); + } + + if (doMSBComputation) { + curReluImpl->relu(nullptr, inp, size, msbShare, true); + } + + static const int fieldBits = std::ceil(std::log2(prime_mod)); + const uint64_t bitsForA = std::ceil(std::log2(6 * divisor)); + const uint64_t totalBitlen = fieldBits + bitsForA; + bool OT1oo4FitsIn64Bits = (totalBitlen <= 64); + + intType *localShareCorr = new intType[size]; + int totalRandomBytesForSmallRing = sci::ceil_val(bitsForA * size, 8); + uint8_t *localShareCorrSmallRingPacked = + new uint8_t[totalRandomBytesForSmallRing]; + uint64_t *localShareCorrSmallRing = new uint64_t[size]; + intType *otMsgCorrField = new intType[4 * size]; + intType *otMsgCorrSmallRing = new intType[4 * size]; + + if (curParty == sci::ALICE) { + curPrgInstance->random_mod_p<intType>(localShareCorr, size, prime_mod); + curPrgInstance->random_data(localShareCorrSmallRingPacked, + totalRandomBytesForSmallRing); + for (int i = 0; i < size; i++) { + localShareCorrSmallRing[i] = sci::readFromPackedArr( + localShareCorrSmallRingPacked, totalRandomBytesForSmallRing, + i * bitsForA, bitsForA); + uint8_t localShareMSB = getFieldMsb(inp[i]); + for (int j = 0; j < 4; j++) { + uint8_t b0 = j & 1; + uint8_t b1 = + (j >> 1) & + 1; // b1,b0 is the bit representation of j = [msb(a)]_1, msb(a_1) + uint8_t temp = ((msbShare[i] + b1 + localShareMSB) & 1) & + ((msbShare[i] + b1 + b0) & 1); + signedIntType curMsg = -localShareCorr[i]; + intType curMsgSmallRing = -localShareCorrSmallRing[i]; + if (temp & (localShareMSB == 0)) { + // msb(a_0)=0, msb(a_1)=0, msb(a)=1 + curMsg -= 1; + curMsgSmallRing -= 1; + } else if (temp & (localShareMSB == 1)) { + // msb(a_0)=1, msb(a_1)=1, msb(a)=0 + curMsg += 1; + curMsgSmallRing += 1; + } + intType curMsgField = sci::neg_mod(curMsg, (int64_t)prime_mod); + curMsgSmallRing = curMsgSmallRing & sci::all1Mask(bitsForA); + otMsgCorrField[i * 4 + j] = curMsgField; + otMsgCorrSmallRing[i * 4 + j] = curMsgSmallRing; + } + } + if (OT1oo4FitsIn64Bits) { + uint64_t **otMessages1oo4 = new uint64_t *[size]; + for (int i = 0; i < size; i++) { + otMessages1oo4[i] = new uint64_t[4]; + for (int j = 0; j < 4; j++) + otMessages1oo4[i][j] = + (((uint64_t)otMsgCorrSmallRing[i * 4 + j]) << fieldBits) + + ((uint64_t)otMsgCorrField[i * 4 + j]); + } + curotpack->kkot[1]->send_impl(otMessages1oo4, size, totalBitlen); + for (int i = 0; i < size; i++) { + delete[] otMessages1oo4[i]; + } + delete[] otMessages1oo4; + } else { + sci::block128 **otMessages1oo4 = new sci::block128 *[size]; + for (int i = 0; i < size; i++) { + otMessages1oo4[i] = new sci::block128[4]; + for (int j = 0; j < 4; j++) + otMessages1oo4[i][j] = _mm_set_epi64x(otMsgCorrSmallRing[i * 4 + j], + otMsgCorrField[i * 4 + j]); + } + curkkot->send_impl(otMessages1oo4, size, 4); + for (int i = 0; i < size; i++) { + delete[] otMessages1oo4[i]; + } + delete[] otMessages1oo4; + } + for (int i = 0; i < size; i++) { +#ifdef __SIZEOF_INT128__ + intType temp = + (((__int128)localShareCorr[i]) * ((__int128)ringQuot)) % prime_mod; +#else + intType temp = sci::moduloMult(localShareCorr[i], ringQuot, prime_mod); +#endif + outp[i] = sci::neg_mod(outp[i] + temp, (int64_t)prime_mod); + } + } else { + uint8_t *choiceBits = new uint8_t[size]; + for (int i = 0; i < size; i++) { + uint8_t localShareMSB = getFieldMsb(inp[i]); + choiceBits[i] = (msbShare[i] << 1) + localShareMSB; + } + + if (OT1oo4FitsIn64Bits) { + uint64_t *otRecvMsg1oo4 = new uint64_t[size]; + curotpack->kkot[1]->recv_impl(otRecvMsg1oo4, choiceBits, size, + totalBitlen); + for (int i = 0; i < size; i++) { + otMsgCorrField[i] = otRecvMsg1oo4[i] & sci::all1Mask(fieldBits); + otMsgCorrSmallRing[i] = otRecvMsg1oo4[i] >> fieldBits; + } + delete[] otRecvMsg1oo4; + } else { + sci::block128 *otRecvMsg1oo4 = new sci::block128[size]; + curkkot->recv_impl(otRecvMsg1oo4, choiceBits, size, 4); + for (int i = 0; i < size; i++) { + uint64_t temp = _mm_extract_epi64(otRecvMsg1oo4[i], 0); + otMsgCorrField[i] = temp; + temp = _mm_extract_epi64(otRecvMsg1oo4[i], 1); + otMsgCorrSmallRing[i] = temp; + } + delete[] otRecvMsg1oo4; + } + + for (int i = 0; i < size; i++) { + localShareCorr[i] = otMsgCorrField[i]; + localShareCorrSmallRing[i] = otMsgCorrSmallRing[i]; +#ifdef __SIZEOF_INT128__ + intType temp = + (((__int128)localShareCorr[i]) * ((__int128)ringQuot)) % prime_mod; +#else + intType temp = sci::moduloMult(localShareCorr[i], ringQuot, prime_mod); +#endif + outp[i] = sci::neg_mod(outp[i] + temp, (int64_t)prime_mod); + } + + delete[] choiceBits; + } + + int totalComp = 3 * size; + int compPerElt = 3; + if (2 * ringRem < divisor) { + // A+d<0 becomes moot + totalComp = 2 * size; + compPerElt = 2; + } + + intType *localShareA_all3 = new intType[3 * size]; + uint8_t *localShareA_all3_drelu = new uint8_t[3 * size]; + uint64_t bitsAmask = sci::all1Mask(bitsForA); + uint64_t bitsAMinusOneMask = sci::all1Mask((bitsForA - 1)); + uint64_t *radixCompValues = new uint64_t[3 * size]; + uint8_t *carryBit = new uint8_t[3 * size]; + for (int i = 0; i < size; i++) { + intType localShareA = + (inp[i] % divisor) - + (getFieldMsb(inp[i]) - localShareCorrSmallRing[i]) * ringRem; + for (int j = 0; j < compPerElt; j++) { + localShareA_all3[compPerElt * i + j] = localShareA; + } + + if (curParty == sci::ALICE) { + if (compPerElt == 3) { + localShareA_all3[3 * i] = + (localShareA_all3[3 * i] - divisor) & bitsAmask; + localShareA_all3[3 * i + 2] = + (localShareA_all3[3 * i + 2] + divisor) & bitsAmask; + } else { + localShareA_all3[2 * i] = + (localShareA_all3[2 * i] - divisor) & bitsAmask; + } + } + for (int j = 0; j < compPerElt; j++) { + radixCompValues[compPerElt * i + j] = + (localShareA_all3[compPerElt * i + j] & bitsAMinusOneMask); + localShareA_all3_drelu[compPerElt * i + j] = + (localShareA_all3[compPerElt * i + j] >> (bitsForA - 1)); + if (curParty == sci::BOB) { + radixCompValues[compPerElt * i + j] = + bitsAMinusOneMask - radixCompValues[compPerElt * i + j]; + } + } + } + + MillionaireProtocol millionaire(curParty, curio, curotpack); + millionaire.compare(carryBit, radixCompValues, totalComp, bitsForA - 1); + for (int i = 0; i < totalComp; i++) { + localShareA_all3_drelu[i] = (localShareA_all3_drelu[i] + carryBit[i]) & 1; + } + + if (curParty == sci::ALICE) { + uint64_t **otMsg = new uint64_t *[totalComp]; + intType *localShareDRelu = new intType[totalComp]; + curPrgInstance->random_mod_p<intType>(localShareDRelu, totalComp, + prime_mod); + for (int i = 0; i < totalComp; i++) { + otMsg[i] = new uint64_t[2]; + otMsg[i][0] = + sci::neg_mod(-localShareDRelu[i] + (localShareA_all3_drelu[i]), + (int64_t)prime_mod); + otMsg[i][1] = sci::neg_mod(-localShareDRelu[i] + + ((localShareA_all3_drelu[i] + 1) & 1), + (int64_t)prime_mod); + } + curiknp->send_impl(otMsg, totalComp, fieldBits); + for (int i = 0; i < size; i++) { + intType curCTermShare = 0; + for (int j = 0; j < compPerElt; j++) { + curCTermShare = + sci::neg_mod(curCTermShare + localShareDRelu[compPerElt * i + j], + (int64_t)prime_mod); + } + outp[i] = sci::neg_mod(outp[i] - curCTermShare, (int64_t)prime_mod); + delete[] otMsg[i]; + } + delete[] otMsg; + delete[] localShareDRelu; + } else { + uint64_t *otDataRecvd = new uint64_t[totalComp]; + curiknp->recv_impl(otDataRecvd, localShareA_all3_drelu, totalComp, + fieldBits); + for (int i = 0; i < size; i++) { + intType curCTermShare = 0; + for (int j = 0; j < compPerElt; j++) { + uint64_t curDReluAns = otDataRecvd[compPerElt * i + j]; + curCTermShare = + sci::neg_mod(curCTermShare + curDReluAns, (int64_t)prime_mod); + } + outp[i] = sci::neg_mod(outp[i] - curCTermShare, (int64_t)prime_mod); + } + delete[] otDataRecvd; + } + + if (doMSBComputation) + delete[] msbShare; + delete[] localShareCorr; + delete[] localShareCorrSmallRingPacked; + delete[] localShareCorrSmallRing; + delete[] otMsgCorrField; + delete[] otMsgCorrSmallRing; + delete[] localShareA_all3; + delete[] localShareA_all3_drelu; + delete[] radixCompValues; + delete[] carryBit; +} + +template <typename intType> +void funcFieldDivWrapper(int size, intType *inp, intType *outp, intType divisor, + uint8_t *msbShare) { + assert(size % 8 == 0); +#ifdef MULTITHREADED_TRUNC + std::thread truncThreads[num_threads]; + int chunk_size = (size / (8 * num_threads)) * 8; + for (int i = 0; i < num_threads; i++) { + int offset = i * chunk_size; + int curSize; + if (i == (num_threads - 1)) { + curSize = size - offset; + } else { + curSize = chunk_size; + } + int curParty = party; + if (i & 1) + curParty = 3 - curParty; + uint8_t *msbShareArg = msbShare; + if (msbShare != nullptr) + msbShareArg = msbShareArg + offset; + truncThreads[i] = std::thread( + funcFieldDiv<intType>, curParty, ioArr[i], otpackArr[i], + otInstanceArr[i], kkotInstanceArr[i], reluArr[i], prgInstanceArr[i], + curSize, inp + offset, outp + offset, divisor, msbShareArg); + } + for (int i = 0; i < num_threads; ++i) { + truncThreads[i].join(); + } +#else + funcFieldDiv<intType>(party, io, otpack, iknpOT, kkot, relu, prg128Instance, + size, inp, outp, divisor, msbShare); +#endif +} + +#endif // FUNCTIONALITIES_UNIFORM_H__ diff --git a/SCI/src/functionalities_wrapper.h b/SCI/src/functionalities_wrapper.h deleted file mode 100644 index 5cb86213..00000000 --- a/SCI/src/functionalities_wrapper.h +++ /dev/null @@ -1,1464 +0,0 @@ -/* -Authors: Nishant Kumar, Deevashwer Rathee -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#ifndef FUNCTIONALITIES_WRAPPER_H__ -#define FUNCTIONALITIES_WRAPPER_H__ - -#include "globals.h" //This should be the first file to be included, to make sure all #define's come first -#include "functionalities.h" -#include "NonLinear/relu-ring.h" -#include "NonLinear/relu-field.h" -#include <vector> -#include <cstdlib> -#include <fstream> - - -#ifdef VERIFY_LAYERWISE -#include "functionalities_pt.h" - -#endif - -void Conv2D(int32_t N, int32_t H, int32_t W, int32_t CI, - int32_t FH, int32_t FW, int32_t CO, - int32_t zPadHLeft, int32_t zPadHRight, - int32_t zPadWLeft, int32_t zPadWRight, - int32_t strideH, int32_t strideW, - intType* inputArr, intType* filterArr, - intType* outArr); - -void Conv2DGroup(int32_t N, int32_t H, int32_t W, int32_t CI, - int32_t FH, int32_t FW, int32_t CO, - int32_t zPadHLeft, int32_t zPadHRight, - int32_t zPadWLeft, int32_t zPadWRight, - int32_t strideH, int32_t strideW, int32_t G, - intType* inputArr, intType* filterArr, - intType* outArr); - -void MatMul2D(int32_t s1, int32_t s2, int32_t s3, const intType* A, const intType* B, intType* C, bool modelIsA) -{ -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - - std::cout<<"Matmul called s1,s2,s3 = "<<s1<<" "<<s2<<" "<<s3<<std::endl; - int partyWithAInAB_mul = sci::ALICE; //By default, the model is A and server/Alice has it - // So, in the AB mult, party with A = server and party with B = client. - int partyWithBInAB_mul = sci::BOB; - if (!modelIsA){ - //Model is B - partyWithAInAB_mul = sci::BOB; - partyWithBInAB_mul = sci::ALICE; - } - -#if defined(SCI_OT) -#ifndef MULTITHREADED_MATMUL - if (partyWithAInAB_mul==sci::ALICE){ - if (party==sci::ALICE){ - matmulImpl->funcOTSenderInputA(s1,s2,s3,A,C,iknpOT); - } - else{ - matmulImpl->funcOTReceiverInputB(s1,s2,s3,B,C,iknpOT); - } - } - else{ - if (party==sci::BOB){ - matmulImpl->funcOTSenderInputA(s1,s2,s3,A,C,iknpOTRoleReversed); - } - else{ - matmulImpl->funcOTReceiverInputB(s1,s2,s3,B,C,iknpOTRoleReversed); - } - } - - if (party==sci::ALICE){ - //Now irrespective of whether A is the model or B is the model and whether - // server holds A or B, server should add locally A*B. - // - // Add also A*own share of B - intType* CTemp = new intType[s1*s3]; - matmulImpl->ideal_func(s1,s2,s3,A,B,CTemp); - sci::elemWiseAdd<intType>(s1*s3,C,CTemp,C); - delete[] CTemp; - } - else{ - //For minionn kind of hacky runs, switch this off -#ifndef HACKY_RUN - if (modelIsA){ - for(int i=0;i<s1*s2;i++) assert(A[i]==0); - } - else{ - for(int i=0;i<s1*s2;i++) assert(B[i]==0); - } -#endif - } - -#else //MULTITHREADED_MATMUL is ON - intType* C_ans_arr[numThreads]; - std::thread matmulThreads[numThreads]; - for(int i=0;i<numThreads;i++){ - C_ans_arr[i] = new intType[s1*s3]; - matmulThreads[i] = std::thread(funcMatmulThread,i,numThreads,s1,s2,s3,A,B,C_ans_arr[i],partyWithAInAB_mul); - } - for(int i=0;i<numThreads;i++){ - matmulThreads[i].join(); - } - for(int i=0;i<s1*s3;i++){ - C[i] = 0; - } - for(int i=0;i<numThreads;i++){ - for(int j=0;j<s1*s3;j++){ - C[j] += C_ans_arr[i][j]; - } - delete[] C_ans_arr[i]; - } - - if (party==sci::ALICE){ - intType* CTemp = new intType[s1*s3]; - matmulImpl->ideal_func(s1,s2,s3,A,B,CTemp); - sci::elemWiseAdd<intType>(s1*s3,C,CTemp,C); - delete[] CTemp; - } - else{ - //For minionn kind of hacky runs, switch this off -#ifndef HACKY_RUN - if (modelIsA){ - for(int i=0;i<s1*s2;i++) assert(A[i]==0); - } - else{ - for(int i=0;i<s1*s2;i++) assert(B[i]==0); - } -#endif - } -#endif - intType moduloMask = (1ULL<<bitlength)-1; - if (bitlength==64) moduloMask = -1; - for(int i=0;i<s1*s3;i++){ - C[i] = C[i] & moduloMask; - } - -#elif defined(SCI_HE) - assert(modelIsA == false && "Assuming code generated by compiler produces B as the model."); - std::vector<std::vector<intType>> At(s2); - std::vector<std::vector<intType>> Bt(s3); - std::vector<std::vector<intType>> Ct(s3); - for(int i = 0; i < s2; i++) { - At[i].resize(s1); - for(int j = 0; j < s1; j++) { - At[i][j] = Arr2DIdxRowM(A,s1,s2,j,i); - } - } - for(int i = 0; i < s3; i++) { - Bt[i].resize(s2); - Ct[i].resize(s1); - for(int j = 0; j < s2; j++) { - Bt[i][j] = Arr2DIdxRowM(B,s2,s3,j,i); - } - } - heFCImpl->matrix_multiplication(s3,s2,s1,Bt,At,Ct); - for(int i = 0; i < s1; i++) { - for(int j = 0; j < s3; j++) { - Arr2DIdxRowM(C,s1,s3,i,j) = Ct[j][i]; - } - } -#endif - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - MatmulTimeInMilliSec += temp; - std::cout<<"Time in sec for current matmul = "<<(temp/1000.0)<<std::endl; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - MatmulCommSent += curComm; -#endif - -#ifdef VERIFY_LAYERWISE -#ifdef SCI_HE - for(int i = 0; i < s1; i++) { - for(int j = 0; j < s3; j++) { - assert(Arr2DIdxRowM(C,s1,s3,i,j) < prime_mod); - } - } -#endif - if (party == SERVER) { - funcReconstruct2PCCons(nullptr, A, s1*s2); - funcReconstruct2PCCons(nullptr, B, s2*s3); - funcReconstruct2PCCons(nullptr, C, s1*s3); - } - else { - signedIntType* VA = new signedIntType[s1*s2]; - funcReconstruct2PCCons(VA, A, s1*s2); - signedIntType* VB = new signedIntType[s2*s3]; - funcReconstruct2PCCons(VB, B, s2*s3); - signedIntType* VC = new signedIntType[s1*s3]; - funcReconstruct2PCCons(VC, C, s1*s3); - - std::vector<std::vector<uint64_t>> VAvec; - std::vector<std::vector<uint64_t>> VBvec; - std::vector<std::vector<uint64_t>> VCvec; - VAvec.resize(s1,std::vector<uint64_t>(s2,0)); - VBvec.resize(s2,std::vector<uint64_t>(s3,0)); - VCvec.resize(s1,std::vector<uint64_t>(s3,0)); - - for(int i = 0; i < s1; i++) { - for(int j = 0; j < s2; j++) { - VAvec[i][j] = getRingElt(Arr2DIdxRowM(VA,s1,s2,i,j)); - } - } - for(int i = 0; i < s2; i++) { - for(int j = 0; j < s3; j++) { - VBvec[i][j] = getRingElt(Arr2DIdxRowM(VB,s2,s3,i,j)); - } - } - - MatMul2D_pt(s1, s2, s3, VAvec, VBvec, VCvec, 0); - - bool pass = true; - for(int i = 0; i < s1; i++) { - for(int j = 0; j < s3; j++) { - if(Arr2DIdxRowM(VC,s1,s3,i,j) != getSignedVal(VCvec[i][j])) { - pass = false; - } - } - } - if (pass == true) std::cout << GREEN << "MatMul Output Matches" << RESET << std::endl; - else std::cout << RED << "MatMul Output Mismatch" << RESET << std::endl; - - delete[] VA; - delete[] VB; - delete[] VC; - } -#endif -} - - -void ArgMax(int32_t s1, int32_t s2, intType* inArr, intType* outArr) -{ -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - - static int ctr = 1; - std::cout<<"ArgMax "<<ctr<<" called, s1="<<s1<<", s2="<<s2<<std::endl; - ctr++; - - assert(s1==1 && "ArgMax impl right now assumes s1==1"); - argmaxImpl->ArgMaxMPC(s2,inArr,outArr); - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - ArgmaxTimeInMilliSec += temp; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - ArgmaxCommSent += curComm; -#endif - -#ifdef VERIFY_LAYERWISE - if (party == SERVER) { - funcReconstruct2PCCons(nullptr, inArr, s1*s2); - funcReconstruct2PCCons(nullptr, outArr, s1); - } - else { - signedIntType* VinArr = new signedIntType[s1*s2]; - funcReconstruct2PCCons(VinArr, inArr, s1*s2); - signedIntType* VoutArr = new signedIntType[s1]; - funcReconstruct2PCCons(VoutArr, outArr, s1); - - std::vector<std::vector<uint64_t>> VinVec; - VinVec.resize(s1,std::vector<uint64_t>(s2,0)); - std::vector<uint64_t> VoutVec(s1); - - for(int i = 0; i < s1; i++) { - for(int j = 0; j < s2; j++) { - VinVec[i][j] = getRingElt(Arr2DIdxRowM(VinArr,s1,s2,i,j)); - } - } - - ArgMax_pt(s1, s2, VinVec, VoutVec); - - bool pass = true; - for(int i = 0; i < s1; i++) { - if(VoutArr[i] != getSignedVal(VoutVec[i])) { - pass = false; - std::cout << VoutArr[i] << "\t" << getSignedVal(VoutVec[i]) << std::endl; - } - } - if (pass == true) std::cout << GREEN << "ArgMax1 Output Matches" << RESET << std::endl; - else std::cout << RED << "ArgMax1 Output Mismatch" << RESET << std::endl; - - delete[] VinArr; - delete[] VoutArr; - } -#endif -} - - -void Relu(int32_t size, intType* inArr, intType* outArr, int sf, bool doTruncation) -{ -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - - static int ctr = 1; - std::cout<<"Relu "<<ctr<<" called size="<<size<<std::endl; - ctr++; - - intType moduloMask = sci::all1Mask(bitlength); - int eightDivElemts = ((size + 8 - 1)/8)*8; //(ceil of s1*s2/8.0)*8 - uint8_t* msbShare = new uint8_t[eightDivElemts]; - intType* tempInp = new intType[eightDivElemts]; - intType* tempOutp = new intType[eightDivElemts]; - sci::copyElemWisePadded(size, inArr, eightDivElemts, tempInp, 0); - -#ifndef MULTITHREADED_NONLIN - reluImpl->relu(tempOutp, tempInp, eightDivElemts, nullptr); -#else - std::thread relu_threads[numThreads]; - int chunk_size = (eightDivElemts/(8*numThreads))*8; - for (int i = 0; i < numThreads; ++i) { - int offset = i*chunk_size; - int lnum_relu; - if (i == (numThreads - 1)) { - lnum_relu = eightDivElemts - offset; - } else { - lnum_relu = chunk_size; - } - relu_threads[i] = std::thread(funcReLUThread, i, tempOutp+offset, tempInp+offset, lnum_relu, nullptr, false); - } - for (int i = 0; i < numThreads; ++i) { - relu_threads[i].join(); - } -#endif - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - ReluTimeInMilliSec += temp; - std::cout<<"Time in sec for current relu = "<<(temp/1000.0)<<std::endl; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - ReluCommSent += curComm; -#endif - - if (doTruncation) - { -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - for(int i=0;i<eightDivElemts;i++){ - msbShare[i] = 0; //After relu, all numbers are +ve - } - -#ifdef SCI_OT - for(int i=0;i<eightDivElemts;i++){ - tempOutp[i] = tempOutp[i] & moduloMask; - } - funcTruncateTwoPowerRingWrapper(eightDivElemts, tempOutp, outArr, sf, msbShare, true); -#else - funcFieldDivWrapper<intType>(size, tempOutp, outArr, 1ULL<<sf, msbShare); -#endif - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - TruncationTimeInMilliSec += temp; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - TruncationCommSent += curComm; -#endif - } - else { - for(int i=0;i<size;i++){ - outArr[i] = tempOutp[i]; - } - } - -#ifdef SCI_OT - for(int i=0;i<size;i++){ - outArr[i] = outArr[i] & moduloMask; - } -#endif - -#ifdef VERIFY_LAYERWISE -#ifdef SCI_HE - for(int i=0;i<size;i++){ - assert(tempOutp[i] < prime_mod); - assert(outArr[i] < prime_mod); - } -#endif - - if (party == SERVER){ - funcReconstruct2PCCons(nullptr, inArr, size); - funcReconstruct2PCCons(nullptr, tempOutp, size); - funcReconstruct2PCCons(nullptr, outArr, size); - } - else{ - signedIntType* VinArr = new signedIntType[size]; - funcReconstruct2PCCons(VinArr, inArr, size); - signedIntType* VtempOutpArr = new signedIntType[size]; - funcReconstruct2PCCons(VtempOutpArr, tempOutp, size); - signedIntType* VoutArr = new signedIntType[size]; - funcReconstruct2PCCons(VoutArr, outArr, size); - - std::vector<uint64_t> VinVec; - VinVec.resize(size,0); - - std::vector<uint64_t> VoutVec; - VoutVec.resize(size,0); - - for(int i=0;i<size;i++){ - VinVec[i] = getRingElt(VinArr[i]); - } - - Relu_pt(size, VinVec, VoutVec, 0, false); // sf = 0 - - bool pass = true; - for(int i=0;i<size;i++){ - if (VtempOutpArr[i] != getSignedVal(VoutVec[i])) { - pass = false; - } - } - if (pass == true) std::cout << GREEN << "ReLU Output Matches" << RESET << std::endl; - else std::cout << RED << "ReLU Output Mismatch" << RESET << std::endl; - - ScaleDown_pt(size, VoutVec, sf); - - pass = true; - for(int i=0;i<size;i++){ - if (VoutArr[i] != getSignedVal(VoutVec[i])) { - pass = false; - } - } - if (pass == true) std::cout << GREEN << "Truncation (after ReLU) Output Matches" << RESET << std::endl; - else std::cout << RED << "Truncation (after ReLU) Output Mismatch" << RESET << std::endl; - - delete[] VinArr; - delete[] VtempOutpArr; - delete[] VoutArr; - } -#endif - - delete[] tempInp; - delete[] tempOutp; - delete[] msbShare; -} - -void MaxPool(int32_t N, int32_t H, int32_t W, int32_t C, - int32_t ksizeH, int32_t ksizeW, - int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, - int32_t strideH, int32_t strideW, - int32_t N1, int32_t imgH, int32_t imgW, int32_t C1, - intType* inArr, - intType* outArr) -{ -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - - static int ctr = 1; - std::cout<<"Maxpool "<<ctr<<" called N="<<N<<", H="<<H<<", W="<<W<<", C="<<C<<", ksizeH="<<ksizeH<<", ksizeW="<<ksizeW<<std::endl; - ctr++; - - uint64_t moduloMask = sci::all1Mask(bitlength); - int rowsOrig = N*H*W*C; - int rows = ((rowsOrig + 8 - 1)/8)*8; //(ceil of rows/8.0)*8 - int cols = ksizeH*ksizeW; - - intType* reInpArr = new intType[rows*cols]; - intType* maxi = new intType[rows]; - intType* maxiIdx = new intType[rows]; - - int rowIdx = 0; - for(int n=0;n<N;n++){ - for(int c=0;c<C;c++){ - int32_t leftTopCornerH = -zPadHLeft; - int32_t extremeRightBottomCornerH = imgH - 1 + zPadHRight; - while((leftTopCornerH + ksizeH - 1) <= extremeRightBottomCornerH){ - int32_t leftTopCornerW = -zPadWLeft; - int32_t extremeRightBottomCornerW = imgW - 1 + zPadWRight; - while((leftTopCornerW + ksizeW - 1) <= extremeRightBottomCornerW){ - - for(int fh=0;fh<ksizeH;fh++){ - for(int fw=0;fw<ksizeW;fw++){ - int32_t colIdx = fh*ksizeW + fw; - int32_t finalIdx = rowIdx*(ksizeH*ksizeW) + colIdx; - - int32_t curPosH = leftTopCornerH + fh; - int32_t curPosW = leftTopCornerW + fw; - - intType temp = 0; - if ((((curPosH < 0) || (curPosH >= imgH)) || ((curPosW < 0) || (curPosW >= imgW)))){ - temp = 0; - } - else{ - temp = Arr4DIdxRowM(inArr,N,imgH,imgW,C,n,curPosH,curPosW,c); - } - reInpArr[finalIdx] = temp; - } - } - - rowIdx += 1; - leftTopCornerW = leftTopCornerW + strideW; - } - - leftTopCornerH = leftTopCornerH + strideH; - } - } - } - - for(int i=rowsOrig;i<rows;i++){ - for(int j=0;j<cols;j++){ - reInpArr[i*cols + j] = 0; //The extra padded values - } - } - -#ifndef MULTITHREADED_NONLIN - maxpoolImpl->funcMaxMPC(rows, cols, reInpArr, maxi, maxiIdx); -#else - std::thread maxpool_threads[numThreads]; - int chunk_size = (rows/(8*numThreads))*8; - for (int i = 0; i < numThreads; ++i) { - int offset = i*chunk_size; - int lnum_rows; - if (i == (numThreads - 1)) { - lnum_rows = rows - offset; - } else { - lnum_rows = chunk_size; - } - maxpool_threads[i] = std::thread(funcMaxpoolThread, i, lnum_rows, cols, - reInpArr+offset*cols, maxi+offset, maxiIdx+offset); - } - for (int i = 0; i < numThreads; ++i) { - maxpool_threads[i].join(); - } -#endif - - for(int n=0;n<N;n++){ - for(int c=0;c<C;c++){ - for(int h=0;h<H;h++){ - for(int w=0;w<W;w++){ - int iidx = n*C*H*W + c*H*W + h*W + w; - Arr4DIdxRowM(outArr,N,H,W,C,n,h,w,c) = maxi[iidx]; -#ifdef SCI_OT - Arr4DIdxRowM(outArr,N,H,W,C,n,h,w,c) = Arr4DIdxRowM(outArr,N,H,W,C,n,h,w,c) & moduloMask; -#endif - } - } - } - } - - delete[] reInpArr; - delete[] maxi; - delete[] maxiIdx; - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - MaxpoolTimeInMilliSec += temp; - std::cout<<"Time in sec for current maxpool = "<<(temp/1000.0)<<std::endl; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - MaxpoolCommSent += curComm; -#endif - -#ifdef VERIFY_LAYERWISE -#ifdef SCI_HE - for(int i=0;i<N;i++){ - for(int j=0;j<H;j++){ - for(int k=0;k<W;k++){ - for(int p=0;p<C;p++){ - assert(Arr4DIdxRowM(outArr,N,H,W,C,i,j,k,p) < prime_mod); - } - } - } - } -#endif - if (party == SERVER) { - funcReconstruct2PCCons(nullptr, inArr, N*imgH*imgW*C); - funcReconstruct2PCCons(nullptr, outArr, N*H*W*C); - } - else { - signedIntType* VinArr = new signedIntType[N*imgH*imgW*C]; - funcReconstruct2PCCons(VinArr, inArr, N*imgH*imgW*C); - signedIntType* VoutArr = new signedIntType[N*H*W*C]; - funcReconstruct2PCCons(VoutArr, outArr, N*H*W*C); - - std::vector< std::vector< std::vector< std::vector<uint64_t>>>> VinVec; - VinVec.resize(N,std::vector< std::vector< std::vector<uint64_t>>>(imgH,std::vector< std::vector<uint64_t>>(imgW,std::vector<uint64_t>(C,0)))); - - std::vector< std::vector< std::vector< std::vector<uint64_t>>>> VoutVec; - VoutVec.resize(N,std::vector< std::vector< std::vector<uint64_t>>>(H,std::vector< std::vector<uint64_t>>(W,std::vector<uint64_t>(C,0)))); - - for(int i=0;i<N;i++){ - for(int j=0;j<imgH;j++){ - for(int k=0;k<imgW;k++){ - for(int p=0;p<C;p++){ - VinVec[i][j][k][p] = getRingElt(Arr4DIdxRowM(VinArr,N,imgH,imgW,C,i,j,k,p)); - } - } - } - } - - MaxPool_pt(N, H, W, C, ksizeH, ksizeW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, N1, imgH, imgW, C1, VinVec, VoutVec); - - bool pass = true; - for(int i=0;i<N;i++){ - for(int j=0;j<H;j++){ - for(int k=0;k<W;k++){ - for(int p=0;p<C;p++){ - if (Arr4DIdxRowM(VoutArr,N,H,W,C,i,j,k,p) != getSignedVal(VoutVec[i][j][k][p])) { - pass = false; - } - } - } - } - } - if (pass == true) std::cout << GREEN << "Maxpool Output Matches" << RESET << std::endl; - else std::cout << RED << "Maxpool Output Mismatch" << RESET << std::endl; - - delete[] VinArr; - delete[] VoutArr; - } -#endif -} - -void AvgPool(int32_t N, int32_t H, int32_t W, int32_t C, - int32_t ksizeH, int32_t ksizeW, - int32_t zPadHLeft, int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, - int32_t strideH, int32_t strideW, - int32_t N1, int32_t imgH, int32_t imgW, int32_t C1, - intType* inArr, - intType* outArr) -{ -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - - static int ctr = 1; - std::cout<<"AvgPool "<<ctr<<" called N="<<N<<", H="<<H<<", W="<<W<<", C="<<C<<", ksizeH="<<ksizeH<<", ksizeW="<<ksizeW<<std::endl; - ctr++; - - uint64_t moduloMask = sci::all1Mask(bitlength); - int rows = N*H*W*C; - int rowsPadded = ((rows + 8 - 1)/8)*8; - intType* filterSum = new intType[rowsPadded]; - intType* filterAvg = new intType[rowsPadded]; - - int rowIdx = 0; - for(int n=0;n<N;n++){ - for(int c=0;c<C;c++){ - int32_t leftTopCornerH = -zPadHLeft; - int32_t extremeRightBottomCornerH = imgH - 1 + zPadHRight; - while((leftTopCornerH + ksizeH - 1) <= extremeRightBottomCornerH){ - int32_t leftTopCornerW = -zPadWLeft; - int32_t extremeRightBottomCornerW = imgW - 1 + zPadWRight; - while((leftTopCornerW + ksizeW - 1) <= extremeRightBottomCornerW){ - - intType curFilterSum = 0; - for(int fh=0;fh<ksizeH;fh++){ - for(int fw=0;fw<ksizeW;fw++){ - int32_t curPosH = leftTopCornerH + fh; - int32_t curPosW = leftTopCornerW + fw; - - intType temp = 0; - if ((((curPosH < 0) || (curPosH >= imgH)) || ((curPosW < 0) || (curPosW >= imgW)))){ - temp = 0; - } - else{ - temp = Arr4DIdxRowM(inArr,N,imgH,imgW,C,n,curPosH,curPosW,c); - } -#ifdef SCI_OT - curFilterSum += temp; -#else - curFilterSum = sci::neg_mod(curFilterSum+temp,(int64_t)prime_mod); -#endif - } - } - - filterSum[rowIdx] = curFilterSum; - rowIdx += 1; - leftTopCornerW = leftTopCornerW + strideW; - } - - leftTopCornerH = leftTopCornerH + strideH; - } - } - } - - for(int i=rows;i<rowsPadded;i++){ - filterSum[i] = 0; - } - -#ifdef SCI_OT - for(int i=0;i<rowsPadded;i++){ - filterSum[i] = filterSum[i] & moduloMask; - } - funcAvgPoolTwoPowerRingWrapper(rowsPadded,filterSum,filterAvg,ksizeH*ksizeW); -#else - funcFieldDivWrapper<intType>(rowsPadded,filterSum,filterAvg,ksizeH*ksizeW,nullptr); -#endif - - for(int n=0;n<N;n++){ - for(int c=0;c<C;c++){ - for(int h=0;h<H;h++){ - for(int w=0;w<W;w++){ - int iidx = n*C*H*W + c*H*W + h*W + w; - Arr4DIdxRowM(outArr,N,H,W,C,n,h,w,c) = filterAvg[iidx]; -#ifdef SCI_OT - Arr4DIdxRowM(outArr,N,H,W,C,n,h,w,c) = Arr4DIdxRowM(outArr,N,H,W,C,n,h,w,c) & moduloMask; -#endif - } - } - } - } - - delete[] filterSum; - delete[] filterAvg; - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - AvgpoolTimeInMilliSec += temp; - std::cout<<"Time in sec for current avgpool = "<<(temp/1000.0)<<std::endl; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - AvgpoolCommSent += curComm; -#endif - -#ifdef VERIFY_LAYERWISE -#ifdef SCI_HE - for(int i=0;i<N;i++){ - for(int j=0;j<H;j++){ - for(int k=0;k<W;k++){ - for(int p=0;p<C;p++){ - assert(Arr4DIdxRowM(outArr,N,H,W,C,i,j,k,p) < prime_mod); - } - } - } - } -#endif - if (party == SERVER) { - funcReconstruct2PCCons(nullptr, inArr, N*imgH*imgW*C); - funcReconstruct2PCCons(nullptr, outArr, N*H*W*C); - } - else { - signedIntType* VinArr = new signedIntType[N*imgH*imgW*C]; - funcReconstruct2PCCons(VinArr, inArr, N*imgH*imgW*C); - signedIntType* VoutArr = new signedIntType[N*H*W*C]; - funcReconstruct2PCCons(VoutArr, outArr, N*H*W*C); - - std::vector< std::vector< std::vector< std::vector<uint64_t>>>> VinVec; - VinVec.resize(N,std::vector< std::vector< std::vector<uint64_t>>>(imgH,std::vector< std::vector<uint64_t>>(imgW,std::vector<uint64_t>(C,0)))); - - std::vector< std::vector< std::vector< std::vector<uint64_t>>>> VoutVec; - VoutVec.resize(N,std::vector< std::vector< std::vector<uint64_t>>>(H,std::vector< std::vector<uint64_t>>(W,std::vector<uint64_t>(C,0)))); - - for(int i=0;i<N;i++){ - for(int j=0;j<imgH;j++){ - for(int k=0;k<imgW;k++){ - for(int p=0;p<C;p++){ - VinVec[i][j][k][p] = getRingElt(Arr4DIdxRowM(VinArr,N,imgH,imgW,C,i,j,k,p)); - } - } - } - } - - AvgPool_pt(N, H, W, C, ksizeH, ksizeW, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, N1, imgH, imgW, C1, VinVec, VoutVec); - - bool pass = true; - for(int i=0;i<N;i++){ - for(int j=0;j<H;j++){ - for(int k=0;k<W;k++){ - for(int p=0;p<C;p++){ - if (Arr4DIdxRowM(VoutArr,N,H,W,C,i,j,k,p) != getSignedVal(VoutVec[i][j][k][p])) { - pass = false; - } - } - } - } - } - - if (pass == true) std::cout << GREEN << "AvgPool Output Matches" << RESET << std::endl; - else std::cout << RED << "AvgPool Output Mismatch" << RESET << std::endl; - - delete[] VinArr; - delete[] VoutArr; - } -#endif -} - -void Conv2DWrapper(signedIntType N, signedIntType H, signedIntType W, signedIntType CI, - signedIntType FH, signedIntType FW, signedIntType CO, - signedIntType zPadHLeft, signedIntType zPadHRight, - signedIntType zPadWLeft, signedIntType zPadWRight, - signedIntType strideH, signedIntType strideW, - intType* inputArr, - intType* filterArr, - intType* outArr) -{ -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - - static int ctr = 1; - std::cout<<"Conv2DCSF "<<ctr<<" called N="<<N<<", H="<<H<<", W="<<W<<", CI="<<CI<<", FH="<<FH<<", FW="<<FW<<", CO="<<CO<<", S="<<strideH<<std::endl; - ctr++; - - signedIntType newH = (((H + (zPadHLeft+zPadHRight) - FH)/strideH) + 1); - signedIntType newW = (((W + (zPadWLeft+zPadWRight) - FW)/strideW) + 1); - -#ifdef SCI_OT - // If its a ring, then its a OT based -- use the default Conv2DCSF implementation that comes from the EzPC library - Conv2D(N,H,W,CI,FH,FW,CO,zPadHLeft,zPadHRight,zPadWLeft,zPadWRight,strideH,strideW,inputArr,filterArr,outArr); -#else - // If its a field, then its a HE based -- use the HE based conv implementation - std::vector< std::vector< std::vector< std::vector<intType>>>> inputVec; - inputVec.resize(N,std::vector< std::vector< std::vector<intType>>>(H,std::vector< std::vector<intType>>(W,std::vector<intType>(CI,0)))); - - std::vector< std::vector< std::vector< std::vector<intType>>>> filterVec; - filterVec.resize(FH,std::vector< std::vector< std::vector<intType>>>(FW,std::vector< std::vector<intType>>(CI,std::vector<intType>(CO,0)))); - - std::vector< std::vector< std::vector< std::vector<intType>>>> outputVec; - outputVec.resize(N,std::vector< std::vector< std::vector<intType>>>(newH,std::vector< std::vector<intType>>(newW,std::vector<intType>(CO,0)))); - - for(int i=0;i<N;i++){ - for(int j=0;j<H;j++){ - for(int k=0;k<W;k++){ - for(int p=0;p<CI;p++){ - inputVec[i][j][k][p] = Arr4DIdxRowM(inputArr,N,H,W,CI,i,j,k,p); - } - } - } - } - for(int i=0;i<FH;i++){ - for(int j=0;j<FW;j++){ - for(int k=0;k<CI;k++){ - for(int p=0;p<CO;p++){ - filterVec[i][j][k][p] = Arr4DIdxRowM(filterArr,FH,FW,CI,CO,i,j,k,p); - } - } - } - } - - heConvImpl->convolution(N,H,W,CI,FH,FW,CO, - zPadHLeft,zPadHRight,zPadWLeft,zPadWRight,strideH,strideW,inputVec,filterVec,outputVec); - - for(int i=0;i<N;i++){ - for(int j=0;j<newH;j++){ - for(int k=0;k<newW;k++){ - for(int p=0;p<CO;p++){ - Arr4DIdxRowM(outArr,N,newH,newW,CO,i,j,k,p) = outputVec[i][j][k][p]; - } - } - } - } - -#endif - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - ConvTimeInMilliSec += temp; - std::cout<<"Time in sec for current conv = "<<(temp/1000.0)<<std::endl; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - ConvCommSent += curComm; -#endif - -#ifdef VERIFY_LAYERWISE -#ifdef SCI_HE - for(int i=0;i<N;i++){ - for(int j=0;j<newH;j++){ - for(int k=0;k<newW;k++){ - for(int p=0;p<CO;p++){ - assert(Arr4DIdxRowM(outArr,N,newH,newW,CO,i,j,k,p) < prime_mod); - } - } - } - } -#endif - if (party == SERVER) { - funcReconstruct2PCCons(nullptr, inputArr, N*H*W*CI); - funcReconstruct2PCCons(nullptr, filterArr, FH*FW*CI*CO); - funcReconstruct2PCCons(nullptr, outArr, N*newH*newW*CO); - } - else { - signedIntType* VinputArr = new signedIntType[N*H*W*CI]; - funcReconstruct2PCCons(VinputArr, inputArr, N*H*W*CI); - signedIntType* VfilterArr = new signedIntType[FH*FW*CI*CO]; - funcReconstruct2PCCons(VfilterArr, filterArr, FH*FW*CI*CO); - signedIntType* VoutputArr = new signedIntType[N*newH*newW*CO]; - funcReconstruct2PCCons(VoutputArr, outArr, N*newH*newW*CO); - - std::vector< std::vector< std::vector< std::vector<uint64_t>>>> VinputVec; - VinputVec.resize(N,std::vector< std::vector< std::vector<uint64_t>>>(H,std::vector< std::vector<uint64_t>>(W,std::vector<uint64_t>(CI,0)))); - - std::vector< std::vector< std::vector< std::vector<uint64_t>>>> VfilterVec; - VfilterVec.resize(FH,std::vector< std::vector< std::vector<uint64_t>>>(FW,std::vector< std::vector<uint64_t>>(CI,std::vector<uint64_t>(CO,0)))); - - std::vector< std::vector< std::vector< std::vector<uint64_t>>>> VoutputVec; - VoutputVec.resize(N,std::vector< std::vector< std::vector<uint64_t>>>(newH,std::vector< std::vector<uint64_t>>(newW,std::vector<uint64_t>(CO,0)))); - - for(int i=0;i<N;i++){ - for(int j=0;j<H;j++){ - for(int k=0;k<W;k++){ - for(int p=0;p<CI;p++){ - VinputVec[i][j][k][p] = getRingElt(Arr4DIdxRowM(VinputArr,N,H,W,CI,i,j,k,p)); - } - } - } - } - for(int i=0;i<FH;i++){ - for(int j=0;j<FW;j++){ - for(int k=0;k<CI;k++){ - for(int p=0;p<CO;p++){ - VfilterVec[i][j][k][p] = getRingElt(Arr4DIdxRowM(VfilterArr,FH,FW,CI,CO,i,j,k,p)); - } - } - } - } - - Conv2DWrapper_pt(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideH, strideW, VinputVec, VfilterVec, VoutputVec); // consSF = 0 - - bool pass = true; - for(int i=0;i<N;i++){ - for(int j=0;j<newH;j++){ - for(int k=0;k<newW;k++){ - for(int p=0;p<CO;p++){ - if (Arr4DIdxRowM(VoutputArr,N,newH,newW,CO,i,j,k,p) != getSignedVal(VoutputVec[i][j][k][p])) { - pass = false; - } - } - } - } - } - if (pass == true) std::cout << GREEN << "Convolution Output Matches" << RESET << std::endl; - else std::cout << RED << "Convolution Output Mismatch" << RESET << std::endl; - - delete[] VinputArr; - delete[] VfilterArr; - delete[] VoutputArr; - } -#endif -} - -void Conv2DGroupWrapper(signedIntType N, signedIntType H, signedIntType W, signedIntType CI, - signedIntType FH, signedIntType FW, signedIntType CO, - signedIntType zPadHLeft, signedIntType zPadHRight, - signedIntType zPadWLeft, signedIntType zPadWRight, - signedIntType strideH, signedIntType strideW, signedIntType G, - intType* inputArr, - intType* filterArr, - intType* outArr) -{ -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - - static int ctr = 1; - std::cout<<"Conv2DGroupCSF "<<ctr<<" called N="<<N<<", H="<<H<<", W="<<W<<", CI="<<CI<<", FH="<<FH<<", FW="<<FW<<", CO="<<CO<<", S="<<strideH<<",G="<<G<<std::endl; - ctr++; - -#ifdef SCI_OT - // If its a ring, then its a OT based -- use the default Conv2DGroupCSF implementation that comes from the EzPC library - Conv2DGroup(N,H,W,CI,FH,FW,CO,zPadHLeft,zPadHRight,zPadWLeft,zPadWRight,strideH,strideW,G,inputArr,filterArr,outArr); -#else - assert(false && "Grouped conv not implemented in HE"); -#endif - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - ConvTimeInMilliSec += temp; - std::cout<<"Time in sec for current conv = "<<(temp/1000.0)<<std::endl; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - ConvCommSent += curComm; -#endif - -} - -void ElemWiseActModelVectorMult(int32_t size, intType* inArr, intType* multArrVec, intType* outputArr) -{ -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - - if (party==CLIENT){ - for(int i=0;i<size;i++){ - assert((multArrVec[i] == 0) - && "The semantics of ElemWiseActModelVectorMult dictate multArrVec should be the model and client share should be 0 for it."); - } - } - - static int batchNormCtr = 1; - std::cout<<"Starting fused batchNorm #"<<batchNormCtr<<std::endl; - batchNormCtr++; - -#ifdef SCI_OT -#ifdef MULTITHREADED_DOTPROD - std::thread dotProdThreads[numThreads]; - int chunk_size = (size/numThreads); - intType* inputArrPtr; - if (party==SERVER){ - inputArrPtr = multArrVec; - } - else{ - inputArrPtr = inArr; - } - for (int i = 0; i < numThreads; i++) { - int offset = i*chunk_size; - int curSize; - if (i == (numThreads - 1)) { - curSize = size - offset; - } - else{ - curSize = chunk_size; - } - dotProdThreads[i] = std::thread(funcDotProdThread, - i, numThreads, curSize, inputArrPtr+offset, outputArr+offset); - } - for (int i = 0; i < numThreads; ++i) { - dotProdThreads[i].join(); - } -#else - if (party==SERVER){ - matmulImpl->funcDotProdOTSender(size,multArrVec,outputArr,iknpOT); - } - else{ - matmulImpl->funcDotProdOTReceiver(size,inArr,outputArr,iknpOT); - } -#endif - - if (party==SERVER){ - for(int i=0;i<size;i++){ - outputArr[i] += (inArr[i]*multArrVec[i]); - } - } - else{ - for(int i=0;i<size;i++){ - assert(multArrVec[i]==0 && "Client's share of model is non-zero."); - } - } - -#else // SCI-HE - std::vector<uint64_t> tempInArr(size); - std::vector<uint64_t> tempOutArr(size); - std::vector<uint64_t> tempMultArr(size); - - for(int i = 0; i < size; i++) { - tempInArr[i] = inArr[i]; - tempMultArr[i] = multArrVec[i]; - } - - heProdImpl->elemwise_product(size, tempInArr, tempMultArr, tempOutArr); - - for(int i = 0; i < size; i++) { - outputArr[i] = tempOutArr[i]; - } -#endif - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - BatchNormInMilliSec += temp; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - BatchNormCommSent += curComm; -#endif - -#ifdef VERIFY_LAYERWISE -#ifdef SCI_HE - for(int i=0;i<size;i++){ - assert(outputArr[i] < prime_mod); - } -#endif - if (party == SERVER) { - funcReconstruct2PCCons(nullptr, inArr, size); - funcReconstruct2PCCons(nullptr, multArrVec, size); - funcReconstruct2PCCons(nullptr, outputArr, size); - } - else { - signedIntType* VinArr = new signedIntType[size]; - funcReconstruct2PCCons(VinArr, inArr, size); - signedIntType* VmultArr = new signedIntType[size]; - funcReconstruct2PCCons(VmultArr, multArrVec, size); - signedIntType* VoutputArr = new signedIntType[size]; - funcReconstruct2PCCons(VoutputArr, outputArr, size); - - std::vector<uint64_t> VinVec(size); - std::vector<uint64_t> VmultVec(size); - std::vector<uint64_t> VoutputVec(size); - - for(int i=0;i<size;i++){ - VinVec[i] = getRingElt(VinArr[i]); - VmultVec[i] = getRingElt(VmultArr[i]); - } - - ElemWiseActModelVectorMult_pt(size, VinVec, VmultVec, VoutputVec); - - bool pass = true; - for(int i=0;i<size;i++){ - if (VoutputArr[i] != getSignedVal(VoutputVec[i])){ - pass = false; - } - } - if (pass == true) std::cout << GREEN << "ElemWiseSecretVectorMult Output Matches" << RESET << std::endl; - else std::cout << RED << "ElemWiseSecretVectorMult Output Mismatch" << RESET << std::endl; - - delete[] VinArr; - delete[] VmultArr; - delete[] VoutputArr; - } -#endif -} - -void ScaleDown(int32_t size, intType* inArr, int32_t sf) -{ -#ifdef LOG_LAYERWISE - INIT_ALL_IO_DATA_SENT; - INIT_TIMER; -#endif - - int eightDivElemts = ((size + 8 - 1)/8)*8; //(ceil of s1*s2/8.0)*8 - intType* tempInp; - if(size != eightDivElemts) { - tempInp = new intType[eightDivElemts]; - memcpy(tempInp, inArr, sizeof(intType)*size); - } - else { - tempInp = inArr; - } - uint64_t moduloMask = sci::all1Mask(bitlength); - for(int i=0;i<eightDivElemts;i++){ - tempInp[i] = tempInp[i] & moduloMask; - } - intType* outp = new intType[eightDivElemts]; - -#ifdef SCI_OT - funcTruncateTwoPowerRingWrapper(eightDivElemts, tempInp, outp, sf, nullptr); -#else - funcFieldDivWrapper<intType>(eightDivElemts, tempInp, outp, 1ULL<<sf, nullptr); -#endif - -#ifdef LOG_LAYERWISE - auto temp = TIMER_TILL_NOW; - TruncationTimeInMilliSec += temp; - uint64_t curComm; - FIND_ALL_IO_TILL_NOW(curComm); - TruncationCommSent += curComm; -#endif - -#ifdef VERIFY_LAYERWISE -#ifdef SCI_HE - for(int i=0;i<size;i++){ - assert(outp[i] < prime_mod); - } -#endif - - if (party == SERVER) { - funcReconstruct2PCCons(nullptr, inArr, size); - funcReconstruct2PCCons(nullptr, outp, size); - } - else { - signedIntType* VinArr = new signedIntType[size]; - funcReconstruct2PCCons(VinArr, inArr, size); - signedIntType* VoutpArr = new signedIntType[size]; - funcReconstruct2PCCons(VoutpArr, outp, size); - - std::vector<uint64_t> VinVec; - VinVec.resize(size,0); - - for(int i=0;i<size;i++){ - VinVec[i] = getRingElt(VinArr[i]); - } - - ScaleDown_pt(size, VinVec, sf); - - bool pass = true; - for(int i=0;i<size;i++){ - if (VoutpArr[i] != getSignedVal(VinVec[i])){ - pass = false; - } - } - - if (pass == true) std::cout << GREEN << "Truncation4 Output Matches" << RESET << std::endl; - else std::cout << RED << "Truncation4 Output Mismatch" << RESET << std::endl; - - delete[] VinArr; - delete[] VoutpArr; - } -#endif - - memcpy(inArr, outp, sizeof(intType)*size); - delete[] outp; - if(size != eightDivElemts) - delete[] tempInp; -} - -void ScaleUp(int32_t size, intType* arr, int32_t sf){ - for(int i=0;i<size;i++){ -#ifdef SCI_OT - arr[i] = (arr[i]<<sf); -#else - arr[i] = sci::neg_mod(arr[i]<<sf, (int64_t)prime_mod); -#endif - } -} - -void StartComputation(){ - startTimeTracker = std::chrono::high_resolution_clock::now(); - for(int i=0;i<numThreads;i++){ - auto temp = ioArr[i]->counter; - communicationTracker[i] = temp; - std::cout<<"Thread i = "<<i<<", total data sent till now = "<<temp<<std::endl; - } - std::cout<<"-----------Syncronizing-----------"<<std::endl; - io->sync(); - std::cout<<"-----------Syncronized - now starting execution-----------"<<std::endl; -} - -void EndComputation(){ - auto endTimer = std::chrono::high_resolution_clock::now(); - auto execTimeInMilliSec = std::chrono::duration_cast<std::chrono::milliseconds>(endTimer-startTimeTracker).count(); - uint64_t totalComm = 0; - for(int i=0;i<numThreads;i++){ - auto temp = ioArr[i]->counter; - std::cout<<"Thread i = "<<i<<", total data sent till now = "<<temp<<std::endl; - totalComm += (temp - communicationTracker[i]); - } - uint64_t totalCommClient; - std::cout<<"------------------------------------------------------\n"; - std::cout<<"------------------------------------------------------\n"; - std::cout<<"------------------------------------------------------\n"; - std::cout<<"Total time taken = "<<execTimeInMilliSec<<" milliseconds.\n"; - std::cout<<"Total data sent = "<<(totalComm/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - if (party==SERVER){ - io->recv_data(&totalCommClient, sizeof(uint64_t)); - std::cout<<"Total comm (sent+received) = "<<((totalComm+totalCommClient)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - } - else if (party==CLIENT){ - io->send_data(&totalComm, sizeof(uint64_t)); - std::cout<<"Total comm (sent+received) = (see SERVER OUTPUT)"<<std::endl; - } - std::cout<<"------------------------------------------------------\n"; - -#ifdef LOG_LAYERWISE - std::cout<<"Total time in Conv = "<<(ConvTimeInMilliSec/1000.0)<<" seconds."<<std::endl; - std::cout<<"Total time in Matmul = "<<(MatmulTimeInMilliSec/1000.0)<<" seconds."<<std::endl; - std::cout<<"Total time in BatchNorm = "<<(BatchNormInMilliSec/1000.0)<<" seconds."<<std::endl; - std::cout<<"Total time in Truncation = "<<(TruncationTimeInMilliSec/1000.0)<<" seconds."<<std::endl; - std::cout<<"Total time in Relu = "<<(ReluTimeInMilliSec/1000.0)<<" seconds."<<std::endl; - std::cout<<"Total time in MaxPool = "<<(MaxpoolTimeInMilliSec/1000.0)<<" seconds."<<std::endl; - std::cout<<"Total time in AvgPool = "<<(AvgpoolTimeInMilliSec/1000.0)<<" seconds."<<std::endl; - std::cout<<"Total time in Argmax = "<<(ArgmaxTimeInMilliSec/1000.0)<<" seconds."<<std::endl; - std::cout<<"------------------------------------------------------\n"; - std::cout<<"Conv data sent = "<<((ConvCommSent)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Matmul data sent = "<<((MatmulCommSent)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"BatchNorm data sent = "<<((BatchNormCommSent)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Truncation data sent = "<<((TruncationCommSent)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Relu data sent = "<<((ReluCommSent)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Maxpool data sent = "<<((MaxpoolCommSent)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Avgpool data sent = "<<((AvgpoolCommSent)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Argmax data sent = "<<((ArgmaxCommSent)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"------------------------------------------------------\n"; - if (party==SERVER){ - uint64_t ConvCommSentClient = 0; - uint64_t MatmulCommSentClient = 0; - uint64_t BatchNormCommSentClient = 0; - uint64_t TruncationCommSentClient = 0; - uint64_t ReluCommSentClient = 0; - uint64_t MaxpoolCommSentClient = 0; - uint64_t AvgpoolCommSentClient = 0; - uint64_t ArgmaxCommSentClient = 0; - io->recv_data(&ConvCommSentClient, sizeof(uint64_t)); - io->recv_data(&MatmulCommSentClient, sizeof(uint64_t)); - io->recv_data(&BatchNormCommSentClient, sizeof(uint64_t)); - io->recv_data(&TruncationCommSentClient, sizeof(uint64_t)); - io->recv_data(&ReluCommSentClient, sizeof(uint64_t)); - io->recv_data(&MaxpoolCommSentClient, sizeof(uint64_t)); - io->recv_data(&AvgpoolCommSentClient, sizeof(uint64_t)); - io->recv_data(&ArgmaxCommSentClient, sizeof(uint64_t)); - std::cout<<"Conv data (sent+received) = "<<((ConvCommSent+ConvCommSentClient)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Matmul data (sent+received) = "<<((MatmulCommSent+MatmulCommSentClient)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"BatchNorm data (sent+received) = "<<((BatchNormCommSent+BatchNormCommSentClient)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Truncation data (sent+received) = "<<((TruncationCommSent+TruncationCommSentClient)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Relu data (sent+received) = "<<((ReluCommSent+ReluCommSentClient)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Maxpool data (sent+received) = "<<((MaxpoolCommSent+MaxpoolCommSentClient)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Avgpool data (sent+received) = "<<((AvgpoolCommSent+AvgpoolCommSentClient)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - std::cout<<"Argmax data (sent+received) = "<<((ArgmaxCommSent+ArgmaxCommSentClient)/(1.0*(1ULL<<20)))<<" MiB."<<std::endl; - -#ifdef WRITE_LOG - std::string file_addr = "results-Porthos2PC-server.csv"; - bool write_title = true; { - std::fstream result(file_addr.c_str(), std::fstream::in); - if(result.is_open()) - write_title = false; - result.close(); - } - std::fstream result(file_addr.c_str(), std::fstream::out|std::fstream::app); - if(write_title){ - result << "Network,Algebra,Bitlen,Base,#Threads,Total Time,Total Comm,Conv Time,Conv Comm,MatMul Time,MatMul Comm,BatchNorm Time,BatchNorm Comm,Truncation Time,Truncation Comm,ReLU Time,ReLU Comm,MaxPool Time,MaxPool Comm,AvgPool Time,AvgPool Comm,ArgMax Time,ArgMax Comm" << std::endl; - } - result << get_network_label(network_name) << "," - << (isNativeRing ? "Ring": "Field") << "," - << bitlength << "," - << baseForRelu << "," - << numThreads << "," - << execTimeInMilliSec/1000.0 << "," - << (totalComm+totalCommClient)/(1.0*(1ULL<<20)) << "," - << ConvTimeInMilliSec/1000.0 << "," - << (ConvCommSent+ConvCommSentClient)/(1.0*(1ULL<<20)) << "," - << MatmulTimeInMilliSec/1000.0 << "," - << (MatmulCommSent+MatmulCommSentClient)/(1.0*(1ULL<<20)) << "," - << BatchNormInMilliSec/1000.0 << "," - << (BatchNormCommSent+BatchNormCommSentClient)/(1.0*(1ULL<<20)) << "," - << TruncationTimeInMilliSec/1000.0 << "," - << (TruncationCommSent+TruncationCommSentClient)/(1.0*(1ULL<<20)) << "," - << ReluTimeInMilliSec/1000.0 << "," - << (ReluCommSent+ReluCommSentClient)/(1.0*(1ULL<<20)) << "," - << MaxpoolTimeInMilliSec/1000.0 << "," - << (MaxpoolCommSent+MaxpoolCommSentClient)/(1.0*(1ULL<<20)) << "," - << AvgpoolTimeInMilliSec/1000.0 << "," - << (AvgpoolCommSent+AvgpoolCommSentClient)/(1.0*(1ULL<<20)) << "," - << ArgmaxTimeInMilliSec/1000.0 << "," - << (ArgmaxCommSent+ArgmaxCommSentClient)/(1.0*(1ULL<<20)) << std::endl; - result.close(); -#endif - } - else if (party==CLIENT){ - io->send_data(&ConvCommSent, sizeof(uint64_t)); - io->send_data(&MatmulCommSent, sizeof(uint64_t)); - io->send_data(&BatchNormCommSent, sizeof(uint64_t)); - io->send_data(&TruncationCommSent, sizeof(uint64_t)); - io->send_data(&ReluCommSent, sizeof(uint64_t)); - io->send_data(&MaxpoolCommSent, sizeof(uint64_t)); - io->send_data(&AvgpoolCommSent, sizeof(uint64_t)); - io->send_data(&ArgmaxCommSent, sizeof(uint64_t)); - } -#endif -} - -inline void ClearMemSecret1(int32_t s1, intType* arr){ - delete[] arr; -} - -inline void ClearMemSecret2(int32_t s1, int32_t s2, intType* arr){ - delete[] arr; //At the end of the day, everything is done using 1D array -} - -inline void ClearMemSecret3(int32_t s1, int32_t s2, int32_t s3, intType* arr){ - delete[] arr; -} - -inline void ClearMemSecret4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, intType* arr){ - delete[] arr; -} - -inline void ClearMemSecret5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, intType* arr){ - delete[] arr; -} - -inline void ClearMemPublic(int32_t x){ - return; -} - -inline void ClearMemPublic1(int32_t s1, int32_t* arr){ - delete[] arr; -} - -inline void ClearMemPublic2(int32_t s1, int32_t s2, int32_t* arr){ - delete[] arr; -} - -inline void ClearMemPublic3(int32_t s1, int32_t s2, int32_t s3, int32_t* arr){ - delete[] arr; -} - -inline void ClearMemPublic4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t* arr){ - delete[] arr; -} - -inline void ClearMemPublic5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int32_t* arr){ - delete[] arr; -} - -inline void ClearMemPublic(int64_t x){ - return; -} - -inline void ClearMemPublic1(int32_t s1, int64_t* arr){ - delete[] arr; -} - -inline void ClearMemPublic2(int32_t s1, int32_t s2, int64_t* arr){ - delete[] arr; -} - -inline void ClearMemPublic3(int32_t s1, int32_t s2, int32_t s3, int64_t* arr){ - delete[] arr; -} - -inline void ClearMemPublic4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int64_t* arr){ - delete[] arr; -} - -inline void ClearMemPublic5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, int32_t s5, int64_t* arr){ - delete[] arr; -} - -intType SecretAdd(intType x, intType y){ -#ifdef SCI_OT - return (x+y); -#else - return sci::neg_mod(x+y, (int64_t)prime_mod); -#endif -} - -intType SecretSub(intType x, intType y){ -#ifdef SCI_OT - return (x-y); -#else - return sci::neg_mod(x-y, (int64_t)prime_mod); -#endif -} - -intType SecretMult(intType x, intType y){ - //Not being used in any of our networks right now - assert(false); -} - -void ElemWiseVectorPublicDiv(int32_t s1, intType* arr1, int32_t divisor, intType* outArr){ - //Not being used in any of our networks right now - assert(false); -} - -void ElemWiseSecretSharedVectorMult(int32_t size, intType* inArr, intType* multArrVec, intType* outputArr){ - //Not being used in any of our networks right now - assert(false); -} - -void Floor(int32_t s1, intType* inArr, intType* outArr, int32_t sf){ - //Not being used in any of our networks right now - assert(false); -} - -#endif //FUNCTIONALITIES_WRAPPER_H__ diff --git a/SCI/src/globals.cpp b/SCI/src/globals.cpp new file mode 100644 index 00000000..e5978f1d --- /dev/null +++ b/SCI/src/globals.cpp @@ -0,0 +1,109 @@ +/* +Authors: Nishant Kumar, Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "globals.h" + +sci::NetIO *io; +sci::OTPack<sci::NetIO> *otpack; + +#ifdef SCI_OT +LinearOT *mult; +AuxProtocols *aux; +Truncation *truncation; +XTProtocol *xt; +MathFunctions *math; +#endif +ArgMaxProtocol<sci::NetIO, intType> *argmax; +ReLUProtocol<sci::NetIO, intType> *relu; +MaxPoolProtocol<sci::NetIO, intType> *maxpool; +// Additional classes for Athos +#ifdef SCI_OT +MatMulUniform<sci::NetIO, intType, sci::IKNP<sci::NetIO>> *multUniform; +#endif +#ifdef SCI_HE +ConvField *he_conv; +FCField *he_fc; +ElemWiseProdField *he_prod; +#endif +sci::IKNP<sci::NetIO> *iknpOT; +sci::IKNP<sci::NetIO> *iknpOTRoleReversed; +sci::KKOT<sci::NetIO> *kkot; +sci::PRG128 *prg128Instance; + +sci::NetIO *ioArr[MAX_THREADS]; +sci::OTPack<sci::NetIO> *otpackArr[MAX_THREADS]; +#ifdef SCI_OT +LinearOT *multArr[MAX_THREADS]; +AuxProtocols *auxArr[MAX_THREADS]; +Truncation *truncationArr[MAX_THREADS]; +XTProtocol *xtArr[MAX_THREADS]; +MathFunctions *mathArr[MAX_THREADS]; +#endif +ReLUProtocol<sci::NetIO, intType> *reluArr[MAX_THREADS]; +MaxPoolProtocol<sci::NetIO, intType> *maxpoolArr[MAX_THREADS]; +// Additional classes for Athos +#ifdef SCI_OT +MatMulUniform<sci::NetIO, intType, sci::IKNP<sci::NetIO>> + *multUniformArr[MAX_THREADS]; +#endif +sci::IKNP<sci::NetIO> *otInstanceArr[MAX_THREADS]; +sci::KKOT<sci::NetIO> *kkotInstanceArr[MAX_THREADS]; +sci::PRG128 *prgInstanceArr[MAX_THREADS]; + +std::chrono::time_point<std::chrono::high_resolution_clock> start_time; +uint64_t comm_threads[MAX_THREADS]; +uint64_t num_rounds; + +#ifdef LOG_LAYERWISE +uint64_t ConvTimeInMilliSec = 0; +uint64_t MatAddTimeInMilliSec = 0; +uint64_t BatchNormInMilliSec = 0; +uint64_t TruncationTimeInMilliSec = 0; +uint64_t ReluTimeInMilliSec = 0; +uint64_t MaxpoolTimeInMilliSec = 0; +uint64_t AvgpoolTimeInMilliSec = 0; +uint64_t MatMulTimeInMilliSec = 0; +uint64_t MatAddBroadCastTimeInMilliSec = 0; +uint64_t MulCirTimeInMilliSec = 0; +uint64_t ScalarMulTimeInMilliSec = 0; +uint64_t SigmoidTimeInMilliSec = 0; +uint64_t TanhTimeInMilliSec = 0; +uint64_t SqrtTimeInMilliSec = 0; +uint64_t NormaliseL2TimeInMilliSec = 0; +uint64_t ArgMaxTimeInMilliSec = 0; + +uint64_t ConvCommSent = 0; +uint64_t MatAddCommSent = 0; +uint64_t BatchNormCommSent = 0; +uint64_t TruncationCommSent = 0; +uint64_t ReluCommSent = 0; +uint64_t MaxpoolCommSent = 0; +uint64_t AvgpoolCommSent = 0; +uint64_t MatMulCommSent = 0; +uint64_t MatAddBroadCastCommSent = 0; +uint64_t MulCirCommSent = 0; +uint64_t ScalarMulCommSent = 0; +uint64_t SigmoidCommSent = 0; +uint64_t TanhCommSent = 0; +uint64_t SqrtCommSent = 0; +uint64_t NormaliseL2CommSent = 0; +uint64_t ArgMaxCommSent = 0; +#endif diff --git a/SCI/src/globals.h b/SCI/src/globals.h index f2b40732..73c43d73 100644 --- a/SCI/src/globals.h +++ b/SCI/src/globals.h @@ -1,412 +1,138 @@ -/* -Authors: Nishant Kumar, Deevashwer Rathee -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#ifndef GLOBALS_H___ -#define GLOBALS_H___ - -#include <cstdint> //Only keep standard headers over here -#include <chrono> //Keep the local repo based headers below, once constants are defined -#include <thread> -#include <map> - -// #define NDEBUG //This must come first -- so that this marco is used throughout code - //Defining this will disable all asserts throughout code -#define LOG_LAYERWISE -#define USE_EIGEN -#define RUNOPTI -#ifdef RUNOPTI -#define MULTITHREADED_MATMUL -#define MULTITHREADED_NONLIN -#define MULTITHREADED_TRUNC -#define MULTITHREADED_DOTPROD -#endif -#define VERIFY_LAYERWISE -#define WRITE_LOG - -enum NetworkName { - Default, MiniONN, SqNet, ResNet18, ResNet50, DenseNet121, ResNet32_Cifar100 -}; - -NetworkName network_name = Default; - -inline std::string get_network_label(NetworkName network_name) { - switch(network_name) { - case MiniONN: - return "MiniONN"; - case SqNet: - return "SqNet"; - case ResNet18: - return "ResNet18"; - case ResNet50: - return "ResNet50"; - case DenseNet121: - return "DenseNet121"; - case ResNet32_Cifar100: - return "ResNet32_Cifar100"; - } - return "Unknown-Network"; -} - -// To use 64 bitlen, define BITLEN_64 in the main program before including this. -// Otherwise default to 32 bits -#if defined(SCI_HE) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = false; -#elif defined(SCI_OT) - #if defined(BITLEN_64) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_63) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_62) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_61) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_60) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_59) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_58) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_57) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_56) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_55) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_54) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_53) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_52) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_51) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_50) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_49) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_48) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_47) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_46) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_45) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_44) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_43) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_42) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_41) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_40) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_39) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_38) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_37) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_36) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_35) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_34) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #elif defined(BITLEN_33) - typedef uint64_t intType; - typedef int64_t signedIntType; - static const bool isNativeRing = true; - #else - typedef uint32_t intType; - typedef int32_t signedIntType; - static const bool isNativeRing = true; - #endif -#endif - -#if defined(BITLEN_64) - int32_t bitlength = 64; -#elif defined(BITLEN_63) - int32_t bitlength = 63; -#elif defined(BITLEN_62) - int32_t bitlength = 62; -#elif defined(BITLEN_61) - int32_t bitlength = 61; -#elif defined(BITLEN_60) - int32_t bitlength = 60; -#elif defined(BITLEN_59) - int32_t bitlength = 59; -#elif defined(BITLEN_58) - int32_t bitlength = 58; -#elif defined(BITLEN_57) - int32_t bitlength = 57; -#elif defined(BITLEN_56) - int32_t bitlength = 56; -#elif defined(BITLEN_55) - int32_t bitlength = 55; -#elif defined(BITLEN_54) - int32_t bitlength = 54; -#elif defined(BITLEN_53) - int32_t bitlength = 53; -#elif defined(BITLEN_52) - int32_t bitlength = 52; -#elif defined(BITLEN_51) - int32_t bitlength = 51; -#elif defined(BITLEN_50) - int32_t bitlength = 50; -#elif defined(BITLEN_49) - int32_t bitlength = 49; -#elif defined(BITLEN_48) - int32_t bitlength = 48; -#elif defined(BITLEN_47) - int32_t bitlength = 47; -#elif defined(BITLEN_46) - int32_t bitlength = 46; -#elif defined(BITLEN_45) - int32_t bitlength = 45; -#elif defined(BITLEN_44) - int32_t bitlength = 44; -#elif defined(BITLEN_43) - int32_t bitlength = 43; -#elif defined(BITLEN_42) - int32_t bitlength = 42; -#elif defined(BITLEN_41) - int32_t bitlength = 41; -#elif defined(BITLEN_40) - int32_t bitlength = 40; -#elif defined(BITLEN_39) - int32_t bitlength = 39; -#elif defined(BITLEN_38) - int32_t bitlength = 38; -#elif defined(BITLEN_37) - int32_t bitlength = 37; -#elif defined(BITLEN_36) - int32_t bitlength = 36; -#elif defined(BITLEN_35) - int32_t bitlength = 35; -#elif defined(BITLEN_34) - int32_t bitlength = 34; -#elif defined(BITLEN_33) - int32_t bitlength = 33; -#elif defined(BITLEN_32) - int32_t bitlength = 32; -#else - #if defined(SCI_OT) - int32_t bitlength = 32; //In ring case, default to 32 - #else - int32_t bitlength = -1; //In field case, error condition: expecting one of the above macros - #endif -#endif - -/* -Bitlength 32 prime: 4293918721 -Bitlength 33 prime: 8589475841 -Bitlength 34 prime: 17179672577 -Bitlength 35 prime: 34359410689 -Bitlength 36 prime: 68718428161 -Bitlength 37 prime: 137438822401 -Bitlength 38 prime: 274876334081 -Bitlength 39 prime: 549755486209 -Bitlength 40 prime: 1099510054913 -Bitlength 41 prime: 2199023190017 -*/ - -#ifdef SCI_HE - const std::map<int32_t, uint64_t> default_prime_mod { - { 32, 4293918721 }, - { 33, 8589475841 }, - { 34, 17179672577 }, - { 35, 34359410689 }, - { 36, 68718428161 }, - { 37, 137438822401 }, - { 38, 274876334081 }, - { 39, 549755486209 }, - { 40, 1099510054913 }, - { 41, 2199023190017 }, - }; - uint64_t prime_mod = default_prime_mod.at(bitlength); -#else -#if defined(BITLEN_64) - uint64_t prime_mod = 0ULL; -#else - uint64_t prime_mod = 1ULL << bitlength; -#endif -#endif - -const int32_t baseForRelu = 4; -int32_t party = 0; -extern const int numThreads = 4; - -#ifdef LOG_LAYERWISE -uint64_t ConvTimeInMilliSec = 0; -uint64_t MatmulTimeInMilliSec = 0; -uint64_t BatchNormInMilliSec = 0; -uint64_t TruncationTimeInMilliSec = 0; -uint64_t ReluTimeInMilliSec = 0; -uint64_t MaxpoolTimeInMilliSec = 0; -uint64_t AvgpoolTimeInMilliSec = 0; -uint64_t ArgmaxTimeInMilliSec = 0; - -uint64_t ConvCommSent = 0; -uint64_t MatmulCommSent = 0; -uint64_t BatchNormCommSent = 0; -uint64_t TruncationCommSent = 0; -uint64_t ReluCommSent = 0; -uint64_t MaxpoolCommSent = 0; -uint64_t AvgpoolCommSent = 0; -uint64_t ArgmaxCommSent = 0; - -#endif - -#include "utils/constants.h" -#include "utils/net_io_channel.h" -#include "OT/emp-ot.h" -const int SERVER = sci::ALICE; -const int CLIENT = sci::BOB; - -// Keep above order of headers same -- constants.h has definitions of ALICE and BOB -// Other headers are needed first to define io, iknpOT etc. -- so that in rest of the files -// these can be directly used. - -sci::NetIO* io; -sci::IKNP<sci::NetIO>* iknpOT; //ALICE/server is the sender, Bob/client is the receiver -sci::IKNP<sci::NetIO>* iknpOTRoleReversed;//Reverse as above -sci::KKOT<sci::NetIO>* kkot; -sci::OTPack<sci::NetIO> *otpack; - -// For multiThreading -// NOTE : The otInstances are defined as follows: -// If threadNum is even, then ALICE is sender and BOB is receiver ; reverse if threadNum is odd -// Here threadNum \in [0,numThreads) -sci::NetIO* ioArr[numThreads]; -sci::IKNP<sci::NetIO>* otInstanceArr[numThreads]; -sci::OTPack<sci::NetIO>* otpackArr[numThreads]; -sci::KKOT<sci::NetIO>* kkotInstanceArr[numThreads]; -sci::PRG128* prg128Instance; -sci::PRG128* prgInstanceArr[numThreads]; - -#include "linear-primary.h" -Matmul<sci::NetIO, intType, sci::IKNP<sci::NetIO>>* matmulInstanceArr[numThreads]; -Matmul<sci::NetIO, intType, sci::IKNP<sci::NetIO>>* matmulImpl; -#include "NonLinear/relu-interface.h" -ReLUProtocol<sci::NetIO, intType>* reluImplArr[numThreads]; -ReLUProtocol<sci::NetIO, intType>* reluImpl; -#include "NonLinear/maxpool.h" -MaxPoolProtocol<sci::NetIO, intType>* maxpoolImplArr[numThreads]; -MaxPoolProtocol<sci::NetIO, intType>* maxpoolImpl; -#include "NonLinear/argmax.h" -#include "LinearHE/conv-field.h" -#include "LinearHE/fc-field.h" -#include "LinearHE/elemwise-prod-field.h" -//Add extra headers here - - -// sci::OTIdeal<sci::NetIO>* otIdeal; -// Matmul<sci::NetIO, intType, sci::OTIdeal<sci::NetIO>>* matmulImpl; - -ConvField* heConvImpl; -FCField* heFCImpl; -ElemWiseProdField* heProdImpl; - -ArgMaxProtocol<sci::NetIO, intType>* argmaxImpl; -std::chrono::time_point<std::chrono::high_resolution_clock> startTimeTracker; -uint64_t communicationTracker[numThreads]; - -void checkIfUsingEigen(){ -#ifdef USE_EIGEN - std::cout<<"Using Eigen for Matmul"<<std::endl; -#else - std::cout<<"Using normal Matmul"<<std::endl; -#endif -} - -void assertFieldRun(){ - assert(sizeof(intType)==sizeof(uint64_t)); - assert(sizeof(signedIntType)==sizeof(int64_t)); - assert(bitlength>=32 && bitlength<=41); -} - -#endif //GLOBALS_H__ +/* +Authors: Nishant Kumar, Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef GLOBALS_H___ +#define GLOBALS_H___ + +#include "NonLinear/argmax.h" +#include "NonLinear/maxpool.h" +#include "NonLinear/relu-interface.h" +#include "defines.h" +#include "defines_uniform.h" +#include <chrono> +#include <cstdint> +#include <thread> +#ifdef SCI_OT +#include "BuildingBlocks/aux-protocols.h" +#include "BuildingBlocks/truncation.h" +#include "LinearOT/linear-ot.h" +#include "LinearOT/linear-uniform.h" +#include "Math/math-functions.h" +#endif +// Additional Headers for Athos +#ifdef SCI_HE +#include "LinearHE/conv-field.h" +#include "LinearHE/elemwise-prod-field.h" +#include "LinearHE/fc-field.h" +#endif + +// #define MULTI_THREADING + +#define MAX_THREADS 4 + +extern sci::NetIO *io; +extern sci::OTPack<sci::NetIO> *otpack; + +#ifdef SCI_OT +extern LinearOT *mult; +extern AuxProtocols *aux; +extern Truncation *truncation; +extern XTProtocol *xt; +extern MathFunctions *math; +#endif +extern ArgMaxProtocol<sci::NetIO, intType> *argmax; +extern ReLUProtocol<sci::NetIO, intType> *relu; +extern MaxPoolProtocol<sci::NetIO, intType> *maxpool; +// Additional classes for Athos +#ifdef SCI_OT +extern MatMulUniform<sci::NetIO, intType, sci::IKNP<sci::NetIO>> *multUniform; +#endif +#ifdef SCI_HE +extern ConvField *he_conv; +extern FCField *he_fc; +extern ElemWiseProdField *he_prod; +#endif +extern sci::IKNP<sci::NetIO> *iknpOT; +extern sci::IKNP<sci::NetIO> *iknpOTRoleReversed; +extern sci::KKOT<sci::NetIO> *kkot; +extern sci::PRG128 *prg128Instance; + +extern sci::NetIO *ioArr[MAX_THREADS]; +extern sci::OTPack<sci::NetIO> *otpackArr[MAX_THREADS]; +#ifdef SCI_OT +extern LinearOT *multArr[MAX_THREADS]; +extern AuxProtocols *auxArr[MAX_THREADS]; +extern Truncation *truncationArr[MAX_THREADS]; +extern XTProtocol *xtArr[MAX_THREADS]; +extern MathFunctions *mathArr[MAX_THREADS]; +#endif +extern ReLUProtocol<sci::NetIO, intType> *reluArr[MAX_THREADS]; +extern MaxPoolProtocol<sci::NetIO, intType> *maxpoolArr[MAX_THREADS]; +// Additional classes for Athos +#ifdef SCI_OT +extern MatMulUniform<sci::NetIO, intType, sci::IKNP<sci::NetIO>> + *multUniformArr[MAX_THREADS]; +#endif +extern sci::IKNP<sci::NetIO> *otInstanceArr[MAX_THREADS]; +extern sci::KKOT<sci::NetIO> *kkotInstanceArr[MAX_THREADS]; +extern sci::PRG128 *prgInstanceArr[MAX_THREADS]; + +extern std::chrono::time_point<std::chrono::high_resolution_clock> start_time; +extern uint64_t comm_threads[MAX_THREADS]; +extern uint64_t num_rounds; + +#ifdef LOG_LAYERWISE +extern uint64_t ConvTimeInMilliSec; +extern uint64_t MatAddTimeInMilliSec; +extern uint64_t BatchNormInMilliSec; +extern uint64_t TruncationTimeInMilliSec; +extern uint64_t ReluTimeInMilliSec; +extern uint64_t MaxpoolTimeInMilliSec; +extern uint64_t AvgpoolTimeInMilliSec; +extern uint64_t MatMulTimeInMilliSec; +extern uint64_t MatAddBroadCastTimeInMilliSec; +extern uint64_t MulCirTimeInMilliSec; +extern uint64_t ScalarMulTimeInMilliSec; +extern uint64_t SigmoidTimeInMilliSec; +extern uint64_t TanhTimeInMilliSec; +extern uint64_t SqrtTimeInMilliSec; +extern uint64_t NormaliseL2TimeInMilliSec; +extern uint64_t ArgMaxTimeInMilliSec; + +extern uint64_t ConvCommSent; +extern uint64_t MatAddCommSent; +extern uint64_t BatchNormCommSent; +extern uint64_t TruncationCommSent; +extern uint64_t ReluCommSent; +extern uint64_t MaxpoolCommSent; +extern uint64_t AvgpoolCommSent; +extern uint64_t MatMulCommSent; +extern uint64_t MatAddBroadCastCommSent; +extern uint64_t MulCirCommSent; +extern uint64_t ScalarMulCommSent; +extern uint64_t SigmoidCommSent; +extern uint64_t TanhCommSent; +extern uint64_t SqrtCommSent; +extern uint64_t NormaliseL2CommSent; +extern uint64_t ArgMaxCommSent; +#endif + +#endif // GLOBALS_H__ diff --git a/SCI/src/library_fixed.cpp b/SCI/src/library_fixed.cpp new file mode 100644 index 00000000..79fe0df5 --- /dev/null +++ b/SCI/src/library_fixed.cpp @@ -0,0 +1,2805 @@ +/* +Authors: Deevashwer Rathee, G Rahul Kranti Kiran +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "library_fixed.h" +#include "globals.h" +#include "library_fixed_common.h" + +using namespace std; +using namespace sci; + +void initialize() { + assert(num_threads <= MAX_THREADS); + + for (int i = 0; i < num_threads; i++) { + ioArr[i] = + new sci::NetIO(party == ALICE ? nullptr : address.c_str(), port + i); + if (i == 0) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); + } else { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); + } + } + io = ioArr[0]; + otpack = otpackArr[0]; + + for (int i = 0; i < num_threads; i++) { + if (i & 1) { + auxArr[i] = new AuxProtocols(3 - party, ioArr[i], otpackArr[i]); + truncationArr[i] = + new Truncation(3 - party, ioArr[i], otpackArr[i], auxArr[i]); + xtArr[i] = new XTProtocol(3 - party, ioArr[i], otpackArr[i], auxArr[i]); + multArr[i] = new LinearOT(3 - party, ioArr[i], otpackArr[i]); + mathArr[i] = new MathFunctions(3 - party, ioArr[i], otpackArr[i]); + } else { + auxArr[i] = new AuxProtocols(party, ioArr[i], otpackArr[i]); + truncationArr[i] = + new Truncation(party, ioArr[i], otpackArr[i], auxArr[i]); + xtArr[i] = new XTProtocol(party, ioArr[i], otpackArr[i], auxArr[i]); + multArr[i] = new LinearOT(party, ioArr[i], otpackArr[i]); + mathArr[i] = new MathFunctions(party, ioArr[i], otpackArr[i]); + } + } + aux = auxArr[0]; + truncation = truncationArr[0]; + xt = xtArr[0]; + mult = multArr[0]; + math = mathArr[0]; + + io->sync(); + num_rounds = io->num_rounds; + start_time = std::chrono::high_resolution_clock::now(); + for (int i = 0; i < num_threads; i++) { + auto temp = ioArr[i]->counter; + comm_threads[i] = temp; + } +} + +void finalize() { + auto end_time = chrono::high_resolution_clock::now(); + auto execTimeInMilliSec = + chrono::duration_cast<chrono::milliseconds>(end_time - start_time) + .count(); + uint64_t totalComm = 0; + for (int i = 0; i < num_threads; i++) { + auto temp = ioArr[i]->counter; + totalComm += (temp - comm_threads[i]); + } + uint64_t totalCommClient; + std::cout << "------------------------------------------------------\n"; + std::cout << "------------------------------------------------------\n"; + std::cout << "------------------------------------------------------\n"; + std::cout << "Total time taken = " << execTimeInMilliSec + << " milliseconds.\n"; + std::cout << "Total data sent = " << (totalComm / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Number of rounds = " << ioArr[0]->num_rounds - num_rounds + << std::endl; + if (party == SERVER) { + io->recv_data(&totalCommClient, sizeof(uint64_t)); + std::cout << "Total comm (sent+received) = " + << ((totalComm + totalCommClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + } else if (party == CLIENT) { + io->send_data(&totalComm, sizeof(uint64_t)); + std::cout << "Total comm (sent+received) = (see SERVER OUTPUT)" + << std::endl; + } + std::cout << "------------------------------------------------------\n"; + +#ifdef LOG_LAYERWISE + std::cout << "Total time in MatAdd = " << (MatAddTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in BatchNorm = " << (BatchNormInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in MatMul = " << (MatMulTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in Conv = " << (ConvTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in ReLU = " << (ReluTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in MatAddBroadCast = " + << (MatAddBroadCastTimeInMilliSec / 1000.0) << " seconds." + << std::endl; + std::cout << "Total time in MulCir = " << (MulCirTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in ScalarMul = " + << (ScalarMulTimeInMilliSec / 1000.0) << " seconds." << std::endl; + std::cout << "Total time in Sigmoid = " << (SigmoidTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in Tanh = " << (TanhTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in Sqrt = " << (SqrtTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in NormaliseL2 = " + << (NormaliseL2TimeInMilliSec / 1000.0) << " seconds." << std::endl; + std::cout << "Total time in ArgMax = " << (ArgMaxTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "------------------------------------------------------\n"; + std::cout << "MatAdd data sent = " + << ((MatAddCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "BatchNorm data sent = " + << ((BatchNormCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "MatMul data sent = " + << ((MatMulCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "Conv data sent = " << ((ConvCommSent) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "ReLU data sent = " << ((ReluCommSent) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "MatAddBroadCast data sent = " + << ((MatAddBroadCastCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "MulCir data sent = " + << ((MulCirCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "Sigmoid data sent = " + << ((SigmoidCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "Tanh data sent = " << ((TanhCommSent) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Sqrt data sent = " << ((SqrtCommSent) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "NormaliseL2 data sent = " + << ((NormaliseL2CommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "ArgMax data sent = " + << ((ArgMaxCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "------------------------------------------------------\n"; + + if (party == SERVER) { + uint64_t MatAddCommSentClient = 0; + uint64_t BatchNormCommSentClient = 0; + uint64_t MatMulCommSentClient = 0; + uint64_t ConvCommSentClient = 0; + uint64_t ReluCommSentClient = 0; + uint64_t MatAddBroadCastCommSentClient = 0; + uint64_t MulCirCommSentClient = 0; + uint64_t ScalarMulCommSentClient = 0; + uint64_t SigmoidCommSentClient = 0; + uint64_t TanhCommSentClient = 0; + uint64_t SqrtCommSentClient = 0; + uint64_t NormaliseL2CommSentClient = 0; + uint64_t ArgMaxCommSentClient = 0; + io->recv_data(&MatAddCommSentClient, sizeof(uint64_t)); + io->recv_data(&BatchNormCommSentClient, sizeof(uint64_t)); + io->recv_data(&MatMulCommSentClient, sizeof(uint64_t)); + io->recv_data(&ConvCommSentClient, sizeof(uint64_t)); + io->recv_data(&ReluCommSentClient, sizeof(uint64_t)); + io->recv_data(&MatAddBroadCastCommSentClient, sizeof(uint64_t)); + io->recv_data(&MulCirCommSentClient, sizeof(uint64_t)); + io->recv_data(&ScalarMulCommSentClient, sizeof(uint64_t)); + io->recv_data(&SigmoidCommSentClient, sizeof(uint64_t)); + io->recv_data(&TanhCommSentClient, sizeof(uint64_t)); + io->recv_data(&SqrtCommSentClient, sizeof(uint64_t)); + io->recv_data(&NormaliseL2CommSentClient, sizeof(uint64_t)); + io->recv_data(&ArgMaxCommSentClient, sizeof(uint64_t)); + std::cout << "MatAdd data (sent+received) = " + << ((MatAddCommSent + MatAddCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "BatchNorm data (sent+received) = " + << ((BatchNormCommSent + BatchNormCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "MatMul data (sent+received) = " + << ((MatMulCommSent + MatMulCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Conv data (sent+received) = " + << ((ConvCommSent + ConvCommSentClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "ReLU data (sent+received) = " + << ((ReluCommSent + ReluCommSentClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "MatAddBroadCast data (sent+received) = " + << ((MatAddBroadCastCommSent + MatAddBroadCastCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "MulCir data (sent+received) = " + << ((MulCirCommSent + MulCirCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "ScalarMul data (sent+received) = " + << ((ScalarMulCommSent + ScalarMulCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Sigmoid data (sent+received) = " + << ((SigmoidCommSent + SigmoidCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Sqrt data (sent+received) = " + << ((SqrtCommSent + SqrtCommSentClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Tanh data (sent+received) = " + << ((TanhCommSent + TanhCommSentClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "NormaliseL2 data (sent+received) = " + << ((NormaliseL2CommSent + NormaliseL2CommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "ArgMax data (sent+received) = " + << ((ArgMaxCommSent + ArgMaxCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + } else if (party == CLIENT) { + io->send_data(&MatAddCommSent, sizeof(uint64_t)); + io->send_data(&BatchNormCommSent, sizeof(uint64_t)); + io->send_data(&MatMulCommSent, sizeof(uint64_t)); + io->send_data(&ConvCommSent, sizeof(uint64_t)); + io->send_data(&ReluCommSent, sizeof(uint64_t)); + io->send_data(&MatAddBroadCastCommSent, sizeof(uint64_t)); + io->send_data(&MulCirCommSent, sizeof(uint64_t)); + io->send_data(&ScalarMulCommSent, sizeof(uint64_t)); + io->send_data(&SigmoidCommSent, sizeof(uint64_t)); + io->send_data(&TanhCommSent, sizeof(uint64_t)); + io->send_data(&SqrtCommSent, sizeof(uint64_t)); + io->send_data(&NormaliseL2CommSent, sizeof(uint64_t)); + io->send_data(&ArgMaxCommSent, sizeof(uint64_t)); + } +#endif + + for (int i = 0; i < num_threads; i++) { + delete ioArr[i]; + delete otpackArr[i]; + delete auxArr[i]; + delete xtArr[i]; + delete truncationArr[i]; + delete multArr[i]; + delete mathArr[i]; + } +} + +void reconstruct(int64_t *A, int64_t *B, int32_t I, int32_t J, int bwA) { + reconstruct(I * J, (uint64_t *)A, (uint64_t *)B, bwA); + for (int i = 0; i < I * J; i++) { + B[i] = signed_val((uint64_t)B[i], bwA); + } +} + +void reconstruct(int dim, uint64_t *x, uint64_t *y, int bw_x) { + uint64_t mask = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + if (party == sci::ALICE) { + io->send_data(x, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + y[i] = 0; + } + } else { + io->recv_data(y, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + y[i] = (y[i] + x[i]) & mask; + } + } +} + +void typecast_to_uint64(int64_t *A, uint64_t *A64, int32_t I, int32_t J, + int32_t bwA) { + uint64_t mask = (bwA == 64 ? -1 : ((1ULL << bwA) - 1)); + + for (int i = 0; i < I * J; i++) { + A64[i] = uint64_t(A[i]) & mask; + } + return; +} + +void typecast_from_uint64(uint64_t *A64, int64_t *A, int32_t I, int32_t J, + int bwA) { + for (int i = 0; i < I * J; i++) { + if (bwA <= 8) + A[i] = int64_t(int8_t(A64[i])); + else if (bwA <= 16) + A[i] = int64_t(int16_t(A64[i])); + else if (bwA <= 32) + A[i] = int64_t(int32_t(A64[i])); + else + A[i] = int64_t(A64[i]); + } + return; +} + +void reconstruct(uint64_t *A, int64_t *B, int32_t I, int32_t J, int bwA) { + reconstruct(I * J, A, (uint64_t *)B, bwA); + for (int i = 0; i < I * J; i++) { + B[i] = signed_val((uint64_t)B[i], bwA); + } +} + +void AdjustScaleShr(uint64_t *A, uint64_t *B, int32_t I, int32_t J, int32_t bwA, + int32_t scale) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + + int32_t dim = I * J; +#ifdef DIV_RESCALING + truncation->div_pow2(dim, A, B, scale, bwA, true); +#else + truncation->truncate(dim, A, B, scale, bwA, true); +#endif + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + MatAddTimeInMilliSec += temp; + std::cout << "Time in sec for current AdjustScaleShr = " << (temp / 1000.0) + << std::endl; + MatAddCommSent += curComm; +#endif +} + +void MatAdd(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, int32_t J, + int32_t bwA, int32_t bwB, int32_t bwC, int32_t bwTemp, int32_t shrA, + int32_t shrB, int32_t shrC, int32_t demote, bool subroutine) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + assert(bwTemp <= 64); + assert(bwA <= bwTemp); + assert(bwB <= bwTemp); + assert(bwC <= bwTemp); + + int32_t dim = I * J; + uint64_t maskTemp = (bwTemp == 64 ? -1 : ((1ULL << bwTemp) - 1)); + + uint64_t *tmpA = new uint64_t[dim]; + uint64_t *tmpB = new uint64_t[dim]; + uint64_t *tmpC = new uint64_t[dim]; + + xt->s_extend(dim, A, tmpA, bwA, bwTemp); + xt->s_extend(dim, B, tmpB, bwB, bwTemp); + +#ifdef DIV_RESCALING + truncation->div_pow2(dim, tmpA, A, shrA + shrC, bwTemp, true); + truncation->div_pow2(dim, tmpB, B, shrB + shrC, bwTemp, true); +#else + truncation->truncate(dim, tmpA, A, shrA + shrC, bwTemp, true); + truncation->truncate(dim, tmpB, B, shrB + shrC, bwTemp, true); +#endif + + for (int i = 0; i < dim; i++) { + tmpC[i] = (A[i] + B[i]) & maskTemp; + } + +#ifdef DIV_RESCALING + truncation->div_pow2(dim, tmpC, C, demote, bwTemp, true); +#else + truncation->truncate(dim, tmpC, C, demote, bwTemp, true); +#endif + aux->reduce(dim, C, C, bwTemp, bwC); + + delete[] tmpA; + delete[] tmpB; + delete[] tmpC; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + if (!subroutine) { + MatAddTimeInMilliSec += temp; + std::cout << "Time in sec for current MatAdd = " << (temp / 1000.0) + << std::endl; + MatAddCommSent += curComm; + } +#endif +} + +void MatAddBroadCast(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, + int32_t J, int32_t bwA, int32_t bwB, int32_t bwC, + int32_t bwTemp, int32_t shrA, int32_t shrB, int32_t shrC, + int32_t demote, bool scalar_A) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + int32_t dim = I * J; + + uint64_t tmp; + if (scalar_A) { + if (party == BOB) + A[0] = 0; // assert(A[0] == 0); + uint64_t *tmpA = new uint64_t[dim]; + for (int i = 0; i < dim; i++) { +#ifndef DIV_RESCALING + tmpA[i] = signed_val(A[0], bwA) >> (shrA + shrC); +#else + tmpA[i] = signed_val(A[0], bwA) / (1LL << (shrA + shrC)); +#endif + } + MatAdd(tmpA, B, C, I, J, bwTemp, bwB, bwC, bwTemp, 0, shrB + shrC, 0, + demote, true); + + delete[] tmpA; + } else { + if (party == BOB) + B[0] = 0; // assert(B[0] == 0); + uint64_t *tmpB = new uint64_t[dim]; + for (int i = 0; i < dim; i++) { +#ifndef DIV_RESCALING + tmpB[i] = signed_val(B[0], bwB) >> (shrB + shrC); +#else + tmpB[i] = signed_val(B[0], bwB) / (1LL << (shrB + shrC)); +#endif + } + MatAdd(A, tmpB, C, I, J, bwA, bwTemp, bwC, bwTemp, shrA + shrC, 0, 0, + demote, true); + + delete[] tmpB; + } + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + MatAddBroadCastTimeInMilliSec += temp; + std::cout << "Time in sec for current MatAddBroadCast = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + MatAddBroadCastCommSent += curComm; +#endif +} + +void AddOrSubCir(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, int32_t J, + int32_t bwA, int32_t bwB, int32_t bwC, int32_t bwTemp, + int32_t shrA, int32_t shrB, int32_t shrC, bool add, + int32_t demote) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + int32_t dim = I * J; + + uint64_t *tmpB = new uint64_t[dim]; + + xt->s_extend(J, B, tmpB, bwB, bwTemp); +#ifdef DIV_RESCALING + truncation->div_pow2(J, tmpB, B, shrB + shrC, bwTemp, true); +#else + truncation->truncate(J, tmpB, B, shrB + shrC, bwTemp, true); +#endif + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + if (add) { + tmpB[i * J + j] = B[j]; + } else { + tmpB[i * J + j] = (-1 * B[j]); + } + } + } + MatAdd(A, tmpB, C, I, J, bwA, bwTemp, bwC, bwTemp, shrA + shrC, 0, 0, demote, + true); + + delete[] tmpB; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + MatAddTimeInMilliSec += temp; + std::cout << "Time in sec for current AddOrSubCir = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + MatAddCommSent += curComm; +#endif +} + +void ScalarMul(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, int32_t J, + int32_t bwA, int32_t bwB, int32_t bwTemp, int32_t bwC, + int32_t shrA, int32_t shrB, int32_t demote) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + int32_t shift = shrA + shrB + demote; + + uint64_t maskTemp = (bwTemp == 64 ? -1 : ((1ULL << bwTemp) - 1)); + uint64_t *tmpC = new uint64_t[I * J]; + + xt->s_extend(I * J, B, tmpC, bwB, bwTemp); + for (int i = 0; i < I * J; i++) { + C[i] = (tmpC[i] * A[0]) & maskTemp; + } +#ifdef DIV_RESCALING + truncation->div_pow2(I * J, C, tmpC, shift, bwTemp, true); + aux->reduce(I * J, tmpC, C, bwTemp, bwC); +#else + if ((bwTemp - bwC) >= shift) { + truncation->truncate_and_reduce(I * J, C, tmpC, shift, bwTemp); + aux->reduce(I * J, tmpC, C, bwTemp - shift, bwC); + } else { + truncation->truncate(I * J, C, tmpC, shift, bwTemp, true); + aux->reduce(I * J, tmpC, C, bwTemp, bwC); + } +#endif + + delete[] tmpC; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + ScalarMulTimeInMilliSec += temp; + std::cout << "Time in sec for current ScalarMul = " << (temp / 1000.0) + << std::endl; + ScalarMulCommSent += curComm; +#endif +} + +void MulCir_thread(int32_t tid, uint64_t *A, uint64_t *B, uint64_t *C, + int32_t dim, int32_t bwA, int32_t bwB, int32_t bwC, + int32_t bwTemp, int32_t shrA, int32_t shrB, int32_t demote) { + int32_t shift = shrA + shrB + demote; + + uint64_t *tmpC = new uint64_t[dim]; + + multArr[tid]->hadamard_product(dim, A, B, C, bwA, bwB, bwA + bwB, true, true, + MultMode::None); +#ifdef DIV_RESCALING + truncationArr[tid]->div_pow2(dim, C, tmpC, shift, bwA + bwB, true); + auxArr[tid]->reduce(dim, tmpC, C, bwA + bwB, bwC); +#else + if ((bwA + bwB - bwC) >= shift) { + truncationArr[tid]->truncate_and_reduce(dim, C, tmpC, shift, bwA + bwB); + auxArr[tid]->reduce(dim, tmpC, C, bwA + bwB - shift, bwC); + } else { + truncationArr[tid]->truncate(dim, C, tmpC, shift, bwA + bwB, true); + auxArr[tid]->reduce(dim, tmpC, C, bwA + bwB, bwC); + } +#endif + delete[] tmpC; +} + +void MulCir(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t demote, + int64_t bwA, int64_t bwB, int64_t bwTemp, int64_t bwC, uint64_t *A, + uint64_t *B, uint64_t *C) { +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". MulCir (" << I << " x " << J << ")" << std::endl; + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shift_demote = log2(demote); + + int min_chunk_size = THREADING_MIN_CHUNK_SIZE; + std::vector<int> chunks_per_thread = + divide_instances(::num_threads, I * J, min_chunk_size); + + int offset = 0; + int lnum_threads = chunks_per_thread.size(); + std::thread threads[lnum_threads]; + for (int i = 0; i < lnum_threads; i++) { + threads[i] = std::thread(MulCir_thread, i, A + offset, B + offset, + C + offset, chunks_per_thread[i], bwA, bwB, bwC, + bwTemp, shiftA, shiftB, shift_demote); + offset += chunks_per_thread[i]; + } + for (int i = 0; i < lnum_threads; ++i) { + threads[i].join(); + } + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + MulCirTimeInMilliSec += temp; + std::cout << "Time in sec for current MulCir = " << (temp / 1000.0) + << std::endl; + MulCirCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recB = new int64_t[I * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(B, recB, I, J, bwB); + reconstruct(C, recC, I, J, bwC); + cleartext_MulCir(recA, recB, correctC, I, J, shrA, shrB, demote); + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != signed_val(correctC[i], bwC)) { + pass = false; + } + // std::cout << i << "\t" << int(recC[i]) << "\t" << + // int(signed_val(correctC[i],bwC)) << std::endl; + } + if (pass == true) + std::cout << GREEN << "MulCir Output Matches" << RESET << std::endl; + else + std::cout << RED << "MulCir Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] recC; + delete[] correctC; +#endif +} + +void MatMul_thread(int32_t tid, uint64_t *A, uint64_t *B, uint64_t *C, + int32_t I, int32_t K, int32_t J, int32_t bwA, int32_t bwB, + int32_t bwC, int32_t bwTemp, int32_t shrA, int32_t shrB, + int32_t H1, int32_t demote, + MultMode mode = MultMode::Alice_has_B) { + assert(bwA + bwB >= bwC); + int32_t depth = ceil(log2(K)); + int32_t shift = shrA + shrB + demote + H1 - depth; + + uint64_t maskC = (bwC == 64 ? -1 : ((1ULL << bwC) - 1)); + uint64_t *tmpC = new uint64_t[I * J]; + + multArr[tid]->matrix_multiplication(I, K, J, A, B, C, bwA, bwB, bwA + bwB, + true, true, true, mode); + if (shift <= 0) { + for (int i = 0; i < I * J; i++) { + tmpC[i] = (C[i] << (-1 * shift)) & maskC; + } + auxArr[tid]->reduce(I * J, tmpC, C, bwA + bwB, bwC); +#ifdef DIV_RESCALING + } else { + truncationArr[tid]->div_pow2(I * J, C, tmpC, shift, bwA + bwB, true); + auxArr[tid]->reduce(I * J, tmpC, C, bwA + bwB, bwC); + } +#else + } else if ((bwA + bwB - bwC) >= shift) { + truncationArr[tid]->truncate_and_reduce(I * J, C, tmpC, shift, bwA + bwB); + auxArr[tid]->reduce(I * J, tmpC, C, bwA + bwB - shift, bwC); + } else { + truncationArr[tid]->truncate(I * J, C, tmpC, shift, bwA + bwB, true); + auxArr[tid]->reduce(I * J, tmpC, C, bwA + bwB, bwC); + } +#endif + + delete[] tmpC; +} + +void MatMul(int64_t I, int64_t K, int64_t J, int64_t shrA, int64_t shrB, + int64_t H1, int64_t H2, int64_t demote, int32_t bwA, int32_t bwB, + int32_t bwTemp, int32_t bwC, uint64_t *A, uint64_t *B, uint64_t *C, + uint64_t *tmp, bool verbose) { +#ifdef LOG_LAYERWISE + if (verbose) + std::cout << ctr++ << ". MatMul (" << I << " x " << K << " x " << J << ")" + << std::endl; + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + if (party == CLIENT) { + for (int i = 0; i < K * J; i++) { + assert(B[i] == 0 && + "The multiplication mode for MatMul is set assuming the server " + "has the model weights (B) in the clear, and therefore, the " + "client's share for the weights must be zero. If the weights " + "should also be secret-shared, then change the MultMode in this " + "function to MultMode::None"); + } + } + + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shift_demote = log2(demote); + + int min_chunk_size = ceil(THREADING_MIN_CHUNK_SIZE / double(K * J)); + std::vector<int> chunks_per_thread = + divide_instances(::num_threads, I, min_chunk_size); + + int offset = 0; + int lnum_threads = chunks_per_thread.size(); + // cout << "lnum_threads: " << lnum_threads << endl; + // cout << "chunks[0]: " << chunks_per_thread[0] << endl; + std::thread threads[lnum_threads]; + for (int i = 0; i < lnum_threads; i++) { + MultMode mode = (i & 1 ? MultMode::Bob_has_B : MultMode::Alice_has_B); + threads[i] = + std::thread(MatMul_thread, i, A + (K * offset), B, C + (J * offset), + chunks_per_thread[i], K, J, bwA, bwB, bwC, bwTemp, shiftA, + shiftB, H1, shift_demote, mode); + offset += chunks_per_thread[i]; + } + for (int i = 0; i < lnum_threads; ++i) { + threads[i].join(); + } + + if (!verbose) + return; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + MatMulCommSent += curComm; + MatMulTimeInMilliSec += temp; + std::cout << "Time in sec for current MatMul = " << (temp / 1000.0) + << std::endl; +#endif +} + +void MatMul(int64_t I, int64_t K, int64_t J, int64_t shrA, int64_t shrB, + int64_t H1, int64_t H2, int64_t demote, int32_t bwA, int32_t bwB, + int32_t bwTemp, int32_t bwC, int64_t *A, int64_t *B, int64_t *C, + int64_t *tmp, bool verbose) { +#ifdef CLEARTEXT_ONLY + cleartext_MatMul(A, B, C, tmp, I, K, J, shrA, shrB, H1, H2, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } + +#else + uint64_t *tmpA = new uint64_t[I * K]; + typecast_to_uint64(A, tmpA, I, K, bwA); + uint64_t *tmpB = new uint64_t[K * J]; + typecast_to_uint64(B, tmpB, K, J, bwB); + uint64_t *tmpC = new uint64_t[I * J]; + + MatMul(I, K, J, shrA, shrB, H1, H2, demote, bwA, bwB, bwTemp, bwC, tmpA, tmpB, + tmpC, nullptr, verbose); + + typecast_from_uint64(tmpC, C, I, J, bwC); + + delete[] tmpA; + delete[] tmpB; + delete[] tmpC; +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * K]; + int64_t *recB = new int64_t[K * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(A, recA, I, K, bwA); + reconstruct(B, recB, K, J, bwB); + reconstruct(C, recC, I, J, bwC); + + cleartext_MatMul(recA, recB, correctC, tmp, I, K, J, shrA, shrB, H1, H2, + demote); + + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != correctC[i]) { + pass = false; + if (verbose) + std::cout << i << "\t" << int(recC[i]) << "\t" << int(correctC[i]) + << std::endl; + } + // if (verbose) std::cout << i << "\t" << int(recC[i]) << "\t" << + // int(correctC[i]) << std::endl; + } + if (pass == true) + std::cout << GREEN << "MatMul Output Matches" << RESET << std::endl; + else + std::cout << RED << "MatMul Output Mismatch" << RESET << std::endl; + /* + if (!pass) { + for(int i = 0; i < I*J; i++) { + if(recC[i] != correctC[i]) { + std::cout << i << "\t" << int(recC[i]) << "\t" << + int(correctC[i]) << std::endl; + } + } + } + */ + } + + delete[] recA; + delete[] recB; + delete[] recC; + delete[] correctC; +#endif +#endif +} + +void Sigmoid_thread(int32_t tid, uint64_t *A, uint64_t *B, int32_t dim, + int32_t bwA, int32_t bwB, int32_t sA, int32_t sB) { + mathArr[tid]->sigmoid(dim, A, B, bwA, bwB, sA, sB); +} + +void Sigmoid(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, uint64_t *A, uint64_t *B) { +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". Sigmoid (" << I << " x " << J << ")" << std::endl; + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + int32_t s_A = log2(scale_in); + int32_t s_B = log2(scale_out); + + int min_chunk_size = THREADING_MIN_CHUNK_SIZE; + std::vector<int> chunks_per_thread = + divide_instances(::num_threads, I * J, min_chunk_size); + + int offset = 0; + int lnum_threads = chunks_per_thread.size(); + std::thread threads[lnum_threads]; + for (int i = 0; i < lnum_threads; i++) { + threads[i] = std::thread(Sigmoid_thread, i, A + offset, B + offset, + chunks_per_thread[i], bwA, bwB, s_A, s_B); + offset += chunks_per_thread[i]; + } + for (int i = 0; i < lnum_threads; ++i) { + threads[i].join(); + } + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + SigmoidTimeInMilliSec += temp; + std::cout << "Time in sec for current Sigmoid = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + SigmoidCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recB = new int64_t[I * J]; + int64_t *correctB = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(B, recB, I, J, bwA); + cleartext_Sigmoid(recA, I, J, scale_in, scale_out, bwA, bwA, correctB); + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recB[i] != correctB[i]) { + pass = false; + std::cout << recA[i] / double(1LL << s_A) << "\t" + << recB[i] / double(1LL << s_B) << "\t" + << correctB[i] / double(1LL << s_B) << std::endl; + } + // std::cout << recA[i]/double(1LL << s_A) << "\t" << recB[i]/double(1LL + // << s_B) << "\t" << correctB[i]/double(1LL << s_B) << std::endl; + } + if (pass == true) + std::cout << GREEN << "Sigmoid Output Matches" << RESET << std::endl; + else + std::cout << RED << "Sigmoid Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] correctB; +#endif +} + +void TanH_thread(int32_t tid, uint64_t *A, uint64_t *B, int32_t dim, + int32_t bwA, int32_t bwB, int32_t sA, int32_t sB) { + mathArr[tid]->tanh(dim, A, B, bwA, bwB, sA, sB); +} + +void TanH(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, uint64_t *A, uint64_t *B) { +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". TanH (" << I << " x " << J << ")" << std::endl; + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + + int32_t s_A = log2(scale_in); + int32_t s_B = log2(scale_out); + + int min_chunk_size = THREADING_MIN_CHUNK_SIZE; + std::vector<int> chunks_per_thread = + divide_instances(::num_threads, I * J, min_chunk_size); + + int offset = 0; + int lnum_threads = chunks_per_thread.size(); + std::thread threads[lnum_threads]; + for (int i = 0; i < lnum_threads; i++) { + threads[i] = std::thread(TanH_thread, i, A + offset, B + offset, + chunks_per_thread[i], bwA, bwB, s_A, s_B); + offset += chunks_per_thread[i]; + } + for (int i = 0; i < lnum_threads; ++i) { + threads[i].join(); + } +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + TanhTimeInMilliSec += temp; + std::cout << "Time in sec for current TanH = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + TanhCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recB = new int64_t[I * J]; + int64_t *correctB = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(B, recB, I, J, bwA); + cleartext_TanH(recA, I, J, scale_in, scale_out, bwA, bwA, correctB); + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recB[i] != correctB[i]) { + pass = false; + } + // std::cout << recA[i]/double(1LL << s_A) << "\t" << recB[i]/double(1LL + // << s_B) << "\t" << correctB[i]/double(1LL << s_B) << std::endl; + } + if (pass == true) + std::cout << GREEN << "TanH Output Matches" << RESET << std::endl; + else + std::cout << RED << "TanH Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] correctB; +#endif +} + +void Sqrt_thread(int32_t tid, uint64_t *A, uint64_t *B, int32_t dim, + int32_t bwA, int32_t bwB, int32_t sA, int32_t sB, + bool inverse) { + mathArr[tid]->sqrt(dim, A, B, bwA, bwB, sA, sB, inverse); +} + +void Sqrt(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, bool inverse, uint64_t *A, uint64_t *B) { +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". Sqrt (" << I << " x " << J << ")" << std::endl; + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + + int32_t s_A = log2(scale_in); + int32_t s_B = log2(scale_out); + + int min_chunk_size = THREADING_MIN_CHUNK_SIZE; + std::vector<int> chunks_per_thread = + divide_instances(::num_threads, I * J, min_chunk_size); + + int offset = 0; + int lnum_threads = chunks_per_thread.size(); + std::thread threads[lnum_threads]; + for (int i = 0; i < lnum_threads; i++) { + threads[i] = std::thread(Sqrt_thread, i, A + offset, B + offset, + chunks_per_thread[i], bwA, bwB, s_A, s_B, inverse); + offset += chunks_per_thread[i]; + } + for (int i = 0; i < lnum_threads; ++i) { + threads[i].join(); + } +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + SqrtTimeInMilliSec += temp; + std::cout << "Time in sec for current Sqrt = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + SqrtCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recB = new int64_t[I * J]; + int64_t *correctB = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(B, recB, I, J, bwB); + cleartext_sqrt(recA, I, J, scale_in, scale_out, bwA, bwB, correctB, inverse); + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recB[i] != correctB[i]) { + pass = false; + } + } + if (pass == true) + std::cout << GREEN << "Sqrt Output Matches" << RESET << std::endl; + else + std::cout << RED << "Sqrt Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] correctB; +#endif +} + +void Exp(uint64_t *A, uint64_t *B, int32_t I, int32_t J, int32_t bwA, + int32_t bwB, int32_t sA, int32_t sB) { + math->lookup_table_exp(I * J, A, B, bwA, bwB, sA, sB); +} + +void Div(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, int32_t J, + int32_t bwA, int32_t bwB, int32_t bwC, int32_t sA, int32_t sB, + int32_t sC) { + math->div(I * J, A, B, C, bwA, bwB, bwC, sA, sB, sC, true, false); +} + +void ArgMax(uint64_t *A, int32_t I, int32_t J, int32_t bwA, int32_t bw_index, + uint64_t *index) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + argmax = new ArgMaxProtocol<NetIO, uint64_t>(party, RING, io, bwA, MILL_PARAM, + 0, otpack); + + argmax->ArgMaxMPC(I * J, A, index, false, nullptr); + if (bw_index > bwA) { + xt->z_extend(1, index, index, bwA, bw_index); + } + + delete argmax; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + ArgMaxTimeInMilliSec += temp; + std::cout << "Time in sec for current ArgMax = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + ArgMaxCommSent += curComm; +#endif +} + +void MaxPool2D(uint64_t *A, int32_t I, int32_t J, int32_t bwA, int32_t bwB, + uint64_t *B) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + + maxpool = new MaxPoolProtocol<NetIO, uint64_t>(party, RING, io, bwA, + MILL_PARAM, 0, otpack); + uint64_t *B_temp = new uint64_t[I]; + maxpool->funcMaxMPC(I, J, A, B_temp, nullptr); + if (bwB > bwA) { + xt->z_extend(I, B_temp, B, bwA, bwB); + } else { + memcpy(B, B_temp, sizeof(uint64_t) * I); + } + delete[] B_temp; + delete maxpool; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + MaxpoolTimeInMilliSec += temp; + std::cout << "Time in sec for current MaxPool = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + MaxpoolCommSent += curComm; +#endif +} + +void GroupedMatMul_thread(int32_t tid, uint64_t *A, uint64_t *B, uint64_t *C, + int32_t I, int32_t K, int32_t J, int32_t G, + int32_t bwA, int32_t bwB, int32_t bwC, int32_t bwTemp, + int32_t shrA, int32_t shrB, int32_t H1, int32_t H2, + int32_t demote, + MultMode mode = MultMode::Alice_has_A) { + // assert(bwA + bwB >= bwC); + int32_t depth = H1 + H2; + int32_t shift = shrA + shrB + demote - H2; + int out_size = G * I * J; + + for (int32_t g = 0; g < G; g++) { + multArr[tid]->matrix_multiplication(I, K, J, A + (g * I * K), + B + (g * K * J), C + (g * I * J), bwA, + bwB, bwA + bwB, true, true, true, mode); + } + + uint64_t maskC = (bwC == 64 ? -1 : ((1ULL << bwC) - 1)); + uint64_t *tmpC = new uint64_t[out_size]; + + if (shift <= 0) { + if (bwA + bwB < bwC) { + xtArr[tid]->s_extend(out_size, C, tmpC, bwA + bwB, bwC); + } else { + auxArr[tid]->reduce(out_size, C, tmpC, bwA + bwB, bwC); + } + for (int i = 0; i < out_size; i++) { + C[i] = (tmpC[i] * (1ULL << (-1 * shift))) & maskC; + } +#ifdef DIV_RESCALING + } else { + truncationArr[tid]->div_pow2(out_size, C, tmpC, shift, bwA + bwB, true); + if (bwA + bwB < bwC) { + xtArr[tid]->s_extend(out_size, tmpC, C, bwA + bwB, bwC); + } else { + auxArr[tid]->reduce(out_size, tmpC, C, bwA + bwB, bwC); + } + } +#else + } else if ((bwA + bwB - bwC) >= shift) { + truncationArr[tid]->truncate_and_reduce(out_size, C, tmpC, shift, + bwA + bwB); + if (bwA + bwB < bwC) { + xtArr[tid]->s_extend(out_size, tmpC, C, bwA + bwB - shift, bwC); + } else { + auxArr[tid]->reduce(out_size, tmpC, C, bwA + bwB - shift, bwC); + } + } else { + truncationArr[tid]->truncate(out_size, C, tmpC, shift, bwA + bwB, true); + if (bwA + bwB < bwC) { + xtArr[tid]->s_extend(out_size, tmpC, C, bwA + bwB, bwC); + } else { + auxArr[tid]->reduce(out_size, tmpC, C, bwA + bwB, bwC); + } + } +#endif + + delete[] tmpC; +} + +void Convolution(int32_t N, int32_t H, int32_t W, int32_t CIN, int32_t HF, + int32_t WF, int32_t CINF, int32_t COUTF, int32_t HOUT, + int32_t WOUT, int32_t HPADL, int32_t HPADR, int32_t WPADL, + int32_t WPADR, int32_t HSTR, int32_t WSTR, int32_t HDL, + int32_t WDL, int32_t G, int32_t bwA, int32_t bwB, int32_t bwC, + int32_t bwTemp, int32_t shrA, int32_t shrB, int32_t H1, + int32_t H2, int32_t demote, uint64_t *A, uint64_t *B, + uint64_t *C) { +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". Convolution (I = (" << N << "x" << H << "x" << W + << "x" << CIN << "), F = (" << G << "x" << HF << "x" << WF << "x" + << CINF << "x" << COUTF << "), S = (" << HSTR << "x" << WSTR << "))" + << std::endl; + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + + if (party == CLIENT) { + for (int i = 0; i < G * HF * WF * CINF * COUTF; i++) { + assert(B[i] == 0 && + "The multiplication mode for convolution is set assuming the " + "server has the model weights (B) in the clear, and therefore, " + "the client's share for the weights must be zero. If the weights " + "should also be secret-shared, then change the MultMode in this " + "function to MultMode::None"); + } + } + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shift_demote = log2(demote); + + int32_t reshaped_image_size = HF * WF * CINF * N * HOUT * WOUT; + + uint64_t *Image = new uint64_t[G * reshaped_image_size]; + uint64_t *Filter = new uint64_t[G * COUTF * HF * WF * CINF]; + uint64_t *Output = new uint64_t[G * COUTF * N * HOUT * WOUT]; + std::vector<int> chunks_per_thread; + if (G > 1) { + chunks_per_thread = divide_instances(::num_threads, G, COUTF); + } else { + int min_chunk_size = + ceil(THREADING_MIN_CHUNK_SIZE / double(reshaped_image_size)); + chunks_per_thread = divide_instances(::num_threads, COUTF, min_chunk_size); + } + + cout << "chunks_per_thread[0]: " << chunks_per_thread[0] << endl; + for (int g = 0; g < G; g++) { + Conv2DReshapeInputGroup(N, H, W, CIN, HF, WF, HPADL, HPADR, WPADL, WPADR, + HSTR, WSTR, g, G, HF * WF * CINF, N * HOUT * WOUT, + A, Image + (g * reshaped_image_size)); + for (int co = 0; co < COUTF; co++) { + for (int f = 0; f < HF * WF * CINF; f++) { + Filter[g * (COUTF * HF * WF * CINF) + co * (HF * WF * CINF) + f] = + B[g * (HF * WF * CINF * COUTF) + f * COUTF + co]; + } + } + } + + int offset = 0; + int lnum_threads = chunks_per_thread.size(); + std::thread threads[lnum_threads]; + for (int i = 0; i < lnum_threads; i++) { + MultMode mode = (i & 1 ? MultMode::Bob_has_A : MultMode::Alice_has_A); + if (G > 1) { + threads[i] = std::thread( + GroupedMatMul_thread, i, Filter + (offset * COUTF * HF * WF * CINF), + Image + (offset * reshaped_image_size), + Output + (offset * COUTF * N * HOUT * WOUT), COUTF, HF * WF * CINF, + N * HOUT * WOUT, chunks_per_thread[i], bwB, bwA, bwC, bwTemp, shiftB, + shiftA, H1, H2, shift_demote, mode); + } else { + threads[i] = std::thread( + GroupedMatMul_thread, i, Filter + (offset * HF * WF * CINF), Image, + Output + (offset * N * HOUT * WOUT), chunks_per_thread[i], + HF * WF * CINF, N * HOUT * WOUT, 1, bwB, bwA, bwC, bwTemp, shiftB, + shiftA, H1, H2, shift_demote, mode); + } + offset += chunks_per_thread[i]; + } + for (int i = 0; i < lnum_threads; ++i) { + threads[i].join(); + } + + for (int g = 0; g < G; g++) { + Conv2DReshapeMatMulOPGroup(N, HOUT, WOUT, COUTF * G, g, G, + Output + (g * COUTF * N * HOUT * WOUT), C); + } + delete[] Image; + delete[] Filter; + delete[] Output; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + ConvCommSent += curComm; + ConvTimeInMilliSec += temp; + std::cout << "Time in sec for current Conv = " << (temp / 1000.0) + << std::endl; +#endif + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[N * H * W * CIN]; + int64_t *recB = new int64_t[G * HF * WF * CINF * COUTF]; + int64_t *recC = new int64_t[N * HOUT * WOUT * COUTF * G]; + int64_t *correctC = new int64_t[N * HOUT * WOUT * COUTF * G]; + reconstruct(A, recA, N, H * W * CIN, bwA); + reconstruct(B, recB, G, HF * WF * CINF * COUTF, bwB); + reconstruct(C, recC, N, HOUT * WOUT * COUTF * G, bwC); + cleartext_Convolution(recA, recB, correctC, nullptr, N, H, W, CIN, HF, WF, + CINF, COUTF, HOUT, WOUT, HPADL, HPADR, WPADL, WPADR, + HSTR, WSTR, HDL, WDL, G, shrA, shrB, H1, H2, demote); + + for (int i = 0; i < N * HOUT * WOUT * COUTF * G; i++) { + uint64_t tmpC = uint64_t(correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < N * HOUT * WOUT * COUTF * G; i++) { + if (recC[i] != (correctC[i])) { + pass = false; + } + std::cout << i << "\t" << int(recC[i]) << "\t" << int(correctC[i]) + << std::endl; + } + if (pass == true) + std::cout << GREEN << "Convolution Output Matches" << RESET << std::endl; + else + std::cout << RED << "Convolution Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] recC; + delete[] correctC; +#endif +} + +void ReLU(uint64_t *A, uint64_t *B, int32_t I, int32_t J, int32_t bwA, + int32_t bwB, uint64_t six, int32_t div) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + + assert(bwA >= bwB); + + int32_t dim = I * J; + uint64_t *tmpB = new uint64_t[dim]; + math->ReLU(dim, A, tmpB, bwA, six); + +#ifdef DIV_RESCALING + truncation->div_pow2(dim, tmpB, B, div, bwA, true); + aux->reduce(dim, B, B, bwA, bwB); +#else + if ((bwA - bwB) >= div) { + truncation->truncate_and_reduce(dim, tmpB, B, div, bwA); + aux->reduce(dim, B, B, bwA - div, bwB); + } else { + truncation->truncate(dim, tmpB, B, div, bwA, true); + aux->reduce(dim, B, B, bwA, bwB); + } +#endif + + delete[] tmpB; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + ReluTimeInMilliSec += temp; + std::cout << "Time in sec for current ReLU = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + ReluCommSent += curComm; +#endif +} + +void BNorm(uint64_t *A, uint64_t *BNW, uint64_t *BNB, uint64_t *B, int32_t I, + int32_t J, int32_t bwA, int32_t bwBNW, int32_t bwBNB, int32_t bwTemp, + int32_t bwB, int32_t shA, int32_t shBNB, int32_t shB) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + uint64_t maskTemp = (bwTemp == 64 ? -1 : ((1ULL << bwTemp) - 1)); + + uint64_t *tmpA = new uint64_t[I * J]; + uint64_t *tmpBNB = new uint64_t[J]; + uint64_t *tmpBNW = new uint64_t[J]; + uint64_t *tmpB = new uint64_t[I * J]; + xt->s_extend(I * J, A, tmpA, bwA, bwTemp); + xt->s_extend(J, BNB, tmpBNB, bwBNB, bwTemp); + // xt->s_extend(J, BNW, tmpBNW, bwBNW, bwTemp); + memcpy(tmpBNW, BNW, J * sizeof(uint64_t)); + if (shA <= 0) { + for (int i = 0; i < I * J; i++) { + A[i] = (tmpA[i] << (-1 * shA)); + } + } else { +#ifdef DIV_RESCALING + truncation->div_pow2(I * J, tmpA, A, shA, bwTemp, true); +#else + truncation->truncate(I * J, tmpA, A, shA, bwTemp, true); +#endif + } + if (shBNB <= 0) { + for (int i = 0; i < J; i++) { + BNB[i] = (tmpBNB[i] << (-1 * shBNB)); + } + } else { +#ifdef DIV_RESCALING + truncation->div_pow2(J, tmpBNB, BNB, shBNB, bwTemp, true); +#else + truncation->truncate(J, tmpBNB, BNB, shBNB, bwTemp, true); +#endif + } + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + tmpA[i * J + j] = (A[i * J + j] + BNB[j]) & maskTemp; + } + } + // mult->hadamard_product(I*J, tmpA, tmpBNW, tmpB, bwTemp, bwTemp, bwTemp, + // true, true); + mult->matrix_multiplication(I, J, 1, tmpA, tmpBNW, tmpB, bwTemp, bwBNW, + bwTemp, true, true, false, MultMode::Alice_has_B); + + if (shB <= 0) { + for (int i = 0; i < I * J; i++) { + B[i] = (tmpB[i] << (-1 * shB)); + } + } else { +#ifdef DIV_RESCALING + truncation->div_pow2(I * J, tmpB, B, shB, bwTemp, true); +#else + truncation->truncate(I * J, tmpB, B, shB, bwTemp, true); +#endif + } + aux->reduce(I * J, B, B, bwTemp, bwB); + + delete[] tmpA; + delete[] tmpBNB; + delete[] tmpBNW; + delete[] tmpB; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + BatchNormInMilliSec += temp; + std::cout << "Time in sec for current BatchNorm = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + BatchNormCommSent += curComm; +#endif +} + +void NormaliseL2(uint64_t *A, uint64_t *B, int32_t I, int32_t J, int32_t bwA, + int32_t scaleA, int32_t shrA) { +#ifdef LOG_LAYERWISE + INIT_TIMER; + INIT_ALL_IO_DATA_SENT; +#endif + int32_t scale_in = -1 * scaleA; + int32_t scale_out = -1 * (scaleA + 1); + int32_t bw_sumSquare = (2 * bwA - 2 * shrA) + ceil(log2(J)); + uint64_t mask_sumSquare = + (bw_sumSquare == 64 ? -1 : ((1ULL << (bw_sumSquare)) - 1)); + + uint64_t *tmpB = new uint64_t[I * J]; + uint64_t *sumSquare = new uint64_t[I]; + uint64_t *inverseNorm = new uint64_t[I]; + mult->hadamard_product(I * J, A, A, tmpB, bwA, bwA, 2 * bwA, true, true, + MultMode::None); + truncation->truncate(I * J, tmpB, B, 2 * shrA, 2 * bwA, true); + // truncation->truncate_and_reduce(I*J, tmpB, B, 2*shrA, 2*bwA); + for (int i = 0; i < I; i++) { + sumSquare[i] = 0; + for (int j = 0; j < J; j++) { + sumSquare[i] = (sumSquare[i] + B[i * J + j]); + } + sumSquare[i] &= mask_sumSquare; + } + + math->sqrt(I, sumSquare, inverseNorm, bw_sumSquare, bwA + shrA, + 2 * (scale_in - shrA), scale_out - scale_in + shrA, true); + + mult->matrix_multiplication(1, I, J, inverseNorm, A, B, bwA + shrA, bwA, + bwA + shrA, true, true, false, MultMode::None); + +#ifdef DIV_RESCALING + truncation->div_pow2(I * J, B, tmpB, shrA, bwA + shrA, true); + aux->reduce(I * J, tmpB, tmpB, bwA + shrA, bwA); +#else + truncation->truncate_and_reduce(I * J, B, tmpB, shrA, bwA + shrA); +#endif + + for (int i = 0; i < I; i++) { + for (int j = 0; j < J; j++) { + B[i * J + j] = tmpB[j * I + i]; + } + } + + delete[] tmpB; + delete[] sumSquare; + delete[] inverseNorm; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + NormaliseL2TimeInMilliSec += temp; + std::cout << "Time in sec for current NormaliseL2 = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + NormaliseL2CommSent += curComm; +#endif +} + +// template<class int64_t, class int64_t, class int64_t, class int64_t> +void MatAdd(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t shrC, + int64_t demote, int64_t bwA, int64_t bwB, int64_t bwTemp, + int64_t bwC, int64_t *A, int64_t *B, int64_t *C, bool verbose) { +#ifdef CLEARTEXT_ONLY + cleartext_MatAdd(A, B, C, I, J, shrA, shrB, shrC, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } + +#else +#ifdef LOG_LAYERWISE + if (verbose) + std::cout << "MatAdd (" << I << " x " << J << ")" << std::endl; +#endif + // C = (A / (shrA*shrC) + B / (shrB*ShrC)) / demote + // int32_t bwA = sizeof(int64_t)*8; + // int32_t bwB = sizeof(int64_t)*8; + // int32_t bwC = sizeof(int64_t)*8; + // int32_t bwTemp = sizeof(int64_t)*8; + + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + uint64_t *tmpB = new uint64_t[I * J]; + typecast_to_uint64(B, tmpB, I, J, bwB); + uint64_t *tmpC = new uint64_t[I * J]; + + MatAdd(tmpA, tmpB, tmpC, I, J, bwA, bwB, bwC, bwTemp, shiftA, shiftB, shiftC, + shift_demote); + + typecast_from_uint64(tmpC, C, I, J, bwC); + + delete[] tmpA; + delete[] tmpB; + delete[] tmpC; + + if (!verbose) + return; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recB = new int64_t[I * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(B, recB, I, J, bwB); + reconstruct(C, recC, I, J, bwC); + cleartext_MatAdd(recA, recB, correctC, I, J, shrA, shrB, shrC, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + /* + for(int i = 0; i < I*J; i++) { + std::cout << i << "\t" << int64_t(recA[i]) << std::endl; + } + for(int i = 0; i < I*J; i++) { + std::cout << i << "\t" << int64_t(recB[i]) << std::endl; + } + */ + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // if (verbose) std::cout << i << "\t" << int(recC[i]) << "\t" << + // int(correctC[i]) << std::endl; + } + if (pass == true) + std::cout << GREEN << "MatAdd Output Matches" << RESET << std::endl; + else + std::cout << RED << "MatAdd Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] recC; + delete[] correctC; +#endif +#endif +} + +// template<class int64_t, class int64_t, class int64_t, class int64_t> +void MatSub(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t shrC, + int64_t demote, int64_t bwA, int64_t bwB, int64_t bwTemp, + int64_t bwC, int64_t *A, int64_t *B, int64_t *C) { +#ifdef CLEARTEXT_ONLY + cleartext_MatSub(A, B, C, I, J, shrA, shrB, shrC, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } +#else +#ifdef LOG_LAYERWISE + std::cout << "MatSub (" << I << " x " << J << ")" << std::endl; +#endif + int64_t *minus_B = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + minus_B[i] = int64_t(-1) * B[i]; + } + MatAdd(I, J, shrA, shrB, shrC, demote, bwA, bwB, bwTemp, bwC, A, minus_B, C, + false); + + delete[] minus_B; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recB = new int64_t[I * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(B, recB, I, J, bwB); + reconstruct(C, recC, I, J, bwC); + cleartext_MatSub(recA, recB, correctC, I, J, shrA, shrB, shrC, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // std::cout << i << "\t" << int(recC[i]) << "\t" << int(correctC[i]) << + // std::endl; + } + if (pass == true) + std::cout << GREEN << "MatSub Output Matches" << RESET << std::endl; + else + std::cout << RED << "MatSub Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] recC; + delete[] correctC; +#endif +#endif +} + +void MatAddBroadCastA(int64_t I, int64_t J, int64_t shrA, int64_t shrB, + int64_t shrC, int64_t demote, int64_t bwA, int64_t bwB, + int64_t bwTemp, int64_t bwC, int64_t A, int64_t *B, + int64_t *C, bool verbose) { +#ifdef CLEARTEXT_ONLY + cleartext_MatAddBroadCastA(&A, B, C, I, J, shrA, shrB, shrC, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } +#else +#ifdef LOG_LAYERWISE + if (verbose) + std::cout << "MatAddBroadCastA (" << I << " x " << J << ")" << std::endl; +#endif + + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + + uint64_t tmpA = uint64_t(A); + uint64_t *tmpB = new uint64_t[I * J]; + typecast_to_uint64(B, tmpB, I, J, bwB); + uint64_t *tmpC = new uint64_t[I * J]; + + MatAddBroadCast(&tmpA, tmpB, tmpC, I, J, bwA, bwB, bwC, bwTemp, shiftA, + shiftB, shiftC, shift_demote, true); + typecast_from_uint64(tmpC, C, I, J, bwC); + + delete[] tmpB; + delete[] tmpC; + + if (!verbose) + return; + +#ifdef VERIFY_LAYERWISE + int64_t *recB = new int64_t[I * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(B, recB, I, J, bwB); + reconstruct(C, recC, I, J, bwC); + cleartext_MatAddBroadCastA(&A, recB, correctC, I, J, shrA, shrB, shrC, + demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // if (verbose) std::cout << i << "\t" << int(recC[i]) << "\t" << + // int(correctC[i]) << std::endl; + } + if (pass == true) + std::cout << GREEN << "MatAddBroadCastA Output Matches" << RESET + << std::endl; + else + std::cout << RED << "MatAddBroadCastA Output Mismatch" << RESET + << std::endl; + } + + delete[] recB; + delete[] recC; + delete[] correctC; +#endif +#endif +} + +void MatAddBroadCastB(int64_t I, int64_t J, int64_t shrA, int64_t shrB, + int64_t shrC, int64_t demote, int64_t bwA, int64_t bwB, + int64_t bwTemp, int64_t bwC, int64_t *A, int64_t B, + int64_t *C, bool verbose) { +#ifdef CLEARTEXT_ONLY + cleartext_MatAddBroadCastB(A, &B, C, I, J, shrA, shrB, shrC, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } + +#else +#ifdef LOG_LAYERWISE + if (verbose) + std::cout << "MatAddBroadCastB (" << I << " x " << J << ")" << std::endl; +#endif + // int32_t bwA = sizeof(int64_t)*8; + // int32_t bwB = sizeof(int64_t)*8; + // int32_t bwC = sizeof(int64_t)*8; + // int32_t bwTemp = sizeof(int64_t)*8; + + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + + uint64_t tmpB = uint64_t(B); + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + uint64_t *tmpC = new uint64_t[I * J]; + + MatAddBroadCast(tmpA, &tmpB, tmpC, I, J, bwA, bwB, bwC, bwTemp, shiftA, + shiftB, shiftC, shift_demote, false); + typecast_from_uint64(tmpC, C, I, J, bwC); + + delete[] tmpA; + delete[] tmpC; + + if (!verbose) + return; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(C, recC, I, J, bwC); + cleartext_MatAddBroadCastB(recA, &B, correctC, I, J, shrA, shrB, shrC, + demote); + + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // if (verbose) std::cout << i << "\t" << int(recA[i]) << "\t" << + // int(recC[i]) << "\t" << int(correctC[i]) << std::endl; + } + if (pass == true) + std::cout << GREEN << "MatAddBroadCastB Output Matches" << RESET + << std::endl; + else + std::cout << RED << "MatAddBroadCastB Output Mismatch" << RESET + << std::endl; + } + + delete[] recA; + delete[] recC; + delete[] correctC; +#endif +#endif +} + +void MatSubBroadCastA(int64_t I, int64_t J, int64_t shrA, int64_t shrB, + int64_t shrC, int64_t demote, int64_t bwA, int64_t bwB, + int64_t bwTemp, int64_t bwC, int64_t A, int64_t *B, + int64_t *C) { +#ifdef CLEARTEXT_ONLY + cleartext_MatSubBroadCastA(&A, B, C, I, J, shrA, shrB, shrC, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } +#else +#ifdef LOG_LAYERWISE + std::cout << "MatSubBroadCastA (" << I << " x " << J << ")" << std::endl; +#endif + int64_t *minus_B = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + minus_B[i] = int64_t(-1) * B[i]; + } + MatAddBroadCastA(I, J, shrA, shrB, shrC, demote, bwA, bwB, bwTemp, bwC, A, + minus_B, C, false); + + delete[] minus_B; + +#ifdef VERIFY_LAYERWISE + int64_t *recB = new int64_t[I * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(B, recB, I, J, bwB); + reconstruct(C, recC, I, J, bwC); + cleartext_MatSubBroadCastA(&A, recB, correctC, I, J, shrA, shrB, shrC, + demote); + + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // std::cout << i << "\t" << int(recC[i]) << "\t" << int(correctC[i]) << + // std::endl; + } + if (pass == true) + std::cout << GREEN << "MatSubBroadCastA Output Matches" << RESET + << std::endl; + else + std::cout << RED << "MatSubBroadCastA Output Mismatch" << RESET + << std::endl; + } + + delete[] recB; + delete[] recC; + delete[] correctC; +#endif +#endif +} + +void MatSubBroadCastB(int64_t I, int64_t J, int64_t shrA, int64_t shrB, + int64_t shrC, int64_t demote, int64_t bwA, int64_t bwB, + int64_t bwTemp, int64_t bwC, int64_t *A, int64_t B, + int64_t *C) { +#ifdef CLEARTEXT_ONLY + cleartext_MatSubBroadCastB(A, &B, C, I, J, shrA, shrB, shrC, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } +#else +#ifdef LOG_LAYERWISE + std::cout << "MatSubBroadCastB (" << I << " x " << J << ")" << std::endl; +#endif + + int64_t minus_B = int64_t(-1) * (B); + MatAddBroadCastB(I, J, shrA, shrB, shrC, demote, bwA, bwB, bwTemp, bwC, A, + minus_B, C, false); + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(C, recC, I, J, bwC); + cleartext_MatSubBroadCastB(recA, &B, correctC, I, J, shrA, shrB, shrC, + demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // if (verbose) std::cout << i << "\t" << int(recA[i]) << "\t" << + // int(recC[i]) << "\t" << int(correctC[i]) << std::endl; + } + if (pass == true) + std::cout << GREEN << "MatSubBroadCastB Output Matches" << RESET + << std::endl; + else + std::cout << RED << "MatSubBroadCastB Output Mismatch" << RESET + << std::endl; + } + + delete[] recA; + delete[] recC; + delete[] correctC; +#endif +#endif +} + +// template<class int64_t> +void AdjustScaleShl(int64_t I, int64_t J, int64_t scale, int64_t *A) { + // A = (A * scale) + for (int i = 0; i < I * J; i++) { + A[i] = A[i] * int64_t(scale); + } +} + +void MulCir(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t demote, + int64_t bwA, int64_t bwB, int64_t bwTemp, int64_t bwC, int64_t *A, + int64_t *B, int64_t *C) { +#ifdef CLEARTEXT_ONLY + cleartext_MulCir(A, B, C, I, J, shrA, shrB, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } + +#else +#ifdef LOG_LAYERWISE + std::cout << "MulCir (" << I << " x " << J << ")" << std::endl; +#endif + + MulCir(I, J, shrA, shrB, demote, bwA, bwB, bwTemp, bwC, (uint64_t *)A, + (uint64_t *)B, (uint64_t *)C); + +#endif +} + +void ScalarMul(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t demote, + int64_t bwA, int64_t bwB, int64_t bwTemp, int64_t bwC, int64_t A, + int64_t *B, int64_t *C) { +#ifdef CLEARTEXT_ONLY + cleartext_ScalarMul(&A, B, C, I, J, shrA, shrB, demote); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } +#else +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". ScalarMul (" << I << " x " << J << ")" << std::endl; +#endif + + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shift_demote = log2(demote); + + uint64_t *tmpA = new uint64_t[1]; + typecast_to_uint64(&A, tmpA, 1, 1, bwA); + uint64_t *tmpB = new uint64_t[I * J]; + typecast_to_uint64(B, tmpB, I, J, bwB); + + uint64_t *tmpC = new uint64_t[I * J]; + + ScalarMul(tmpA, tmpB, tmpC, I, J, bwA, bwB, bwTemp, bwC, shiftA, shiftB, + shift_demote); + typecast_from_uint64(tmpC, C, I, J, bwC); + + delete[] tmpA; + delete[] tmpB; + delete[] tmpC; + +#ifdef VERIFY_LAYERWISE + int64_t *recB = new int64_t[I * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(B, recB, I, J, bwB); + reconstruct(C, recC, I, J, bwC); + cleartext_ScalarMul(&A, recB, correctC, I, J, shrA, shrB, demote); + + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // if (verbose) std::cout << i << "\t" << int(recC[i]) << "\t" << + // int(correctC[i]) << std::endl; + } + if (pass == true) + std::cout << GREEN << "ScalarMul Output Matches" << RESET << std::endl; + else + std::cout << RED << "ScalarMul Output Mismatch" << RESET << std::endl; + } + + delete[] recB; + delete[] recC; + delete[] correctC; +#endif +#endif +} + +void Sigmoid(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, int64_t *A, int64_t *B) { +#ifdef CLEARTEXT_ONLY + cleartext_Sigmoid(A, I, J, scale_in, scale_out, bwA, bwB, B); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (B[i]) % (1LL << bwB); + B[i] = signed_val(tmpC, bwB); + } +#else +#ifdef LOG_LAYERWISE + std::cout << "Sigmoid (" << I << " x " << J << ")" << std::endl; +#endif + + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + + uint64_t *tmpB = new uint64_t[I * J]; + Sigmoid(I, J, scale_in, scale_out, bwA, bwB, tmpA, tmpB); + typecast_from_uint64(tmpB, B, I, J, bwB); + + delete[] tmpA; + delete[] tmpB; + +#endif +} + +void TanH(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, int64_t *A, int64_t *B) { +#ifdef CLEARTEXT_ONLY + cleartext_TanH(A, I, J, scale_in, scale_out, bwA, bwB, B); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (B[i]) % (1LL << bwB); + B[i] = signed_val(tmpC, bwB); + } +#else +#ifdef LOG_LAYERWISE + std::cout << "TanH (" << I << " x " << J << ")" << std::endl; +#endif + + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + + uint64_t *tmpB = new uint64_t[I * J]; + TanH(I, J, scale_in, scale_out, bwA, bwA, tmpA, tmpB); + typecast_from_uint64(tmpB, B, I, J, bwB); + + delete[] tmpA; + delete[] tmpB; + +#endif +} + +// template<class int64_t> +void ArgMax(int64_t I, int64_t J, int32_t bwA, int32_t bw_index, int64_t *A, + int64_t *index) { +#ifdef CLEARTEXT_ONLY + int32_t index_tmp; + cleartext_ArgMax(A, (int32_t)I, (int32_t)J, &index_tmp); + *index = index_tmp; +#else +#ifdef LOG_LAYERWISE + std::cout << "ArgMax (" << I << " x " << J << ")" << std::endl; +#endif + + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + + uint64_t *tmp_index = new uint64_t[1]; + ArgMax(tmpA, I, J, bwA, bw_index, tmp_index); + typecast_from_uint64(tmp_index, index, 1, 1, bw_index); + + delete[] tmpA; + delete[] tmp_index; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *rec_index = new int64_t[1]; + int *correct_index = new int[1]; + reconstruct(A, recA, I, J, bwA); + reconstruct(index, rec_index, 1, 1, bw_index); + + cleartext_ArgMax(recA, I, J, correct_index); + + if (party == 2) { + bool pass = true; + if (rec_index[0] != correct_index[0]) { + pass = false; + } + std::cout << rec_index[0] << "\t" << correct_index[0] << std::endl; + if (pass == true) + std::cout << GREEN << "ArgMax Output Matches" << RESET << std::endl; + else + std::cout << RED << "ArgMax Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] rec_index; + delete[] correct_index; +#endif +#endif +} + +void AdjustScaleShr(int32_t I, int32_t J, int32_t scale, int64_t bwA, + int64_t *A) { +#ifdef CLEARTEXT_ONLY + for (int i = 0; i < I * J; i++) { + A[i] /= scale; + } +#else +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". AdjustScaleShr (" << I << " x " << J << ")" + << std::endl; +#endif + + int32_t shift_scale = ceil(log2(scale)); + + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + + uint64_t *tmpB = new uint64_t[I * J]; + AdjustScaleShr(tmpA, tmpB, I, J, bwA, shift_scale); + typecast_from_uint64(tmpB, A, I, J, bwA); + + delete[] tmpA; + delete[] tmpB; +#endif +} + +void Convolution(int32_t N, int32_t H, int32_t W, int32_t CIN, int32_t HF, + int32_t WF, int32_t CINF, int32_t COUTF, int32_t HOUT, + int32_t WOUT, int32_t HPADL, int32_t HPADR, int32_t WPADL, + int32_t WPADR, int32_t HSTR, int32_t WSTR, int32_t HDL, + int32_t WDL, int32_t G, int32_t shrA, int32_t shrB, int32_t H1, + int32_t H2, int32_t demote, int32_t bwA, int32_t bwB, + int32_t bwTemp, int32_t bwC, int64_t *A, int64_t *B, + int64_t *C, int64_t *tmp, bool verbose) { +#ifdef CLEARTEXT_ONLY + cleartext_Convolution(A, B, C, nullptr, N, H, W, CIN, HF, WF, CINF, COUTF, + HOUT, WOUT, HPADL, HPADR, WPADL, WPADR, HSTR, WSTR, HDL, + WDL, G, shrA, shrB, H1, H2, demote); + for (int i = 0; i < N * HOUT * WOUT * COUTF * G; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } + +#else + assert((HDL == 1) && (WDL == 1)); + + uint64_t *tmpA = new uint64_t[N * H * W * CIN]; + typecast_to_uint64(A, tmpA, N, H * W * CIN, bwA); + uint64_t *tmpB = new uint64_t[G * HF * WF * CINF * COUTF]; + typecast_to_uint64(B, tmpB, G, HF * WF * CINF * COUTF, bwB); + + uint64_t *tmpC = new uint64_t[N * HOUT * WOUT * COUTF * G]; + Convolution(N, H, W, CIN, HF, WF, CINF, COUTF, HOUT, WOUT, HPADL, HPADR, + WPADL, WPADR, HSTR, WSTR, HDL, WDL, G, bwA, bwB, bwC, bwTemp, + shrA, shrB, H1, H2, demote, tmpA, tmpB, tmpC); + + typecast_from_uint64(tmpC, C, N, HOUT * WOUT * COUTF * G, bwC); + + delete[] tmpA; + delete[] tmpB; + delete[] tmpC; +#endif +} + +void NormaliseL2(int32_t N, int32_t H, int32_t W, int32_t C, int32_t scaleA, + int32_t shrA, int32_t bwA, int64_t *A, int64_t *B) { +#ifdef CLEARTEXT_ONLY + cleartext_NormaliseL2(A, B, N, H, W, C, scaleA, shrA, bwA, bwA); + for (int i = 0; i < (N * H * W * C); i++) { + uint64_t tmpB = (B[i]) % (1LL << bwA); + B[i] = signed_val(tmpB, bwA); + } +#else +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". NormaliseL2 (" << N * H * W << " x " << C << ")" + << std::endl; +#endif + int32_t scale_in = -1 * scaleA; + int32_t scale_out = -1 * (scaleA + 1); + + uint64_t *tmpA = new uint64_t[N * H * W * C]; + typecast_to_uint64(A, tmpA, N * H * W, C, bwA); + uint64_t *tmpB = new uint64_t[N * H * W * C]; + + NormaliseL2(tmpA, tmpB, N * H * W, C, bwA, scaleA, shrA); + typecast_from_uint64(tmpB, B, N * H * W, C, bwA); + + delete[] tmpA; + delete[] tmpB; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[N * H * W * C]; + int64_t *recB = new int64_t[N * H * W * C]; + int64_t *correctB = new int64_t[N * H * W * C]; + reconstruct(A, recA, N * H * W, C, bwA); + reconstruct(B, recB, N * H * W, C, bwA); + cleartext_NormaliseL2(recA, correctB, N, H, W, C, scaleA, shrA, bwA, bwA); + // cleartext_NormaliseL2_seedot<int64_t>(recA, correctB, N, H, W, C, scaleA, + // shrA); + for (int i = 0; i < (N * H * W * C); i++) { + uint64_t tmpB = (correctB[i]) % (1LL << bwA); + correctB[i] = signed_val(tmpB, bwA); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < N * H * W * C; i++) { + if (recB[i] != correctB[i]) { + pass = false; + } + std::cout << double(recA[i]) / (1LL << scale_in) << "\t" + << double(recB[i]) / (1LL << scale_out) << "\t" + << double(correctB[i]) / (1LL << scale_out) << std::endl; + } + if (pass == true) + std::cout << GREEN << "NormaliseL2 Output Matches" << RESET << std::endl; + else + std::cout << RED << "NormaliseL2 Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] correctB; +#endif +#endif +} + +void Relu6(int32_t N, int32_t H, int32_t W, int32_t C, int64_t six, int32_t div, + int32_t bwA, int32_t bwB, int64_t *A, int64_t *B) { +#ifdef CLEARTEXT_ONLY + cleartext_Relu6(A, B, N, H, W, C, six, div); + for (int i = 0; i < N * H * W * C; i++) { + uint64_t tmpC = (B[i]) % (1LL << bwB); + B[i] = signed_val(tmpC, bwB); + } +#else +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". Relu6 (" << N << "x" << H << "x" << W << "x" << C + << ")" << std::endl; +#endif + + int32_t shift_div = log2(div); + + uint64_t *tmpA = new uint64_t[N * H * W * C]; + typecast_to_uint64(A, tmpA, N * H * W, C, bwA); + + uint64_t *tmpB = new uint64_t[N * H * W * C]; + ReLU(tmpA, tmpB, N * H * W, C, bwA, bwB, six, shift_div); + typecast_from_uint64(tmpB, B, N * H * W, C, bwB); + + delete[] tmpA; + delete[] tmpB; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[N * H * W * C]; + int64_t *recB = new int64_t[N * H * W * C]; + int64_t *correctB = new int64_t[N * H * W * C]; + reconstruct(A, recA, N * H * W, C, bwA); + reconstruct(B, recB, N * H * W, C, bwB); + + cleartext_Relu6(recA, correctB, N, H, W, C, six, div); + for (int i = 0; i < N * H * W * C; i++) { + uint64_t tmpC = (correctB[i]) % (1LL << bwB); + correctB[i] = signed_val(tmpC, bwB); + } + if (party == 2) { + bool pass = true; + for (int i = 0; i < N * H * W * C; i++) { + if (recB[i] != correctB[i]) { + pass = false; + } + } + if (pass == true) + std::cout << GREEN << "Relu6 Output Matches" << RESET << std::endl; + else + std::cout << RED << "Relu6 Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] correctB; +#endif +#endif +} + +void BNorm(int32_t I, int32_t J, int32_t shA, int32_t shBNB, int32_t shB, + int32_t bwA, int32_t bwBNW, int32_t bwBNB, int32_t bwTemp, + int32_t bwB, int64_t *A, int64_t *BNW, int64_t *BNB, int64_t *B) { +#ifdef CLEARTEXT_ONLY + cleartext_BNorm(A, BNW, BNB, B, I, J, shA, shBNB, shB); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (B[i]) % (1LL << bwB); + B[i] = signed_val(tmpC, bwB); + } +#else +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". BNorm (" << I << " x " << J << ")" << std::endl; +#endif + + assert(bwA <= bwTemp); + assert(bwBNB <= bwTemp); + assert(bwBNW <= bwTemp); + assert(bwB <= bwTemp); + + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + uint64_t *tmpBNW = new uint64_t[J]; + typecast_to_uint64(BNW, tmpBNW, 1, J, bwBNW); + uint64_t *tmpBNB = new uint64_t[J]; + typecast_to_uint64(BNB, tmpBNB, 1, J, bwBNB); + uint64_t *tmpB = new uint64_t[I * J]; + + BNorm(tmpA, tmpBNW, tmpBNB, tmpB, I, J, bwA, bwBNW, bwBNB, bwTemp, bwB, shA, + shBNB, shB); + + typecast_from_uint64(tmpB, B, I, J, bwB); + + delete[] tmpA; + delete[] tmpBNW; + delete[] tmpBNB; + delete[] tmpB; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recBNW = new int64_t[J]; + int64_t *recBNB = new int64_t[J]; + int64_t *recB = new int64_t[I * J]; + int64_t *correctB = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(BNW, recBNW, 1, J, bwBNW); + reconstruct(BNB, recBNB, 1, J, bwBNB); + reconstruct(B, recB, I, J, bwB); + cleartext_BNorm(recA, recBNW, recBNB, correctB, I, J, shA, shBNB, shB); + for (int i = 0; i < I * J; i++) { + uint64_t tmpC = (correctB[i]) % (1LL << bwB); + correctB[i] = signed_val(tmpC, bwB); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recB[i] != correctB[i]) { + pass = false; + } + // std::cout << i << "\t" << int(recB[i]) << "\t" << int(correctB[i]) << + // std::endl; + } + if (pass == true) + std::cout << GREEN << "BNorm Output Matches" << RESET << std::endl; + else + std::cout << RED << "BNorm Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recBNW; + delete[] recBNB; + delete[] recB; + delete[] correctB; +#endif +#endif +} + +void MaxPool2D(int I, int J, int bwA, int bwB, int64_t *A, int64_t *B) { +#ifdef CLEARTEXT_ONLY + cleartext_MaxPool2D(A, I, J, B); +#else +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". MaxPool2D (" << I << " x " << J << ")" << std::endl; +#endif + + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + + uint64_t *tmp_max = new uint64_t[I]; + MaxPool2D(tmpA, I, J, bwA, bwB, tmp_max); + typecast_from_uint64(tmp_max, B, I, 1, bwB); + + delete[] tmpA; + delete[] tmp_max; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recB = new int64_t[I]; + int64_t *correct_max = new int64_t[I]; + reconstruct(A, recA, I, J, bwA); + reconstruct(B, recB, I, 1, bwB); + + cleartext_MaxPool2D(recA, I, J, correct_max); + + // for(int i=0; i<I; i++){ + // B[i] = (party == 2 ? correct_max[i] : 0); + //} + if (party == 2) { + bool pass = true; + for (int i = 0; i < I; i++) { + if (recB[i] != correct_max[i]) { + // if(i <= 10) + // std::cout<<"s: "<<recB[i]<<" | e: "<<correct_max[i]<<std::endl; + pass = false; + } + } + if (pass == true) + std::cout << GREEN << "MaxPool Output Matches" << RESET << std::endl; + else + std::cout << RED << "MaxPool Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] correct_max; +#endif +#endif +} + +// void fillArrayFullSize2D(int64_t *src, int64_t *dst, int I1, int I2, int J1, +// int J2) +// { +// int itersx = (J1) / (I1); +// int itersy = (J2) / (I2); + +// for (int i = 0; i < itersx; i++) +// { +// for (int j = 0; j < itersy; j++) +// { +// for (int k = 0; k < I1 * I2; k++) +// dst[i * J2 + j + k] = src[k]; +// } +// } +// } + +void MBConv(int32_t N, int32_t H, int32_t W, int32_t Cin, int32_t Ct, + int32_t HF, int32_t WF, int32_t Cout, int32_t Hout, int32_t Wout, + int32_t HPADL, int32_t HPADR, int32_t WPADL, int32_t WPADR, + int32_t HSTR, int32_t WSTR, int32_t D1, int32_t D2, int32_t D3, + int64_t SIX_1, int64_t SIX_2, int32_t shr1, int32_t shr2, + int32_t shr3, int32_t shr4, int32_t shr5, int32_t shr6, + int32_t shr7, int32_t shr8, int32_t shr9, int32_t shl1, + int32_t shl2, int32_t shl3, int32_t shl4, int32_t shl5, + int32_t shl6, int32_t shl7, int32_t shl8, int32_t shl9, int32_t bwA, + int32_t bwF1, int32_t bwB1W, int32_t bwB1B, int32_t bwF2, + int32_t bwB2W, int32_t bwB2B, int32_t bwF3, int32_t bwB3W, + int32_t bwB3B, int32_t bwC, int32_t bwX, int32_t bwT, int32_t bwU, + int32_t bwUB1W, int32_t bwUB2W, int32_t bwUB3W, int64_t *A, + int64_t *F1, int64_t *BN1W, int64_t *BN1B, int64_t *F2, + int64_t *BN2W, int64_t *BN2B, int64_t *F3, int64_t *BN3W, + int64_t *BN3B, int64_t *C, int64_t *X, int64_t *T, int64_t *U) { +#ifdef CLEARTEXT_ONLY + cleartext_MBConv(A, F1, BN1W, BN1B, F2, BN2W, BN2B, F3, BN3W, BN3B, C, + nullptr, nullptr, nullptr, N, H, W, Cin, Ct, HF, WF, Cout, + Hout, Wout, HPADL, HPADR, WPADL, WPADR, HSTR, WSTR, D1, D2, + D3, SIX_1, SIX_2, shr1, shr2, shr3, shr4, shr5, shr6, shr7, + shr8, shr9, shl1, shl2, shl3, shl4, shl5, shl6, shl7, shl8, + shl9); + for (int i = 0; i < N * Hout * Wout * Cout; i++) { + uint64_t tmpC = (C[i]) % (1LL << bwC); + C[i] = signed_val(tmpC, bwC); + } +#else +#ifdef LOG_LAYERWISE + std::cout << "MBConv: Conv -> BNorm -> ReLU6 -> Conv -> BNorm -> ReLU6 -> " + "Conv -> BNorm" + << std::endl; +#endif + int32_t depth_1 = ceil(log2(Cin)); + int64_t *tmpU = new int64_t[N * H * W * Ct]; + Convolution(N, H, W, Cin, 1, 1, Cin, Ct, H, W, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, + 1, D1, depth_1 - D1, 1, bwA, bwF1, bwU, bwU, A, F1, tmpU, nullptr, + true); + + int64_t *tmpUB1W = new int64_t[N * H * W * Ct]; + int64_t *tmpX = new int64_t[N * H * W * Ct]; + BNorm(N * H * W, Ct, int32_t(log2(shr1 / double(shl1))), + int32_t(log2(shr2 / double(shl2))), 0, bwU, bwB1W, bwB1B, bwUB1W, + bwUB1W, tmpU, BN1W, BN1B, tmpUB1W); + + Relu6(N, H, W, Ct, SIX_1, shr3, bwUB1W, bwX, tmpUB1W, tmpX); + if (shl3 > 1) { + for (int i = 0; i < N * H * W * Ct; i++) { + tmpX[i] = (tmpX[i] * shl3); + } + } + + int32_t depth_2 = ceil(log2(HF * WF)); + delete[] tmpU; + tmpU = new int64_t[N * Hout * Wout * Ct]; + Convolution(N, H, W, Ct, HF, WF, 1, 1, Hout, Wout, HPADL, HPADR, WPADL, WPADR, + HSTR, WSTR, 1, 1, Ct, 1, 1, D2, depth_2 - D2, 1, bwX, bwF2, bwU, + bwU, tmpX, F2, tmpU, nullptr, true); + + int64_t *tmpUB2W = new int64_t[N * Hout * Wout * Ct]; + int64_t *tmpT = new int64_t[N * Hout * Wout * Ct]; + BNorm(N * Hout * Wout, Ct, int32_t(log2(shr4 / double(shl4))), + int32_t(log2(shr5 / double(shl5))), 0, bwU, bwB2W, bwB2B, bwUB2W, + bwUB2W, tmpU, BN2W, BN2B, tmpUB2W); + + Relu6(N, Hout, Wout, Ct, SIX_2, shr6, bwUB2W, bwT, tmpUB2W, tmpT); + + int32_t depth_3 = ceil(log2(Ct)); + delete[] tmpU; + tmpU = new int64_t[N * Hout * Wout * Cout]; + Convolution(N, Hout, Wout, Ct, 1, 1, Ct, Cout, Hout, Wout, 0, 0, 0, 0, 1, 1, + 1, 1, 1, 1, 1, D3, depth_3 - D3, 1, bwT, bwF3, bwU, bwU, tmpT, F3, + tmpU, nullptr, true); + + BNorm(N * Hout * Wout, Cout, int32_t(log2(shr7 / double(shl7))), + int32_t(log2(shr8 / double(shl8))), int32_t(log2(shr9 / double(shl9))), + bwU, bwB3W, bwB3B, bwUB3W, bwC, tmpU, BN3W, BN3B, C); + + delete[] tmpU; + delete[] tmpT; + delete[] tmpX; + delete[] tmpUB1W; + delete[] tmpUB2W; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[N * H * W * Cin]; + int64_t *recF1 = new int64_t[Cin * Ct]; + int64_t *recBN1W = new int64_t[Ct]; + int64_t *recBN1B = new int64_t[Ct]; + int64_t *recF2 = new int64_t[Ct * HF * WF]; + int64_t *recBN2W = new int64_t[Ct]; + int64_t *recBN2B = new int64_t[Ct]; + int64_t *recF3 = new int64_t[Ct * Cout]; + int64_t *recBN3W = new int64_t[Cout]; + int64_t *recBN3B = new int64_t[Cout]; + int64_t *recC = new int64_t[N * Hout * Wout * Cout]; + int64_t *correctC = new int64_t[N * Hout * Wout * Cout]; + + reconstruct(A, recA, N * H * W, Cin, bwA); + reconstruct(F1, recF1, Cin, Ct, bwF1); + reconstruct(BN1W, recBN1W, 1, Ct, bwB1W); + reconstruct(BN1B, recBN1B, 1, Ct, bwB1B); + reconstruct(F2, recF2, Ct, HF * WF, bwF2); + reconstruct(BN2W, recBN2W, 1, Ct, bwB2W); + reconstruct(BN2B, recBN2B, 1, Ct, bwB2B); + reconstruct(F3, recF3, Ct, Cout, bwF3); + reconstruct(BN3W, recBN3W, 1, Cout, bwB3W); + reconstruct(BN3B, recBN3B, 1, Cout, bwB3B); + reconstruct(C, recC, N * Hout * Wout, Cout, bwC); + + cleartext_MBConv(recA, recF1, recBN1W, recBN1B, recF2, recBN2W, recBN2B, + recF3, recBN3W, recBN3B, correctC, nullptr, nullptr, nullptr, + N, H, W, Cin, Ct, HF, WF, Cout, Hout, Wout, HPADL, HPADR, + WPADL, WPADR, HSTR, WSTR, D1, D2, D3, SIX_1, SIX_2, shr1, + shr2, shr3, shr4, shr5, shr6, shr7, shr8, shr9, shl1, shl2, + shl3, shl4, shl5, shl6, shl7, shl8, shl9); + for (int i = 0; i < N * Hout * Wout * Cout; i++) { + uint64_t tmpC = (correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpC, bwC); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < N * Hout * Wout * Cout; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // std::cout << i << "\t" << int(recC[i]) << "\t" << int(correctC[i]) << + // std::endl; + } + if (pass == true) + std::cout << GREEN << "MBConv Output Matches" << RESET << std::endl; + else + std::cout << RED << "MBConv Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recC; + delete[] correctC; +#endif +#endif +} + +void AddOrSubCir4D(int32_t N, int32_t H, int32_t W, int32_t C, int32_t shrA, + int32_t shrB, int32_t shrC, bool add, int32_t demote, + int32_t bwA, int32_t bwB, int32_t bwTemp, int32_t bwC, + int64_t *A, int64_t *B, int64_t *X) { +#ifdef CLEARTEXT_ONLY + cleartext_AddOrSubCir4D(A, B, X, N, H, W, C, shrA, shrB, shrC, add, demote); + for (int i = 0; i < (N * H * W * C); i++) { + uint64_t tmpX = (X[i]) % (1LL << bwC); + X[i] = signed_val(tmpX, bwC); + } +#else +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". AddOrSubCir4D (" << N << "x" << H << "x" << W << "x" + << C << ")" << std::endl; +#endif + // C = (A / (shrA*shrC) + B / (shrB*ShrC)) / demote + int32_t shiftA = log2(shrA); + int32_t shiftB = log2(shrB); + int32_t shiftC = log2(shrC); + int32_t shift_demote = log2(demote); + + uint64_t *tmpA = new uint64_t[N * H * W * C]; + typecast_to_uint64(A, tmpA, N * H * W, C, bwA); + uint64_t *tmpB = new uint64_t[C]; + typecast_to_uint64(B, tmpB, 1, C, bwB); + uint64_t *tmpC = new uint64_t[N * H * W * C]; + + AddOrSubCir(tmpA, tmpB, tmpC, N * H * W, C, bwA, bwB, bwC, bwTemp, shiftA, + shiftB, shiftC, add, shift_demote); + + typecast_from_uint64(tmpC, X, N * H * W, C, bwC); + +#ifdef VERIFY_LAYERWISE + int64_t *origA = new int64_t[N * H * W * C]; + typecast_from_uint64(tmpA, origA, N * H * W, C, bwA); + int64_t *recA = new int64_t[N * H * W * C]; + int64_t *recB = new int64_t[C]; + int64_t *recC = new int64_t[N * H * W * C]; + int64_t *correctC = new int64_t[N * H * W * C]; + reconstruct(origA, recA, N * H * W, C, bwA); + reconstruct(B, recB, C, 1, bwB); + reconstruct(X, recC, N * H * W, C, bwC); + cleartext_AddOrSubCir4D(recA, recB, correctC, N, H, W, C, shrA, shrB, shrC, + add, demote); + for (int i = 0; i < (N * H * W * C); i++) { + uint64_t tmpX = uint64_t(correctC[i]) % (1LL << bwC); + correctC[i] = signed_val(tmpX, bwC); + } + + if (party == 2) { + bool pass = true; + for (int i = 0; i < N * H * W * C; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // std::cout << i << "\t" << int(recA[i]) << "\t" << int(recB[i%C]) << + // "\t" << int(recC[i]) << "\t" << int(correctC[i]) << std::endl; + } + if (pass == true) + std::cout << GREEN << "AddOrSubCir4D Output Matches" << RESET + << std::endl; + else + std::cout << RED << "AddOrSubCir4D Output Mismatch" << RESET << std::endl; + } + + delete[] origA; + delete[] recA; + delete[] recB; + delete[] recC; + delete[] correctC; +#endif + + delete[] tmpA; + delete[] tmpB; + delete[] tmpC; +#endif +} + +void MatAdd4(int32_t N, int32_t H, int32_t W, int32_t C, int32_t shrA, + int32_t shrB, int32_t shrC, int32_t demote, int32_t bwA, + int32_t bwB, int32_t bwTemp, int32_t bwC, int64_t *A, int64_t *B, + int64_t *X) { + MatAdd(N * H * W, C, shrA, shrB, shrC, demote, bwA, bwB, bwTemp, bwC, A, B, X, + true); +} + +// Athos wrappers. Athos passes scale factor as is. We need to take pow_2 +int64_t pow_2(int32_t p) { + int64_t res = 1; + for (int i = 0; i < p; i++) { + res *= 2; + } + return res; +} + +void Sigmoid(int32_t I, int32_t J, int32_t scale_in, int32_t scale_out, + int32_t bwA, int32_t bwB, uint64_t *A, uint64_t *B) { + Sigmoid((int64_t)I, (int64_t)J, pow_2(scale_in), pow_2(scale_out), + (int64_t)bwA, (int64_t)bwB, A, B); +} + +void TanH(int32_t I, int32_t J, int32_t scale_in, int32_t scale_out, + int32_t bwA, int32_t bwB, uint64_t *A, uint64_t *B) { + TanH((int64_t)I, (int64_t)J, pow_2(scale_in), pow_2(scale_out), (int64_t)bwA, + (int64_t)bwB, A, B); +} + +void Sqrt(int32_t I, int32_t J, int32_t scale_in, int32_t scale_out, + int32_t bwA, int32_t bwB, bool inverse, uint64_t *A, uint64_t *B) { + Sqrt((int64_t)I, (int64_t)J, pow_2(scale_in), pow_2(scale_out), (int64_t)bwA, + (int64_t)bwB, inverse, A, B); +} + +void Exp(int32_t I, int32_t J, int32_t shrA, int32_t shrB, int32_t bwA, + int64_t *A, int64_t *B) { +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". Exp (" << I << " x " << J << ")" << std::endl; +#endif + + int32_t s_A = log2(shrA); + int32_t s_B = log2(shrB); + + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + + uint64_t *tmpB = new uint64_t[I * J]; + Exp(tmpA, tmpB, I, J, bwA, bwA, s_A, s_B); + typecast_from_uint64(tmpB, B, I, J, bwA); + + delete[] tmpA; + delete[] tmpB; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recB = new int64_t[I * J]; + int64_t *correctB = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(B, recB, I, J, bwA); + cleartext_Exp_lookup(recA, I, J, bwA, shrA, shrB, correctB, 1); + + if (party == 2) { + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recB[i] != correctB[i]) { + pass = false; + } + // std::cout << recA[i]/double(1LL << s_A) << "\t" << recB[i]/double(1LL + // << s_B) << "\t" << correctB[i]/double(1LL << s_B) << std::endl; + } + if (pass == true) + std::cout << GREEN << "Exp Output Matches" << RESET << std::endl; + else + std::cout << RED << "Exp Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] correctB; +#endif + return; +} + +void Div(int32_t I, int32_t J, int32_t shrA, int32_t shrB, int32_t shrC, + int32_t bwA, int64_t *A, int64_t *B, int64_t *C) { +#ifdef LOG_LAYERWISE + std::cout << ctr++ << ". Div (" << I << " x " << J << ")" << std::endl; +#endif + + int32_t s_A = log2(shrA); + int32_t s_B = log2(shrB); + int32_t s_C = log2(shrB); + + uint64_t *tmpA = new uint64_t[I * J]; + typecast_to_uint64(A, tmpA, I, J, bwA); + + uint64_t *tmpB = new uint64_t[I * J]; + typecast_to_uint64(B, tmpB, I, J, bwA); + + uint64_t *tmpC = new uint64_t[I * J]; + Div(tmpA, tmpB, tmpC, I, J, bwA, bwA, bwA, s_A, s_B, s_C); + typecast_from_uint64(tmpC, C, I, J, bwA); + + delete[] tmpA; + delete[] tmpB; + delete[] tmpC; + +#ifdef VERIFY_LAYERWISE + int64_t *recA = new int64_t[I * J]; + int64_t *recB = new int64_t[I * J]; + int64_t *recC = new int64_t[I * J]; + int64_t *correctC = new int64_t[I * J]; + reconstruct(A, recA, I, J, bwA); + reconstruct(B, recB, I, J, bwA); + reconstruct(C, recC, I, J, bwA); + + if (party == 2) { + cleartext_div(recA, recB, I, J, shrA, shrB, shrC, correctC, false); + bool pass = true; + for (int i = 0; i < I * J; i++) { + if (recC[i] != correctC[i]) { + pass = false; + } + // std::cout << recA[i]/double(1LL << s_A) << "\t" << recB[i]/double(1LL + // << s_B) << "\t" << recC[i]/double(1LL << s_C) << "\t" << + // correctC[i]/double(1LL << s_C) << std::endl; + } + if (pass == true) + std::cout << GREEN << "Div Output Matches" << RESET << std::endl; + else + std::cout << RED << "Div Output Mismatch" << RESET << std::endl; + } + + delete[] recA; + delete[] recB; + delete[] recC; + delete[] correctC; +#endif + return; +} + +void output_vector(int64_t *x, int32_t I, int32_t J, int32_t bwX) { + int64_t *y = new int64_t[I * J]; + reconstruct(x, y, I, J, bwX); + if (party == 2) { + for (int i = 0; i < I * J; i++) { + std::cout << y[i] << " "; + } + std::cout << std::endl; + } + delete[] y; +} diff --git a/SCI/src/library_fixed.h b/SCI/src/library_fixed.h new file mode 100644 index 00000000..482a2bbb --- /dev/null +++ b/SCI/src/library_fixed.h @@ -0,0 +1,298 @@ +/* +Authors: Deevashwer Rathee, G Rahul Kranti Kiran +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef LIBRARY_FIXED_H__ +#define LIBRARY_FIXED_H__ + +#include "cleartext_library_fixed.h" +#include "defines.h" +#include "library_fixed_uniform.h" +#include <chrono> +#include <iostream> +#include <string> +#include <vector> + +static int32_t ctr = 1; + +inline std::vector<int> divide_instances( + // Total number of threads + int num_threads, + // Number of instances + int num_instances, + // Minimum chunk size of each thread + int min_chunk_size = THREADING_MIN_CHUNK_SIZE) { + int lnum_threads = + std::min(int(ceil(num_instances / double(min_chunk_size))), num_threads); + std::vector<int> chunks_per_thread(lnum_threads); + int chunk_size = num_instances / lnum_threads; + for (int i = 0; i < lnum_threads; ++i) { + int offset = i * chunk_size; + if (i == (lnum_threads - 1)) { + chunks_per_thread[i] = num_instances - offset; + } else { + chunks_per_thread[i] = chunk_size; + } + } + return chunks_per_thread; +} + +void initialize(); + +void finalize(); + +void reconstruct(int dim, uint64_t *x, uint64_t *y, int bw_x); + +void AdjustScaleShr(uint64_t *A, uint64_t *B, int32_t I, int32_t J, int32_t bwA, + int32_t scale); + +void AdjustScaleShr(int32_t I, int32_t J, int32_t scale, int64_t bwA, + int64_t *A); + +void MatAdd(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, int32_t J, + int32_t bwA, int32_t bwB, int32_t bwC, int32_t bwTemp, int32_t shrA, + int32_t shrB, int32_t shrC, int32_t demote, + bool subroutine = false); + +void MatAddBroadCast(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, + int32_t J, int32_t bwA, int32_t bwB, int32_t bwC, + int32_t bwTemp, int32_t shrA, int32_t shrB, int32_t shrC, + int32_t demote, bool scalar_A = true); + +void AddOrSubCir(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, int32_t J, + int32_t bwA, int32_t bwB, int32_t bwC, int32_t bwTemp, + int32_t shrA, int32_t shrB, int32_t shrC, bool add, + int32_t demote); + +void AddOrSubCir4D(int32_t N, int32_t H, int32_t W, int32_t C, int32_t shrA, + int32_t shrB, int32_t shrC, bool add, int32_t demote, + int32_t bwA, int32_t bwB, int32_t bwTemp, int32_t bwC, + int64_t *A, int64_t *B, int64_t *X); + +void Exp(uint64_t *A, uint64_t *B, int32_t I, int32_t J, int32_t bwA, + int32_t bwB, int32_t sA, int32_t sB); + +void Div(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, int32_t J, + int32_t bwA, int32_t bwB, int32_t bwC, int32_t sA, int32_t sB, + int32_t sC); + +void ArgMax(uint64_t *A, int32_t I, int32_t J, int32_t bwA, int32_t bw_index, + uint64_t *index); + +void MaxPool2D(uint64_t *A, int32_t I, int32_t J, int32_t bwA, int32_t bwB, + uint64_t *B); + +void MaxPool2D(int I, int J, int bwA, int bwB, int64_t *A, int64_t *B); + +void Convolution(int32_t N, int32_t H, int32_t W, int32_t CIN, int32_t HF, + int32_t WF, int32_t CINF, int32_t COUTF, int32_t HOUT, + int32_t WOUT, int32_t HPADL, int32_t HPADR, int32_t WPADL, + int32_t WPADR, int32_t HSTR, int32_t WSTR, int32_t HDL, + int32_t WDL, int32_t G, int32_t bwA, int32_t bwB, int32_t bwC, + int32_t bwTemp, int32_t shrA, int32_t shrB, int32_t H1, + int32_t H2, int32_t demote, uint64_t *A, uint64_t *B, + uint64_t *C); + +void Convolution(int32_t N, int32_t H, int32_t W, int32_t CIN, int32_t HF, + int32_t WF, int32_t CINF, int32_t COUTF, int32_t HOUT, + int32_t WOUT, int32_t HPADL, int32_t HPADR, int32_t WPADL, + int32_t WPADR, int32_t HSTR, int32_t WSTR, int32_t HDL, + int32_t WDL, int32_t G, int32_t shrA, int32_t shrB, int32_t H1, + int32_t H2, int32_t demote, int32_t bwA, int32_t bwB, + int32_t bwTemp, int32_t bwC, int64_t *A, int64_t *B, + int64_t *C, int64_t *tmp, bool verbose = true); + +void ReLU(uint64_t *A, uint64_t *B, int32_t I, int32_t J, int32_t bwA, + int32_t bwB, uint64_t six, int32_t div); +void Relu6(int32_t N, int32_t H, int32_t W, int32_t C, int64_t six, int32_t div, + int32_t bwA, int32_t bwB, int64_t *A, int64_t *B); + +void BNorm(uint64_t *A, uint64_t *BNW, uint64_t *BNB, uint64_t *B, int32_t I, + int32_t J, int32_t bwA, int32_t bwBNW, int32_t bwBNB, int32_t bwTemp, + int32_t bwB, int32_t shA, int32_t shBNB, int32_t shB); + +void NormaliseL2(uint64_t *A, uint64_t *B, int32_t I, int32_t J, int32_t bwA, + int32_t scaleA, int32_t shrA); +void BNorm(int32_t I, int32_t J, int32_t shA, int32_t shBNB, int32_t shB, + int32_t bwA, int32_t bwBNW, int32_t bwBNB, int32_t bwTemp, + int32_t bwB, int64_t *A, int64_t *BNW, int64_t *BNB, int64_t *B); + +void NormaliseL2(int32_t N, int32_t H, int32_t W, int32_t C, int32_t scaleA, + int32_t shrA, int32_t bwA, int64_t *A, int64_t *B); + +void MBConv(int32_t N, int32_t H, int32_t W, int32_t Cin, int32_t Ct, + int32_t HF, int32_t WF, int32_t Cout, int32_t Hout, int32_t Wout, + int32_t HPADL, int32_t HPADR, int32_t WPADL, int32_t WPADR, + int32_t HSTR, int32_t WSTR, int32_t D1, int32_t D2, int32_t D3, + int64_t SIX_1, int64_t SIX_2, int32_t shr1, int32_t shr2, + int32_t shr3, int32_t shr4, int32_t shr5, int32_t shr6, + int32_t shr7, int32_t shr8, int32_t shr9, int32_t shl1, + int32_t shl2, int32_t shl3, int32_t shl4, int32_t shl5, + int32_t shl6, int32_t shl7, int32_t shl8, int32_t shl9, int32_t bwA, + int32_t bwF1, int32_t bwB1W, int32_t bwB1B, int32_t bwF2, + int32_t bwB2W, int32_t bwB2B, int32_t bwF3, int32_t bwB3W, + int32_t bwB3B, int32_t bwC, int32_t bwX, int32_t bwT, int32_t bwU, + int32_t bwUB1W, int32_t bwUB2W, int32_t bwUB3W, int64_t *A, + int64_t *F1, int64_t *BN1W, int64_t *BN1B, int64_t *F2, + int64_t *BN2W, int64_t *BN2B, int64_t *F3, int64_t *BN3W, + int64_t *BN3B, int64_t *C, int64_t *X, int64_t *T, int64_t *U); + +void output_vector(int64_t *x, int32_t I, int32_t J, int32_t bwX); + +/* + MatAdd fucntion for EzPC compatibility followed by MatAdd + function developed using SeeDot. +*/ +void MatAdd(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t shrC, + int64_t demote, int64_t bwA, int64_t bwB, int64_t bwTemp, + int64_t bwC, int64_t *A, int64_t *B, int64_t *C, + bool verbose = true); + +void MatAdd4(int32_t N, int32_t H, int32_t W, int32_t C, int32_t shrA, + int32_t shrB, int32_t shrC, int32_t demote, int32_t bwA, + int32_t bwB, int32_t bwTemp, int32_t bwC, int64_t *A, int64_t *B, + int64_t *X); + +/**/ +void MatSub(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t shrC, + int64_t demote, int64_t bwA, int64_t bwB, int64_t bwTemp, + int64_t bwC, int64_t *A, int64_t *B, int64_t *C); + +/**/ +void MatAddBroadCastA(int64_t I, int64_t J, int64_t shrA, int64_t shrB, + int64_t shrC, int64_t demote, int64_t bwA, int64_t bwB, + int64_t bwTemp, int64_t bwC, int64_t A, int64_t *B, + int64_t *C, bool verbose = true); + +/**/ +void MatAddBroadCastB(int64_t I, int64_t J, int64_t shrA, int64_t shrB, + int64_t shrC, int64_t demote, int64_t bwA, int64_t bwB, + int64_t bwTemp, int64_t bwC, int64_t *A, int64_t B, + int64_t *C, bool verbose = true); + +/**/ +void MatSubBroadCastA(int64_t I, int64_t J, int64_t shrA, int64_t shrB, + int64_t shrC, int64_t demote, int64_t bwA, int64_t bwB, + int64_t bwTemp, int64_t bwC, int64_t A, int64_t *B, + int64_t *C); + +/**/ +void MatSubBroadCastB(int64_t I, int64_t J, int64_t shrA, int64_t shrB, + int64_t shrC, int64_t demote, int64_t bwA, int64_t bwB, + int64_t bwTemp, int64_t bwC, int64_t *A, int64_t B, + int64_t *C); + +/**/ +void MulCir(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t demote, + int64_t bwA, int64_t bwB, int64_t bwTemp, int64_t bwC, uint64_t *A, + uint64_t *B, uint64_t *C); + +void MulCir(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t demote, + int64_t bwA, int64_t bwB, int64_t bwTemp, int64_t bwC, int64_t *A, + int64_t *B, int64_t *C); + +void MatMul(int64_t I, int64_t K, int64_t J, int64_t shrA, int64_t shrB, + int64_t H1, int64_t H2, int64_t demote, int32_t bwA, int32_t bwB, + int32_t bwTemp, int32_t bwC, int64_t *A, int64_t *B, int64_t *C, + int64_t *tmp, bool verbose = true); + +void MatMul(int64_t I, int64_t K, int64_t J, int64_t shrA, int64_t shrB, + int64_t H1, int64_t H2, int64_t demote, int32_t bwA, int32_t bwB, + int32_t bwTemp, int32_t bwC, uint64_t *A, uint64_t *B, uint64_t *C, + uint64_t *tmp, bool verbose = true); + +/**/ +void ScalarMul(uint64_t *A, uint64_t *B, uint64_t *C, int32_t I, int32_t J, + int32_t bwA, int32_t bwB, int32_t bwTemp, int32_t bwC, + int32_t shrA, int32_t shrB, int32_t demote); + +void ScalarMul(int64_t I, int64_t J, int64_t shrA, int64_t shrB, int64_t demote, + int64_t bwA, int64_t bwB, int64_t bwTemp, int64_t bwC, int64_t A, + int64_t *B, int64_t *C); + +/**/ + +void Sigmoid(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, uint64_t *A, uint64_t *B); + +void Sigmoid(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, int64_t *A, int64_t *B); + +/**/ +void TanH(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, int64_t *A, int64_t *B); + +void TanH(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, uint64_t *A, uint64_t *B); + +void Sqrt(int64_t I, int64_t J, int64_t scale_in, int64_t scale_out, + int64_t bwA, int64_t bwB, bool inverse, uint64_t *A, uint64_t *B); + +void reconstruct(int64_t *A, int64_t *B, int32_t I, int32_t J, int bwA); + +// template<class int64_t> +void AdjustScaleShl(int64_t I, int64_t J, int64_t scale, int64_t *A); + +// template<class int64_t> +void ArgMax(int64_t I, int64_t J, int32_t bwA, int32_t bw_index, int64_t *A, + int64_t *index); + +void typecast_to_uint64(int64_t *A, uint64_t *A64, int32_t I, int32_t J, + int32_t bwA); + +void typecast_from_uint64(uint64_t *A64, int64_t *A, int32_t I, int32_t J, + int bwA); + +void Exp(int32_t I, int32_t J, int32_t shrA, int32_t shrB, int32_t bwA, + int64_t *A, int64_t *B); + +void Div(int32_t I, int32_t J, int32_t shrA, int32_t shrB, int32_t shrC, + int32_t bwA, int64_t *A, int64_t *B, int64_t *C); + +// Athos Wrappers +#ifdef SCI_OT +void Sigmoid(int32_t I, int32_t J, int32_t scale_in, int32_t scale_out, + int32_t bwA, int32_t bwB, uint64_t *A, uint64_t *B); + +void TanH(int32_t I, int32_t J, int32_t scale_in, int32_t scale_out, + int32_t bwA, int32_t bwB, uint64_t *A, uint64_t *B); + +void Sqrt(int32_t I, int32_t J, int32_t scale_in, int32_t scale_out, + int32_t bwA, int32_t bwB, bool inverse, uint64_t *A, uint64_t *B); +#endif + +#ifdef SCI_HE +void Sigmoid(int32_t I, int32_t J, int32_t scale_in, int32_t scale_out, + int32_t bwA, int32_t bwB, uint64_t *A, uint64_t *B) { + assert(false && "Sigmoid not supported in SCI_HE."); +} + +void TanH(int32_t I, int32_t J, int32_t scale_in, int32_t scale_out, + int32_t bwA, int32_t bwB, uint64_t *A, uint64_t *B) { + assert(false && "TanH not supported in SCI_HE."); +} + +void Sqrt(int32_t I, int32_t J, int32_t scale_in, int32_t scale_out, + int32_t bwA, int32_t bwB, bool inverse, uint64_t *A, uint64_t *B) { + assert(false && "Sqrt not supported in SCI_HE."); +} +#endif + +#endif diff --git a/SCI/src/library_fixed_common.h b/SCI/src/library_fixed_common.h new file mode 100644 index 00000000..86de42d0 --- /dev/null +++ b/SCI/src/library_fixed_common.h @@ -0,0 +1,257 @@ +/* +Authors: Nishant Kumar +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +/************************ Standard Conv **************************/ + +static void Conv2DReshapeFilter(int32_t FH, int32_t FW, int32_t CI, int32_t CO, + uint64_t *inputArr, uint64_t *outputArr) { + for (uint32_t co = (int32_t)0; co < (uint32_t)CO; co++) { + for (uint32_t fh = (int32_t)0; fh < (uint32_t)FH; fh++) { + for (uint32_t fw = (int32_t)0; fw < (uint32_t)FW; fw++) { + for (uint32_t ci = (int32_t)0; ci < (uint32_t)CI; ci++) { + + int32_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci); + Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) = + Arr4DIdxRowM(inputArr, FH, FW, CI, CO, fh, fw, ci, co); + } + } + } + } +} + +static void Conv2DReshapeMatMulOP(int32_t N, int32_t finalH, int32_t finalW, + int32_t CO, uint64_t *inputArr, + uint64_t *outputArr) { + for (uint32_t co = (int32_t)0; co < (uint32_t)CO; co++) { + for (uint32_t n = (int32_t)0; n < (uint32_t)N; n++) { + for (uint32_t h = (int32_t)0; h < (uint32_t)finalH; h++) { + for (uint32_t w = (int32_t)0; w < (uint32_t)finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) = + Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +static void Conv2DReshapeInput(int32_t N, int32_t H, int32_t W, int32_t CI, + int32_t FH, int32_t FW, int32_t zPadHLeft, + int32_t zPadHRight, int32_t zPadWLeft, + int32_t zPadWRight, int32_t strideH, + int32_t strideW, int32_t RRows, int32_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int32_t linIdxFilterMult = (int32_t)0; + for (uint32_t n = (int32_t)0; n < (uint32_t)N; n++) { + + int32_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int32_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint32_t fh = (int32_t)0; fh < (uint32_t)FH; fh++) { + for (uint32_t fw = (int32_t)0; fw < (uint32_t)FW; fw++) { + + int32_t curPosH = (leftTopCornerH + fh); + + int32_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int64_t)0); + for (uint32_t ci = (int32_t)0; ci < (uint32_t)CI; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int64_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + ci); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CI) + (fw * CI)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +/************************ Grouped Conv **************************/ + +static void Conv2DReshapeFilterGroup(int32_t FH, int32_t FW, int32_t CI, + int32_t CO, int32_t g, int32_t G, + uint64_t *inputArr, uint64_t *outputArr) { + + int32_t CIG = (CI / G); + + int32_t COG = (CO / G); + + int32_t startCO = (g * COG); + for (uint32_t co = (int32_t)0; co < (uint32_t)COG; co++) { + for (uint32_t fh = (int32_t)0; fh < (uint32_t)FH; fh++) { + for (uint32_t fw = (int32_t)0; fw < (uint32_t)FW; fw++) { + for (uint32_t ci = (int32_t)0; ci < (uint32_t)CIG; ci++) { + + int32_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci); + Arr2DIdxRowM(outputArr, (CO / G), ((FH * FW) * (CI / G)), co, + linIdx) = Arr4DIdxRowM(inputArr, FH, FW, (CI / G), CO, + fh, fw, ci, (co + startCO)); + } + } + } + } +} + +static void Conv2DReshapeMatMulOPGroup(int32_t N, int32_t finalH, + int32_t finalW, int32_t CO, int32_t g, + int32_t G, uint64_t *inputArr, + uint64_t *outputArr) { + + int32_t COG = (CO / G); + + int32_t startCO = (g * COG); + for (uint32_t co = (int32_t)0; co < (uint32_t)COG; co++) { + for (uint32_t n = (int32_t)0; n < (uint32_t)N; n++) { + for (uint32_t h = (int32_t)0; h < (uint32_t)finalH; h++) { + for (uint32_t w = (int32_t)0; w < (uint32_t)finalW; w++) { + Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, + (co + startCO)) = + Arr2DIdxRowM(inputArr, (CO / G), ((N * finalH) * finalW), co, + ((((n * finalH) * finalW) + (h * finalW)) + w)); + } + } + } + } +} + +static void Conv2DReshapeInputGroup(int32_t N, int32_t H, int32_t W, int32_t CI, + int32_t FH, int32_t FW, int32_t zPadHLeft, + int32_t zPadHRight, int32_t zPadWLeft, + int32_t zPadWRight, int32_t strideH, + int32_t strideW, int32_t g, int32_t G, + int32_t RRows, int32_t RCols, + uint64_t *inputArr, uint64_t *outputArr) { + + int32_t linIdxFilterMult = (int32_t)0; + + int32_t CIG = (CI / G); + for (uint32_t n = (int32_t)0; n < (uint32_t)N; n++) { + + int32_t leftTopCornerH = ((int32_t)0 - zPadHLeft); + + int32_t extremeRightBottomCornerH = ((H - (int32_t)1) + zPadHRight); + while ( + (((leftTopCornerH + FH) - (int32_t)1) <= extremeRightBottomCornerH)) { + + int32_t leftTopCornerW = ((int32_t)0 - zPadWLeft); + + int32_t extremeRightBottomCornerW = ((W - (int32_t)1) + zPadWRight); + while ( + (((leftTopCornerW + FW) - (int32_t)1) <= extremeRightBottomCornerW)) { + for (uint32_t fh = (int32_t)0; fh < (uint32_t)FH; fh++) { + for (uint32_t fw = (int32_t)0; fw < (uint32_t)FW; fw++) { + + int32_t curPosH = (leftTopCornerH + fh); + + int32_t curPosW = (leftTopCornerW + fw); + + uint64_t val = funcSSCons((int64_t)0); + + int32_t startCI = (g * CIG); + for (uint32_t ci = (int32_t)0; ci < (uint32_t)CIG; ci++) { + if ((((curPosH < (int32_t)0) || (curPosH >= H)) || + ((curPosW < (int32_t)0) || (curPosW >= W)))) { + val = funcSSCons((int64_t)0); + } else { + val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW, + (ci + startCI)); + } + Arr2DIdxRowM(outputArr, RRows, RCols, + ((((fh * FW) * CIG) + (fw * CIG)) + ci), + linIdxFilterMult) = val; + } + } + } + linIdxFilterMult = (linIdxFilterMult + (int32_t)1); + leftTopCornerW = (leftTopCornerW + strideW); + } + + leftTopCornerH = (leftTopCornerH + strideH); + } + } +} + +static void Conv2DGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, + int32_t FW, int32_t CO, int32_t zPadHLeft, + int32_t zPadHRight, int32_t zPadWLeft, + int32_t zPadWRight, int32_t strideH, int32_t strideW, + int32_t G, uint64_t *inputArr, uint64_t *filterArr, + uint64_t *outArr) { + + int32_t CIG = (CI / G); + + int32_t reshapedFilterRows = (CO / G); + + int32_t reshapedFilterCols = ((FH * FW) * CIG); + + int32_t reshapedIPRows = ((FH * FW) * CIG); + + int32_t outH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int32_t outW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int32_t reshapedIPCols = ((N * outH) * outW); + for (uint32_t g = (int32_t)0; g < (uint32_t)G; g++) { + + uint64_t *inputReshaped = + make_array<uint64_t>(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = + make_array<uint64_t>(reshapedFilterRows, reshapedIPCols); + + uint64_t *filterReshaped = + make_array<uint64_t>(reshapedFilterRows, reshapedFilterCols); + Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped); + Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, + zPadWLeft, zPadWRight, strideH, strideW, g, G, + reshapedIPRows, reshapedIPCols, inputArr, + inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); + } +} diff --git a/SCI/src/library_fixed_uniform.cpp b/SCI/src/library_fixed_uniform.cpp new file mode 100644 index 00000000..1fcfee09 --- /dev/null +++ b/SCI/src/library_fixed_uniform.cpp @@ -0,0 +1,1943 @@ +/* +Authors: Nishant Kumar, Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "library_fixed_uniform.h" +#include "cleartext_library_fixed_uniform.h" +#include "functionalities_uniform.h" +#include "library_fixed_common.h" + +#ifdef SCI_HE +uint64_t prime_mod = sci::default_prime_mod.at(bitlength); +#elif SCI_OT +uint64_t prime_mod = (bitlength == 64 ? 0ULL : 1ULL << bitlength); +uint64_t moduloMask = prime_mod - 1; +uint64_t moduloMidPt = prime_mod / 2; +#endif + +void MatMul2D(int32_t s1, int32_t s2, int32_t s3, const intType *A, + const intType *B, intType *C, bool modelIsA) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + + std::cout << "Matmul called s1,s2,s3 = " << s1 << " " << s2 << " " << s3 + << std::endl; + int partyWithAInAB_mul = + sci::ALICE; // By default, the model is A and server/Alice has it + // So, in the AB mult, party with A = server and party with B + // = client. + int partyWithBInAB_mul = sci::BOB; + if (!modelIsA) { + // Model is B + partyWithAInAB_mul = sci::BOB; + partyWithBInAB_mul = sci::ALICE; + } + +#if defined(SCI_OT) +#ifndef MULTITHREADED_MATMUL +#ifdef USE_LINEAR_UNIFORM + if (partyWithAInAB_mul == sci::ALICE) { + if (party == sci::ALICE) { + multUniform->funcOTSenderInputA(s1, s2, s3, A, C, iknpOT); + } else { + multUniform->funcOTReceiverInputB(s1, s2, s3, B, C, iknpOT); + } + } else { + if (party == sci::BOB) { + multUniform->funcOTSenderInputA(s1, s2, s3, A, C, iknpOTRoleReversed); + } else { + multUniform->funcOTReceiverInputB(s1, s2, s3, B, C, iknpOTRoleReversed); + } + } +#else // USE_LINEAR_UNIFORM + if (modelIsA) { + mult->matmul_cross_terms(s1, s2, s3, A, B, C, bitlength, bitlength, + bitlength, true, MultMode::Alice_has_A); + } else { + mult->matmul_cross_terms(s1, s2, s3, A, B, C, bitlength, bitlength, + bitlength, true, MultMode::Alice_has_B); + } +#endif // USE_LINEAR_UNIFORM + + if (party == sci::ALICE) { + // Now irrespective of whether A is the model or B is the model and whether + // server holds A or B, server should add locally A*B. + // + // Add also A*own share of B + intType *CTemp = new intType[s1 * s3]; +#ifdef USE_LINEAR_UNIFORM + multUniform->ideal_func(s1, s2, s3, A, B, CTemp); +#else // USE_LINEAR_UNIFORM + mult->matmul_cleartext(s1, s2, s3, A, B, CTemp, true); +#endif // USE_LINEAR_UNIFORM + sci::elemWiseAdd<intType>(s1 * s3, C, CTemp, C); + delete[] CTemp; + } else { + // For minionn kind of hacky runs, switch this off +#ifndef HACKY_RUN + if (modelIsA) { + for (int i = 0; i < s1 * s2; i++) + assert(A[i] == 0); + } else { + for (int i = 0; i < s1 * s2; i++) + assert(B[i] == 0); + } +#endif + } + +#else // MULTITHREADED_MATMUL is ON + int required_num_threads = num_threads; + if (s2 < num_threads) { + required_num_threads = s2; + } + intType *C_ans_arr[required_num_threads]; + std::thread matmulThreads[required_num_threads]; + for (int i = 0; i < required_num_threads; i++) { + C_ans_arr[i] = new intType[s1 * s3]; + matmulThreads[i] = std::thread(funcMatmulThread, i, required_num_threads, + s1, s2, s3, (intType *)A, (intType *)B, + (intType *)C_ans_arr[i], partyWithAInAB_mul); + } + for (int i = 0; i < required_num_threads; i++) { + matmulThreads[i].join(); + } + for (int i = 0; i < s1 * s3; i++) { + C[i] = 0; + } + for (int i = 0; i < required_num_threads; i++) { + for (int j = 0; j < s1 * s3; j++) { + C[j] += C_ans_arr[i][j]; + } + delete[] C_ans_arr[i]; + } + + if (party == sci::ALICE) { + intType *CTemp = new intType[s1 * s3]; +#ifdef USE_LINEAR_UNIFORM + multUniform->ideal_func(s1, s2, s3, A, B, CTemp); +#else // USE_LINEAR_UNIFORM + mult->matmul_cleartext(s1, s2, s3, A, B, CTemp, true); +#endif // USE_LINEAR_UNIFORM + sci::elemWiseAdd<intType>(s1 * s3, C, CTemp, C); + delete[] CTemp; + } else { + // For minionn kind of hacky runs, switch this off +#ifndef HACKY_RUN + if (modelIsA) { + for (int i = 0; i < s1 * s2; i++) + assert(A[i] == 0); + } else { + for (int i = 0; i < s1 * s2; i++) + assert(B[i] == 0); + } +#endif + } +#endif + intType moduloMask = (1ULL << bitlength) - 1; + if (bitlength == 64) + moduloMask = -1; + for (int i = 0; i < s1 * s3; i++) { + C[i] = C[i] & moduloMask; + } + +#elif defined(SCI_HE) + // We only support matrix vector multiplication. + assert(modelIsA == false && + "Assuming code generated by compiler produces B as the model."); + std::vector<std::vector<intType>> At(s2); + std::vector<std::vector<intType>> Bt(s3); + std::vector<std::vector<intType>> Ct(s3); + for (int i = 0; i < s2; i++) { + At[i].resize(s1); + for (int j = 0; j < s1; j++) { + At[i][j] = getRingElt(Arr2DIdxRowM(A, s1, s2, j, i)); + } + } + for (int i = 0; i < s3; i++) { + Bt[i].resize(s2); + Ct[i].resize(s1); + for (int j = 0; j < s2; j++) { + Bt[i][j] = getRingElt(Arr2DIdxRowM(B, s2, s3, j, i)); + } + } + he_fc->matrix_multiplication(s3, s2, s1, Bt, At, Ct); + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s3; j++) { + Arr2DIdxRowM(C, s1, s3, i, j) = getRingElt(Ct[j][i]); + } + } +#endif + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + MatMulTimeInMilliSec += temp; + std::cout << "Time in sec for current matmul = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + MatMulCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE +#ifdef SCI_HE + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s3; j++) { + assert(Arr2DIdxRowM(C, s1, s3, i, j) < prime_mod); + } + } +#endif + if (party == SERVER) { + funcReconstruct2PCCons(nullptr, A, s1 * s2); + funcReconstruct2PCCons(nullptr, B, s2 * s3); + funcReconstruct2PCCons(nullptr, C, s1 * s3); + } else { + signedIntType *VA = new signedIntType[s1 * s2]; + funcReconstruct2PCCons(VA, A, s1 * s2); + signedIntType *VB = new signedIntType[s2 * s3]; + funcReconstruct2PCCons(VB, B, s2 * s3); + signedIntType *VC = new signedIntType[s1 * s3]; + funcReconstruct2PCCons(VC, C, s1 * s3); + + std::vector<std::vector<uint64_t>> VAvec; + std::vector<std::vector<uint64_t>> VBvec; + std::vector<std::vector<uint64_t>> VCvec; + VAvec.resize(s1, std::vector<uint64_t>(s2, 0)); + VBvec.resize(s2, std::vector<uint64_t>(s3, 0)); + VCvec.resize(s1, std::vector<uint64_t>(s3, 0)); + + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s2; j++) { + VAvec[i][j] = getRingElt(Arr2DIdxRowM(VA, s1, s2, i, j)); + } + } + for (int i = 0; i < s2; i++) { + for (int j = 0; j < s3; j++) { + VBvec[i][j] = getRingElt(Arr2DIdxRowM(VB, s2, s3, i, j)); + } + } + + MatMul2D_pt(s1, s2, s3, VAvec, VBvec, VCvec, 0); + + bool pass = true; + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s3; j++) { + if (Arr2DIdxRowM(VC, s1, s3, i, j) != getSignedVal(VCvec[i][j])) { + pass = false; + } + } + } + if (pass == true) + std::cout << GREEN << "MatMul Output Matches" << RESET << std::endl; + else + std::cout << RED << "MatMul Output Mismatch" << RESET << std::endl; + + delete[] VA; + delete[] VB; + delete[] VC; + } +#endif +} + +static void Conv2D(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, + int32_t FW, int32_t CO, int32_t zPadHLeft, + int32_t zPadHRight, int32_t zPadWLeft, int32_t zPadWRight, + int32_t strideH, int32_t strideW, uint64_t *inputArr, + uint64_t *filterArr, uint64_t *outArr) { + + int32_t reshapedFilterRows = CO; + + int32_t reshapedFilterCols = ((FH * FW) * CI); + + int32_t reshapedIPRows = ((FH * FW) * CI); + + int32_t newH = + ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + (int32_t)1); + + int32_t newW = + ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + (int32_t)1); + + int32_t reshapedIPCols = ((N * newH) * newW); + + uint64_t *filterReshaped = + make_array<uint64_t>(reshapedFilterRows, reshapedFilterCols); + + uint64_t *inputReshaped = + make_array<uint64_t>(reshapedIPRows, reshapedIPCols); + + uint64_t *matmulOP = make_array<uint64_t>(reshapedFilterRows, reshapedIPCols); + Conv2DReshapeFilter(FH, FW, CI, CO, filterArr, filterReshaped); + Conv2DReshapeInput(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, reshapedIPRows, + reshapedIPCols, inputArr, inputReshaped); + MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols, + filterReshaped, inputReshaped, matmulOP, 1); + Conv2DReshapeMatMulOP(N, newH, newW, CO, matmulOP, outArr); + ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped); + ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped); + ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP); +} + +void Conv2DWrapper(signedIntType N, signedIntType H, signedIntType W, + signedIntType CI, signedIntType FH, signedIntType FW, + signedIntType CO, signedIntType zPadHLeft, + signedIntType zPadHRight, signedIntType zPadWLeft, + signedIntType zPadWRight, signedIntType strideH, + signedIntType strideW, intType *inputArr, intType *filterArr, + intType *outArr) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + + static int ctr = 1; + std::cout << "Conv2DCSF " << ctr << " called N=" << N << ", H=" << H + << ", W=" << W << ", CI=" << CI << ", FH=" << FH << ", FW=" << FW + << ", CO=" << CO << ", S=" << strideH << std::endl; + ctr++; + + signedIntType newH = (((H + (zPadHLeft + zPadHRight) - FH) / strideH) + 1); + signedIntType newW = (((W + (zPadWLeft + zPadWRight) - FW) / strideW) + 1); + +#ifdef SCI_OT + // If its a ring, then its a OT based -- use the default Conv2DCSF + // implementation that comes from the EzPC library + Conv2D(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, + strideH, strideW, inputArr, filterArr, outArr); +#endif + +#ifdef SCI_HE + // If its a field, then its a HE based -- use the HE based conv implementation + std::vector<std::vector<std::vector<std::vector<intType>>>> inputVec; + inputVec.resize(N, std::vector<std::vector<std::vector<intType>>>( + H, std::vector<std::vector<intType>>( + W, std::vector<intType>(CI, 0)))); + + std::vector<std::vector<std::vector<std::vector<intType>>>> filterVec; + filterVec.resize(FH, std::vector<std::vector<std::vector<intType>>>( + FW, std::vector<std::vector<intType>>( + CI, std::vector<intType>(CO, 0)))); + + std::vector<std::vector<std::vector<std::vector<intType>>>> outputVec; + outputVec.resize(N, std::vector<std::vector<std::vector<intType>>>( + newH, std::vector<std::vector<intType>>( + newW, std::vector<intType>(CO, 0)))); + + for (int i = 0; i < N; i++) { + for (int j = 0; j < H; j++) { + for (int k = 0; k < W; k++) { + for (int p = 0; p < CI; p++) { + inputVec[i][j][k][p] = + getRingElt(Arr4DIdxRowM(inputArr, N, H, W, CI, i, j, k, p)); + } + } + } + } + for (int i = 0; i < FH; i++) { + for (int j = 0; j < FW; j++) { + for (int k = 0; k < CI; k++) { + for (int p = 0; p < CO; p++) { + filterVec[i][j][k][p] = + getRingElt(Arr4DIdxRowM(filterArr, FH, FW, CI, CO, i, j, k, p)); + } + } + } + } + + he_conv->convolution(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, + zPadWLeft, zPadWRight, strideH, strideW, inputVec, + filterVec, outputVec); + + for (int i = 0; i < N; i++) { + for (int j = 0; j < newH; j++) { + for (int k = 0; k < newW; k++) { + for (int p = 0; p < CO; p++) { + Arr4DIdxRowM(outArr, N, newH, newW, CO, i, j, k, p) = + getRingElt(outputVec[i][j][k][p]); + } + } + } + } + +#endif + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + ConvTimeInMilliSec += temp; + std::cout << "Time in sec for current conv = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + ConvCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE +#ifdef SCI_HE + for (int i = 0; i < N; i++) { + for (int j = 0; j < newH; j++) { + for (int k = 0; k < newW; k++) { + for (int p = 0; p < CO; p++) { + assert(Arr4DIdxRowM(outArr, N, newH, newW, CO, i, j, k, p) < + prime_mod); + } + } + } + } +#endif + if (party == SERVER) { + funcReconstruct2PCCons(nullptr, inputArr, N * H * W * CI); + funcReconstruct2PCCons(nullptr, filterArr, FH * FW * CI * CO); + funcReconstruct2PCCons(nullptr, outArr, N * newH * newW * CO); + } else { + signedIntType *VinputArr = new signedIntType[N * H * W * CI]; + funcReconstruct2PCCons(VinputArr, inputArr, N * H * W * CI); + signedIntType *VfilterArr = new signedIntType[FH * FW * CI * CO]; + funcReconstruct2PCCons(VfilterArr, filterArr, FH * FW * CI * CO); + signedIntType *VoutputArr = new signedIntType[N * newH * newW * CO]; + funcReconstruct2PCCons(VoutputArr, outArr, N * newH * newW * CO); + + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> VinputVec; + VinputVec.resize(N, std::vector<std::vector<std::vector<uint64_t>>>( + H, std::vector<std::vector<uint64_t>>( + W, std::vector<uint64_t>(CI, 0)))); + + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> VfilterVec; + VfilterVec.resize(FH, std::vector<std::vector<std::vector<uint64_t>>>( + FW, std::vector<std::vector<uint64_t>>( + CI, std::vector<uint64_t>(CO, 0)))); + + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> VoutputVec; + VoutputVec.resize(N, std::vector<std::vector<std::vector<uint64_t>>>( + newH, std::vector<std::vector<uint64_t>>( + newW, std::vector<uint64_t>(CO, 0)))); + + for (int i = 0; i < N; i++) { + for (int j = 0; j < H; j++) { + for (int k = 0; k < W; k++) { + for (int p = 0; p < CI; p++) { + VinputVec[i][j][k][p] = + getRingElt(Arr4DIdxRowM(VinputArr, N, H, W, CI, i, j, k, p)); + } + } + } + } + for (int i = 0; i < FH; i++) { + for (int j = 0; j < FW; j++) { + for (int k = 0; k < CI; k++) { + for (int p = 0; p < CO; p++) { + VfilterVec[i][j][k][p] = getRingElt( + Arr4DIdxRowM(VfilterArr, FH, FW, CI, CO, i, j, k, p)); + } + } + } + } + + Conv2DWrapper_pt(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, VinputVec, VfilterVec, + VoutputVec); // consSF = 0 + + bool pass = true; + for (int i = 0; i < N; i++) { + for (int j = 0; j < newH; j++) { + for (int k = 0; k < newW; k++) { + for (int p = 0; p < CO; p++) { + if (Arr4DIdxRowM(VoutputArr, N, newH, newW, CO, i, j, k, p) != + getSignedVal(VoutputVec[i][j][k][p])) { + pass = false; + } + } + } + } + } + if (pass == true) + std::cout << GREEN << "Convolution Output Matches" << RESET << std::endl; + else + std::cout << RED << "Convolution Output Mismatch" << RESET << std::endl; + + delete[] VinputArr; + delete[] VfilterArr; + delete[] VoutputArr; + } +#endif +} + +#ifdef SCI_OT +void Conv2DGroup(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t FH, + int32_t FW, int32_t CO, int32_t zPadHLeft, int32_t zPadHRight, + int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, + int32_t strideW, int32_t G, intType *inputArr, + intType *filterArr, intType *outArr); +#endif + +void Conv2DGroupWrapper(signedIntType N, signedIntType H, signedIntType W, + signedIntType CI, signedIntType FH, signedIntType FW, + signedIntType CO, signedIntType zPadHLeft, + signedIntType zPadHRight, signedIntType zPadWLeft, + signedIntType zPadWRight, signedIntType strideH, + signedIntType strideW, signedIntType G, + intType *inputArr, intType *filterArr, + intType *outArr) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + + static int ctr = 1; + std::cout << "Conv2DGroupCSF " << ctr << " called N=" << N << ", H=" << H + << ", W=" << W << ", CI=" << CI << ", FH=" << FH << ", FW=" << FW + << ", CO=" << CO << ", S=" << strideH << ",G=" << G << std::endl; + ctr++; + +#ifdef SCI_OT + // If its a ring, then its a OT based -- use the default Conv2DGroupCSF + // implementation that comes from the EzPC library + Conv2DGroup(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, G, inputArr, filterArr, outArr); +#endif + +#ifdef SCI_HE + assert(false && "Grouped conv not implemented in HE"); +#endif + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + ConvTimeInMilliSec += temp; + std::cout << "Time in sec for current conv = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + ConvCommSent += curComm; +#endif +} + +void ElemWiseActModelVectorMult(int32_t size, intType *inArr, + intType *multArrVec, intType *outputArr) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + + if (party == CLIENT) { + for (int i = 0; i < size; i++) { + assert((multArrVec[i] == 0) && + "The semantics of ElemWiseActModelVectorMult dictate multArrVec " + "should be the model and client share should be 0 for it."); + } + } + + static int batchNormCtr = 1; + std::cout << "Starting fused batchNorm #" << batchNormCtr << std::endl; + batchNormCtr++; + +#ifdef SCI_OT +#ifdef MULTITHREADED_DOTPROD + std::thread dotProdThreads[num_threads]; + int chunk_size = ceil(size / double(num_threads)); + intType *inputArrPtr; + if (party == SERVER) { + inputArrPtr = multArrVec; + } else { + inputArrPtr = inArr; + } + for (int i = 0; i < num_threads; i++) { + int offset = i * chunk_size; + int curSize; + curSize = + ((i + 1) * chunk_size > size ? max(0, size - offset) : chunk_size); + /* + if (i == (num_threads - 1)) { + curSize = size - offset; + } + else{ + curSize = chunk_size; + } + */ + dotProdThreads[i] = std::thread(funcDotProdThread, i, num_threads, curSize, + multArrVec + offset, inArr + offset, + outputArr + offset, false); + } + for (int i = 0; i < num_threads; ++i) { + dotProdThreads[i].join(); + } +#else + matmul->hadamard_cross_terms(size, multArrVec, inArr, outputArr, bitlength, + bitlength, bitlength, MultMode::Alice_has_A); +#endif + + if (party == SERVER) { + for (int i = 0; i < size; i++) { + outputArr[i] += (inArr[i] * multArrVec[i]); + } + } else { + for (int i = 0; i < size; i++) { + assert(multArrVec[i] == 0 && "Client's share of model is non-zero."); + } + } + +#endif // SCI_OT + +#ifdef SCI_HE + std::vector<uint64_t> tempInArr(size); + std::vector<uint64_t> tempOutArr(size); + std::vector<uint64_t> tempMultArr(size); + + for (int i = 0; i < size; i++) { + tempInArr[i] = getRingElt(inArr[i]); + tempMultArr[i] = getRingElt(multArrVec[i]); + } + + he_prod->elemwise_product(size, tempInArr, tempMultArr, tempOutArr); + + for (int i = 0; i < size; i++) { + outputArr[i] = getRingElt(tempOutArr[i]); + } +#endif + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + BatchNormInMilliSec += temp; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + BatchNormCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE +#ifdef SCI_HE + for (int i = 0; i < size; i++) { + assert(outputArr[i] < prime_mod); + } +#endif + if (party == SERVER) { + funcReconstruct2PCCons(nullptr, inArr, size); + funcReconstruct2PCCons(nullptr, multArrVec, size); + funcReconstruct2PCCons(nullptr, outputArr, size); + } else { + signedIntType *VinArr = new signedIntType[size]; + funcReconstruct2PCCons(VinArr, inArr, size); + signedIntType *VmultArr = new signedIntType[size]; + funcReconstruct2PCCons(VmultArr, multArrVec, size); + signedIntType *VoutputArr = new signedIntType[size]; + funcReconstruct2PCCons(VoutputArr, outputArr, size); + + std::vector<uint64_t> VinVec(size); + std::vector<uint64_t> VmultVec(size); + std::vector<uint64_t> VoutputVec(size); + + for (int i = 0; i < size; i++) { + VinVec[i] = getRingElt(VinArr[i]); + VmultVec[i] = getRingElt(VmultArr[i]); + } + + ElemWiseActModelVectorMult_pt(size, VinVec, VmultVec, VoutputVec); + + bool pass = true; + for (int i = 0; i < size; i++) { + if (VoutputArr[i] != getSignedVal(VoutputVec[i])) { + pass = false; + } + } + if (pass == true) + std::cout << GREEN << "ElemWiseSecretVectorMult Output Matches" << RESET + << std::endl; + else + std::cout << RED << "ElemWiseSecretVectorMult Output Mismatch" << RESET + << std::endl; + + delete[] VinArr; + delete[] VmultArr; + delete[] VoutputArr; + } +#endif +} + +void ArgMax(int32_t s1, int32_t s2, intType *inArr, intType *outArr) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + + static int ctr = 1; + std::cout << "ArgMax " << ctr << " called, s1=" << s1 << ", s2=" << s2 + << std::endl; + ctr++; + + assert(s1 == 1 && "ArgMax impl right now assumes s1==1"); + argmax->ArgMaxMPC(s2, inArr, outArr); + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + ArgMaxTimeInMilliSec += temp; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + ArgMaxCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE + if (party == SERVER) { + funcReconstruct2PCCons(nullptr, inArr, s1 * s2); + funcReconstruct2PCCons(nullptr, outArr, s1); + } else { + signedIntType *VinArr = new signedIntType[s1 * s2]; + funcReconstruct2PCCons(VinArr, inArr, s1 * s2); + signedIntType *VoutArr = new signedIntType[s1]; + funcReconstruct2PCCons(VoutArr, outArr, s1); + + std::vector<std::vector<uint64_t>> VinVec; + VinVec.resize(s1, std::vector<uint64_t>(s2, 0)); + std::vector<uint64_t> VoutVec(s1); + + for (int i = 0; i < s1; i++) { + for (int j = 0; j < s2; j++) { + VinVec[i][j] = getRingElt(Arr2DIdxRowM(VinArr, s1, s2, i, j)); + } + } + + ArgMax_pt(s1, s2, VinVec, VoutVec); + + bool pass = true; + for (int i = 0; i < s1; i++) { + if (VoutArr[i] != getSignedVal(VoutVec[i])) { + pass = false; + std::cout << VoutArr[i] << "\t" << getSignedVal(VoutVec[i]) + << std::endl; + } + } + if (pass == true) + std::cout << GREEN << "ArgMax1 Output Matches" << RESET << std::endl; + else + std::cout << RED << "ArgMax1 Output Mismatch" << RESET << std::endl; + + delete[] VinArr; + delete[] VoutArr; + } +#endif +} + +void Relu(int32_t size, intType *inArr, intType *outArr, int sf, + bool doTruncation) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + + static int ctr = 1; + std::cout << "Relu " << ctr << " called size=" << size << std::endl; + ctr++; + + intType moduloMask = sci::all1Mask(bitlength); + int eightDivElemts = ((size + 8 - 1) / 8) * 8; //(ceil of s1*s2/8.0)*8 + uint8_t *msbShare = new uint8_t[eightDivElemts]; + intType *tempInp = new intType[eightDivElemts]; + intType *tempOutp = new intType[eightDivElemts]; + sci::copyElemWisePadded(size, inArr, eightDivElemts, tempInp, 0); + +#ifndef MULTITHREADED_NONLIN + relu->relu(tempOutp, tempInp, eightDivElemts, nullptr); +#else + std::thread relu_threads[num_threads]; + int chunk_size = (eightDivElemts / (8 * num_threads)) * 8; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_relu; + if (i == (num_threads - 1)) { + lnum_relu = eightDivElemts - offset; + } else { + lnum_relu = chunk_size; + } + relu_threads[i] = std::thread(funcReLUThread, i, tempOutp + offset, + tempInp + offset, lnum_relu, nullptr, false); + } + for (int i = 0; i < num_threads; ++i) { + relu_threads[i].join(); + } +#endif + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + ReluTimeInMilliSec += temp; + std::cout << "Time in sec for current relu = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + ReluCommSent += curComm; +#endif + + if (doTruncation) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + for (int i = 0; i < eightDivElemts; i++) { + msbShare[i] = 0; // After relu, all numbers are +ve + } + + intType *tempTruncOutp = new intType[eightDivElemts]; +#ifdef SCI_OT + for (int i = 0; i < eightDivElemts; i++) { + tempOutp[i] = tempOutp[i] & moduloMask; + } + // funcTruncateTwoPowerRingWrapper(eightDivElemts, tempOutp, tempTruncOutp, + // sf, msbShare, true); + truncation->truncate(eightDivElemts, tempOutp, tempTruncOutp, sf, bitlength, + true, msbShare); +#else + funcFieldDivWrapper<intType>(eightDivElemts, tempOutp, tempTruncOutp, + 1ULL << sf, msbShare); +#endif + memcpy(outArr, tempTruncOutp, size * sizeof(intType)); + delete[] tempTruncOutp; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + TruncationTimeInMilliSec += temp; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + TruncationCommSent += curComm; +#endif + } else { + for (int i = 0; i < size; i++) { + outArr[i] = tempOutp[i]; + } + } + +#ifdef SCI_OT + for (int i = 0; i < size; i++) { + outArr[i] = outArr[i] & moduloMask; + } +#endif + +#ifdef VERIFY_LAYERWISE +#ifdef SCI_HE + for (int i = 0; i < size; i++) { + assert(tempOutp[i] < prime_mod); + assert(outArr[i] < prime_mod); + } +#endif + + if (party == SERVER) { + funcReconstruct2PCCons(nullptr, inArr, size); + funcReconstruct2PCCons(nullptr, tempOutp, size); + funcReconstruct2PCCons(nullptr, outArr, size); + } else { + signedIntType *VinArr = new signedIntType[size]; + funcReconstruct2PCCons(VinArr, inArr, size); + signedIntType *VtempOutpArr = new signedIntType[size]; + funcReconstruct2PCCons(VtempOutpArr, tempOutp, size); + signedIntType *VoutArr = new signedIntType[size]; + funcReconstruct2PCCons(VoutArr, outArr, size); + + std::vector<uint64_t> VinVec; + VinVec.resize(size, 0); + + std::vector<uint64_t> VoutVec; + VoutVec.resize(size, 0); + + for (int i = 0; i < size; i++) { + VinVec[i] = getRingElt(VinArr[i]); + } + + Relu_pt(size, VinVec, VoutVec, 0, false); // sf = 0 + + bool pass = true; + for (int i = 0; i < size; i++) { + if (VtempOutpArr[i] != getSignedVal(VoutVec[i])) { + pass = false; + } + } + if (pass == true) + std::cout << GREEN << "ReLU Output Matches" << RESET << std::endl; + else + std::cout << RED << "ReLU Output Mismatch" << RESET << std::endl; + + ScaleDown_pt(size, VoutVec, sf); + + pass = true; + for (int i = 0; i < size; i++) { + if (VoutArr[i] != getSignedVal(VoutVec[i])) { + pass = false; + } + } + if (pass == true) + std::cout << GREEN << "Truncation (after ReLU) Output Matches" << RESET + << std::endl; + else + std::cout << RED << "Truncation (after ReLU) Output Mismatch" << RESET + << std::endl; + + delete[] VinArr; + delete[] VtempOutpArr; + delete[] VoutArr; + } +#endif + + delete[] tempInp; + delete[] tempOutp; + delete[] msbShare; +} + +void MaxPool(int32_t N, int32_t H, int32_t W, int32_t C, int32_t ksizeH, + int32_t ksizeW, int32_t zPadHLeft, int32_t zPadHRight, + int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, + int32_t strideW, int32_t N1, int32_t imgH, int32_t imgW, + int32_t C1, intType *inArr, intType *outArr) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + + static int ctr = 1; + std::cout << "Maxpool " << ctr << " called N=" << N << ", H=" << H + << ", W=" << W << ", C=" << C << ", ksizeH=" << ksizeH + << ", ksizeW=" << ksizeW << std::endl; + ctr++; + + uint64_t moduloMask = sci::all1Mask(bitlength); + int rowsOrig = N * H * W * C; + int rows = ((rowsOrig + 8 - 1) / 8) * 8; //(ceil of rows/8.0)*8 + int cols = ksizeH * ksizeW; + + intType *reInpArr = new intType[rows * cols]; + intType *maxi = new intType[rows]; + intType *maxiIdx = new intType[rows]; + + int rowIdx = 0; + for (int n = 0; n < N; n++) { + for (int c = 0; c < C; c++) { + int32_t leftTopCornerH = -zPadHLeft; + int32_t extremeRightBottomCornerH = imgH - 1 + zPadHRight; + while ((leftTopCornerH + ksizeH - 1) <= extremeRightBottomCornerH) { + int32_t leftTopCornerW = -zPadWLeft; + int32_t extremeRightBottomCornerW = imgW - 1 + zPadWRight; + while ((leftTopCornerW + ksizeW - 1) <= extremeRightBottomCornerW) { + + for (int fh = 0; fh < ksizeH; fh++) { + for (int fw = 0; fw < ksizeW; fw++) { + int32_t colIdx = fh * ksizeW + fw; + int32_t finalIdx = rowIdx * (ksizeH * ksizeW) + colIdx; + + int32_t curPosH = leftTopCornerH + fh; + int32_t curPosW = leftTopCornerW + fw; + + intType temp = 0; + if ((((curPosH < 0) || (curPosH >= imgH)) || + ((curPosW < 0) || (curPosW >= imgW)))) { + temp = 0; + } else { + temp = Arr4DIdxRowM(inArr, N, imgH, imgW, C, n, curPosH, + curPosW, c); + } + reInpArr[finalIdx] = temp; + } + } + + rowIdx += 1; + leftTopCornerW = leftTopCornerW + strideW; + } + + leftTopCornerH = leftTopCornerH + strideH; + } + } + } + + for (int i = rowsOrig; i < rows; i++) { + for (int j = 0; j < cols; j++) { + reInpArr[i * cols + j] = 0; // The extra padded values + } + } + +#ifndef MULTITHREADED_NONLIN + maxpool->funcMaxMPC(rows, cols, reInpArr, maxi, maxiIdx); +#else + std::thread maxpool_threads[num_threads]; + int chunk_size = (rows / (8 * num_threads)) * 8; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_rows; + if (i == (num_threads - 1)) { + lnum_rows = rows - offset; + } else { + lnum_rows = chunk_size; + } + maxpool_threads[i] = + std::thread(funcMaxpoolThread, i, lnum_rows, cols, + reInpArr + offset * cols, maxi + offset, maxiIdx + offset); + } + for (int i = 0; i < num_threads; ++i) { + maxpool_threads[i].join(); + } +#endif + + for (int n = 0; n < N; n++) { + for (int c = 0; c < C; c++) { + for (int h = 0; h < H; h++) { + for (int w = 0; w < W; w++) { + int iidx = n * C * H * W + c * H * W + h * W + w; + Arr4DIdxRowM(outArr, N, H, W, C, n, h, w, c) = getRingElt(maxi[iidx]); + } + } + } + } + + delete[] reInpArr; + delete[] maxi; + delete[] maxiIdx; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + MaxpoolTimeInMilliSec += temp; + std::cout << "Time in sec for current maxpool = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + MaxpoolCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE +#ifdef SCI_HE + for (int i = 0; i < N; i++) { + for (int j = 0; j < H; j++) { + for (int k = 0; k < W; k++) { + for (int p = 0; p < C; p++) { + assert(Arr4DIdxRowM(outArr, N, H, W, C, i, j, k, p) < prime_mod); + } + } + } + } +#endif + if (party == SERVER) { + funcReconstruct2PCCons(nullptr, inArr, N * imgH * imgW * C); + funcReconstruct2PCCons(nullptr, outArr, N * H * W * C); + } else { + signedIntType *VinArr = new signedIntType[N * imgH * imgW * C]; + funcReconstruct2PCCons(VinArr, inArr, N * imgH * imgW * C); + signedIntType *VoutArr = new signedIntType[N * H * W * C]; + funcReconstruct2PCCons(VoutArr, outArr, N * H * W * C); + + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> VinVec; + VinVec.resize(N, std::vector<std::vector<std::vector<uint64_t>>>( + imgH, std::vector<std::vector<uint64_t>>( + imgW, std::vector<uint64_t>(C, 0)))); + + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> VoutVec; + VoutVec.resize(N, std::vector<std::vector<std::vector<uint64_t>>>( + H, std::vector<std::vector<uint64_t>>( + W, std::vector<uint64_t>(C, 0)))); + + for (int i = 0; i < N; i++) { + for (int j = 0; j < imgH; j++) { + for (int k = 0; k < imgW; k++) { + for (int p = 0; p < C; p++) { + VinVec[i][j][k][p] = + getRingElt(Arr4DIdxRowM(VinArr, N, imgH, imgW, C, i, j, k, p)); + } + } + } + } + + MaxPool_pt(N, H, W, C, ksizeH, ksizeW, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, N1, imgH, imgW, C1, VinVec, + VoutVec); + + bool pass = true; + for (int i = 0; i < N; i++) { + for (int j = 0; j < H; j++) { + for (int k = 0; k < W; k++) { + for (int p = 0; p < C; p++) { + if (Arr4DIdxRowM(VoutArr, N, H, W, C, i, j, k, p) != + getSignedVal(VoutVec[i][j][k][p])) { + pass = false; + // std::cout << i << "\t" << j << "\t" << k << "\t" << p << "\t" + // << Arr4DIdxRowM(VoutArr,N,H,W,C,i,j,k,p) << "\t" << + // getSignedVal(VoutVec[i][j][k][p]) << std::endl; + } + } + } + } + } + if (pass == true) + std::cout << GREEN << "Maxpool Output Matches" << RESET << std::endl; + else + std::cout << RED << "Maxpool Output Mismatch" << RESET << std::endl; + + delete[] VinArr; + delete[] VoutArr; + } +#endif +} + +void AvgPool(int32_t N, int32_t H, int32_t W, int32_t C, int32_t ksizeH, + int32_t ksizeW, int32_t zPadHLeft, int32_t zPadHRight, + int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, + int32_t strideW, int32_t N1, int32_t imgH, int32_t imgW, + int32_t C1, intType *inArr, intType *outArr) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + + static int ctr = 1; + std::cout << "AvgPool " << ctr << " called N=" << N << ", H=" << H + << ", W=" << W << ", C=" << C << ", ksizeH=" << ksizeH + << ", ksizeW=" << ksizeW << std::endl; + ctr++; + + uint64_t moduloMask = sci::all1Mask(bitlength); + int rows = N * H * W * C; + int rowsPadded = ((rows + 8 - 1) / 8) * 8; + intType *filterSum = new intType[rowsPadded]; + intType *filterAvg = new intType[rowsPadded]; + + int rowIdx = 0; + for (int n = 0; n < N; n++) { + for (int c = 0; c < C; c++) { + int32_t leftTopCornerH = -zPadHLeft; + int32_t extremeRightBottomCornerH = imgH - 1 + zPadHRight; + while ((leftTopCornerH + ksizeH - 1) <= extremeRightBottomCornerH) { + int32_t leftTopCornerW = -zPadWLeft; + int32_t extremeRightBottomCornerW = imgW - 1 + zPadWRight; + while ((leftTopCornerW + ksizeW - 1) <= extremeRightBottomCornerW) { + + intType curFilterSum = 0; + for (int fh = 0; fh < ksizeH; fh++) { + for (int fw = 0; fw < ksizeW; fw++) { + int32_t curPosH = leftTopCornerH + fh; + int32_t curPosW = leftTopCornerW + fw; + + intType temp = 0; + if ((((curPosH < 0) || (curPosH >= imgH)) || + ((curPosW < 0) || (curPosW >= imgW)))) { + temp = 0; + } else { + temp = Arr4DIdxRowM(inArr, N, imgH, imgW, C, n, curPosH, + curPosW, c); + } +#ifdef SCI_OT + curFilterSum += temp; +#else + curFilterSum = + sci::neg_mod(curFilterSum + temp, (int64_t)prime_mod); +#endif + } + } + + filterSum[rowIdx] = curFilterSum; + rowIdx += 1; + leftTopCornerW = leftTopCornerW + strideW; + } + + leftTopCornerH = leftTopCornerH + strideH; + } + } + } + + for (int i = rows; i < rowsPadded; i++) { + filterSum[i] = 0; + } + +#ifdef SCI_OT + for (int i = 0; i < rowsPadded; i++) { + filterSum[i] = filterSum[i] & moduloMask; + } + funcAvgPoolTwoPowerRingWrapper(rowsPadded, filterSum, filterAvg, + ksizeH * ksizeW); +#else + funcFieldDivWrapper<intType>(rowsPadded, filterSum, filterAvg, + ksizeH * ksizeW, nullptr); +#endif + + for (int n = 0; n < N; n++) { + for (int c = 0; c < C; c++) { + for (int h = 0; h < H; h++) { + for (int w = 0; w < W; w++) { + int iidx = n * C * H * W + c * H * W + h * W + w; + Arr4DIdxRowM(outArr, N, H, W, C, n, h, w, c) = filterAvg[iidx]; +#ifdef SCI_OT + Arr4DIdxRowM(outArr, N, H, W, C, n, h, w, c) = + Arr4DIdxRowM(outArr, N, H, W, C, n, h, w, c) & moduloMask; +#endif + } + } + } + } + + delete[] filterSum; + delete[] filterAvg; + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + AvgpoolTimeInMilliSec += temp; + std::cout << "Time in sec for current avgpool = " << (temp / 1000.0) + << std::endl; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + AvgpoolCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE +#ifdef SCI_HE + for (int i = 0; i < N; i++) { + for (int j = 0; j < H; j++) { + for (int k = 0; k < W; k++) { + for (int p = 0; p < C; p++) { + assert(Arr4DIdxRowM(outArr, N, H, W, C, i, j, k, p) < prime_mod); + } + } + } + } +#endif + if (party == SERVER) { + funcReconstruct2PCCons(nullptr, inArr, N * imgH * imgW * C); + funcReconstruct2PCCons(nullptr, outArr, N * H * W * C); + } else { + signedIntType *VinArr = new signedIntType[N * imgH * imgW * C]; + funcReconstruct2PCCons(VinArr, inArr, N * imgH * imgW * C); + signedIntType *VoutArr = new signedIntType[N * H * W * C]; + funcReconstruct2PCCons(VoutArr, outArr, N * H * W * C); + + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> VinVec; + VinVec.resize(N, std::vector<std::vector<std::vector<uint64_t>>>( + imgH, std::vector<std::vector<uint64_t>>( + imgW, std::vector<uint64_t>(C, 0)))); + + std::vector<std::vector<std::vector<std::vector<uint64_t>>>> VoutVec; + VoutVec.resize(N, std::vector<std::vector<std::vector<uint64_t>>>( + H, std::vector<std::vector<uint64_t>>( + W, std::vector<uint64_t>(C, 0)))); + + for (int i = 0; i < N; i++) { + for (int j = 0; j < imgH; j++) { + for (int k = 0; k < imgW; k++) { + for (int p = 0; p < C; p++) { + VinVec[i][j][k][p] = + getRingElt(Arr4DIdxRowM(VinArr, N, imgH, imgW, C, i, j, k, p)); + } + } + } + } + + AvgPool_pt(N, H, W, C, ksizeH, ksizeW, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, N1, imgH, imgW, C1, VinVec, + VoutVec); + + bool pass = true; + for (int i = 0; i < N; i++) { + for (int j = 0; j < H; j++) { + for (int k = 0; k < W; k++) { + for (int p = 0; p < C; p++) { + if (Arr4DIdxRowM(VoutArr, N, H, W, C, i, j, k, p) != + getSignedVal(VoutVec[i][j][k][p])) { + pass = false; + } + } + } + } + } + + if (pass == true) + std::cout << GREEN << "AvgPool Output Matches" << RESET << std::endl; + else + std::cout << RED << "AvgPool Output Mismatch" << RESET << std::endl; + + delete[] VinArr; + delete[] VoutArr; + } +#endif +} + +void ScaleDown(int32_t size, intType *inArr, int32_t sf) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + + int eightDivElemts = ((size + 8 - 1) / 8) * 8; //(ceil of s1*s2/8.0)*8 + intType *tempInp; + if (size != eightDivElemts) { + tempInp = new intType[eightDivElemts]; + memcpy(tempInp, inArr, sizeof(intType) * size); + } else { + tempInp = inArr; + } + uint64_t moduloMask = sci::all1Mask(bitlength); + for (int i = 0; i < eightDivElemts; i++) { + tempInp[i] = tempInp[i] & moduloMask; + } + intType *outp = new intType[eightDivElemts]; + +#ifdef SCI_OT + // funcTruncateTwoPowerRingWrapper(eightDivElemts, tempInp, outp, sf, + // nullptr); + truncation->truncate(eightDivElemts, tempInp, outp, sf, bitlength, true); +#else + funcFieldDivWrapper<intType>(eightDivElemts, tempInp, outp, 1ULL << sf, + nullptr); +#endif + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + TruncationTimeInMilliSec += temp; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + TruncationCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE +#ifdef SCI_HE + for (int i = 0; i < size; i++) { + assert(outp[i] < prime_mod); + } +#endif + + if (party == SERVER) { + funcReconstruct2PCCons(nullptr, inArr, size); + funcReconstruct2PCCons(nullptr, outp, size); + } else { + signedIntType *VinArr = new signedIntType[size]; + funcReconstruct2PCCons(VinArr, inArr, size); + signedIntType *VoutpArr = new signedIntType[size]; + funcReconstruct2PCCons(VoutpArr, outp, size); + + std::vector<uint64_t> VinVec; + VinVec.resize(size, 0); + + for (int i = 0; i < size; i++) { + VinVec[i] = getRingElt(VinArr[i]); + } + + ScaleDown_pt(size, VinVec, sf); + + bool pass = true; + for (int i = 0; i < size; i++) { + if (VoutpArr[i] != getSignedVal(VinVec[i])) { + pass = false; + } + } + + if (pass == true) + std::cout << GREEN << "Truncation4 Output Matches" << RESET << std::endl; + else + std::cout << RED << "Truncation4 Output Mismatch" << RESET << std::endl; + + delete[] VinArr; + delete[] VoutpArr; + } +#endif + + memcpy(inArr, outp, sizeof(intType) * size); + delete[] outp; + if (size != eightDivElemts) + delete[] tempInp; +} + +void ScaleUp(int32_t size, intType *arr, int32_t sf) { + for (int i = 0; i < size; i++) { +#ifdef SCI_OT + arr[i] = (arr[i] << sf); +#else + arr[i] = sci::neg_mod(arr[i] << sf, (int64_t)prime_mod); +#endif + } +} + +void StartComputation() { + assert(bitlength < 64 && bitlength > 0); + assert(num_threads <= MAX_THREADS); +#ifdef SCI_HE + prime_mod = sci::default_prime_mod.at(bitlength); +#elif SCI_OT + prime_mod = (bitlength == 64 ? 0ULL : 1ULL << bitlength); + moduloMask = prime_mod - 1; + moduloMidPt = prime_mod / 2; +#endif + std::cout << "bitlength: " << bitlength << std::endl; + std::cout << "prime_mod: " << prime_mod << std::endl; + checkIfUsingEigen(); + for (int i = 0; i < num_threads; i++) { + ioArr[i] = new sci::NetIO(party == sci::ALICE ? nullptr : address.c_str(), + port + i); + otInstanceArr[i] = new sci::IKNP<sci::NetIO>(ioArr[i]); + prgInstanceArr[i] = new sci::PRG128(); + kkotInstanceArr[i] = new sci::KKOT<sci::NetIO>(ioArr[i]); +#ifdef SCI_OT + multUniformArr[i] = + new MatMulUniform<sci::NetIO, intType, sci::IKNP<sci::NetIO>>( + party, bitlength, ioArr[i], otInstanceArr[i], nullptr); +#endif + if (i == 0) { + otpackArr[i] = new sci::OTPack<sci::NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new sci::OTPack<sci::NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new sci::OTPack<sci::NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); + } else { + otpackArr[i] = new sci::OTPack<sci::NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); + } + } + + io = ioArr[0]; + otpack = otpackArr[0]; + iknpOT = new sci::IKNP<sci::NetIO>(io); + iknpOTRoleReversed = new sci::IKNP<sci::NetIO>(io); + kkot = new sci::KKOT<sci::NetIO>(io); + prg128Instance = new sci::PRG128(); + +#ifdef SCI_OT + mult = new LinearOT(party, io, otpack); + truncation = new Truncation(party, io, otpack); + multUniform = new MatMulUniform<sci::NetIO, intType, sci::IKNP<sci::NetIO>>( + party, bitlength, io, iknpOT, iknpOTRoleReversed); + relu = new ReLURingProtocol<sci::NetIO, intType>(party, RING, io, bitlength, + MILL_PARAM, otpack); + maxpool = new MaxPoolProtocol<sci::NetIO, intType>( + party, RING, io, bitlength, MILL_PARAM, 0, otpack, relu); + argmax = new ArgMaxProtocol<sci::NetIO, intType>(party, RING, io, bitlength, + MILL_PARAM, 0, otpack, relu); + math = new MathFunctions(party, io, otpack); +#endif + +#ifdef SCI_HE + relu = new ReLUFieldProtocol<sci::NetIO, intType>( + party, FIELD, io, bitlength, MILL_PARAM, prime_mod, otpack); + maxpool = new MaxPoolProtocol<sci::NetIO, intType>( + party, FIELD, io, bitlength, MILL_PARAM, prime_mod, otpack, relu); + argmax = new ArgMaxProtocol<sci::NetIO, intType>( + party, FIELD, io, bitlength, MILL_PARAM, prime_mod, otpack, relu); + he_conv = new ConvField(party, io); + he_fc = new FCField(party, io); + he_prod = new ElemWiseProdField(party, io); + assertFieldRun(); +#endif + +#if defined MULTITHREADED_NONLIN && defined SCI_OT + for (int i = 0; i < num_threads; i++) { + if (i & 1) { + reluArr[i] = new ReLURingProtocol<sci::NetIO, intType>( + 3 - party, RING, ioArr[i], bitlength, MILL_PARAM, otpackArr[i]); + maxpoolArr[i] = new MaxPoolProtocol<sci::NetIO, intType>( + 3 - party, RING, ioArr[i], bitlength, MILL_PARAM, 0, otpackArr[i], + reluArr[i]); + multArr[i] = new LinearOT(3 - party, ioArr[i], otpackArr[i]); + truncationArr[i] = new Truncation(3 - party, ioArr[i], otpackArr[i]); + } else { + reluArr[i] = new ReLURingProtocol<sci::NetIO, intType>( + party, RING, ioArr[i], bitlength, MILL_PARAM, otpackArr[i]); + maxpoolArr[i] = new MaxPoolProtocol<sci::NetIO, intType>( + party, RING, ioArr[i], bitlength, MILL_PARAM, 0, otpackArr[i], + reluArr[i]); + multArr[i] = new LinearOT(party, ioArr[i], otpackArr[i]); + truncationArr[i] = new Truncation(party, ioArr[i], otpackArr[i]); + } + } +#endif + +#ifdef SCI_HE + for (int i = 0; i < num_threads; i++) { + if (i & 1) { + reluArr[i] = new ReLUFieldProtocol<sci::NetIO, intType>( + 3 - party, FIELD, ioArr[i], bitlength, MILL_PARAM, prime_mod, + otpackArr[i]); + maxpoolArr[i] = new MaxPoolProtocol<sci::NetIO, intType>( + 3 - party, FIELD, ioArr[i], bitlength, MILL_PARAM, prime_mod, + otpackArr[i], reluArr[i]); + } else { + reluArr[i] = new ReLUFieldProtocol<sci::NetIO, intType>( + party, FIELD, ioArr[i], bitlength, MILL_PARAM, prime_mod, + otpackArr[i]); + maxpoolArr[i] = new MaxPoolProtocol<sci::NetIO, intType>( + party, FIELD, ioArr[i], bitlength, MILL_PARAM, prime_mod, + otpackArr[i], reluArr[i]); + } + } +#endif + +// Math Protocols +#ifdef SCI_OT + for (int i = 0; i < num_threads; i++) { + if (i & 1) { + auxArr[i] = new AuxProtocols(3 - party, ioArr[i], otpackArr[i]); + truncationArr[i] = + new Truncation(3 - party, ioArr[i], otpackArr[i], auxArr[i]); + xtArr[i] = new XTProtocol(3 - party, ioArr[i], otpackArr[i], auxArr[i]); + mathArr[i] = new MathFunctions(3 - party, ioArr[i], otpackArr[i]); + } else { + auxArr[i] = new AuxProtocols(party, ioArr[i], otpackArr[i]); + truncationArr[i] = + new Truncation(party, ioArr[i], otpackArr[i], auxArr[i]); + xtArr[i] = new XTProtocol(party, ioArr[i], otpackArr[i], auxArr[i]); + mathArr[i] = new MathFunctions(party, ioArr[i], otpackArr[i]); + } + } + aux = auxArr[0]; + truncation = truncationArr[0]; + xt = xtArr[0]; + mult = multArr[0]; + math = mathArr[0]; +#endif + + if (party == sci::ALICE) { + iknpOT->setup_send(); + iknpOTRoleReversed->setup_recv(); + } else if (party == sci::BOB) { + iknpOT->setup_recv(); + iknpOTRoleReversed->setup_send(); + } + + cout << "After base ots, communication = " << (io->counter) << " bytes" + << endl; + start_time = std::chrono::high_resolution_clock::now(); + for (int i = 0; i < num_threads; i++) { + auto temp = ioArr[i]->counter; + comm_threads[i] = temp; + std::cout << "Thread i = " << i << ", total data sent till now = " << temp + << std::endl; + } + std::cout << "-----------Syncronizing-----------" << std::endl; + io->sync(); + num_rounds = io->num_rounds; + std::cout << "-----------Syncronized - now starting execution-----------" + << std::endl; +} + +void EndComputation() { + auto endTimer = std::chrono::high_resolution_clock::now(); + auto execTimeInMilliSec = + std::chrono::duration_cast<std::chrono::milliseconds>(endTimer - + start_time) + .count(); + uint64_t totalComm = 0; + for (int i = 0; i < num_threads; i++) { + auto temp = ioArr[i]->counter; + std::cout << "Thread i = " << i << ", total data sent till now = " << temp + << std::endl; + totalComm += (temp - comm_threads[i]); + } + uint64_t totalCommClient; + std::cout << "------------------------------------------------------\n"; + std::cout << "------------------------------------------------------\n"; + std::cout << "------------------------------------------------------\n"; + std::cout << "Total time taken = " << execTimeInMilliSec + << " milliseconds.\n"; + std::cout << "Total data sent = " << (totalComm / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Number of rounds = " << ioArr[0]->num_rounds - num_rounds + << std::endl; + if (party == SERVER) { + io->recv_data(&totalCommClient, sizeof(uint64_t)); + std::cout << "Total comm (sent+received) = " + << ((totalComm + totalCommClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + } else if (party == CLIENT) { + io->send_data(&totalComm, sizeof(uint64_t)); + std::cout << "Total comm (sent+received) = (see SERVER OUTPUT)" + << std::endl; + } + std::cout << "------------------------------------------------------\n"; + +#ifdef LOG_LAYERWISE + std::cout << "Total time in Conv = " << (ConvTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in MatMul = " << (MatMulTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in BatchNorm = " << (BatchNormInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in Truncation = " + << (TruncationTimeInMilliSec / 1000.0) << " seconds." << std::endl; + std::cout << "Total time in Relu = " << (ReluTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in MaxPool = " << (MaxpoolTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in AvgPool = " << (AvgpoolTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in ArgMax = " << (ArgMaxTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in MatAdd = " << (MatAddTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in MatAddBroadCast = " + << (MatAddBroadCastTimeInMilliSec / 1000.0) << " seconds." + << std::endl; + std::cout << "Total time in MulCir = " << (MulCirTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in ScalarMul = " + << (ScalarMulTimeInMilliSec / 1000.0) << " seconds." << std::endl; + std::cout << "Total time in Sigmoid = " << (SigmoidTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in Tanh = " << (TanhTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in Sqrt = " << (SqrtTimeInMilliSec / 1000.0) + << " seconds." << std::endl; + std::cout << "Total time in NormaliseL2 = " + << (NormaliseL2TimeInMilliSec / 1000.0) << " seconds." << std::endl; + std::cout << "------------------------------------------------------\n"; + std::cout << "Conv data sent = " << ((ConvCommSent) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "MatMul data sent = " + << ((MatMulCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "BatchNorm data sent = " + << ((BatchNormCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "Truncation data sent = " + << ((TruncationCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "Relu data sent = " << ((ReluCommSent) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Maxpool data sent = " + << ((MaxpoolCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "Avgpool data sent = " + << ((AvgpoolCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "ArgMax data sent = " + << ((ArgMaxCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "MatAdd data sent = " + << ((MatAddCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "MatAddBroadCast data sent = " + << ((MatAddBroadCastCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "MulCir data sent = " + << ((MulCirCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "Sigmoid data sent = " + << ((SigmoidCommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "Tanh data sent = " << ((TanhCommSent) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Sqrt data sent = " << ((SqrtCommSent) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "NormaliseL2 data sent = " + << ((NormaliseL2CommSent) / (1.0 * (1ULL << 20))) << " MiB." + << std::endl; + std::cout << "------------------------------------------------------\n"; + if (party == SERVER) { + uint64_t ConvCommSentClient = 0; + uint64_t MatMulCommSentClient = 0; + uint64_t BatchNormCommSentClient = 0; + uint64_t TruncationCommSentClient = 0; + uint64_t ReluCommSentClient = 0; + uint64_t MaxpoolCommSentClient = 0; + uint64_t AvgpoolCommSentClient = 0; + uint64_t ArgMaxCommSentClient = 0; + uint64_t MatAddCommSentClient = 0; + uint64_t MatAddBroadCastCommSentClient = 0; + uint64_t MulCirCommSentClient = 0; + uint64_t ScalarMulCommSentClient = 0; + uint64_t SigmoidCommSentClient = 0; + uint64_t TanhCommSentClient = 0; + uint64_t SqrtCommSentClient = 0; + uint64_t NormaliseL2CommSentClient = 0; + + io->recv_data(&ConvCommSentClient, sizeof(uint64_t)); + io->recv_data(&MatMulCommSentClient, sizeof(uint64_t)); + io->recv_data(&BatchNormCommSentClient, sizeof(uint64_t)); + io->recv_data(&TruncationCommSentClient, sizeof(uint64_t)); + io->recv_data(&ReluCommSentClient, sizeof(uint64_t)); + io->recv_data(&MaxpoolCommSentClient, sizeof(uint64_t)); + io->recv_data(&AvgpoolCommSentClient, sizeof(uint64_t)); + io->recv_data(&ArgMaxCommSentClient, sizeof(uint64_t)); + io->recv_data(&MatAddCommSentClient, sizeof(uint64_t)); + io->recv_data(&MatAddBroadCastCommSentClient, sizeof(uint64_t)); + io->recv_data(&MulCirCommSentClient, sizeof(uint64_t)); + io->recv_data(&ScalarMulCommSentClient, sizeof(uint64_t)); + io->recv_data(&SigmoidCommSentClient, sizeof(uint64_t)); + io->recv_data(&TanhCommSentClient, sizeof(uint64_t)); + io->recv_data(&SqrtCommSentClient, sizeof(uint64_t)); + io->recv_data(&NormaliseL2CommSentClient, sizeof(uint64_t)); + + std::cout << "Conv data (sent+received) = " + << ((ConvCommSent + ConvCommSentClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "MatMul data (sent+received) = " + << ((MatMulCommSent + MatMulCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "BatchNorm data (sent+received) = " + << ((BatchNormCommSent + BatchNormCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Truncation data (sent+received) = " + << ((TruncationCommSent + TruncationCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Relu data (sent+received) = " + << ((ReluCommSent + ReluCommSentClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Maxpool data (sent+received) = " + << ((MaxpoolCommSent + MaxpoolCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Avgpool data (sent+received) = " + << ((AvgpoolCommSent + AvgpoolCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "ArgMax data (sent+received) = " + << ((ArgMaxCommSent + ArgMaxCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "MatAdd data (sent+received) = " + << ((MatAddCommSent + MatAddCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "MatAddBroadCast data (sent+received) = " + << ((MatAddBroadCastCommSent + MatAddBroadCastCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "MulCir data (sent+received) = " + << ((MulCirCommSent + MulCirCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "ScalarMul data (sent+received) = " + << ((ScalarMulCommSent + ScalarMulCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Sigmoid data (sent+received) = " + << ((SigmoidCommSent + SigmoidCommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Tanh data (sent+received) = " + << ((TanhCommSent + TanhCommSentClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "Sqrt data (sent+received) = " + << ((SqrtCommSent + SqrtCommSentClient) / (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + std::cout << "NormaliseL2 data (sent+received) = " + << ((NormaliseL2CommSent + NormaliseL2CommSentClient) / + (1.0 * (1ULL << 20))) + << " MiB." << std::endl; + +#ifdef WRITE_LOG + std::string file_addr = "results-Porthos2PC-server.csv"; + bool write_title = true; + { + std::fstream result(file_addr.c_str(), std::fstream::in); + if (result.is_open()) + write_title = false; + result.close(); + } + std::fstream result(file_addr.c_str(), + std::fstream::out | std::fstream::app); + if (write_title) { + result << "Algebra,Bitlen,Base,#Threads,Total Time,Total Comm,Conv " + "Time,Conv Comm,MatMul Time,MatMul Comm,BatchNorm " + "Time,BatchNorm Comm,Truncation Time,Truncation Comm,ReLU " + "Time,ReLU Comm,MaxPool Time,MaxPool Comm,AvgPool Time,AvgPool " + "Comm,ArgMax Time,ArgMax Comm" + << std::endl; + } + result << (isNativeRing ? "Ring" : "Field") << "," << bitlength << "," + << MILL_PARAM << "," << num_threads << "," + << execTimeInMilliSec / 1000.0 << "," + << (totalComm + totalCommClient) / (1.0 * (1ULL << 20)) << "," + << ConvTimeInMilliSec / 1000.0 << "," + << (ConvCommSent + ConvCommSentClient) / (1.0 * (1ULL << 20)) << "," + << MatMulTimeInMilliSec / 1000.0 << "," + << (MatMulCommSent + MatMulCommSentClient) / (1.0 * (1ULL << 20)) + << "," << BatchNormInMilliSec / 1000.0 << "," + << (BatchNormCommSent + BatchNormCommSentClient) / + (1.0 * (1ULL << 20)) + << "," << TruncationTimeInMilliSec / 1000.0 << "," + << (TruncationCommSent + TruncationCommSentClient) / + (1.0 * (1ULL << 20)) + << "," << ReluTimeInMilliSec / 1000.0 << "," + << (ReluCommSent + ReluCommSentClient) / (1.0 * (1ULL << 20)) << "," + << MaxpoolTimeInMilliSec / 1000.0 << "," + << (MaxpoolCommSent + MaxpoolCommSentClient) / (1.0 * (1ULL << 20)) + << "," << AvgpoolTimeInMilliSec / 1000.0 << "," + << (AvgpoolCommSent + AvgpoolCommSentClient) / (1.0 * (1ULL << 20)) + << "," << ArgMaxTimeInMilliSec / 1000.0 << "," + << (ArgMaxCommSent + ArgMaxCommSentClient) / (1.0 * (1ULL << 20)) + << std::endl; + result.close(); +#endif + } else if (party == CLIENT) { + io->send_data(&ConvCommSent, sizeof(uint64_t)); + io->send_data(&MatMulCommSent, sizeof(uint64_t)); + io->send_data(&BatchNormCommSent, sizeof(uint64_t)); + io->send_data(&TruncationCommSent, sizeof(uint64_t)); + io->send_data(&ReluCommSent, sizeof(uint64_t)); + io->send_data(&MaxpoolCommSent, sizeof(uint64_t)); + io->send_data(&AvgpoolCommSent, sizeof(uint64_t)); + io->send_data(&ArgMaxCommSent, sizeof(uint64_t)); + io->send_data(&MatAddCommSent, sizeof(uint64_t)); + io->send_data(&MatAddBroadCastCommSent, sizeof(uint64_t)); + io->send_data(&MulCirCommSent, sizeof(uint64_t)); + io->send_data(&ScalarMulCommSent, sizeof(uint64_t)); + io->send_data(&SigmoidCommSent, sizeof(uint64_t)); + io->send_data(&TanhCommSent, sizeof(uint64_t)); + io->send_data(&SqrtCommSent, sizeof(uint64_t)); + io->send_data(&NormaliseL2CommSent, sizeof(uint64_t)); + } +#endif +} + +intType SecretAdd(intType x, intType y) { +#ifdef SCI_OT + return (x + y); +#else + return sci::neg_mod(x + y, (int64_t)prime_mod); +#endif +} + +intType SecretSub(intType x, intType y) { +#ifdef SCI_OT + return (x - y); +#else + return sci::neg_mod(x - y, (int64_t)prime_mod); +#endif +} + +intType SecretMult(intType x, intType y) { + // Not being used in any of our networks right now + assert(false); +} + +void ElemWiseVectorPublicDiv(int32_t s1, intType *arr1, int32_t divisor, + intType *outArr) { + intType *inp; + intType *out; + const int alignment = 8; + size_t aligned_size = + (s1 + alignment - 1) & -alignment; // rounding up to multiple of alignment + + if ((size_t)s1 != aligned_size) { + inp = new intType[aligned_size]; + out = new intType[aligned_size]; + memcpy(inp, arr1, s1 * sizeof(intType)); + memset(inp + s1, 0, (aligned_size - s1) * sizeof(intType)); + } else { + inp = arr1; + out = outArr; + } + assert(divisor > 0 && "No support for division by a negative divisor."); + +#ifdef SCI_OT + funcAvgPoolTwoPowerRingWrapper(aligned_size, inp, out, (intType)divisor); +#else + funcFieldDivWrapper(aligned_size, inp, out, (intType)divisor, nullptr); +#endif + + if ((size_t)s1 != aligned_size) { + memcpy(outArr, out, s1 * sizeof(intType)); + delete[] inp; + delete[] out; + } + + return; +} + +void ElemWiseSecretSharedVectorMult(int32_t size, intType *inArr, + intType *multArrVec, intType *outputArr) { +#ifdef LOG_LAYERWISE + INIT_ALL_IO_DATA_SENT; + INIT_TIMER; +#endif + static int batchNormCtr = 1; + std::cout << "Starting fused batchNorm #" << batchNormCtr << std::endl; + batchNormCtr++; + +#ifdef SCI_OT +#ifdef MULTITHREADED_DOTPROD + std::thread dotProdThreads[num_threads]; + int chunk_size = (size / num_threads); + for (int i = 0; i < num_threads; i++) { + int offset = i * chunk_size; + int curSize; + if (i == (num_threads - 1)) { + curSize = size - offset; + } else { + curSize = chunk_size; + } + dotProdThreads[i] = std::thread(funcDotProdThread, i, num_threads, curSize, + multArrVec + offset, inArr + offset, + outputArr + offset, true); + } + for (int i = 0; i < num_threads; ++i) { + dotProdThreads[i].join(); + } +#else + matmul->hadamard_cross_terms(size, multArrVec, inArr, outputArr, bitlength, + bitlength, bitlength, MultMode::None); +#endif + + for (int i = 0; i < size; i++) { + outputArr[i] += (inArr[i] * multArrVec[i]); + } +#endif + +#ifdef LOG_LAYERWISE + auto temp = TIMER_TILL_NOW; + BatchNormInMilliSec += temp; + uint64_t curComm; + FIND_ALL_IO_TILL_NOW(curComm); + BatchNormCommSent += curComm; +#endif + +#ifdef VERIFY_LAYERWISE + if (party == SERVER) { + funcReconstruct2PCCons(nullptr, inArr, size); + funcReconstruct2PCCons(nullptr, multArrVec, size); + funcReconstruct2PCCons(nullptr, outputArr, size); + } else { + signedIntType *VinArr = new signedIntType[size]; + funcReconstruct2PCCons(VinArr, inArr, size); + signedIntType *VmultArr = new signedIntType[size]; + funcReconstruct2PCCons(VmultArr, multArrVec, size); + signedIntType *VoutputArr = new signedIntType[size]; + funcReconstruct2PCCons(VoutputArr, outputArr, size); + + std::vector<uint64_t> VinVec(size); + std::vector<uint64_t> VmultVec(size); + std::vector<uint64_t> VoutputVec(size); + + for (int i = 0; i < size; i++) { + VinVec[i] = getRingElt(VinArr[i]); + VmultVec[i] = getRingElt(VmultArr[i]); + } + + ElemWiseSecretSharedVectorMult_pt(size, VinVec, VmultVec, VoutputVec); + + bool pass = true; + for (int i = 0; i < size; i++) { + if (VoutputArr[i] != getSignedVal(VoutputVec[i])) { + pass = false; + } + } + if (pass == true) + std::cout << GREEN << "ElemWiseSecretSharedVectorMult Output Matches" + << RESET << std::endl; + else + std::cout << RED << "ElemWiseSecretSharedVectorMult Output Mismatch" + << RESET << std::endl; + + delete[] VinArr; + delete[] VmultArr; + delete[] VoutputArr; + } +#endif +} + +void Floor(int32_t s1, intType *inArr, intType *outArr, int32_t sf) { + // Not being used in any of our networks right now + assert(false); +} diff --git a/SCI/src/library_fixed_uniform.h b/SCI/src/library_fixed_uniform.h new file mode 100644 index 00000000..993ec808 --- /dev/null +++ b/SCI/src/library_fixed_uniform.h @@ -0,0 +1,192 @@ +/* +Authors: Nishant Kumar +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#ifndef LIBRARY_FIXED_UNIFORM_H__ +#define LIBRARY_FIXED_UNIFORM_H__ + +#include "defines_uniform.h" +#include "utils/ArgMapping/ArgMapping.h" + +// Note of the bracket around each expression use -- if this is not there, not +// macro expansion +// can result in hard in trace bugs when expanded around expressions like 1-2. +#define Arr1DIdxRowM(arr, s0, i) (*((arr) + (i))) +#define Arr2DIdxRowM(arr, s0, s1, i, j) (*((arr) + (i) * (s1) + (j))) +#define Arr3DIdxRowM(arr, s0, s1, s2, i, j, k) \ + (*((arr) + (i) * (s1) * (s2) + (j) * (s2) + (k))) +#define Arr4DIdxRowM(arr, s0, s1, s2, s3, i, j, k, l) \ + (*((arr) + (i) * (s1) * (s2) * (s3) + (j) * (s2) * (s3) + (k) * (s3) + (l))) +#define Arr5DIdxRowM(arr, s0, s1, s2, s3, s4, i, j, k, l, m) \ + (*((arr) + (i) * (s1) * (s2) * (s3) * (s4) + (j) * (s2) * (s3) * (s4) + \ + (k) * (s3) * (s4) + (l) * (s4) + (m))) + +#define Arr2DIdxColM(arr, s0, s1, i, j) (*((arr) + (j) * (s0) + (i))) + +intType funcSSCons(int64_t x); +void funcReconstruct2PCCons(signedIntType *y, const intType *x, int len); +signedIntType funcReconstruct2PCCons(intType x, int revealParty); + +void MatMul2D(int32_t s1, int32_t s2, int32_t s3, const intType *A, + const intType *B, intType *C, bool modelIsA); + +void Conv2DWrapper(signedIntType N, signedIntType H, signedIntType W, + signedIntType CI, signedIntType FH, signedIntType FW, + signedIntType CO, signedIntType zPadHLeft, + signedIntType zPadHRight, signedIntType zPadWLeft, + signedIntType zPadWRight, signedIntType strideH, + signedIntType strideW, intType *inputArr, intType *filterArr, + intType *outArr); + +void Conv2DGroupWrapper(signedIntType N, signedIntType H, signedIntType W, + signedIntType CI, signedIntType FH, signedIntType FW, + signedIntType CO, signedIntType zPadHLeft, + signedIntType zPadHRight, signedIntType zPadWLeft, + signedIntType zPadWRight, signedIntType strideH, + signedIntType strideW, signedIntType G, + intType *inputArr, intType *filterArr, intType *outArr); + +void ElemWiseActModelVectorMult(int32_t size, intType *inArr, + intType *multArrVec, intType *outputArr); + +void ArgMax(int32_t s1, int32_t s2, intType *inArr, intType *outArr); + +void Relu(int32_t size, intType *inArr, intType *outArr, int sf, + bool doTruncation); + +void MaxPool(int32_t N, int32_t H, int32_t W, int32_t C, int32_t ksizeH, + int32_t ksizeW, int32_t zPadHLeft, int32_t zPadHRight, + int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, + int32_t strideW, int32_t N1, int32_t imgH, int32_t imgW, + int32_t C1, intType *inArr, intType *outArr); + +void AvgPool(int32_t N, int32_t H, int32_t W, int32_t C, int32_t ksizeH, + int32_t ksizeW, int32_t zPadHLeft, int32_t zPadHRight, + int32_t zPadWLeft, int32_t zPadWRight, int32_t strideH, + int32_t strideW, int32_t N1, int32_t imgH, int32_t imgW, + int32_t C1, intType *inArr, intType *outArr); + +void ScaleDown(int32_t size, intType *inArr, int32_t sf); + +void ScaleUp(int32_t size, intType *arr, int32_t sf); + +void StartComputation(); + +void EndComputation(); + +intType SecretAdd(intType x, intType y); + +intType SecretSub(intType x, intType y); + +intType SecretMult(intType x, intType y); + +void ElemWiseVectorPublicDiv(int32_t s1, intType *arr1, int32_t divisor, + intType *outArr); + +void ElemWiseSecretSharedVectorMult(int32_t size, intType *inArr, + intType *multArrVec, intType *outputArr); + +void Floor(int32_t s1, intType *inArr, intType *outArr, int32_t sf); + +inline void ClearMemSecret1(int32_t s1, intType *arr) { delete[] arr; } + +inline void ClearMemSecret2(int32_t s1, int32_t s2, intType *arr) { + delete[] arr; // At the end of the day, everything is done using 1D array +} + +inline void ClearMemSecret3(int32_t s1, int32_t s2, int32_t s3, intType *arr) { + delete[] arr; +} + +inline void ClearMemSecret4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, + intType *arr) { + delete[] arr; +} + +inline void ClearMemSecret5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, + int32_t s5, intType *arr) { + delete[] arr; +} + +inline void ClearMemPublic(int32_t x) { return; } + +inline void ClearMemPublic1(int32_t s1, int32_t *arr) { delete[] arr; } + +inline void ClearMemPublic2(int32_t s1, int32_t s2, int32_t *arr) { + delete[] arr; +} + +inline void ClearMemPublic3(int32_t s1, int32_t s2, int32_t s3, int32_t *arr) { + delete[] arr; +} + +inline void ClearMemPublic4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, + int32_t *arr) { + delete[] arr; +} + +inline void ClearMemPublic5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, + int32_t s5, int32_t *arr) { + delete[] arr; +} + +inline void ClearMemPublic(int64_t x) { return; } + +inline void ClearMemPublic1(int32_t s1, int64_t *arr) { delete[] arr; } + +inline void ClearMemPublic2(int32_t s1, int32_t s2, int64_t *arr) { + delete[] arr; +} + +inline void ClearMemPublic3(int32_t s1, int32_t s2, int32_t s3, int64_t *arr) { + delete[] arr; +} + +inline void ClearMemPublic4(int32_t s1, int32_t s2, int32_t s3, int32_t s4, + int64_t *arr) { + delete[] arr; +} + +inline void ClearMemPublic5(int32_t s1, int32_t s2, int32_t s3, int32_t s4, + int32_t s5, int64_t *arr) { + delete[] arr; +} + +template <typename T> T *make_array(size_t s1) { return new T[s1]; } + +template <typename T> T *make_array(size_t s1, size_t s2) { + return new T[s1 * s2]; +} + +template <typename T> T *make_array(size_t s1, size_t s2, size_t s3) { + return new T[s1 * s2 * s3]; +} + +template <typename T> +T *make_array(size_t s1, size_t s2, size_t s3, size_t s4) { + return new T[s1 * s2 * s3 * s4]; +} + +template <typename T> +T *make_array(size_t s1, size_t s2, size_t s3, size_t s4, size_t s5) { + return new T[s1 * s2 * s3 * s4 * s5]; +} + +#endif diff --git a/SCI/src/linear-primary.h b/SCI/src/linear-primary.h deleted file mode 100644 index 452f3d3a..00000000 --- a/SCI/src/linear-primary.h +++ /dev/null @@ -1,685 +0,0 @@ -/* -Authors: Nishant Kumar -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#ifndef LINEAR_PRIMARY_H__ -#define LINEAR_PRIMARY_H__ -#include <iostream> - -#ifdef USE_EIGEN -#include <Eigen/Dense> -#endif - -#include "Millionaire/millionaire.h" - -template<typename IO, typename intType, typename otType> -class Matmul{ -public: - IO* io = nullptr; - sci::OT<otType>* otImpl = nullptr; - sci::OT<otType>* otImplRoleReversed = nullptr; - int party; - int bitlength; - const int batchSizeOTs = 1ULL<<18; //This is the default size of the batch of OTs that will be done in one go for matmul - // This will be scaled appropriately to manage memory if the matmul dimensions are too large. - - const uint64_t MaxMemToUseInBytes = 2.5*(1<<30); //2.5 GiB - intType moduloMask; - - Matmul(int party, int bitlength, IO* io, sci::OT<otType>* otImpl, sci::OT<otType>* otImplRoleReversed){ - this->party = party; - assert(((party==1)||(party==2)) && "PartyNum should be 1 or 2."); - this->bitlength = bitlength; - this->io = io; - assert(io!=nullptr && "IO can't be nullptr."); - assert(otImpl!=nullptr && "otImpl can't be nullptr."); - this->otImpl = otImpl; - this->otImplRoleReversed = otImplRoleReversed; - if (bitlength==64) moduloMask = -1; - else moduloMask = (1ULL<<bitlength)-1; - } - - ~Matmul(){ - } - -#ifdef USE_EIGEN - void ideal_func_eigen(int s1, int s2, int s3, const intType* A, const intType* B, intType* C){ - Eigen::Matrix<intType, Eigen::Dynamic, Eigen::Dynamic> eigen_a(s1,s2); - Eigen::Matrix<intType, Eigen::Dynamic, Eigen::Dynamic> eigen_b(s2,s3); - Eigen::Matrix<intType, Eigen::Dynamic, Eigen::Dynamic> eigen_c(s1,s3); - - for(int i=0;i<s1;i++){ - for(int j=0;j<s2;j++){ - eigen_a(i,j) = Arr2DIdxRowM(A,s1,s2,i,j); - } - } - for(int i=0;i<s2;i++){ - for(int j=0;j<s3;j++){ - eigen_b(i,j) = Arr2DIdxRowM(B,s2,s3,i,j); - } - } - eigen_c = eigen_a * eigen_b; - for(int i=0;i<s1;i++){ - for(int j=0;j<s3;j++){ - Arr2DIdxRowM(C,s1,s3,i,j) = eigen_c(i,j); - } - } - } -#endif - - void ideal_func(int s1, int s2, int s3, const intType* A, const intType* B, intType* C){ -#ifndef USE_EIGEN - for(int i=0;i<s1;i++){ - for(int j=0;j<s3;j++){ - Arr2DIdxRowM(C,s1,s3,i,j) = 0; - for(int k=0;k<s2;k++){ - Arr2DIdxRowM(C,s1,s3,i,j) += (Arr2DIdxRowM(A,s1,s2,i,k)*Arr2DIdxRowM(B,s2,s3,k,j)); - } - } - } -#else - ideal_func_eigen(s1,s2,s3,A,B,C); -#endif - for(int i=0;i<s1*s3;i++){ - C[i] = C[i] & moduloMask; - } - } - - void verifyMatmulShares(int s1, int s2, int s3, const intType* A_share, const intType* B_share, const intType* C_share){ - if (party==sci::ALICE){ - intType* A_temp_share = new intType[s1*s2]; - intType* B_temp_share = new intType[s2*s3]; - intType* C_temp_share = new intType[s1*s3]; - intType* C_clear = new intType[s1*s3]; - io->recv_data(A_temp_share, sizeof(intType)*s1*s2); - io->recv_data(B_temp_share, sizeof(intType)*s2*s3); - io->recv_data(C_temp_share, sizeof(intType)*s1*s3); - sci::elemWiseAdd<intType>(s1*s2,A_share,A_temp_share,A_temp_share); - sci::elemWiseAdd<intType>(s2*s3,B_share,B_temp_share,B_temp_share); - sci::elemWiseAdd<intType>(s1*s3,C_share,C_temp_share,C_temp_share); - ideal_func(s1,s2,s3,A_temp_share,B_temp_share,C_clear); - for(int i=0;i<s1;i++){ - for(int j=0;j<s3;j++){ - assert(Arr2DIdxRowM(C_clear,s1,s3,i,j)==(Arr2DIdxRowM(C_temp_share,s1,s3,i,j) & moduloMask)); - } - } - delete[] A_temp_share; - delete[] B_temp_share; - delete[] C_temp_share; - delete[] C_clear; - } - else if (party==sci::BOB){ - io->send_data(A_share, sizeof(intType)*s1*s2); - io->send_data(B_share, sizeof(intType)*s2*s3); - io->send_data(C_share, sizeof(intType)*s1*s3); - } - else{ - assert(false); - } - } - - void fillInSimpleValues(int s1, int s2, intType* arr){ - if (party==sci::ALICE){ - for(int i=0;i<s1;i++){ - for(int j=0;j<s2;j++){ - Arr2DIdxRowM(arr,s1,s2,i,j) = i+j+1; - } - } - } - else if (party==sci::BOB){ - for(int i=0;i<s1;i++){ - for(int j=0;j<s2;j++){ - Arr2DIdxRowM(arr,s1,s2,i,j) = 0; - } - } - } - } - - /* - This function is not being used anywhere right now - - matmul where dimensions of matrices are (s1,s2) and (s2,s3) - - inp is input of the sender of size (s1,s2) - - outp is the share of the result of size (s1,s3) - */ - void funcOTSenderNonBatched(int s1, int s2, int s3, const intType* inp, intType* outp, sci::OT<otType>* otInstance){ - uint64_t* corrData = new uint64_t[s1*s2*bitlength*s3]; - uint64_t* rData = new uint64_t[s1*s2*bitlength*s3]; - uint64_t* chunkSizes = new uint64_t[s2*bitlength*s3]; - uint64_t* numChunks = new uint64_t[s2*bitlength*s3]; - - intType* inpColumnMajor = new intType[s1*s2]; - intType* outpColumnMajor = new intType[s1*s3]; - sci::convertRowToColMajor<intType>(s1,s2,inp,inpColumnMajor); - - for(int i=0;i<s1*s3;i++){ - outpColumnMajor[i] = 0; - } - for(int col=0;col<s3;col++){ - for(int j=0;j<s2;j++){ - for(int k=0;k<bitlength;k++){ - for(int i=0;i<s1;i++){ - intType curElem = Arr2DIdxColM(inpColumnMajor,s1,s2,i,j); - Arr4DIdxRowM(corrData,s3,s2,bitlength,s1,col,j,k,i) = ((intType)(((intType)curElem)<<k))>>k; - //casting is imp to make sure that - // right shift happens in apt bitwidth - } - chunkSizes[col*s2*bitlength+j*bitlength+k] = bitlength-k; - numChunks[col*s2*bitlength+j*bitlength+k] = s1; - } - } - } - otInstance->template send_cot_matmul<intType>(rData, corrData, chunkSizes, numChunks, s2*bitlength*s3); - for(int col=0;col<s3;col++){ - for(int i=0;i<s2;i++){ - for(int j=0;j<bitlength;j++){ - for(int k=0;k<s1;k++){ - // Arr3DIdxRowM(rData,s2,bitlength,s1,i,j,k) should be of bitlength-j bits -- top j bits should be 0. - uint64_t curElem = Arr4DIdxRowM(rData,s3,s2,bitlength,s1,col,i,j,k); - assert(((((1ULL<<j)-1)<<(bitlength-j))&curElem)==0 && "assertion failed"); - Arr2DIdxColM(outpColumnMajor,s1,s3,k,col) -= (((intType)curElem)<<j); - } - } - } - } - - sci::convertColToRowMajor<intType>(s1,s3,outpColumnMajor,outp); - for(int i=0;i<s1*s3;i++){ - outp[i] = outp[i] & moduloMask; - } - - delete[] corrData; - delete[] rData; - delete[] chunkSizes; - delete[] numChunks; - } - - /* - This function is not being used anywhere right now - - The matrix multiplication being performed is (s1, s2) * (s2, s3). - - inp is the receiver's array to be multiplied of size (s2, s3) - - outp is the share of the receiver after multiplication of size (s1,s3) - */ - void funcOTReceiverNonBatched(int s1, int s2, int s3, const intType* inp, intType* outp, sci::OT<otType>* otInstance){ - // copy inp from row to column and outp from column to row major - uint8_t* choiceBitArr = new uint8_t[s2*bitlength*s3]; - uint64_t* recv_data = new uint64_t[s1*s2*bitlength*s3]; - uint64_t* chunkSizes = new uint64_t[s2*bitlength*s3]; - uint64_t* numChunks = new uint64_t[s2*bitlength*s3]; - - intType* inpColumnMajor = new intType[s2*s3]; - intType* outpColumnMajor = new intType[s1*s3]; - sci::convertRowToColMajor<intType>(s2,s3,inp,inpColumnMajor); - - for(int j=0;j<s3;j++){ - for(int i=0;i<s2;i++){ - for(int k=0;k<bitlength;k++){ - choiceBitArr[j*s2*bitlength+i*bitlength+k] = (Arr2DIdxColM(inpColumnMajor,s2,s3,i,j) & (1ULL<<k))>>k; //Unsigned right shift - chunkSizes[j*s2*bitlength+i*bitlength+k] = (bitlength-k); - numChunks[j*s2*bitlength+i*bitlength+k] = s1; - } - } - } - otInstance->template recv_cot_matmul<intType>(recv_data, choiceBitArr, chunkSizes, numChunks, s2*s3*bitlength); - // recv_data can be interpreted as a 4d array of size(s3,s2,bitlength,s1) - for(int i=0;i<s1*s3;i++){ - outpColumnMajor[i] = 0; - } - - for(int i=0;i<s3;i++){ - for(int j=0;j<s2;j++){ - for(int k=0;k<bitlength;k++){ - for(int w=0;w<s1;w++){ - Arr2DIdxColM(outpColumnMajor,s1,s3,w,i) += (((intType)Arr4DIdxRowM(recv_data,s3,s2,bitlength,s1,i,j,k,w))<<k); - } - } - } - } - - sci::convertColToRowMajor<intType>(s1,s3,outpColumnMajor,outp); - for(int i=0;i<s1*s3;i++){ - outp[i] = outp[i] & moduloMask; - } - - delete[] choiceBitArr; - delete[] recv_data; - delete[] chunkSizes; - delete[] numChunks; - } - - int chooseOptimalBatchSize(int senderMatmulDims){ - uint64_t temp = MaxMemToUseInBytes/((uint64_t)senderMatmulDims*sizeof(intType)); - if (temp > batchSizeOTs){ - temp = batchSizeOTs; - } - return temp; - } - - /* - - matmul where dimensions of matrices are (s1,s2) and (s2,s3) - - inp is input of the sender of size (s1,s2) - - outp is the share of the result of size (s1,s3) - */ - void funcOTSenderInputA(int s1, int s2, int s3, const intType* inp, intType* outp, sci::OT<otType>* otInstance, bool inpAlreadyColumnMajor=false){ - intType* inpColumnMajor = inp; - if (!inpAlreadyColumnMajor){ - inpColumnMajor = new intType[s1*s2]; - sci::convertRowToColMajor<intType>(s1,s2,inp,inpColumnMajor); - } - intType* outpColumnMajor = new intType[s1*s3]; - int curBatchSizeOTs = chooseOptimalBatchSize(s1); - - intType* corrData = new intType[curBatchSizeOTs*s1]; - intType* data = new intType[curBatchSizeOTs*s1]; - uint32_t* chunkSizes = new uint32_t[curBatchSizeOTs]; - uint32_t* numChunks = new uint32_t[curBatchSizeOTs]; - - for(int i=0;i<s1*s3;i++){ - outpColumnMajor[i] = 0; - } - int numOTs = s2*s3*bitlength; - int bitIdxRecv = 0, rowIdxRecv = 0, colIdxRecv = 0; - for(int i=0;i<numOTs;i+=curBatchSizeOTs){ - int j; - for(j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,s3,s2,bitlength,colIdxRecv,rowIdxRecv,bitIdxRecv); - for(int k=0;k<s1;k++){ - corrData[(j-i)*s1+k] = - (((intType)Arr2DIdxColM(inpColumnMajor,s1,s2,k,rowIdxRecv))<<bitIdxRecv)>>bitIdxRecv; - } - chunkSizes[j-i] = bitlength - bitIdxRecv; - numChunks[j-i] = s1; - } - otInstance->template send_cot_matmul<intType>(data, corrData, chunkSizes, numChunks, j-i, s1); - for(int j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,s3,s2,bitlength,colIdxRecv,rowIdxRecv,bitIdxRecv); - for(int k=0;k<s1;k++){ - Arr2DIdxColM(outpColumnMajor,s1,s3,k,colIdxRecv) -= - (((intType)Arr2DIdxRowM(data,curBatchSizeOTs,s1,(j-i),k))<<bitIdxRecv); - } - } - } - - sci::convertColToRowMajor<intType>(s1,s3,outpColumnMajor,outp); - for(int i=0;i<s1*s3;i++){ - outp[i] = outp[i] & moduloMask; - } - - if (!inpAlreadyColumnMajor) delete[] inpColumnMajor; - delete[] outpColumnMajor; - - delete[] corrData; - delete[] data; - delete[] chunkSizes; - delete[] numChunks; - } - - /* - - The matrix multiplication being performed is (s1, s2) * (s2, s3). - - inp is the receiver's array to be multiplied of size (s2, s3) - - outp is the share of the receiver after multiplication of size (s1,s3) - */ - void funcOTReceiverInputB(int s1, int s2, int s3, const intType* inp, intType* outp, sci::OT<otType>* otInstance, bool inpAlreadyColumnMajor=false){ - // copy inp from row to column and outp from column to row major - intType* inpColumnMajor = inp; - intType* outpColumnMajor = new intType[s1*s3]; - if (!inpAlreadyColumnMajor){ - inpColumnMajor = new intType[s2*s3]; - sci::convertRowToColMajor<intType>(s2,s3,inp,inpColumnMajor); - } - uint64_t masks[64]; - for(int i=0;i<64;i++){ - masks[i] = 1ULL<<i; - } - - int curBatchSizeOTs = chooseOptimalBatchSize(s1); - - intType* data = new intType[curBatchSizeOTs*s1]; - uint8_t* choiceBitArr = new uint8_t[curBatchSizeOTs]; - uint32_t* chunkSizes = new uint32_t[curBatchSizeOTs]; - uint32_t* numChunks = new uint32_t[curBatchSizeOTs]; - - for(int i=0;i<s1*s3;i++){ - outpColumnMajor[i] = 0; - } - - int numOTs = s2*s3*bitlength; - int bitIdxRecv = 0, rowIdxRecv = 0, colIdxRecv = 0; - for(int i=0;i<numOTs;i+=curBatchSizeOTs){ - int j; - for(j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,s3,s2,bitlength,colIdxRecv,rowIdxRecv,bitIdxRecv); - choiceBitArr[j-i] = (Arr2DIdxColM(inpColumnMajor,s2,s3,rowIdxRecv,colIdxRecv) & masks[bitIdxRecv])>>bitIdxRecv; - chunkSizes[j-i] = bitlength - bitIdxRecv; - numChunks[j-i] = s1; - } - otInstance->template recv_cot_matmul<intType>(data, choiceBitArr, chunkSizes, numChunks, j-i, s1); - for(int j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,s3,s2,bitlength,colIdxRecv,rowIdxRecv,bitIdxRecv); - for(int k=0;k<s1;k++){ - Arr2DIdxColM(outpColumnMajor,s1,s3,k,colIdxRecv) += - (((intType)Arr2DIdxRowM(data,curBatchSizeOTs,s1,(j-i),k))<<bitIdxRecv); - } - } - } - - sci::convertColToRowMajor<intType>(s1,s3,outpColumnMajor,outp); - for(int i=0;i<s1*s3;i++){ - outp[i] = outp[i] & moduloMask; - } - - if (!inpAlreadyColumnMajor) delete[] inpColumnMajor; - delete[] outpColumnMajor; - - delete[] data; - delete[] choiceBitArr; - delete[] chunkSizes; - delete[] numChunks; - } - - - /* - - matmul where dimensions of matrices are (s1,s2) and (s2,s3) - - inp is input of the sender of size (s2,s3) - - outp is the share of the result of size (s1,s3) - */ - void funcOTSenderInputB(int s1, int s2, int s3, const intType* inp, intType* outp, sci::OT<otType>* otInstance){ - int curBatchSizeOTs = chooseOptimalBatchSize(s3); - - intType* corrData = new intType[curBatchSizeOTs*s3]; - intType* data = new intType[curBatchSizeOTs*s3]; - uint32_t* chunkSizes = new uint32_t[curBatchSizeOTs]; - uint32_t* numChunks = new uint32_t[curBatchSizeOTs]; - - for(int i=0;i<s1*s3;i++){ - outp[i] = 0; - } - - int numOTs = s1*s2*bitlength; - int bitIdxRecv = 0, rowIdxRecv = 0, colIdxRecv = 0; - for(int i=0;i<numOTs;i+=curBatchSizeOTs){ - int j; - for(j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,s1,s2,bitlength,rowIdxRecv,colIdxRecv,bitIdxRecv); - for(int k=0;k<s3;k++){ - corrData[(j-i)*s3+k] = - (((intType)Arr2DIdxRowM(inp,s2,s3,colIdxRecv,k))<<bitIdxRecv)>>bitIdxRecv; - } - chunkSizes[j-i] = bitlength - bitIdxRecv; - numChunks[j-i] = s3; - } - otInstance->template send_cot_matmul<intType>(data, corrData, chunkSizes, numChunks, j-i, s3); - for(int j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,s1,s2,bitlength,rowIdxRecv,colIdxRecv,bitIdxRecv); - for(int k=0;k<s3;k++){ - Arr2DIdxRowM(outp,s1,s3,rowIdxRecv,k) -= - (((intType)Arr2DIdxRowM(data,curBatchSizeOTs,s3,(j-i),k))<<bitIdxRecv); - } - } - } - for(int i=0;i<s1*s3;i++){ - outp[i] = outp[i] & moduloMask; - } - - delete[] corrData; - delete[] data; - delete[] chunkSizes; - delete[] numChunks; - } - - /* - - The matrix multiplication being performed is (s1, s2) * (s2, s3). - - inp is the receiver's array to be multiplied of size (s1, s2) - - outp is the share of the receiver after multiplication of size (s1,s3) - */ - void funcOTReceiverInputA(int s1, int s2, int s3, const intType* inp, intType* outp, sci::OT<otType>* otInstance){ - uint64_t masks[64]; - for(int i=0;i<64;i++){ - masks[i] = 1ULL<<i; - } - - int curBatchSizeOTs = chooseOptimalBatchSize(s3); - - intType* data = new intType[curBatchSizeOTs*s3]; - uint8_t* choiceBitArr = new uint8_t[curBatchSizeOTs]; - uint32_t* chunkSizes = new uint32_t[curBatchSizeOTs]; - uint32_t* numChunks = new uint32_t[curBatchSizeOTs]; - - for(int i=0;i<s1*s3;i++){ - outp[i] = 0; - } - - int numOTs = s1*s2*bitlength; - int bitIdxRecv = 0, rowIdxRecv = 0, colIdxRecv = 0; - for(int i=0;i<numOTs;i+=curBatchSizeOTs){ - int j; - for(j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,s1,s2,bitlength,rowIdxRecv,colIdxRecv,bitIdxRecv); - choiceBitArr[j-i] = (Arr2DIdxRowM(inp,s1,s2,rowIdxRecv,colIdxRecv) & masks[bitIdxRecv])>>bitIdxRecv; - chunkSizes[j-i] = bitlength - bitIdxRecv; - numChunks[j-i] = s3; - } - otInstance->template recv_cot_matmul<intType>(data, choiceBitArr, chunkSizes, numChunks, j-i, s3); - for(int j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,s1,s2,bitlength,rowIdxRecv,colIdxRecv,bitIdxRecv); - for(int k=0;k<s3;k++){ - Arr2DIdxRowM(outp,s1,s3,rowIdxRecv,k) += (((intType)Arr2DIdxRowM(data,curBatchSizeOTs,s3,(j-i),k))<<bitIdxRecv); - } - } - } - for(int i=0;i<s1*s3;i++){ - outp[i] = outp[i] & moduloMask; - } - - delete[] data; - delete[] choiceBitArr; - delete[] chunkSizes; - delete[] numChunks; - } - - /* - - Dot product functionality - - Sender has input 'inp' of size 'size' - */ - void funcDotProdOTSender(int size, const intType* inp, intType* outp, sci::OT<otType>* otInstance) - { - for(int i=0;i<size;i++){ - outp[i] = 0; - } - int curBatchSizeOTs = batchSizeOTs; - int numOTs = size*bitlength; - intType* curCorrData = new intType[curBatchSizeOTs]; - uint32_t* curChunkSizes = new uint32_t[curBatchSizeOTs]; - uint32_t* curNumChunks = new uint32_t[curBatchSizeOTs]; - intType* curData = new intType[curBatchSizeOTs]; - int bitIdxRecv = 0, cellIdxRecv = 0; - for(int i=0;i<numOTs;i+=curBatchSizeOTs){ - int j; - for(j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,size,bitlength,cellIdxRecv,bitIdxRecv); - curCorrData[j-i] = (((intType)inp[cellIdxRecv])<<bitIdxRecv)>>bitIdxRecv; - curChunkSizes[j-i] = bitlength - bitIdxRecv; - curNumChunks[j-i] = 1; - } - otInstance->template send_cot_matmul<intType>(curData, curCorrData, curChunkSizes, curNumChunks, j-i, size); - for(int j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,size,bitlength,cellIdxRecv,bitIdxRecv); - outp[cellIdxRecv] -= (((intType)curData[j-i])<<bitIdxRecv); - } - } - for(int i=0;i<size;i++){ - outp[i] = outp[i] & moduloMask; - } - - delete[] curCorrData; - delete[] curChunkSizes; - delete[] curNumChunks; - delete[] curData; - } - - /* - - Dot product functionality - - Receiver has input 'inp' of size 'size' - */ - void funcDotProdOTReceiver(int size, const intType* inp, intType* outp, sci::OT<otType>* otInstance) - { - uint64_t masks[64]; - for(int i=0;i<64;i++){ - masks[i] = 1ULL<<i; - } - for(int i=0;i<size;i++){ - outp[i] = 0; - } - int curBatchSizeOTs = batchSizeOTs; - int numOTs = size*bitlength; - uint8_t* curChoiceBits = new uint8_t[curBatchSizeOTs]; - uint32_t* curNumChunks = new uint32_t[curBatchSizeOTs]; - uint32_t* curChunkSizes = new uint32_t[curBatchSizeOTs]; - intType* curData = new intType[curBatchSizeOTs]; - int bitIdxRecv = 0, cellIdxRecv = 0; - for(int i=0;i<numOTs;i+=curBatchSizeOTs){ - int j; - for(j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,size,bitlength,cellIdxRecv,bitIdxRecv); - curChoiceBits[j-i] = (inp[cellIdxRecv] & masks[bitIdxRecv])>>bitIdxRecv; - curChunkSizes[j-i] = bitlength - bitIdxRecv; - curNumChunks[j-i] = 1; - } - otInstance->template recv_cot_matmul<intType>(curData, curChoiceBits, curChunkSizes, curNumChunks, j-i, size); - for(int j=i;(j<numOTs) && (j<i+curBatchSizeOTs);j++){ - // current OT# is j - sci::linIdxRowMInverseMapping(j,size,bitlength,cellIdxRecv,bitIdxRecv); - outp[cellIdxRecv] += (curData[j-i]<<bitIdxRecv); - } - } - for(int i=0;i<size;i++){ - outp[i] = outp[i] & moduloMask; - } - - delete[] curChoiceBits; - delete[] curNumChunks; - delete[] curChunkSizes; - delete[] curData; - } - - /* - This code is unoptimized and not being used anywhere currently. - - Matrix triplet of size (s1,s2)*(s2,s3) - - A_share, B_share, C_share are shares of A,B,C - - shape(A_share) = (s1,s2) - - shape(B_share) = (s2,s3) - - shape(C_share) = (s1,s3) - */ - void generateBeaverMatrixTriplet(int s1, int s2, int s3, sci::PRG128 prg, intType* A_share, intType* B_share, intType* C_share) - { - assert(otImplRoleReversed!=nullptr); - prg.random_data(A_share, s1*s2*sizeof(intType)); - prg.random_data(B_share, s2*s3*sizeof(intType)); - intType* temp = new intType[s1*s3]; - if (party==sci::ALICE){ - // The OTs can be done in parallel - funcOTSenderInputA(s1,s2,s3,A_share,C_share,otImpl); - funcOTReceiverInputB(s1,s2,s3,B_share,temp,otImplRoleReversed); - } - else if (party==sci::BOB){ - funcOTReceiverInputB(s1,s2,s3,B_share,C_share,otImpl); - funcOTSenderInputA(s1,s2,s3,A_share,temp,otImplRoleReversed); - } - else{ - assert(false); - } - - sci::elemWiseAdd<intType>(s1*s3,C_share,temp,C_share); - ideal_func(s1,s2,s3,A_share,B_share,temp); - sci::elemWiseAdd<intType>(s1*s3,C_share,temp,C_share); - } - - /* - This code is unoptimized and not being used anywhere currently. - - Run the online phase of beaver - - Matrices to be multiplied are of size (s1,s2) and (s2,s3). - - X_share => size = (s1,s2), share of X - - Y_share => size = (s2,s3), share of Y - - Z_share => size = (s1,s3), share of output Z=X*Y - - A_share, B_share, C_share are shares of the beaver triplet (A,B,C) - */ - void runBeaverOnlinePhase(int s1, int s2, int s3, const intType* X_share, const intType* Y_share, intType* Z_share, - const intType* A_share, const intType* B_share, const intType* C_share) - { - intType* E_share = new intType[s1*s2]; - intType* F_share = new intType[s2*s3]; - intType* E_temp_share = new intType[s1*s2]; - intType* F_temp_share = new intType[s2*s3]; - intType* Z_temp_share = new intType[s1*s3]; - sci::elemWiseSub<intType>(s1*s2,X_share,A_share,E_share); - sci::elemWiseSub<intType>(s2*s3,Y_share,B_share,F_share); - - if (party==sci::ALICE){ - io->send_data(E_share, sizeof(intType)*s1*s2); - io->send_data(F_share, sizeof(intType)*s2*s3); - io->recv_data(E_temp_share, sizeof(intType)*s1*s2); - io->recv_data(F_temp_share, sizeof(intType)*s2*s3); - } - else if (party==sci::BOB){ - io->recv_data(E_temp_share, sizeof(intType)*s1*s2); - io->recv_data(F_temp_share, sizeof(intType)*s2*s3); - io->send_data(E_share, sizeof(intType)*s1*s2); - io->send_data(F_share, sizeof(intType)*s2*s3); - } - else{ - assert(false); - } - - // Add the shares of E and F to get E and F in the clear - sci::elemWiseAdd<intType>(s1*s2,E_share,E_temp_share,E_share); - sci::elemWiseAdd<intType>(s2*s3,F_share,F_temp_share,F_share); - - // Now E_share and F_share hold the clear values of E & F - ideal_func(s1,s2,s3,E_share,Y_share,Z_temp_share); - if (party==sci::ALICE){ - ideal_func(s1,s2,s3,X_share,F_share,Z_share); - } - else if (party==sci::BOB){ - sci::elemWiseSub<intType>(s1*s2,X_share,E_share,E_temp_share); - ideal_func(s1,s2,s3,E_temp_share,F_share,Z_share); - } - - sci::elemWiseAdd<intType>(s1*s3,Z_share,Z_temp_share,Z_share); - sci::elemWiseAdd<intType>(s1*s3,C_share,Z_share,Z_share); - - delete[] E_share; - delete[] F_share; - delete[] E_temp_share; - delete[] F_temp_share; - delete[] Z_temp_share; - } -}; - -#endif //LINEAR_PRIMARY_H__ diff --git a/SCI/src/utils/ArgMapping/ArgMapping.h b/SCI/src/utils/ArgMapping/ArgMapping.h index 3f925a66..4f3623bc 100644 --- a/SCI/src/utils/ArgMapping/ArgMapping.h +++ b/SCI/src/utils/ArgMapping/ArgMapping.h @@ -17,126 +17,126 @@ #ifndef ARGMAPPING_H #define ARGMAPPING_H +#include <cassert> +#include <iostream> #include <memory> -#include <unordered_map> -#include <string> #include <sstream> -#include <iostream> +#include <string> +#include <unordered_map> typedef std::unordered_map<std::string, const char *> argmap_t; -inline bool parseArgs(int argc, char *argv[], argmap_t& argmap) { - for (long i = 1; i < argc; i++) { - char *x = argv[i]; - long j = 0; - while (x[j] != '=' && x[j] != '\0') j++; - if (x[j] == '\0') return false; - std::string arg(x, j); - if (argmap[arg] == NULL) return false; - argmap[arg] = x+j+1; - } - return true; +inline bool parseArgs(int argc, char *argv[], argmap_t &argmap) { + for (long i = 1; i < argc; i++) { + char *x = argv[i]; + long j = 0; + while (x[j] != '=' && x[j] != '\0') + j++; + if (x[j] == '\0') + return false; + std::string arg(x, j); + if (argmap[arg] == NULL) + return false; + argmap[arg] = x + j + 1; + } + return true; } inline bool doArgProcessing(std::string *value, const char *s) { - *value = std::string(s); - return true; + *value = std::string(s); + return true; } -template<class T> -inline bool doArgProcessing(T *value, const char *s) { - std::string ss(s); - std::stringstream sss(ss); - return bool(sss >> *value); +template <class T> inline bool doArgProcessing(T *value, const char *s) { + std::string ss(s); + std::stringstream sss(ss); + return bool(sss >> *value); } class ArgProcessor { public: - virtual bool process(const char *s) = 0; + virtual bool process(const char *s) = 0; }; /* ArgProcessorDerived: templated subclasses */ -template<class T> -class ArgProcessorDerived : public ArgProcessor { +template <class T> class ArgProcessorDerived : public ArgProcessor { public: - T *value; + T *value; - virtual bool process(const char *s) { - return doArgProcessing(value, s); - } + virtual bool process(const char *s) { return doArgProcessing(value, s); } - ArgProcessorDerived(T* _value) : value(_value) {} - virtual ~ArgProcessorDerived(){}; + ArgProcessorDerived(T *_value) : value(_value) {} + virtual ~ArgProcessorDerived(){}; }; class ArgMapping { public: - std::unordered_map<std::string, std::shared_ptr<ArgProcessor>> map; - std::stringstream doc; - - // no documentation - template<class T> - void arg(const char *name, T& value) { - std::shared_ptr<ArgProcessor> ap = - std::shared_ptr<ArgProcessor>(new ArgProcessorDerived<T>(&value)); - - assert(!map[name]); - map[name] = ap; - } - - // documentation + standard default info - template<class T> - void arg(const char *name, T& value, const char *doc1) { - arg(name, value); - doc << "\t" << name << " \t" << doc1 << " [ default=" << value << " ]" << "\n"; - } - - // documentation + standard non-standard default info: - // NULL => no default info - template<class T> - void arg(const char *name, T& value, const char *doc1, const char *info) { - arg(name, value); - doc << "\t" << name << " \t" << doc1; - if (info) - doc << " [ default=" << info << " ]" << "\n"; - else - doc << "\n"; - } - - inline void note(const char *s); - inline void usage(const char *prog); - inline void parse(int argc, char **argv); - inline std::string documentation(); + std::unordered_map<std::string, std::shared_ptr<ArgProcessor>> map; + std::stringstream doc; + + // no documentation + template <class T> void arg(const char *name, T &value) { + std::shared_ptr<ArgProcessor> ap = + std::shared_ptr<ArgProcessor>(new ArgProcessorDerived<T>(&value)); + + assert(!map[name]); + map[name] = ap; + } + + // documentation + standard default info + template <class T> void arg(const char *name, T &value, const char *doc1) { + arg(name, value); + doc << "\t" << name << " \t" << doc1 << " [ default=" << value << " ]" + << "\n"; + } + + // documentation + standard non-standard default info: + // NULL => no default info + template <class T> + void arg(const char *name, T &value, const char *doc1, const char *info) { + arg(name, value); + doc << "\t" << name << " \t" << doc1; + if (info) + doc << " [ default=" << info << " ]" + << "\n"; + else + doc << "\n"; + } + + inline void note(const char *s); + inline void usage(const char *prog); + inline void parse(int argc, char **argv); + inline std::string documentation(); }; -void ArgMapping::note(const char *s) { - doc << "\t\t " << s << "\n"; -} +void ArgMapping::note(const char *s) { doc << "\t\t " << s << "\n"; } void ArgMapping::usage(const char *prog) { - std::cerr << "Usage: " << prog << " [ name=value ]...\n"; - std::cerr << documentation(); - exit(0); + std::cerr << "Usage: " << prog << " [ name=value ]...\n"; + std::cerr << documentation(); + exit(0); } void ArgMapping::parse(int argc, char **argv) { - for (long i = 1; i < argc; i++) { - const char *x = argv[i]; - long j = 0; - while (x[j] != '=' && x[j] != '\0') j++; - if (x[j] == '\0') usage(argv[0]); - std::string name(x, j); - const char *s = x+j+1; - - std::shared_ptr<ArgProcessor> ap = map[name]; - if (!ap) return usage(argv[0]); - if (!ap->process(s)) usage(argv[0]); - } + for (long i = 1; i < argc; i++) { + const char *x = argv[i]; + long j = 0; + while (x[j] != '=' && x[j] != '\0') + j++; + if (x[j] == '\0') + usage(argv[0]); + std::string name(x, j); + const char *s = x + j + 1; + + std::shared_ptr<ArgProcessor> ap = map[name]; + if (!ap) + return usage(argv[0]); + if (!ap->process(s)) + usage(argv[0]); + } } -std::string ArgMapping::documentation() { - return doc.str(); -} +std::string ArgMapping::documentation() { return doc.str(); } -#endif //ARGMAPPING_H +#endif // ARGMAPPING_H diff --git a/SCI/src/utils/CMakeLists.txt b/SCI/src/utils/CMakeLists.txt index 5efd4dcc..8106d043 100644 --- a/SCI/src/utils/CMakeLists.txt +++ b/SCI/src/utils/CMakeLists.txt @@ -6,6 +6,11 @@ find_package(GMP REQUIRED) add_library(SCI-utils INTERFACE) +target_compile_options(SCI-utils + INTERFACE + "-pthread;-maes;-msse4.1;-mavx;-mavx2;-mrdseed;-faligned-new;-std=c++17;-O3") +# "-pthread;-Wall;-maes;-msse4.1;-mavx;-mavx2;-mrdseed;-faligned-new;-std=c++17;-w;-g;-ggdb;-O0") + if(USE_RANDOM_DEVICE) target_compile_definitions(SCI-utils INTERFACE EMP_USE_RANDOM_DEVICE=1) endif(USE_RANDOM_DEVICE) diff --git a/SCI/src/utils/ThreadPool.h b/SCI/src/utils/ThreadPool.h index f57d34aa..e3a1e483 100644 --- a/SCI/src/utils/ThreadPool.h +++ b/SCI/src/utils/ThreadPool.h @@ -25,102 +25,92 @@ freely, subject to the following restrictions: #ifndef THREAD_POOL_H #define THREAD_POOL_H -#include <vector> -#include <queue> -#include <memory> -#include <thread> -#include <mutex> #include <condition_variable> -#include <future> #include <functional> +#include <future> +#include <memory> +#include <mutex> +#include <queue> #include <stdexcept> +#include <thread> +#include <vector> class ThreadPool { public: - ThreadPool(size_t); - template<class F, class... Args> - auto enqueue(F&& f, Args&&... args) - -> std::future<typename std::result_of<F(Args...)>::type>; - ~ThreadPool(); - int size() const; + ThreadPool(size_t); + template <class F, class... Args> + auto enqueue(F &&f, Args &&... args) + -> std::future<typename std::result_of<F(Args...)>::type>; + ~ThreadPool(); + int size() const; + private: - // need to keep track of threads so we can join them - std::vector< std::thread > workers; - // the task queue - std::queue< std::function<void()> > tasks; - - // synchronization - std::mutex queue_mutex; - std::condition_variable condition; - bool stop; + // need to keep track of threads so we can join them + std::vector<std::thread> workers; + // the task queue + std::queue<std::function<void()>> tasks; + + // synchronization + std::mutex queue_mutex; + std::condition_variable condition; + bool stop; }; - -int inline ThreadPool::size() const { - return workers.size(); -} + +int inline ThreadPool::size() const { return workers.size(); } // the constructor just launches some amount of workers -inline ThreadPool::ThreadPool(size_t threads) - : stop(false) -{ - for(size_t i = 0;i<threads;++i) - workers.emplace_back( - [this] - { - for(;;) - { - std::function<void()> task; - - { - std::unique_lock<std::mutex> lock(this->queue_mutex); - this->condition.wait(lock, - [this]{ return this->stop || !this->tasks.empty(); }); - if(this->stop && this->tasks.empty()) - return; - task = std::move(this->tasks.front()); - this->tasks.pop(); - } - - task(); - } - } - ); +inline ThreadPool::ThreadPool(size_t threads) : stop(false) { + for (size_t i = 0; i < threads; ++i) + workers.emplace_back([this] { + for (;;) { + std::function<void()> task; + + { + std::unique_lock<std::mutex> lock(this->queue_mutex); + this->condition.wait( + lock, [this] { return this->stop || !this->tasks.empty(); }); + if (this->stop && this->tasks.empty()) + return; + task = std::move(this->tasks.front()); + this->tasks.pop(); + } + + task(); + } + }); } // add new work item to the pool -template<class F, class... Args> -auto ThreadPool::enqueue(F&& f, Args&&... args) - -> std::future<typename std::result_of<F(Args...)>::type> -{ - using return_type = typename std::result_of<F(Args...)>::type; - - auto task = std::make_shared< std::packaged_task<return_type()> >( - std::bind(std::forward<F>(f), std::forward<Args>(args)...) - ); - - std::future<return_type> res = task->get_future(); - { - std::unique_lock<std::mutex> lock(queue_mutex); - - // don't allow enqueueing after stopping the pool - if(stop) - throw std::runtime_error("enqueue on stopped ThreadPool"); - - tasks.emplace([task](){ (*task)(); }); - } - condition.notify_one(); - return res; +template <class F, class... Args> +auto ThreadPool::enqueue(F &&f, Args &&... args) + -> std::future<typename std::result_of<F(Args...)>::type> { + using return_type = typename std::result_of<F(Args...)>::type; + + auto task = std::make_shared<std::packaged_task<return_type()>>( + std::bind(std::forward<F>(f), std::forward<Args>(args)...)); + + std::future<return_type> res = task->get_future(); + { + std::unique_lock<std::mutex> lock(queue_mutex); + + // don't allow enqueueing after stopping the pool + if (stop) + throw std::runtime_error("enqueue on stopped ThreadPool"); + + tasks.emplace([task]() { (*task)(); }); + } + condition.notify_one(); + return res; } // the destructor joins all threads -inline ThreadPool::~ThreadPool() -{ - { - std::unique_lock<std::mutex> lock(queue_mutex); - stop = true; - } - condition.notify_all(); - for(std::thread &worker: workers) - worker.join(); +inline ThreadPool::~ThreadPool() { + { + std::unique_lock<std::mutex> lock(queue_mutex); + stop = true; + } + condition.notify_all(); + for (std::thread &worker : workers) + worker.join(); } #endif diff --git a/SCI/src/utils/aes-ni.h b/SCI/src/utils/aes-ni.h index 38ba7aae..5015c488 100644 --- a/SCI/src/utils/aes-ni.h +++ b/SCI/src/utils/aes-ni.h @@ -27,13 +27,13 @@ #ifndef LIBGARBLE_AES_NI_H #define LIBGARBLE_AES_NI_H -#if !defined (__AES__) - #error "AES-NI instructions not enabled" +#if !defined(__AES__) +#error "AES-NI instructions not enabled" #endif -#include <wmmintrin.h> #include <immintrin.h> #include <stdlib.h> +#include <wmmintrin.h> #if defined(HAVE__ALIGNED_MALLOC) #include <malloc.h> #endif @@ -43,8 +43,8 @@ #define BLOCK_SIZE 16 #define KEY_SIZE 0 -#define MAXKC (256/32) -#define MAXKB (256/8) +#define MAXKC (256 / 32) +#define MAXKB (256 / 8) #define MAXNR 14 namespace sci { @@ -52,129 +52,102 @@ namespace sci { typedef unsigned char u8; typedef struct { - block128 rk[15]; - int rounds; + block128 rk[15]; + int rounds; } AESNI_KEY; static block128 one = makeBlock128(0L, 1L); static block128 two = makeBlock128(0L, 2L); -#define ENC_256_round(t) { b1 = _mm_aesenc_si128(b1, key[0].rk[t]); \ - b2 = _mm_aesenc_si128(b2, key[1].rk[t]); \ - b3 = _mm_aesenc_si128(b3, key[2].rk[t]); \ - b4 = _mm_aesenc_si128(b4, key[3].rk[t]); \ - b5 = _mm_aesenc_si128(b5, key[4].rk[t]); \ - b6 = _mm_aesenc_si128(b6, key[5].rk[t]); \ - b7 = _mm_aesenc_si128(b7, key[6].rk[t]); \ - b8 = _mm_aesenc_si128(b8, key[7].rk[t]); \ -} +#define ENC_256_round(t) \ + { \ + b1 = _mm_aesenc_si128(b1, key[0].rk[t]); \ + b2 = _mm_aesenc_si128(b2, key[1].rk[t]); \ + b3 = _mm_aesenc_si128(b3, key[2].rk[t]); \ + b4 = _mm_aesenc_si128(b4, key[3].rk[t]); \ + b5 = _mm_aesenc_si128(b5, key[4].rk[t]); \ + b6 = _mm_aesenc_si128(b6, key[5].rk[t]); \ + b7 = _mm_aesenc_si128(b7, key[6].rk[t]); \ + b8 = _mm_aesenc_si128(b8, key[7].rk[t]); \ + } /* Helper functions to expand keys */ -static inline block128 aes128_keyexpand(block128 key) -{ - key = _mm_xor_si128(key, _mm_slli_si128(key, 4)); - key = _mm_xor_si128(key, _mm_slli_si128(key, 4)); - return _mm_xor_si128(key, _mm_slli_si128(key, 4)); +static inline block128 aes128_keyexpand(block128 key) { + key = _mm_xor_si128(key, _mm_slli_si128(key, 4)); + key = _mm_xor_si128(key, _mm_slli_si128(key, 4)); + return _mm_xor_si128(key, _mm_slli_si128(key, 4)); } -static inline block128 aes192_keyexpand_2(block128 key, block128 key2) -{ - key = _mm_shuffle_epi32(key, 0xff); - key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 4)); - return _mm_xor_si128(key, key2); +static inline block128 aes192_keyexpand_2(block128 key, block128 key2) { + key = _mm_shuffle_epi32(key, 0xff); + key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 4)); + return _mm_xor_si128(key, key2); } -#define KEYEXP128_H(K1, K2, I, S) _mm_xor_si128(aes128_keyexpand(K1), \ - _mm_shuffle_epi32(_mm_aeskeygenassist_si128(K2, I), S)) +#define KEYEXP128_H(K1, K2, I, S) \ + _mm_xor_si128(aes128_keyexpand(K1), \ + _mm_shuffle_epi32(_mm_aeskeygenassist_si128(K2, I), S)) #define KEYEXP128(K, I) KEYEXP128_H(K, K, I, 0xff) #define KEYEXP192(K1, K2, I) KEYEXP128_H(K1, K2, I, 0x55) #define KEYEXP192_2(K1, K2) aes192_keyexpand_2(K1, K2) -#define KEYEXP256(K1, K2, I) KEYEXP128_H(K1, K2, I, 0xff) +#define KEYEXP256(K1, K2, I) KEYEXP128_H(K1, K2, I, 0xff) #define KEYEXP256_2(K1, K2) KEYEXP128_H(K1, K2, 0x00, 0xaa) /* Encryption key setup */ -static inline void aes_key_setup_enc(block128 rk[], const u8* cipherKey, int keylen) -{ - switch (keylen) { - case 16: - { - /* 128 bit key setup */ - rk[0] = _mm_loadu_si128((const block128*) cipherKey); - rk[1] = KEYEXP128(rk[0], 0x01); - rk[2] = KEYEXP128(rk[1], 0x02); - rk[3] = KEYEXP128(rk[2], 0x04); - rk[4] = KEYEXP128(rk[3], 0x08); - rk[5] = KEYEXP128(rk[4], 0x10); - rk[6] = KEYEXP128(rk[5], 0x20); - rk[7] = KEYEXP128(rk[6], 0x40); - rk[8] = KEYEXP128(rk[7], 0x80); - rk[9] = KEYEXP128(rk[8], 0x1B); - rk[10] = KEYEXP128(rk[9], 0x36); - break; - } - case 24: - { - /* 192 bit key setup */ - block128 temp[2]; - rk[0] = _mm_loadu_si128((const block128*) cipherKey); - rk[1] = _mm_loadu_si128((const block128*) (cipherKey+16)); - temp[0] = KEYEXP192(rk[0], rk[1], 0x01); - temp[1] = KEYEXP192_2(temp[0], rk[1]); - rk[1] = (block128)_mm_shuffle_pd((__m128d)rk[1], (__m128d)temp[0], 0); - rk[2] = (block128)_mm_shuffle_pd((__m128d)temp[0], (__m128d)temp[1], 1); - rk[3] = KEYEXP192(temp[0], temp[1], 0x02); - rk[4] = KEYEXP192_2(rk[3], temp[1]); - temp[0] = KEYEXP192(rk[3], rk[4], 0x04); - temp[1] = KEYEXP192_2(temp[0], rk[4]); - rk[4] = (block128)_mm_shuffle_pd((__m128d)rk[4], (__m128d)temp[0], 0); - rk[5] = (block128)_mm_shuffle_pd((__m128d)temp[0], (__m128d)temp[1], 1); - rk[6] = KEYEXP192(temp[0], temp[1], 0x08); - rk[7] = KEYEXP192_2(rk[6], temp[1]); - temp[0] = KEYEXP192(rk[6], rk[7], 0x10); - temp[1] = KEYEXP192_2(temp[0], rk[7]); - rk[7] = (block128)_mm_shuffle_pd((__m128d)rk[7], (__m128d)temp[0], 0); - rk[8] = (block128)_mm_shuffle_pd((__m128d)temp[0], (__m128d)temp[1], 1); - rk[9] = KEYEXP192(temp[0], temp[1], 0x20); - rk[10] = KEYEXP192_2(rk[9], temp[1]); - temp[0] = KEYEXP192(rk[9], rk[10], 0x40); - temp[1] = KEYEXP192_2(temp[0], rk[10]); - rk[10] = (block128)_mm_shuffle_pd((__m128d)rk[10], (__m128d) temp[0], 0); - rk[11] = (block128)_mm_shuffle_pd((__m128d)temp[0],(__m128d) temp[1], 1); - rk[12] = KEYEXP192(temp[0], temp[1], 0x80); - break; - } - case 32: - { - /* 256 bit key setup */ - rk[0] = _mm_loadu_si128((const block128*) cipherKey); - rk[1] = _mm_loadu_si128((const block128*) (cipherKey+16)); - rk[2] = KEYEXP256(rk[0], rk[1], 0x01); - rk[3] = KEYEXP256_2(rk[1], rk[2]); - rk[4] = KEYEXP256(rk[2], rk[3], 0x02); - rk[5] = KEYEXP256_2(rk[3], rk[4]); - rk[6] = KEYEXP256(rk[4], rk[5], 0x04); - rk[7] = KEYEXP256_2(rk[5], rk[6]); - rk[8] = KEYEXP256(rk[6], rk[7], 0x08); - rk[9] = KEYEXP256_2(rk[7], rk[8]); - rk[10] = KEYEXP256(rk[8], rk[9], 0x10); - rk[11] = KEYEXP256_2(rk[9], rk[10]); - rk[12] = KEYEXP256(rk[10], rk[11], 0x20); - rk[13] = KEYEXP256_2(rk[11], rk[12]); - rk[14] = KEYEXP256(rk[12], rk[13], 0x40); - break; - } - } -} - -/* Encryption key (256) setup */ -static inline void aes_key_setup_enc(block128 rk[], const block256 cipherKey) -{ +static inline void aes_key_setup_enc(block128 rk[], const u8 *cipherKey, + int keylen) { + switch (keylen) { + case 16: { + /* 128 bit key setup */ + rk[0] = _mm_loadu_si128((const block128 *)cipherKey); + rk[1] = KEYEXP128(rk[0], 0x01); + rk[2] = KEYEXP128(rk[1], 0x02); + rk[3] = KEYEXP128(rk[2], 0x04); + rk[4] = KEYEXP128(rk[3], 0x08); + rk[5] = KEYEXP128(rk[4], 0x10); + rk[6] = KEYEXP128(rk[5], 0x20); + rk[7] = KEYEXP128(rk[6], 0x40); + rk[8] = KEYEXP128(rk[7], 0x80); + rk[9] = KEYEXP128(rk[8], 0x1B); + rk[10] = KEYEXP128(rk[9], 0x36); + break; + } + case 24: { + /* 192 bit key setup */ + block128 temp[2]; + rk[0] = _mm_loadu_si128((const block128 *)cipherKey); + rk[1] = _mm_loadu_si128((const block128 *)(cipherKey + 16)); + temp[0] = KEYEXP192(rk[0], rk[1], 0x01); + temp[1] = KEYEXP192_2(temp[0], rk[1]); + rk[1] = (block128)_mm_shuffle_pd((__m128d)rk[1], (__m128d)temp[0], 0); + rk[2] = (block128)_mm_shuffle_pd((__m128d)temp[0], (__m128d)temp[1], 1); + rk[3] = KEYEXP192(temp[0], temp[1], 0x02); + rk[4] = KEYEXP192_2(rk[3], temp[1]); + temp[0] = KEYEXP192(rk[3], rk[4], 0x04); + temp[1] = KEYEXP192_2(temp[0], rk[4]); + rk[4] = (block128)_mm_shuffle_pd((__m128d)rk[4], (__m128d)temp[0], 0); + rk[5] = (block128)_mm_shuffle_pd((__m128d)temp[0], (__m128d)temp[1], 1); + rk[6] = KEYEXP192(temp[0], temp[1], 0x08); + rk[7] = KEYEXP192_2(rk[6], temp[1]); + temp[0] = KEYEXP192(rk[6], rk[7], 0x10); + temp[1] = KEYEXP192_2(temp[0], rk[7]); + rk[7] = (block128)_mm_shuffle_pd((__m128d)rk[7], (__m128d)temp[0], 0); + rk[8] = (block128)_mm_shuffle_pd((__m128d)temp[0], (__m128d)temp[1], 1); + rk[9] = KEYEXP192(temp[0], temp[1], 0x20); + rk[10] = KEYEXP192_2(rk[9], temp[1]); + temp[0] = KEYEXP192(rk[9], rk[10], 0x40); + temp[1] = KEYEXP192_2(temp[0], rk[10]); + rk[10] = (block128)_mm_shuffle_pd((__m128d)rk[10], (__m128d)temp[0], 0); + rk[11] = (block128)_mm_shuffle_pd((__m128d)temp[0], (__m128d)temp[1], 1); + rk[12] = KEYEXP192(temp[0], temp[1], 0x80); + break; + } + case 32: { /* 256 bit key setup */ - _mm256_storeu2_m128i(rk + 1, rk, cipherKey); - // rk[0] = _mm_loadu_si128((const block128*) cipherKey); - // rk[1] = _mm_loadu_si128((const block128*) (cipherKey+16)); + rk[0] = _mm_loadu_si128((const block128 *)cipherKey); + rk[1] = _mm_loadu_si128((const block128 *)(cipherKey + 16)); rk[2] = KEYEXP256(rk[0], rk[1], 0x01); rk[3] = KEYEXP256_2(rk[1], rk[2]); rk[4] = KEYEXP256(rk[2], rk[3], 0x02); @@ -188,46 +161,81 @@ static inline void aes_key_setup_enc(block128 rk[], const block256 cipherKey) rk[12] = KEYEXP256(rk[10], rk[11], 0x20); rk[13] = KEYEXP256_2(rk[11], rk[12]); rk[14] = KEYEXP256(rk[12], rk[13], 0x40); + break; + } + } +} + +/* Encryption key (256) setup */ +static inline void aes_key_setup_enc(block128 rk[], const block256 cipherKey) { + /* 256 bit key setup */ + _mm256_storeu2_m128i(rk + 1, rk, cipherKey); + // rk[0] = _mm_loadu_si128((const block128*) cipherKey); + // rk[1] = _mm_loadu_si128((const block128*) (cipherKey+16)); + rk[2] = KEYEXP256(rk[0], rk[1], 0x01); + rk[3] = KEYEXP256_2(rk[1], rk[2]); + rk[4] = KEYEXP256(rk[2], rk[3], 0x02); + rk[5] = KEYEXP256_2(rk[3], rk[4]); + rk[6] = KEYEXP256(rk[4], rk[5], 0x04); + rk[7] = KEYEXP256_2(rk[5], rk[6]); + rk[8] = KEYEXP256(rk[6], rk[7], 0x08); + rk[9] = KEYEXP256_2(rk[7], rk[8]); + rk[10] = KEYEXP256(rk[8], rk[9], 0x10); + rk[11] = KEYEXP256_2(rk[9], rk[10]); + rk[12] = KEYEXP256(rk[10], rk[11], 0x20); + rk[13] = KEYEXP256_2(rk[11], rk[12]); + rk[14] = KEYEXP256(rk[12], rk[13], 0x40); } /* Decryption key setup */ -static inline void aes_key_setup_dec(block128 dk[], const block128 ek[], int rounds) -{ - dk[rounds] = ek[0]; - for (int i = 1; i < rounds; ++i) { - dk[rounds - i] = _mm_aesimc_si128(ek[i]); - } - dk[0] = ek[rounds]; +static inline void aes_key_setup_dec(block128 dk[], const block128 ek[], + int rounds) { + dk[rounds] = ek[0]; + for (int i = 1; i < rounds; ++i) { + dk[rounds - i] = _mm_aesimc_si128(ek[i]); + } + dk[0] = ek[rounds]; } -static inline void AESNI_set_encrypt_key(AESNI_KEY* self, unsigned char* key, int keylen) -{ - switch (keylen) { - case 16: self->rounds = 10; break; - case 24: self->rounds = 12; break; - case 32: self->rounds = 14; break; - } +static inline void AESNI_set_encrypt_key(AESNI_KEY *self, unsigned char *key, + int keylen) { + switch (keylen) { + case 16: + self->rounds = 10; + break; + case 24: + self->rounds = 12; + break; + case 32: + self->rounds = 14; + break; + } - aes_key_setup_enc(self->rk, key, keylen); + aes_key_setup_enc(self->rk, key, keylen); } -static inline void AESNI_set_encrypt_key(AESNI_KEY* self, const block256 key) -{ - self->rounds = 14; - aes_key_setup_enc(self->rk, key); +static inline void AESNI_set_encrypt_key(AESNI_KEY *self, const block256 key) { + self->rounds = 14; + aes_key_setup_enc(self->rk, key); } -static inline void AESNI_set_decrypt_key(AESNI_KEY* self, unsigned char* key, int keylen) -{ - switch (keylen) { - case 16: self->rounds = 10; break; - case 24: self->rounds = 12; break; - case 32: self->rounds = 14; break; - } +static inline void AESNI_set_decrypt_key(AESNI_KEY *self, unsigned char *key, + int keylen) { + switch (keylen) { + case 16: + self->rounds = 10; + break; + case 24: + self->rounds = 12; + break; + case 32: + self->rounds = 14; + break; + } - AESNI_KEY temp_key; - aes_key_setup_enc(temp_key.rk, key, keylen); - aes_key_setup_dec(self->rk, temp_key.rk, self->rounds); + AESNI_KEY temp_key; + aes_key_setup_enc(temp_key.rk, key, keylen); + aes_key_setup_dec(self->rk, temp_key.rk, self->rounds); } /* @@ -283,112 +291,107 @@ static inline void block_decrypt(AESNI_KEY* self, const u8* in, u8* out) */ #ifdef __GNUC__ - #ifndef __clang__ - #pragma GCC push_options - #pragma GCC optimize ("unroll-loops") - #endif +#ifndef __clang__ +#pragma GCC push_options +#pragma GCC optimize("unroll-loops") #endif -static inline void -__attribute__((target("aes,sse2"))) -AESNI_ecb_encrypt_blks_8(block128 *blks, const AESNI_KEY *keys) -{ - for (unsigned int i = 0; i < 8; ++i) - blks[i] = _mm_xor_si128(blks[i], keys[i].rk[0]); - for (int j = 1; j < 14; ++j) - for (unsigned int i = 0; i < 8; ++i) - blks[i] = _mm_aesenc_si128(blks[i], keys[i].rk[j]); +#endif +static inline void __attribute__((target("aes,sse2"))) +AESNI_ecb_encrypt_blks_8(block128 *blks, const AESNI_KEY *keys) { + for (unsigned int i = 0; i < 8; ++i) + blks[i] = _mm_xor_si128(blks[i], keys[i].rk[0]); + for (int j = 1; j < 14; ++j) for (unsigned int i = 0; i < 8; ++i) - blks[i] = _mm_aesenclast_si128(blks[i], keys[i].rk[keys->rounds]); + blks[i] = _mm_aesenc_si128(blks[i], keys[i].rk[j]); + for (unsigned int i = 0; i < 8; ++i) + blks[i] = _mm_aesenclast_si128(blks[i], keys[i].rk[keys->rounds]); } -static inline void -__attribute__((target("aes,sse2"))) -AESNI_ecb_encrypt_blks_ks(block128 *blks, unsigned int nblks, const AESNI_KEY *key) -{ - - for (unsigned int i = 0; i < nblks; ++i) - blks[i] = _mm_xor_si128(one, key[i].rk[0]); - //blks[i] = _mm_xor_si128(blks[i], key[i].rk[0]); - for (int j = 1; j < key->rounds; ++j) - for (unsigned int i = 0; i < nblks; ++i) - blks[i] = _mm_aesenc_si128(blks[i], key[i].rk[j]); +static inline void __attribute__((target("aes,sse2"))) +AESNI_ecb_encrypt_blks_ks(block128 *blks, unsigned int nblks, + const AESNI_KEY *key) { + + for (unsigned int i = 0; i < nblks; ++i) + blks[i] = _mm_xor_si128(one, key[i].rk[0]); + // blks[i] = _mm_xor_si128(blks[i], key[i].rk[0]); + for (int j = 1; j < key->rounds; ++j) for (unsigned int i = 0; i < nblks; ++i) - blks[i] = _mm_aesenclast_si128(blks[i], key[i].rk[key->rounds]); + blks[i] = _mm_aesenc_si128(blks[i], key[i].rk[j]); + for (unsigned int i = 0; i < nblks; ++i) + blks[i] = _mm_aesenclast_si128(blks[i], key[i].rk[key->rounds]); } -static inline void -__attribute__((target("aes,sse2"))) -AESNI_ecb_encrypt_blks_ks_x8(block128 *blks, unsigned int nblks, const AESNI_KEY *key) -{ - __m128i b1, b2, b3, b4, b5, b6, b7, b8; - assert((nblks == 8) && "AESNI_ecb_encrypt_blks_ks_x8 only works for 8 blocks"); - b1 = _mm_xor_si128(one, key[0].rk[0]); - b2 = _mm_xor_si128(one, key[1].rk[0]); - b3 = _mm_xor_si128(one, key[2].rk[0]); - b4 = _mm_xor_si128(one, key[3].rk[0]); - b5 = _mm_xor_si128(one, key[4].rk[0]); - b6 = _mm_xor_si128(one, key[5].rk[0]); - b7 = _mm_xor_si128(one, key[6].rk[0]); - b8 = _mm_xor_si128(one, key[7].rk[0]); - - ENC_256_round(1); - ENC_256_round(2); - ENC_256_round(3); - ENC_256_round(4); - ENC_256_round(5); - ENC_256_round(6); - ENC_256_round(7); - ENC_256_round(8); - ENC_256_round(9); - ENC_256_round(10); - ENC_256_round(11); - ENC_256_round(12); - ENC_256_round(13); - - blks[0] = _mm_aesenclast_si128(b1, key[0].rk[key->rounds]); - blks[1] = _mm_aesenclast_si128(b2, key[1].rk[key->rounds]); - blks[2] = _mm_aesenclast_si128(b3, key[2].rk[key->rounds]); - blks[3] = _mm_aesenclast_si128(b4, key[3].rk[key->rounds]); - blks[4] = _mm_aesenclast_si128(b5, key[4].rk[key->rounds]); - blks[5] = _mm_aesenclast_si128(b6, key[5].rk[key->rounds]); - blks[6] = _mm_aesenclast_si128(b7, key[6].rk[key->rounds]); - blks[7] = _mm_aesenclast_si128(b8, key[7].rk[key->rounds]); +static inline void __attribute__((target("aes,sse2"))) +AESNI_ecb_encrypt_blks_ks_x8(block128 *blks, unsigned int nblks, + const AESNI_KEY *key) { + __m128i b1, b2, b3, b4, b5, b6, b7, b8; + assert((nblks == 8) && + "AESNI_ecb_encrypt_blks_ks_x8 only works for 8 blocks"); + b1 = _mm_xor_si128(one, key[0].rk[0]); + b2 = _mm_xor_si128(one, key[1].rk[0]); + b3 = _mm_xor_si128(one, key[2].rk[0]); + b4 = _mm_xor_si128(one, key[3].rk[0]); + b5 = _mm_xor_si128(one, key[4].rk[0]); + b6 = _mm_xor_si128(one, key[5].rk[0]); + b7 = _mm_xor_si128(one, key[6].rk[0]); + b8 = _mm_xor_si128(one, key[7].rk[0]); + + ENC_256_round(1); + ENC_256_round(2); + ENC_256_round(3); + ENC_256_round(4); + ENC_256_round(5); + ENC_256_round(6); + ENC_256_round(7); + ENC_256_round(8); + ENC_256_round(9); + ENC_256_round(10); + ENC_256_round(11); + ENC_256_round(12); + ENC_256_round(13); + + blks[0] = _mm_aesenclast_si128(b1, key[0].rk[key->rounds]); + blks[1] = _mm_aesenclast_si128(b2, key[1].rk[key->rounds]); + blks[2] = _mm_aesenclast_si128(b3, key[2].rk[key->rounds]); + blks[3] = _mm_aesenclast_si128(b4, key[3].rk[key->rounds]); + blks[4] = _mm_aesenclast_si128(b5, key[4].rk[key->rounds]); + blks[5] = _mm_aesenclast_si128(b6, key[5].rk[key->rounds]); + blks[6] = _mm_aesenclast_si128(b7, key[6].rk[key->rounds]); + blks[7] = _mm_aesenclast_si128(b8, key[7].rk[key->rounds]); } -static inline void -__attribute__((target("aes,sse2"))) -AESNI_ecb_encrypt_blks(block128 *blks, unsigned int nblks, const AESNI_KEY *key) -{ - for (unsigned int i = 0; i < nblks; ++i) - blks[i] = _mm_xor_si128(blks[i], key->rk[0]); - for (int j = 1; j < key->rounds; ++j) - for (unsigned int i = 0; i < nblks; ++i) - blks[i] = _mm_aesenc_si128(blks[i], key->rk[j]); +static inline void __attribute__((target("aes,sse2"))) +AESNI_ecb_encrypt_blks(block128 *blks, unsigned int nblks, + const AESNI_KEY *key) { + for (unsigned int i = 0; i < nblks; ++i) + blks[i] = _mm_xor_si128(blks[i], key->rk[0]); + for (int j = 1; j < key->rounds; ++j) for (unsigned int i = 0; i < nblks; ++i) - blks[i] = _mm_aesenclast_si128(blks[i], key->rk[key->rounds]); + blks[i] = _mm_aesenc_si128(blks[i], key->rk[j]); + for (unsigned int i = 0; i < nblks; ++i) + blks[i] = _mm_aesenclast_si128(blks[i], key->rk[key->rounds]); } #ifdef __GNUC__ - #ifndef __clang__ - #pragma GCC pop_options - #endif +#ifndef __clang__ +#pragma GCC pop_options +#endif #endif -static inline void -__attribute__((target("aes,sse2"))) -AESNI_ecb_decrypt_blks(block128 *blks, unsigned nblks, const AESNI_KEY *key) -{ - unsigned i, j, rnds = key->rounds; +static inline void __attribute__((target("aes,sse2"))) +AESNI_ecb_decrypt_blks(block128 *blks, unsigned nblks, const AESNI_KEY *key) { + unsigned i, j, rnds = key->rounds; + for (i = 0; i < nblks; ++i) + blks[i] = _mm_xor_si128(blks[i], key->rk[0]); + for (j = 1; j < rnds; ++j) for (i = 0; i < nblks; ++i) - blks[i] = _mm_xor_si128(blks[i], key->rk[0]); - for (j = 1; j < rnds; ++j) - for (i = 0; i < nblks; ++i) - blks[i] = _mm_aesdec_si128(blks[i], key->rk[j]); - for (i = 0; i < nblks; ++i) - blks[i] = _mm_aesdeclast_si128(blks[i], key->rk[j]); + blks[i] = _mm_aesdec_si128(blks[i], key->rk[j]); + for (i = 0; i < nblks; ++i) + blks[i] = _mm_aesdeclast_si128(blks[i], key->rk[j]); } /* -static inline void AESNI_encrypt_label(Label& lb, const AESNI_KEY* key, uint64_t gid, uint8_t entry, uint8_t pos){ +static inline void AESNI_encrypt_label(Label& lb, const AESNI_KEY* key, uint64_t +gid, uint8_t entry, uint8_t pos){ // Label counters(one, two); uint64_t tweak_hi = gid; uint64_t tweak_lo = (entry << 2) || (pos << 1); @@ -401,5 +404,5 @@ static inline void AESNI_encrypt_label(Label& lb, const AESNI_KEY* key, uint64_t lb.lo = _mm_xor_si128(counters[0], lb.lo); } */ -} +} // namespace sci #endif diff --git a/SCI/src/utils/aes.h b/SCI/src/utils/aes.h index d702beb4..6ffd1017 100644 --- a/SCI/src/utils/aes.h +++ b/SCI/src/utils/aes.h @@ -56,99 +56,92 @@ namespace sci { -typedef struct { block128 rd_key[11]; unsigned int rounds; } AES_KEY; +typedef struct { + block128 rd_key[11]; + unsigned int rounds; +} AES_KEY; -#define EXPAND_ASSIST(v1,v2,v3,v4,shuff_const,aes_const) \ - v2 = _mm_aeskeygenassist_si128(v4,aes_const); \ - v3 = _mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps(v3), \ - _mm_castsi128_ps(v1), 16)); \ - v1 = _mm_xor_si128(v1,v3); \ - v3 = _mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps(v3), \ - _mm_castsi128_ps(v1), 140)); \ - v1 = _mm_xor_si128(v1,v3); \ - v2 = _mm_shuffle_epi32(v2,shuff_const); \ - v1 = _mm_xor_si128(v1,v2) +#define EXPAND_ASSIST(v1, v2, v3, v4, shuff_const, aes_const) \ + v2 = _mm_aeskeygenassist_si128(v4, aes_const); \ + v3 = _mm_castps_si128( \ + _mm_shuffle_ps(_mm_castsi128_ps(v3), _mm_castsi128_ps(v1), 16)); \ + v1 = _mm_xor_si128(v1, v3); \ + v3 = _mm_castps_si128( \ + _mm_shuffle_ps(_mm_castsi128_ps(v3), _mm_castsi128_ps(v1), 140)); \ + v1 = _mm_xor_si128(v1, v3); \ + v2 = _mm_shuffle_epi32(v2, shuff_const); \ + v1 = _mm_xor_si128(v1, v2) -inline void -__attribute__((target("aes,sse2"))) -AES_set_encrypt_key(const block128 userkey, AES_KEY *key) -{ - block128 x0, x1, x2; - block128 *kp = key->rd_key; - kp[0] = x0 = userkey; - x2 = _mm_setzero_si128(); - EXPAND_ASSIST(x0, x1, x2, x0, 255, 1); - kp[1] = x0; - EXPAND_ASSIST(x0, x1, x2, x0, 255, 2); - kp[2] = x0; - EXPAND_ASSIST(x0, x1, x2, x0, 255, 4); - kp[3] = x0; - EXPAND_ASSIST(x0, x1, x2, x0, 255, 8); - kp[4] = x0; - EXPAND_ASSIST(x0, x1, x2, x0, 255, 16); - kp[5] = x0; - EXPAND_ASSIST(x0, x1, x2, x0, 255, 32); - kp[6] = x0; - EXPAND_ASSIST(x0, x1, x2, x0, 255, 64); - kp[7] = x0; - EXPAND_ASSIST(x0, x1, x2, x0, 255, 128); - kp[8] = x0; - EXPAND_ASSIST(x0, x1, x2, x0, 255, 27); - kp[9] = x0; - EXPAND_ASSIST(x0, x1, x2, x0, 255, 54); - kp[10] = x0; - key->rounds = 10; +inline void __attribute__((target("aes,sse2"))) +AES_set_encrypt_key(const block128 userkey, AES_KEY *key) { + block128 x0, x1, x2; + block128 *kp = key->rd_key; + kp[0] = x0 = userkey; + x2 = _mm_setzero_si128(); + EXPAND_ASSIST(x0, x1, x2, x0, 255, 1); + kp[1] = x0; + EXPAND_ASSIST(x0, x1, x2, x0, 255, 2); + kp[2] = x0; + EXPAND_ASSIST(x0, x1, x2, x0, 255, 4); + kp[3] = x0; + EXPAND_ASSIST(x0, x1, x2, x0, 255, 8); + kp[4] = x0; + EXPAND_ASSIST(x0, x1, x2, x0, 255, 16); + kp[5] = x0; + EXPAND_ASSIST(x0, x1, x2, x0, 255, 32); + kp[6] = x0; + EXPAND_ASSIST(x0, x1, x2, x0, 255, 64); + kp[7] = x0; + EXPAND_ASSIST(x0, x1, x2, x0, 255, 128); + kp[8] = x0; + EXPAND_ASSIST(x0, x1, x2, x0, 255, 27); + kp[9] = x0; + EXPAND_ASSIST(x0, x1, x2, x0, 255, 54); + kp[10] = x0; + key->rounds = 10; } -inline void -__attribute__((target("aes,sse2"))) -AES_ecb_encrypt_blks(block128 *blks, unsigned int nblks, const AES_KEY *key) -{ +inline void __attribute__((target("aes,sse2"))) +AES_ecb_encrypt_blks(block128 *blks, unsigned int nblks, const AES_KEY *key) { + for (unsigned int i = 0; i < nblks; ++i) + blks[i] = _mm_xor_si128(blks[i], key->rd_key[0]); + for (unsigned int j = 1; j < key->rounds; ++j) for (unsigned int i = 0; i < nblks; ++i) - blks[i] = _mm_xor_si128(blks[i], key->rd_key[0]); - for (unsigned int j = 1; j < key->rounds; ++j) - for (unsigned int i = 0; i < nblks; ++i) - blks[i] = _mm_aesenc_si128(blks[i], key->rd_key[j]); - for (unsigned int i = 0; i < nblks; ++i) - blks[i] = _mm_aesenclast_si128(blks[i], key->rd_key[key->rounds]); + blks[i] = _mm_aesenc_si128(blks[i], key->rd_key[j]); + for (unsigned int i = 0; i < nblks; ++i) + blks[i] = _mm_aesenclast_si128(blks[i], key->rd_key[key->rounds]); } -inline void -__attribute__((target("aes,sse2"))) -AES_set_decrypt_key_fast(AES_KEY *dkey, const AES_KEY *ekey) -{ - int j = 0; - int i = ekey->rounds; +inline void __attribute__((target("aes,sse2"))) +AES_set_decrypt_key_fast(AES_KEY *dkey, const AES_KEY *ekey) { + int j = 0; + int i = ekey->rounds; #if (OCB_KEY_LEN == 0) - dkey->rounds = i; + dkey->rounds = i; #endif - dkey->rd_key[i--] = ekey->rd_key[j++]; - while (i) - dkey->rd_key[i--] = _mm_aesimc_si128(ekey->rd_key[j++]); - dkey->rd_key[i] = ekey->rd_key[j]; + dkey->rd_key[i--] = ekey->rd_key[j++]; + while (i) + dkey->rd_key[i--] = _mm_aesimc_si128(ekey->rd_key[j++]); + dkey->rd_key[i] = ekey->rd_key[j]; } -inline void -__attribute__((target("aes,sse2"))) -AES_set_decrypt_key(block128 userkey, AES_KEY *key) -{ - AES_KEY temp_key; - AES_set_encrypt_key(userkey, &temp_key); - AES_set_decrypt_key_fast(key, &temp_key); +inline void __attribute__((target("aes,sse2"))) +AES_set_decrypt_key(block128 userkey, AES_KEY *key) { + AES_KEY temp_key; + AES_set_encrypt_key(userkey, &temp_key); + AES_set_decrypt_key_fast(key, &temp_key); } -inline void -__attribute__((target("aes,sse2"))) -AES_ecb_decrypt_blks(block128 *blks, unsigned nblks, const AES_KEY *key) -{ - unsigned i, j, rnds = key->rounds; - for (i = 0; i < nblks; ++i) - blks[i] = _mm_xor_si128(blks[i], key->rd_key[0]); - for (j = 1; j < rnds; ++j) - for (i = 0; i < nblks; ++i) - blks[i] = _mm_aesdec_si128(blks[i], key->rd_key[j]); +inline void __attribute__((target("aes,sse2"))) +AES_ecb_decrypt_blks(block128 *blks, unsigned nblks, const AES_KEY *key) { + unsigned i, j, rnds = key->rounds; + for (i = 0; i < nblks; ++i) + blks[i] = _mm_xor_si128(blks[i], key->rd_key[0]); + for (j = 1; j < rnds; ++j) for (i = 0; i < nblks; ++i) - blks[i] = _mm_aesdeclast_si128(blks[i], key->rd_key[j]); -} + blks[i] = _mm_aesdec_si128(blks[i], key->rd_key[j]); + for (i = 0; i < nblks; ++i) + blks[i] = _mm_aesdeclast_si128(blks[i], key->rd_key[j]); } +} // namespace sci #endif diff --git a/SCI/src/utils/aes_opt.h b/SCI/src/utils/aes_opt.h index b8c850a7..9ca0094c 100644 --- a/SCI/src/utils/aes_opt.h +++ b/SCI/src/utils/aes_opt.h @@ -27,10 +27,9 @@ SOFTWARE. Enquiries about further applications and development opportunities are welcome. Modified by Mayank Rathee -Reference code: https://github.com/Shay-Gueron/AES-GCM-SIV +Reference code: https://github.com/Shay-Gueron/AES-GCM-SIV */ - #ifndef LIBGARBLE_AES_OPT_H #define LIBGARBLE_AES_OPT_H @@ -40,22 +39,22 @@ Reference code: https://github.com/Shay-Gueron/AES-GCM-SIV #include <wmmintrin.h> #if defined(__INTEL_COMPILER) -# include <ia32intrin.h> +#include <ia32intrin.h> #elif defined(__GNUC__) - # include <emmintrin.h> -# include <smmintrin.h> +#include <emmintrin.h> +#include <smmintrin.h> #endif -#include "utils/block.h" #include "utils/aes-ni.h" +#include "utils/block.h" #include "utils/ubuntu_terminal_colors.h" -#if !defined (ALIGN16) -#if defined (__GNUC__) -# define ALIGN16 __attribute__ ( (aligned (16))) -# else -# define ALIGN16 __declspec (align (16)) -# endif +#if !defined(ALIGN16) +#if defined(__GNUC__) +#define ALIGN16 __attribute__((aligned(16))) +#else +#define ALIGN16 __declspec(align(16)) +#endif #endif // number of batched key schedule @@ -63,929 +62,991 @@ Reference code: https://github.com/Shay-Gueron/AES-GCM-SIV namespace sci { -typedef struct KEY_SCHEDULE -{ - ALIGN16 unsigned char KEY[16*15]; - unsigned int nr; -} ROUND_KEYS; +typedef struct KEY_SCHEDULE { + ALIGN16 unsigned char KEY[16 * 15]; + unsigned int nr; +} ROUND_KEYS; /*********************** 256-bit Key Schedules ***************************/ -/*********************** 1 Key Pipelined in Schedule ***************************/ - -#define KS_BLOCK_RO(t, reg, reg2) { xmm4 = _mm_slli_epi64 (reg, 32); \ - reg = _mm_xor_si128(reg, xmm4); \ - xmm4 = _mm_shuffle_epi8(reg, con3); \ - reg = _mm_xor_si128(reg, xmm4); \ - reg = _mm_xor_si128(reg, reg2); \ -} - -#define KS_round_first_x1(i) { xmm2 = _mm_shuffle_epi8(xmm3, mask); \ - xmm2 = _mm_aesenclast_si128(xmm2, con1); \ - KS_BLOCK_RO(0, xmm1, xmm2); \ - con1 = _mm_slli_epi32(con1, 1); \ - _mm_storeu_si128(&Key_Schedule[(i+1)*2], xmm1); \ -} - -#define KS_round_second_x1(i) { xmm2 = _mm_shuffle_epi32(xmm1, 0xff); \ - xmm2 = _mm_aesenclast_si128(xmm2, xmm14); \ - KS_BLOCK_RO(0, xmm3, xmm2); \ - _mm_storeu_si128(&Key_Schedule[(i+1)*2+1], xmm3); \ -} +/*********************** 1 Key Pipelined in Schedule + * ***************************/ + +#define KS_BLOCK_RO(t, reg, reg2) \ + { \ + xmm4 = _mm_slli_epi64(reg, 32); \ + reg = _mm_xor_si128(reg, xmm4); \ + xmm4 = _mm_shuffle_epi8(reg, con3); \ + reg = _mm_xor_si128(reg, xmm4); \ + reg = _mm_xor_si128(reg, reg2); \ + } + +#define KS_round_first_x1(i) \ + { \ + xmm2 = _mm_shuffle_epi8(xmm3, mask); \ + xmm2 = _mm_aesenclast_si128(xmm2, con1); \ + KS_BLOCK_RO(0, xmm1, xmm2); \ + con1 = _mm_slli_epi32(con1, 1); \ + _mm_storeu_si128(&Key_Schedule[(i + 1) * 2], xmm1); \ + } + +#define KS_round_second_x1(i) \ + { \ + xmm2 = _mm_shuffle_epi32(xmm1, 0xff); \ + xmm2 = _mm_aesenclast_si128(xmm2, xmm14); \ + KS_BLOCK_RO(0, xmm3, xmm2); \ + _mm_storeu_si128(&Key_Schedule[(i + 1) * 2 + 1], xmm3); \ + } + +#define KS_round_last_x1(i) \ + { \ + xmm2 = _mm_shuffle_epi8(xmm3, mask); \ + xmm2 = _mm_aesenclast_si128(xmm2, con1); \ + KS_BLOCK_RO(0, xmm1, xmm2); \ + _mm_storeu_si128(&Key_Schedule[14], xmm1); \ + } + +/*********************** 2 Keys Pipelined in Schedule + * ***************************/ + +#define KS_round_first_x2(k) \ + { \ + keyAAux = _mm_shuffle_epi8(keyARight, mask); \ + keyAAux = _mm_aesenclast_si128(keyAAux, con1); \ + KS_BLOCK_RO(0, keyALeft, keyAAux); \ + keyBAux = _mm_shuffle_epi8(keyBRight, mask); \ + keyBAux = _mm_aesenclast_si128(keyBAux, con1); \ + KS_BLOCK_RO(1, keyBLeft, keyBAux); \ + con1 = _mm_slli_epi32(con1, 1); \ + _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyALeft); \ + _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBLeft); \ + } + +#define KS_round_second_x2(k) \ + { \ + keyAAux = _mm_shuffle_epi32(keyALeft, 0xff); \ + keyAAux = _mm_aesenclast_si128(keyAAux, xmm14); \ + keyBAux = _mm_shuffle_epi32(keyBLeft, 0xff); \ + keyBAux = _mm_aesenclast_si128(keyBAux, xmm14); \ + KS_BLOCK_RO(0, keyARight, keyAAux); \ + KS_BLOCK_RO(1, keyBRight, keyBAux); \ + _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyARight); \ + _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBRight); \ + } + +#define KS_round_last_x2(k) \ + { \ + keyAAux = _mm_shuffle_epi8(keyARight, mask); \ + keyAAux = _mm_aesenclast_si128(keyAAux, con1); \ + keyBAux = _mm_shuffle_epi8(keyBRight, mask); \ + keyBAux = _mm_aesenclast_si128(keyBAux, con1); \ + KS_BLOCK_RO(0, keyALeft, keyAAux); \ + KS_BLOCK_RO(1, keyBLeft, keyBAux); \ + _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyALeft); \ + _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBLeft); \ + } + +/*********************** 8 Keys Pipelined in Schedule + * ***************************/ + +#define KS_round_first_x8(k) \ + { \ + keyAAux = _mm_shuffle_epi8(keyARight, mask); \ + keyAAux = _mm_aesenclast_si128(keyAAux, con1); \ + KS_BLOCK_RO(0, keyALeft, keyAAux); \ + \ + keyBAux = _mm_shuffle_epi8(keyBRight, mask); \ + keyBAux = _mm_aesenclast_si128(keyBAux, con1); \ + KS_BLOCK_RO(1, keyBLeft, keyBAux); \ + \ + keyCAux = _mm_shuffle_epi8(keyCRight, mask); \ + keyCAux = _mm_aesenclast_si128(keyCAux, con1); \ + KS_BLOCK_RO(2, keyCLeft, keyCAux); \ + \ + keyDAux = _mm_shuffle_epi8(keyDRight, mask); \ + keyDAux = _mm_aesenclast_si128(keyDAux, con1); \ + KS_BLOCK_RO(3, keyDLeft, keyDAux); \ + \ + keyEAux = _mm_shuffle_epi8(keyERight, mask); \ + keyEAux = _mm_aesenclast_si128(keyEAux, con1); \ + KS_BLOCK_RO(4, keyELeft, keyEAux); \ + \ + keyFAux = _mm_shuffle_epi8(keyFRight, mask); \ + keyFAux = _mm_aesenclast_si128(keyFAux, con1); \ + KS_BLOCK_RO(5, keyFLeft, keyFAux); \ + \ + keyGAux = _mm_shuffle_epi8(keyGRight, mask); \ + keyGAux = _mm_aesenclast_si128(keyGAux, con1); \ + KS_BLOCK_RO(6, keyGLeft, keyGAux); \ + \ + keyHAux = _mm_shuffle_epi8(keyHRight, mask); \ + keyHAux = _mm_aesenclast_si128(keyHAux, con1); \ + KS_BLOCK_RO(7, keyHLeft, keyHAux); \ + \ + con1 = _mm_slli_epi32(con1, 1); \ + _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyALeft); \ + _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[2].rk[k])), keyCLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[3].rk[k])), keyDLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[4].rk[k])), keyELeft); \ + _mm_storeu_si128((__m128i *)(&(keys[5].rk[k])), keyFLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[6].rk[k])), keyGLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[7].rk[k])), keyHLeft); \ + } + +#define KS_round_second_x8(k) \ + { \ + keyAAux = _mm_shuffle_epi32(keyALeft, 0xff); \ + keyAAux = _mm_aesenclast_si128(keyAAux, xmm14); \ + \ + keyBAux = _mm_shuffle_epi32(keyBLeft, 0xff); \ + keyBAux = _mm_aesenclast_si128(keyBAux, xmm14); \ + \ + keyCAux = _mm_shuffle_epi32(keyCLeft, 0xff); \ + keyCAux = _mm_aesenclast_si128(keyCAux, xmm14); \ + \ + keyDAux = _mm_shuffle_epi32(keyDLeft, 0xff); \ + keyDAux = _mm_aesenclast_si128(keyDAux, xmm14); \ + \ + keyEAux = _mm_shuffle_epi32(keyELeft, 0xff); \ + keyEAux = _mm_aesenclast_si128(keyEAux, xmm14); \ + \ + keyFAux = _mm_shuffle_epi32(keyFLeft, 0xff); \ + keyFAux = _mm_aesenclast_si128(keyFAux, xmm14); \ + \ + keyGAux = _mm_shuffle_epi32(keyGLeft, 0xff); \ + keyGAux = _mm_aesenclast_si128(keyGAux, xmm14); \ + \ + keyHAux = _mm_shuffle_epi32(keyHLeft, 0xff); \ + keyHAux = _mm_aesenclast_si128(keyHAux, xmm14); \ + \ + KS_BLOCK_RO(0, keyARight, keyAAux); \ + KS_BLOCK_RO(1, keyBRight, keyBAux); \ + KS_BLOCK_RO(2, keyCRight, keyCAux); \ + KS_BLOCK_RO(3, keyDRight, keyDAux); \ + KS_BLOCK_RO(4, keyERight, keyEAux); \ + KS_BLOCK_RO(5, keyFRight, keyFAux); \ + KS_BLOCK_RO(6, keyGRight, keyGAux); \ + KS_BLOCK_RO(7, keyHRight, keyHAux); \ + \ + _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyARight); \ + _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBRight); \ + _mm_storeu_si128((__m128i *)(&(keys[2].rk[k])), keyCRight); \ + _mm_storeu_si128((__m128i *)(&(keys[3].rk[k])), keyDRight); \ + _mm_storeu_si128((__m128i *)(&(keys[4].rk[k])), keyERight); \ + _mm_storeu_si128((__m128i *)(&(keys[5].rk[k])), keyFRight); \ + _mm_storeu_si128((__m128i *)(&(keys[6].rk[k])), keyGRight); \ + _mm_storeu_si128((__m128i *)(&(keys[7].rk[k])), keyHRight); \ + } + +#define KS_round_last_x8(k) \ + { \ + keyAAux = _mm_shuffle_epi8(keyARight, mask); \ + keyAAux = _mm_aesenclast_si128(keyAAux, con1); \ + \ + keyBAux = _mm_shuffle_epi8(keyBRight, mask); \ + keyBAux = _mm_aesenclast_si128(keyBAux, con1); \ + \ + keyCAux = _mm_shuffle_epi8(keyCRight, mask); \ + keyCAux = _mm_aesenclast_si128(keyCAux, con1); \ + \ + keyDAux = _mm_shuffle_epi8(keyDRight, mask); \ + keyDAux = _mm_aesenclast_si128(keyDAux, con1); \ + \ + keyEAux = _mm_shuffle_epi8(keyERight, mask); \ + keyEAux = _mm_aesenclast_si128(keyEAux, con1); \ + \ + keyFAux = _mm_shuffle_epi8(keyFRight, mask); \ + keyFAux = _mm_aesenclast_si128(keyFAux, con1); \ + \ + keyGAux = _mm_shuffle_epi8(keyGRight, mask); \ + keyGAux = _mm_aesenclast_si128(keyGAux, con1); \ + \ + keyHAux = _mm_shuffle_epi8(keyHRight, mask); \ + keyHAux = _mm_aesenclast_si128(keyHAux, con1); \ + \ + KS_BLOCK_RO(0, keyALeft, keyAAux); \ + KS_BLOCK_RO(1, keyBLeft, keyBAux); \ + KS_BLOCK_RO(2, keyCLeft, keyCAux); \ + KS_BLOCK_RO(3, keyDLeft, keyDAux); \ + KS_BLOCK_RO(4, keyELeft, keyEAux); \ + KS_BLOCK_RO(5, keyFLeft, keyFAux); \ + KS_BLOCK_RO(6, keyGLeft, keyGAux); \ + KS_BLOCK_RO(7, keyHLeft, keyHAux); \ + \ + _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyALeft); \ + _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[2].rk[k])), keyCLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[3].rk[k])), keyDLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[4].rk[k])), keyELeft); \ + _mm_storeu_si128((__m128i *)(&(keys[5].rk[k])), keyFLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[6].rk[k])), keyGLeft); \ + _mm_storeu_si128((__m128i *)(&(keys[7].rk[k])), keyHLeft); \ + } -#define KS_round_last_x1(i) { xmm2 = _mm_shuffle_epi8(xmm3, mask); \ - xmm2 = _mm_aesenclast_si128(xmm2, con1); \ - KS_BLOCK_RO(0, xmm1, xmm2); \ - _mm_storeu_si128(&Key_Schedule[14], xmm1); \ -} +/*********************** 128-bit Key Schedules ***************************/ -/*********************** 2 Keys Pipelined in Schedule ***************************/ - -#define KS_round_first_x2(k) { keyAAux = _mm_shuffle_epi8(keyARight, mask); \ - keyAAux = _mm_aesenclast_si128(keyAAux, con1); \ - KS_BLOCK_RO(0, keyALeft, keyAAux); \ - keyBAux = _mm_shuffle_epi8(keyBRight, mask); \ - keyBAux = _mm_aesenclast_si128(keyBAux, con1); \ - KS_BLOCK_RO(1, keyBLeft, keyBAux); \ - con1 = _mm_slli_epi32(con1, 1); \ - _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyALeft); \ - _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBLeft); \ -} +#define KS_BLOCK(t, reg, reg2) \ + { \ + globAux = _mm_slli_epi64(reg, 32); \ + reg = _mm_xor_si128(globAux, reg); \ + globAux = _mm_shuffle_epi8(reg, con3); \ + reg = _mm_xor_si128(globAux, reg); \ + reg = _mm_xor_si128(reg2, reg); \ + } + +#define KS_round_2(i) \ + { \ + x2 = _mm_shuffle_epi8(keyA, mask); \ + keyA_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(0, keyA, keyA_aux); \ + x2 = _mm_shuffle_epi8(keyB, mask); \ + keyB_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(1, keyB, keyB_aux); \ + con = _mm_slli_epi32(con, 1); \ + _mm_storeu_si128((__m128i *)(keys[0].KEY + i * 16), keyA); \ + _mm_storeu_si128((__m128i *)(keys[1].KEY + i * 16), keyB); \ + } + +#define KS_round_2_last(i) \ + { \ + x2 = _mm_shuffle_epi8(keyA, mask); \ + keyA_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyB, mask); \ + keyB_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(0, keyA, keyA_aux); \ + KS_BLOCK(1, keyB, keyB_aux); \ + _mm_storeu_si128((__m128i *)(keys[0].KEY + i * 16), keyA); \ + _mm_storeu_si128((__m128i *)(keys[1].KEY + i * 16), keyB); \ + } + +#define KS_round_4(i) \ + { \ + x2 = _mm_shuffle_epi8(keyA, mask); \ + keyA_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(0, keyA, keyA_aux); \ + x2 = _mm_shuffle_epi8(keyB, mask); \ + keyB_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(1, keyB, keyB_aux); \ + x2 = _mm_shuffle_epi8(keyC, mask); \ + keyC_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(2, keyC, keyC_aux); \ + x2 = _mm_shuffle_epi8(keyD, mask); \ + keyD_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(3, keyD, keyD_aux); \ + con = _mm_slli_epi32(con, 1); \ + _mm_storeu_si128((__m128i *)(keys[0].KEY + i * 16), keyA); \ + _mm_storeu_si128((__m128i *)(keys[1].KEY + i * 16), keyB); \ + _mm_storeu_si128((__m128i *)(keys[2].KEY + i * 16), keyC); \ + _mm_storeu_si128((__m128i *)(keys[3].KEY + i * 16), keyD); \ + } + +#define KS_round_4_last(i) \ + { \ + x2 = _mm_shuffle_epi8(keyA, mask); \ + keyA_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyB, mask); \ + keyB_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyC, mask); \ + keyC_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyD, mask); \ + keyD_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(0, keyA, keyA_aux); \ + KS_BLOCK(1, keyB, keyB_aux); \ + KS_BLOCK(2, keyC, keyC_aux); \ + KS_BLOCK(3, keyD, keyD_aux); \ + _mm_storeu_si128((__m128i *)(keys[0].KEY + i * 16), keyA); \ + _mm_storeu_si128((__m128i *)(keys[1].KEY + i * 16), keyB); \ + _mm_storeu_si128((__m128i *)(keys[2].KEY + i * 16), keyC); \ + _mm_storeu_si128((__m128i *)(keys[3].KEY + i * 16), keyD); \ + } + +#define KS_round_8(i) \ + { \ + x2 = _mm_shuffle_epi8(keyA, mask); \ + keyA_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(0, keyA, keyA_aux); \ + x2 = _mm_shuffle_epi8(keyB, mask); \ + keyB_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(1, keyB, keyB_aux); \ + x2 = _mm_shuffle_epi8(keyC, mask); \ + keyC_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(2, keyC, keyC_aux); \ + x2 = _mm_shuffle_epi8(keyD, mask); \ + keyD_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(3, keyD, keyD_aux); \ + x2 = _mm_shuffle_epi8(keyE, mask); \ + keyE_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(4, keyE, keyE_aux); \ + x2 = _mm_shuffle_epi8(keyF, mask); \ + keyF_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(5, keyF, keyF_aux); \ + x2 = _mm_shuffle_epi8(keyG, mask); \ + keyG_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(6, keyG, keyG_aux); \ + x2 = _mm_shuffle_epi8(keyH, mask); \ + keyH_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(7, keyH, keyH_aux); \ + con = _mm_slli_epi32(con, 1); \ + _mm_storeu_si128((__m128i *)(keys[0].KEY + i * 16), keyA); \ + _mm_storeu_si128((__m128i *)(keys[1].KEY + i * 16), keyB); \ + _mm_storeu_si128((__m128i *)(keys[2].KEY + i * 16), keyC); \ + _mm_storeu_si128((__m128i *)(keys[3].KEY + i * 16), keyD); \ + _mm_storeu_si128((__m128i *)(keys[4].KEY + i * 16), keyE); \ + _mm_storeu_si128((__m128i *)(keys[5].KEY + i * 16), keyF); \ + _mm_storeu_si128((__m128i *)(keys[6].KEY + i * 16), keyG); \ + _mm_storeu_si128((__m128i *)(keys[7].KEY + i * 16), keyH); \ + } + +#define KS_round_8_last(i) \ + { \ + x2 = _mm_shuffle_epi8(keyA, mask); \ + keyA_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyB, mask); \ + keyB_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyC, mask); \ + keyC_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyD, mask); \ + keyD_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyE, mask); \ + keyE_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyF, mask); \ + keyF_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyG, mask); \ + keyG_aux = _mm_aesenclast_si128(x2, con); \ + x2 = _mm_shuffle_epi8(keyH, mask); \ + keyH_aux = _mm_aesenclast_si128(x2, con); \ + KS_BLOCK(0, keyA, keyA_aux); \ + KS_BLOCK(1, keyB, keyB_aux); \ + KS_BLOCK(2, keyC, keyC_aux); \ + KS_BLOCK(3, keyD, keyD_aux); \ + KS_BLOCK(4, keyE, keyE_aux); \ + KS_BLOCK(5, keyF, keyF_aux); \ + KS_BLOCK(6, keyG, keyG_aux); \ + KS_BLOCK(7, keyH, keyH_aux); \ + _mm_storeu_si128((__m128i *)(keys[0].KEY + i * 16), keyA); \ + _mm_storeu_si128((__m128i *)(keys[1].KEY + i * 16), keyB); \ + _mm_storeu_si128((__m128i *)(keys[2].KEY + i * 16), keyC); \ + _mm_storeu_si128((__m128i *)(keys[3].KEY + i * 16), keyD); \ + _mm_storeu_si128((__m128i *)(keys[4].KEY + i * 16), keyE); \ + _mm_storeu_si128((__m128i *)(keys[5].KEY + i * 16), keyF); \ + _mm_storeu_si128((__m128i *)(keys[6].KEY + i * 16), keyG); \ + _mm_storeu_si128((__m128i *)(keys[7].KEY + i * 16), keyH); \ + } + +#define READ_KEYS_2(i) \ + { \ + keyA = _mm_loadu_si128((__m128i const *)(keys[0].KEY + i * 16)); \ + keyB = _mm_loadu_si128((__m128i const *)(keys[1].KEY + i * 16)); \ + } + +#define READ_KEYS_4(i) \ + { \ + keyA = _mm_loadu_si128((__m128i const *)(keys[0].KEY + i * 16)); \ + keyB = _mm_loadu_si128((__m128i const *)(keys[1].KEY + i * 16)); \ + keyC = _mm_loadu_si128((__m128i const *)(keys[2].KEY + i * 16)); \ + keyD = _mm_loadu_si128((__m128i const *)(keys[3].KEY + i * 16)); \ + } + +#define READ_KEYS_8(i) \ + { \ + keyA = _mm_loadu_si128((__m128i const *)(keys[0].KEY + i * 16)); \ + keyB = _mm_loadu_si128((__m128i const *)(keys[1].KEY + i * 16)); \ + keyC = _mm_loadu_si128((__m128i const *)(keys[2].KEY + i * 16)); \ + keyD = _mm_loadu_si128((__m128i const *)(keys[3].KEY + i * 16)); \ + keyE = _mm_loadu_si128((__m128i const *)(keys[4].KEY + i * 16)); \ + keyF = _mm_loadu_si128((__m128i const *)(keys[5].KEY + i * 16)); \ + keyG = _mm_loadu_si128((__m128i const *)(keys[6].KEY + i * 16)); \ + keyH = _mm_loadu_si128((__m128i const *)(keys[7].KEY + i * 16)); \ + } + +#define ENC_round_22(i) \ + { \ + block1 = \ + _mm_aesenc_si128(block1, (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block2 = \ + _mm_aesenc_si128(block2, (*(__m128i const *)(keys[1].KEY + i * 16))); \ + } + +#define ENC_round_22_last(i) \ + { \ + block1 = _mm_aesenclast_si128(block1, \ + (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block2 = _mm_aesenclast_si128(block2, \ + (*(__m128i const *)(keys[1].KEY + i * 16))); \ + } + +#define ENC_round_24(i) \ + { \ + block1 = \ + _mm_aesenc_si128(block1, (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block2 = \ + _mm_aesenc_si128(block2, (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block3 = \ + _mm_aesenc_si128(block3, (*(__m128i const *)(keys[1].KEY + i * 16))); \ + block4 = \ + _mm_aesenc_si128(block4, (*(__m128i const *)(keys[1].KEY + i * 16))); \ + } + +#define ENC_round_24_last(i) \ + { \ + block1 = _mm_aesenclast_si128(block1, \ + (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block2 = _mm_aesenclast_si128(block2, \ + (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block3 = _mm_aesenclast_si128(block3, \ + (*(__m128i const *)(keys[1].KEY + i * 16))); \ + block4 = _mm_aesenclast_si128(block4, \ + (*(__m128i const *)(keys[1].KEY + i * 16))); \ + } + +#define ENC_round_48(i) \ + { \ + block1 = \ + _mm_aesenc_si128(block1, (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block2 = \ + _mm_aesenc_si128(block2, (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block3 = \ + _mm_aesenc_si128(block3, (*(__m128i const *)(keys[1].KEY + i * 16))); \ + block4 = \ + _mm_aesenc_si128(block4, (*(__m128i const *)(keys[1].KEY + i * 16))); \ + block5 = \ + _mm_aesenc_si128(block5, (*(__m128i const *)(keys[2].KEY + i * 16))); \ + block6 = \ + _mm_aesenc_si128(block6, (*(__m128i const *)(keys[2].KEY + i * 16))); \ + block7 = \ + _mm_aesenc_si128(block7, (*(__m128i const *)(keys[3].KEY + i * 16))); \ + block8 = \ + _mm_aesenc_si128(block8, (*(__m128i const *)(keys[3].KEY + i * 16))); \ + } + +#define ENC_round_48_last(i) \ + { \ + block1 = _mm_aesenclast_si128(block1, \ + (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block2 = _mm_aesenclast_si128(block2, \ + (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block3 = _mm_aesenclast_si128(block3, \ + (*(__m128i const *)(keys[1].KEY + i * 16))); \ + block4 = _mm_aesenclast_si128(block4, \ + (*(__m128i const *)(keys[1].KEY + i * 16))); \ + block5 = _mm_aesenclast_si128(block5, \ + (*(__m128i const *)(keys[2].KEY + i * 16))); \ + block6 = _mm_aesenclast_si128(block6, \ + (*(__m128i const *)(keys[2].KEY + i * 16))); \ + block7 = _mm_aesenclast_si128(block7, \ + (*(__m128i const *)(keys[3].KEY + i * 16))); \ + block8 = _mm_aesenclast_si128(block8, \ + (*(__m128i const *)(keys[3].KEY + i * 16))); \ + } + +#define ENC_round_88(i) \ + { \ + block1 = \ + _mm_aesenc_si128(block1, (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block2 = \ + _mm_aesenc_si128(block2, (*(__m128i const *)(keys[1].KEY + i * 16))); \ + block3 = \ + _mm_aesenc_si128(block3, (*(__m128i const *)(keys[2].KEY + i * 16))); \ + block4 = \ + _mm_aesenc_si128(block4, (*(__m128i const *)(keys[3].KEY + i * 16))); \ + block5 = \ + _mm_aesenc_si128(block5, (*(__m128i const *)(keys[4].KEY + i * 16))); \ + block6 = \ + _mm_aesenc_si128(block6, (*(__m128i const *)(keys[5].KEY + i * 16))); \ + block7 = \ + _mm_aesenc_si128(block7, (*(__m128i const *)(keys[6].KEY + i * 16))); \ + block8 = \ + _mm_aesenc_si128(block8, (*(__m128i const *)(keys[7].KEY + i * 16))); \ + } + +#define ENC_round_88_last(i) \ + { \ + block1 = _mm_aesenclast_si128(block1, \ + (*(__m128i const *)(keys[0].KEY + i * 16))); \ + block2 = _mm_aesenclast_si128(block2, \ + (*(__m128i const *)(keys[1].KEY + i * 16))); \ + block3 = _mm_aesenclast_si128(block3, \ + (*(__m128i const *)(keys[2].KEY + i * 16))); \ + block4 = _mm_aesenclast_si128(block4, \ + (*(__m128i const *)(keys[3].KEY + i * 16))); \ + block5 = _mm_aesenclast_si128(block5, \ + (*(__m128i const *)(keys[4].KEY + i * 16))); \ + block6 = _mm_aesenclast_si128(block6, \ + (*(__m128i const *)(keys[5].KEY + i * 16))); \ + block7 = _mm_aesenclast_si128(block7, \ + (*(__m128i const *)(keys[6].KEY + i * 16))); \ + block8 = _mm_aesenclast_si128(block8, \ + (*(__m128i const *)(keys[7].KEY + i * 16))); \ + } -#define KS_round_second_x2(k) { keyAAux = _mm_shuffle_epi32(keyALeft, 0xff); \ - keyAAux = _mm_aesenclast_si128(keyAAux, xmm14); \ - keyBAux = _mm_shuffle_epi32(keyBLeft, 0xff); \ - keyBAux = _mm_aesenclast_si128(keyBAux, xmm14); \ - KS_BLOCK_RO(0, keyARight, keyAAux); \ - KS_BLOCK_RO(1, keyBRight, keyBAux); \ - _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyARight); \ - _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBRight); \ -} +/* + * AES key scheduling for 2/4/8 keys + */ +static inline void AES_ks2(block128 *user_key, ROUND_KEYS *KEYS) { + unsigned char *first_key = (unsigned char *)user_key; + ROUND_KEYS *keys = KEYS; + __m128i keyA, keyB, con, mask, x2, keyA_aux, keyB_aux, globAux; + int _con1[4] = {1, 1, 1, 1}; + int _con2[4] = {0x1b, 0x1b, 0x1b, 0x1b}; + int _mask[4] = {0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d}; + unsigned int _con3[4] = {0x0ffffffff, 0x0ffffffff, 0x07060504, 0x07060504}; + __m128i con3 = _mm_loadu_si128((__m128i const *)_con3); -#define KS_round_last_x2(k) { keyAAux = _mm_shuffle_epi8(keyARight, mask); \ - keyAAux = _mm_aesenclast_si128(keyAAux, con1); \ - keyBAux = _mm_shuffle_epi8(keyBRight, mask); \ - keyBAux = _mm_aesenclast_si128(keyBAux, con1); \ - KS_BLOCK_RO(0, keyALeft, keyAAux); \ - KS_BLOCK_RO(1, keyBLeft, keyBAux); \ - _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyALeft); \ - _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBLeft); \ -} + keys[0].nr = 10; + keys[1].nr = 10; -/*********************** 8 Keys Pipelined in Schedule ***************************/ - -#define KS_round_first_x8(k) { keyAAux = _mm_shuffle_epi8(keyARight, mask); \ - keyAAux = _mm_aesenclast_si128(keyAAux, con1); \ - KS_BLOCK_RO(0, keyALeft, keyAAux); \ - \ - keyBAux = _mm_shuffle_epi8(keyBRight, mask); \ - keyBAux = _mm_aesenclast_si128(keyBAux, con1); \ - KS_BLOCK_RO(1, keyBLeft, keyBAux); \ - \ - keyCAux = _mm_shuffle_epi8(keyCRight, mask); \ - keyCAux = _mm_aesenclast_si128(keyCAux, con1); \ - KS_BLOCK_RO(2, keyCLeft, keyCAux); \ - \ - keyDAux = _mm_shuffle_epi8(keyDRight, mask); \ - keyDAux = _mm_aesenclast_si128(keyDAux, con1); \ - KS_BLOCK_RO(3, keyDLeft, keyDAux); \ - \ - keyEAux = _mm_shuffle_epi8(keyERight, mask); \ - keyEAux = _mm_aesenclast_si128(keyEAux, con1); \ - KS_BLOCK_RO(4, keyELeft, keyEAux); \ - \ - keyFAux = _mm_shuffle_epi8(keyFRight, mask); \ - keyFAux = _mm_aesenclast_si128(keyFAux, con1); \ - KS_BLOCK_RO(5, keyFLeft, keyFAux); \ - \ - keyGAux = _mm_shuffle_epi8(keyGRight, mask); \ - keyGAux = _mm_aesenclast_si128(keyGAux, con1); \ - KS_BLOCK_RO(6, keyGLeft, keyGAux); \ - \ - keyHAux = _mm_shuffle_epi8(keyHRight, mask); \ - keyHAux = _mm_aesenclast_si128(keyHAux, con1); \ - KS_BLOCK_RO(7, keyHLeft, keyHAux); \ - \ - con1 = _mm_slli_epi32(con1, 1); \ - _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyALeft); \ - _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[2].rk[k])), keyCLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[3].rk[k])), keyDLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[4].rk[k])), keyELeft); \ - _mm_storeu_si128((__m128i *)(&(keys[5].rk[k])), keyFLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[6].rk[k])), keyGLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[7].rk[k])), keyHLeft); \ -} + keyA = _mm_loadu_si128((__m128i const *)(first_key)); + keyB = _mm_loadu_si128((__m128i const *)(first_key + 16)); -#define KS_round_second_x8(k) { keyAAux = _mm_shuffle_epi32(keyALeft, 0xff); \ - keyAAux = _mm_aesenclast_si128(keyAAux, xmm14); \ - \ - keyBAux = _mm_shuffle_epi32(keyBLeft, 0xff); \ - keyBAux = _mm_aesenclast_si128(keyBAux, xmm14); \ - \ - keyCAux = _mm_shuffle_epi32(keyCLeft, 0xff); \ - keyCAux = _mm_aesenclast_si128(keyCAux, xmm14); \ - \ - keyDAux = _mm_shuffle_epi32(keyDLeft, 0xff); \ - keyDAux = _mm_aesenclast_si128(keyDAux, xmm14); \ - \ - keyEAux = _mm_shuffle_epi32(keyELeft, 0xff); \ - keyEAux = _mm_aesenclast_si128(keyEAux, xmm14); \ - \ - keyFAux = _mm_shuffle_epi32(keyFLeft, 0xff); \ - keyFAux = _mm_aesenclast_si128(keyFAux, xmm14); \ - \ - keyGAux = _mm_shuffle_epi32(keyGLeft, 0xff); \ - keyGAux = _mm_aesenclast_si128(keyGAux, xmm14); \ - \ - keyHAux = _mm_shuffle_epi32(keyHLeft, 0xff); \ - keyHAux = _mm_aesenclast_si128(keyHAux, xmm14); \ - \ - KS_BLOCK_RO(0, keyARight, keyAAux); \ - KS_BLOCK_RO(1, keyBRight, keyBAux); \ - KS_BLOCK_RO(2, keyCRight, keyCAux); \ - KS_BLOCK_RO(3, keyDRight, keyDAux); \ - KS_BLOCK_RO(4, keyERight, keyEAux); \ - KS_BLOCK_RO(5, keyFRight, keyFAux); \ - KS_BLOCK_RO(6, keyGRight, keyGAux); \ - KS_BLOCK_RO(7, keyHRight, keyHAux); \ - \ - _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyARight); \ - _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBRight); \ - _mm_storeu_si128((__m128i *)(&(keys[2].rk[k])), keyCRight); \ - _mm_storeu_si128((__m128i *)(&(keys[3].rk[k])), keyDRight); \ - _mm_storeu_si128((__m128i *)(&(keys[4].rk[k])), keyERight); \ - _mm_storeu_si128((__m128i *)(&(keys[5].rk[k])), keyFRight); \ - _mm_storeu_si128((__m128i *)(&(keys[6].rk[k])), keyGRight); \ - _mm_storeu_si128((__m128i *)(&(keys[7].rk[k])), keyHRight); \ -} + _mm_storeu_si128((__m128i *)keys[0].KEY, keyA); + _mm_storeu_si128((__m128i *)keys[1].KEY, keyB); -#define KS_round_last_x8(k) { keyAAux = _mm_shuffle_epi8(keyARight, mask); \ - keyAAux = _mm_aesenclast_si128(keyAAux, con1); \ - \ - keyBAux = _mm_shuffle_epi8(keyBRight, mask); \ - keyBAux = _mm_aesenclast_si128(keyBAux, con1); \ - \ - keyCAux = _mm_shuffle_epi8(keyCRight, mask); \ - keyCAux = _mm_aesenclast_si128(keyCAux, con1); \ - \ - keyDAux = _mm_shuffle_epi8(keyDRight, mask); \ - keyDAux = _mm_aesenclast_si128(keyDAux, con1); \ - \ - keyEAux = _mm_shuffle_epi8(keyERight, mask); \ - keyEAux = _mm_aesenclast_si128(keyEAux, con1); \ - \ - keyFAux = _mm_shuffle_epi8(keyFRight, mask); \ - keyFAux = _mm_aesenclast_si128(keyFAux, con1); \ - \ - keyGAux = _mm_shuffle_epi8(keyGRight, mask); \ - keyGAux = _mm_aesenclast_si128(keyGAux, con1); \ - \ - keyHAux = _mm_shuffle_epi8(keyHRight, mask); \ - keyHAux = _mm_aesenclast_si128(keyHAux, con1); \ - \ - KS_BLOCK_RO(0, keyALeft, keyAAux); \ - KS_BLOCK_RO(1, keyBLeft, keyBAux); \ - KS_BLOCK_RO(2, keyCLeft, keyCAux); \ - KS_BLOCK_RO(3, keyDLeft, keyDAux); \ - KS_BLOCK_RO(4, keyELeft, keyEAux); \ - KS_BLOCK_RO(5, keyFLeft, keyFAux); \ - KS_BLOCK_RO(6, keyGLeft, keyGAux); \ - KS_BLOCK_RO(7, keyHLeft, keyHAux); \ - \ - _mm_storeu_si128((__m128i *)(&(keys[0].rk[k])), keyALeft); \ - _mm_storeu_si128((__m128i *)(&(keys[1].rk[k])), keyBLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[2].rk[k])), keyCLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[3].rk[k])), keyDLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[4].rk[k])), keyELeft); \ - _mm_storeu_si128((__m128i *)(&(keys[5].rk[k])), keyFLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[6].rk[k])), keyGLeft); \ - _mm_storeu_si128((__m128i *)(&(keys[7].rk[k])), keyHLeft); \ -} + con = _mm_loadu_si128((__m128i const *)_con1); + mask = _mm_loadu_si128((__m128i const *)_mask); -/*********************** 128-bit Key Schedules ***************************/ + KS_round_2(1) KS_round_2(2) KS_round_2(3) KS_round_2(4) KS_round_2(5) + KS_round_2(6) KS_round_2(7) KS_round_2(8) -#define KS_BLOCK(t, reg, reg2) {globAux=_mm_slli_epi64(reg, 32);\ - reg=_mm_xor_si128(globAux, reg);\ - globAux=_mm_shuffle_epi8(reg, con3);\ - reg=_mm_xor_si128(globAux, reg);\ - reg=_mm_xor_si128(reg2, reg);\ - } - -#define KS_round_2(i) { x2 =_mm_shuffle_epi8(keyA, mask); \ - keyA_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(0, keyA, keyA_aux);\ - x2 =_mm_shuffle_epi8(keyB, mask); \ - keyB_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(1, keyB, keyB_aux);\ - con=_mm_slli_epi32(con, 1);\ - _mm_storeu_si128((__m128i *)(keys[0].KEY+i*16), keyA);\ - _mm_storeu_si128((__m128i *)(keys[1].KEY+i*16), keyB); \ - } - -#define KS_round_2_last(i) { x2 =_mm_shuffle_epi8(keyA, mask); \ - keyA_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyB, mask); \ - keyB_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(0, keyA, keyA_aux);\ - KS_BLOCK(1, keyB, keyB_aux);\ - _mm_storeu_si128((__m128i *)(keys[0].KEY+i*16), keyA);\ - _mm_storeu_si128((__m128i *)(keys[1].KEY+i*16), keyB); \ - } - -#define KS_round_4(i) { x2 =_mm_shuffle_epi8(keyA, mask); \ - keyA_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(0, keyA, keyA_aux);\ - x2 =_mm_shuffle_epi8(keyB, mask); \ - keyB_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(1, keyB, keyB_aux);\ - x2 =_mm_shuffle_epi8(keyC, mask); \ - keyC_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(2, keyC, keyC_aux);\ - x2 =_mm_shuffle_epi8(keyD, mask); \ - keyD_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(3, keyD, keyD_aux);\ - con=_mm_slli_epi32(con, 1);\ - _mm_storeu_si128((__m128i *)(keys[0].KEY+i*16), keyA);\ - _mm_storeu_si128((__m128i *)(keys[1].KEY+i*16), keyB); \ - _mm_storeu_si128((__m128i *)(keys[2].KEY+i*16), keyC); \ - _mm_storeu_si128((__m128i *)(keys[3].KEY+i*16), keyD); \ - } - -#define KS_round_4_last(i) { x2 =_mm_shuffle_epi8(keyA, mask); \ - keyA_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyB, mask); \ - keyB_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyC, mask); \ - keyC_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyD, mask); \ - keyD_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(0, keyA, keyA_aux);\ - KS_BLOCK(1, keyB, keyB_aux);\ - KS_BLOCK(2, keyC, keyC_aux);\ - KS_BLOCK(3, keyD, keyD_aux);\ - _mm_storeu_si128((__m128i *)(keys[0].KEY+i*16), keyA);\ - _mm_storeu_si128((__m128i *)(keys[1].KEY+i*16), keyB); \ - _mm_storeu_si128((__m128i *)(keys[2].KEY+i*16), keyC); \ - _mm_storeu_si128((__m128i *)(keys[3].KEY+i*16), keyD); \ - } - -#define KS_round_8(i) { x2 =_mm_shuffle_epi8(keyA, mask); \ - keyA_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(0, keyA, keyA_aux);\ - x2 =_mm_shuffle_epi8(keyB, mask); \ - keyB_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(1, keyB, keyB_aux);\ - x2 =_mm_shuffle_epi8(keyC, mask); \ - keyC_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(2, keyC, keyC_aux);\ - x2 =_mm_shuffle_epi8(keyD, mask); \ - keyD_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(3, keyD, keyD_aux);\ - x2 =_mm_shuffle_epi8(keyE, mask); \ - keyE_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(4, keyE, keyE_aux);\ - x2 =_mm_shuffle_epi8(keyF, mask); \ - keyF_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(5, keyF, keyF_aux);\ - x2 =_mm_shuffle_epi8(keyG, mask); \ - keyG_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(6, keyG, keyG_aux);\ - x2 =_mm_shuffle_epi8(keyH, mask); \ - keyH_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(7, keyH, keyH_aux);\ - con=_mm_slli_epi32(con, 1);\ - _mm_storeu_si128((__m128i *)(keys[0].KEY+i*16), keyA);\ - _mm_storeu_si128((__m128i *)(keys[1].KEY+i*16), keyB); \ - _mm_storeu_si128((__m128i *)(keys[2].KEY+i*16), keyC); \ - _mm_storeu_si128((__m128i *)(keys[3].KEY+i*16), keyD); \ - _mm_storeu_si128((__m128i *)(keys[4].KEY+i*16), keyE);\ - _mm_storeu_si128((__m128i *)(keys[5].KEY+i*16), keyF); \ - _mm_storeu_si128((__m128i *)(keys[6].KEY+i*16), keyG); \ - _mm_storeu_si128((__m128i *)(keys[7].KEY+i*16), keyH); \ - } - -#define KS_round_8_last(i) { x2 =_mm_shuffle_epi8(keyA, mask); \ - keyA_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyB, mask); \ - keyB_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyC, mask); \ - keyC_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyD, mask); \ - keyD_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyE, mask); \ - keyE_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyF, mask); \ - keyF_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyG, mask); \ - keyG_aux=_mm_aesenclast_si128 (x2, con); \ - x2 =_mm_shuffle_epi8(keyH, mask); \ - keyH_aux=_mm_aesenclast_si128 (x2, con); \ - KS_BLOCK(0, keyA, keyA_aux);\ - KS_BLOCK(1, keyB, keyB_aux);\ - KS_BLOCK(2, keyC, keyC_aux);\ - KS_BLOCK(3, keyD, keyD_aux);\ - KS_BLOCK(4, keyE, keyE_aux);\ - KS_BLOCK(5, keyF, keyF_aux);\ - KS_BLOCK(6, keyG, keyG_aux);\ - KS_BLOCK(7, keyH, keyH_aux);\ - _mm_storeu_si128((__m128i *)(keys[0].KEY+i*16), keyA);\ - _mm_storeu_si128((__m128i *)(keys[1].KEY+i*16), keyB); \ - _mm_storeu_si128((__m128i *)(keys[2].KEY+i*16), keyC); \ - _mm_storeu_si128((__m128i *)(keys[3].KEY+i*16), keyD); \ - _mm_storeu_si128((__m128i *)(keys[4].KEY+i*16), keyE);\ - _mm_storeu_si128((__m128i *)(keys[5].KEY+i*16), keyF); \ - _mm_storeu_si128((__m128i *)(keys[6].KEY+i*16), keyG); \ - _mm_storeu_si128((__m128i *)(keys[7].KEY+i*16), keyH); \ - } - -#define READ_KEYS_2(i) {keyA = _mm_loadu_si128((__m128i const*)(keys[0].KEY+i*16));\ - keyB = _mm_loadu_si128((__m128i const*)(keys[1].KEY+i*16));\ - } - -#define READ_KEYS_4(i) {keyA = _mm_loadu_si128((__m128i const*)(keys[0].KEY+i*16));\ - keyB = _mm_loadu_si128((__m128i const*)(keys[1].KEY+i*16));\ - keyC = _mm_loadu_si128((__m128i const*)(keys[2].KEY+i*16));\ - keyD = _mm_loadu_si128((__m128i const*)(keys[3].KEY+i*16));\ - } - -#define READ_KEYS_8(i) {keyA = _mm_loadu_si128((__m128i const*)(keys[0].KEY+i*16));\ - keyB = _mm_loadu_si128((__m128i const*)(keys[1].KEY+i*16));\ - keyC = _mm_loadu_si128((__m128i const*)(keys[2].KEY+i*16));\ - keyD = _mm_loadu_si128((__m128i const*)(keys[3].KEY+i*16));\ - keyE = _mm_loadu_si128((__m128i const*)(keys[4].KEY+i*16));\ - keyF = _mm_loadu_si128((__m128i const*)(keys[5].KEY+i*16));\ - keyG = _mm_loadu_si128((__m128i const*)(keys[6].KEY+i*16));\ - keyH = _mm_loadu_si128((__m128i const*)(keys[7].KEY+i*16));\ - } - -#define ENC_round_22(i) {block1=_mm_aesenc_si128(block1, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block2=_mm_aesenc_si128(block2, (*(__m128i const*)(keys[1].KEY+i*16))); \ - } - -#define ENC_round_22_last(i) {block1=_mm_aesenclast_si128(block1, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block2=_mm_aesenclast_si128(block2, (*(__m128i const*)(keys[1].KEY+i*16))); \ - } - -#define ENC_round_24(i) {block1=_mm_aesenc_si128(block1, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block2=_mm_aesenc_si128(block2, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block3=_mm_aesenc_si128(block3, (*(__m128i const*)(keys[1].KEY+i*16))); \ - block4=_mm_aesenc_si128(block4, (*(__m128i const*)(keys[1].KEY+i*16))); \ - } - -#define ENC_round_24_last(i) {block1=_mm_aesenclast_si128(block1, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block2=_mm_aesenclast_si128(block2, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block3=_mm_aesenclast_si128(block3, (*(__m128i const*)(keys[1].KEY+i*16))); \ - block4=_mm_aesenclast_si128(block4, (*(__m128i const*)(keys[1].KEY+i*16))); \ - } - -#define ENC_round_48(i) {block1=_mm_aesenc_si128(block1, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block2=_mm_aesenc_si128(block2, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block3=_mm_aesenc_si128(block3, (*(__m128i const*)(keys[1].KEY+i*16))); \ - block4=_mm_aesenc_si128(block4, (*(__m128i const*)(keys[1].KEY+i*16))); \ - block5=_mm_aesenc_si128(block5, (*(__m128i const*)(keys[2].KEY+i*16))); \ - block6=_mm_aesenc_si128(block6, (*(__m128i const*)(keys[2].KEY+i*16))); \ - block7=_mm_aesenc_si128(block7, (*(__m128i const*)(keys[3].KEY+i*16))); \ - block8=_mm_aesenc_si128(block8, (*(__m128i const*)(keys[3].KEY+i*16))); \ - } - -#define ENC_round_48_last(i) {block1=_mm_aesenclast_si128(block1, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block2=_mm_aesenclast_si128(block2, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block3=_mm_aesenclast_si128(block3, (*(__m128i const*)(keys[1].KEY+i*16))); \ - block4=_mm_aesenclast_si128(block4, (*(__m128i const*)(keys[1].KEY+i*16))); \ - block5=_mm_aesenclast_si128(block5, (*(__m128i const*)(keys[2].KEY+i*16))); \ - block6=_mm_aesenclast_si128(block6, (*(__m128i const*)(keys[2].KEY+i*16))); \ - block7=_mm_aesenclast_si128(block7, (*(__m128i const*)(keys[3].KEY+i*16))); \ - block8=_mm_aesenclast_si128(block8, (*(__m128i const*)(keys[3].KEY+i*16))); \ - } - -#define ENC_round_88(i) {block1=_mm_aesenc_si128(block1, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block2=_mm_aesenc_si128(block2, (*(__m128i const*)(keys[1].KEY+i*16))); \ - block3=_mm_aesenc_si128(block3, (*(__m128i const*)(keys[2].KEY+i*16))); \ - block4=_mm_aesenc_si128(block4, (*(__m128i const*)(keys[3].KEY+i*16))); \ - block5=_mm_aesenc_si128(block5, (*(__m128i const*)(keys[4].KEY+i*16))); \ - block6=_mm_aesenc_si128(block6, (*(__m128i const*)(keys[5].KEY+i*16))); \ - block7=_mm_aesenc_si128(block7, (*(__m128i const*)(keys[6].KEY+i*16))); \ - block8=_mm_aesenc_si128(block8, (*(__m128i const*)(keys[7].KEY+i*16))); \ - } - -#define ENC_round_88_last(i) {block1=_mm_aesenclast_si128(block1, (*(__m128i const*)(keys[0].KEY+i*16))); \ - block2=_mm_aesenclast_si128(block2, (*(__m128i const*)(keys[1].KEY+i*16))); \ - block3=_mm_aesenclast_si128(block3, (*(__m128i const*)(keys[2].KEY+i*16))); \ - block4=_mm_aesenclast_si128(block4, (*(__m128i const*)(keys[3].KEY+i*16))); \ - block5=_mm_aesenclast_si128(block5, (*(__m128i const*)(keys[4].KEY+i*16))); \ - block6=_mm_aesenclast_si128(block6, (*(__m128i const*)(keys[5].KEY+i*16))); \ - block7=_mm_aesenclast_si128(block7, (*(__m128i const*)(keys[6].KEY+i*16))); \ - block8=_mm_aesenclast_si128(block8, (*(__m128i const*)(keys[7].KEY+i*16))); \ - } + con = _mm_loadu_si128((__m128i const *)_con2); -/* - * AES key scheduling for 2/4/8 keys - */ -static inline void AES_ks2(block128* user_key, ROUND_KEYS *KEYS) { - unsigned char *first_key = (unsigned char*)user_key; - ROUND_KEYS *keys = KEYS; - __m128i keyA, keyB, con, mask, x2, keyA_aux, keyB_aux, globAux; - int _con1[4]={1,1,1,1}; - int _con2[4]={0x1b,0x1b,0x1b,0x1b}; - int _mask[4]={0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d}; - unsigned int _con3[4]={0x0ffffffff, 0x0ffffffff, 0x07060504, 0x07060504}; - __m128i con3=_mm_loadu_si128((__m128i const*)_con3); - - keys[0].nr=10; - keys[1].nr=10; - - keyA = _mm_loadu_si128((__m128i const*)(first_key)); - keyB = _mm_loadu_si128((__m128i const*)(first_key+16)); - - _mm_storeu_si128((__m128i *)keys[0].KEY, keyA); - _mm_storeu_si128((__m128i *)keys[1].KEY, keyB); - - con = _mm_loadu_si128((__m128i const*)_con1); - mask = _mm_loadu_si128((__m128i const*)_mask); - - KS_round_2(1) - KS_round_2(2) - KS_round_2(3) - KS_round_2(4) - KS_round_2(5) - KS_round_2(6) - KS_round_2(7) - KS_round_2(8) - - con = _mm_loadu_si128((__m128i const*)_con2); - - KS_round_2(9) - KS_round_2_last(10) + KS_round_2(9) KS_round_2_last(10) } -static inline void AES_ks4(block128* user_key, ROUND_KEYS *KEYS) { - unsigned char *first_key = (unsigned char*)user_key; - ROUND_KEYS *keys = KEYS; - __m128i keyA, keyB, keyC, keyD, con, mask, x2, keyA_aux, keyB_aux, keyC_aux, keyD_aux, globAux; - int _con1[4]={1,1,1,1}; - int _con2[4]={0x1b,0x1b,0x1b,0x1b}; - int _mask[4]={0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d}; - unsigned int _con3[4]={0x0ffffffff, 0x0ffffffff, 0x07060504, 0x07060504}; - __m128i con3=_mm_loadu_si128((__m128i const*)_con3); - - keys[0].nr=10; - keys[1].nr=10; - keys[2].nr=10; - keys[3].nr=10; - - keyA = _mm_loadu_si128((__m128i const*)(first_key)); - keyB = _mm_loadu_si128((__m128i const*)(first_key+16)); - keyC = _mm_loadu_si128((__m128i const*)(first_key+32)); - keyD = _mm_loadu_si128((__m128i const*)(first_key+48)); - - _mm_storeu_si128((__m128i *)keys[0].KEY, keyA); - _mm_storeu_si128((__m128i *)keys[1].KEY, keyB); - _mm_storeu_si128((__m128i *)keys[2].KEY, keyC); - _mm_storeu_si128((__m128i *)keys[3].KEY, keyD); - - - con = _mm_loadu_si128((__m128i const*)_con1); - mask = _mm_loadu_si128((__m128i const*)_mask); - - KS_round_4(1) - KS_round_4(2) - KS_round_4(3) - KS_round_4(4) - KS_round_4(5) - KS_round_4(6) - KS_round_4(7) - KS_round_4(8) - - con = _mm_loadu_si128((__m128i const*)_con2); - - KS_round_4(9) - KS_round_4_last(10) +static inline void AES_ks4(block128 *user_key, ROUND_KEYS *KEYS) { + unsigned char *first_key = (unsigned char *)user_key; + ROUND_KEYS *keys = KEYS; + __m128i keyA, keyB, keyC, keyD, con, mask, x2, keyA_aux, keyB_aux, keyC_aux, + keyD_aux, globAux; + int _con1[4] = {1, 1, 1, 1}; + int _con2[4] = {0x1b, 0x1b, 0x1b, 0x1b}; + int _mask[4] = {0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d}; + unsigned int _con3[4] = {0x0ffffffff, 0x0ffffffff, 0x07060504, 0x07060504}; + __m128i con3 = _mm_loadu_si128((__m128i const *)_con3); + + keys[0].nr = 10; + keys[1].nr = 10; + keys[2].nr = 10; + keys[3].nr = 10; + + keyA = _mm_loadu_si128((__m128i const *)(first_key)); + keyB = _mm_loadu_si128((__m128i const *)(first_key + 16)); + keyC = _mm_loadu_si128((__m128i const *)(first_key + 32)); + keyD = _mm_loadu_si128((__m128i const *)(first_key + 48)); + + _mm_storeu_si128((__m128i *)keys[0].KEY, keyA); + _mm_storeu_si128((__m128i *)keys[1].KEY, keyB); + _mm_storeu_si128((__m128i *)keys[2].KEY, keyC); + _mm_storeu_si128((__m128i *)keys[3].KEY, keyD); + + con = _mm_loadu_si128((__m128i const *)_con1); + mask = _mm_loadu_si128((__m128i const *)_mask); + + KS_round_4(1) KS_round_4(2) KS_round_4(3) KS_round_4(4) KS_round_4(5) + KS_round_4(6) KS_round_4(7) KS_round_4(8) + + con = _mm_loadu_si128((__m128i const *)_con2); + + KS_round_4(9) KS_round_4_last(10) } -static inline void AES_ks8(block128* user_key, ROUND_KEYS *KEYS) { - unsigned char *first_key = (unsigned char*)user_key; - ROUND_KEYS *keys = KEYS; - __m128i keyA, keyB, keyC, keyD, keyE, keyF, keyG, keyH, keyA_aux, keyB_aux, keyC_aux, keyD_aux, keyE_aux, keyF_aux, keyG_aux, keyH_aux; - __m128i con, mask, x2, globAux; - int _con1[4]={1,1,1,1}; - int _con2[4]={0x1b,0x1b,0x1b,0x1b}; - int _mask[4]={0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d}; - unsigned int _con3[4]={0x0ffffffff, 0x0ffffffff, 0x07060504, 0x07060504}; - __m128i con3 = _mm_loadu_si128((__m128i const*)_con3); - - keys[0].nr=10; - keys[1].nr=10; - keys[2].nr=10; - keys[3].nr=10; - keys[4].nr=10; - keys[5].nr=10; - keys[6].nr=10; - keys[7].nr=10; - - keyA = _mm_loadu_si128((__m128i const*)(first_key)); - keyB = _mm_loadu_si128((__m128i const*)(first_key+16)); - keyC = _mm_loadu_si128((__m128i const*)(first_key+32)); - keyD = _mm_loadu_si128((__m128i const*)(first_key+48)); - keyE = _mm_loadu_si128((__m128i const*)(first_key+64)); - keyF = _mm_loadu_si128((__m128i const*)(first_key+80)); - keyG = _mm_loadu_si128((__m128i const*)(first_key+96)); - keyH = _mm_loadu_si128((__m128i const*)(first_key+112)); - - _mm_storeu_si128((__m128i *)keys[0].KEY, keyA); - _mm_storeu_si128((__m128i *)keys[1].KEY, keyB); - _mm_storeu_si128((__m128i *)keys[2].KEY, keyC); - _mm_storeu_si128((__m128i *)keys[3].KEY, keyD); - _mm_storeu_si128((__m128i *)keys[4].KEY, keyE); - _mm_storeu_si128((__m128i *)keys[5].KEY, keyF); - _mm_storeu_si128((__m128i *)keys[6].KEY, keyG); - _mm_storeu_si128((__m128i *)keys[7].KEY, keyH); - - con = _mm_loadu_si128((__m128i const*)_con1); - mask = _mm_loadu_si128((__m128i const*)_mask); - - KS_round_8(1) - KS_round_8(2) - KS_round_8(3) - KS_round_8(4) - KS_round_8(5) - KS_round_8(6) - KS_round_8(7) - KS_round_8(8) - - con = _mm_loadu_si128((__m128i const*)_con2); - - KS_round_8(9) - KS_round_8_last(10) +static inline void AES_ks8(block128 *user_key, ROUND_KEYS *KEYS) { + unsigned char *first_key = (unsigned char *)user_key; + ROUND_KEYS *keys = KEYS; + __m128i keyA, keyB, keyC, keyD, keyE, keyF, keyG, keyH, keyA_aux, keyB_aux, + keyC_aux, keyD_aux, keyE_aux, keyF_aux, keyG_aux, keyH_aux; + __m128i con, mask, x2, globAux; + int _con1[4] = {1, 1, 1, 1}; + int _con2[4] = {0x1b, 0x1b, 0x1b, 0x1b}; + int _mask[4] = {0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d}; + unsigned int _con3[4] = {0x0ffffffff, 0x0ffffffff, 0x07060504, 0x07060504}; + __m128i con3 = _mm_loadu_si128((__m128i const *)_con3); + + keys[0].nr = 10; + keys[1].nr = 10; + keys[2].nr = 10; + keys[3].nr = 10; + keys[4].nr = 10; + keys[5].nr = 10; + keys[6].nr = 10; + keys[7].nr = 10; + + keyA = _mm_loadu_si128((__m128i const *)(first_key)); + keyB = _mm_loadu_si128((__m128i const *)(first_key + 16)); + keyC = _mm_loadu_si128((__m128i const *)(first_key + 32)); + keyD = _mm_loadu_si128((__m128i const *)(first_key + 48)); + keyE = _mm_loadu_si128((__m128i const *)(first_key + 64)); + keyF = _mm_loadu_si128((__m128i const *)(first_key + 80)); + keyG = _mm_loadu_si128((__m128i const *)(first_key + 96)); + keyH = _mm_loadu_si128((__m128i const *)(first_key + 112)); + + _mm_storeu_si128((__m128i *)keys[0].KEY, keyA); + _mm_storeu_si128((__m128i *)keys[1].KEY, keyB); + _mm_storeu_si128((__m128i *)keys[2].KEY, keyC); + _mm_storeu_si128((__m128i *)keys[3].KEY, keyD); + _mm_storeu_si128((__m128i *)keys[4].KEY, keyE); + _mm_storeu_si128((__m128i *)keys[5].KEY, keyF); + _mm_storeu_si128((__m128i *)keys[6].KEY, keyG); + _mm_storeu_si128((__m128i *)keys[7].KEY, keyH); + + con = _mm_loadu_si128((__m128i const *)_con1); + mask = _mm_loadu_si128((__m128i const *)_mask); + + KS_round_8(1) KS_round_8(2) KS_round_8(3) KS_round_8(4) KS_round_8(5) + KS_round_8(6) KS_round_8(7) KS_round_8(8) + + con = _mm_loadu_si128((__m128i const *)_con2); + + KS_round_8(9) KS_round_8_last(10) } /* * AES key scheduling for circuit generation with 2/4/8 keys */ -static inline void AES_ks2_index(block128 random, uint64_t idx, ROUND_KEYS *KEYS) { - block128 user_key[2]; - user_key[0] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); - user_key[1] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); +static inline void AES_ks2_index(block128 random, uint64_t idx, + ROUND_KEYS *KEYS) { + block128 user_key[2]; + user_key[0] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); + user_key[1] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); - AES_ks2(user_key, KEYS); + AES_ks2(user_key, KEYS); } -static inline void AES_ks4_index(block128 random, uint64_t idx, ROUND_KEYS *KEYS) { - block128 user_key[4]; - user_key[0] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); - user_key[1] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); - idx++; - user_key[2] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); - user_key[3] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); - - AES_ks4(user_key, KEYS); +static inline void AES_ks4_index(block128 random, uint64_t idx, + ROUND_KEYS *KEYS) { + block128 user_key[4]; + user_key[0] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); + user_key[1] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); + idx++; + user_key[2] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); + user_key[3] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); + + AES_ks4(user_key, KEYS); } -static inline void AES_ks8_index(block128 random, uint64_t idx, ROUND_KEYS *KEYS) { - block128 user_key[8]; - user_key[0] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); - user_key[1] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); - idx++; - user_key[2] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); - user_key[3] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); - idx++; - user_key[4] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); - user_key[5] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); - idx++; - user_key[6] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); - user_key[7] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); - - AES_ks8(user_key, KEYS); +static inline void AES_ks8_index(block128 random, uint64_t idx, + ROUND_KEYS *KEYS) { + block128 user_key[8]; + user_key[0] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); + user_key[1] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); + idx++; + user_key[2] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); + user_key[3] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); + idx++; + user_key[4] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); + user_key[5] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); + idx++; + user_key[6] = xorBlocks(makeBlock128(2 * idx, (uint64_t)0), random); + user_key[7] = xorBlocks(makeBlock128(2 * idx + 1, (uint64_t)0), random); + + AES_ks8(user_key, KEYS); } /* - * AES encryptin with + * AES encryptin with * 2 keys 2 ciphers * 2 keys 4 ciphers * 4 keys 8 ciphers * 8 keys 8 ciphers */ -static inline void AES_ecb_ccr_ks2_enc2(block128 *plaintext, block128 *ciphertext, ROUND_KEYS *KEYS) { - unsigned char* PT = (unsigned char*)plaintext; - unsigned char* CT = (unsigned char*)ciphertext; - ROUND_KEYS *keys = KEYS; - __m128i keyA, keyB; - __m128i block1 = _mm_loadu_si128((__m128i const*)(0*16+PT)); - __m128i block2 = _mm_loadu_si128((__m128i const*)(1*16+PT)); - READ_KEYS_2(0) - - block1 = _mm_xor_si128(keyA, block1); - block2 = _mm_xor_si128(keyB, block2); - - ENC_round_22(1) - ENC_round_22(2) - ENC_round_22(3) - ENC_round_22(4) - ENC_round_22(5) - ENC_round_22(6) - ENC_round_22(7) - ENC_round_22(8) - ENC_round_22(9) - ENC_round_22_last(10) - - _mm_storeu_si128((__m128i *)(CT+0*16), block1); - _mm_storeu_si128((__m128i *)(CT+1*16), block2); - +static inline void AES_ecb_ccr_ks2_enc2(block128 *plaintext, + block128 *ciphertext, + ROUND_KEYS *KEYS) { + unsigned char *PT = (unsigned char *)plaintext; + unsigned char *CT = (unsigned char *)ciphertext; + ROUND_KEYS *keys = KEYS; + __m128i keyA, keyB; + __m128i block1 = _mm_loadu_si128((__m128i const *)(0 * 16 + PT)); + __m128i block2 = _mm_loadu_si128((__m128i const *)(1 * 16 + PT)); + READ_KEYS_2(0) + + block1 = _mm_xor_si128(keyA, block1); + block2 = _mm_xor_si128(keyB, block2); + + ENC_round_22(1) ENC_round_22(2) ENC_round_22(3) ENC_round_22(4) + ENC_round_22(5) ENC_round_22(6) ENC_round_22(7) ENC_round_22(8) + ENC_round_22(9) ENC_round_22_last(10) + + _mm_storeu_si128((__m128i *)(CT + 0 * 16), block1); + _mm_storeu_si128((__m128i *)(CT + 1 * 16), block2); } -static inline void AES_ecb_ccr_ks2_enc4(block128 *plaintext, block128 *ciphertext, ROUND_KEYS *KEYS) { - unsigned char* PT = (unsigned char*)plaintext; - unsigned char* CT = (unsigned char*)ciphertext; - ROUND_KEYS *keys = KEYS; - __m128i keyA, keyB; - - __m128i block1 = _mm_loadu_si128((__m128i const*)(0*16+PT)); - __m128i block2 = _mm_loadu_si128((__m128i const*)(1*16+PT)); - __m128i block3 = _mm_loadu_si128((__m128i const*)(2*16+PT)); - __m128i block4 = _mm_loadu_si128((__m128i const*)(3*16+PT)); - - READ_KEYS_2(0) - - block1 = _mm_xor_si128(keyA, block1); - block2 = _mm_xor_si128(keyA, block2); - block3 = _mm_xor_si128(keyB, block3); - block4 = _mm_xor_si128(keyB, block4); - - ENC_round_24(1) - ENC_round_24(2) - ENC_round_24(3) - ENC_round_24(4) - ENC_round_24(5) - ENC_round_24(6) - ENC_round_24(7) - ENC_round_24(8) - ENC_round_24(9) - ENC_round_24_last(10) - - _mm_storeu_si128((__m128i *)(CT+0*16), block1); - _mm_storeu_si128((__m128i *)(CT+1*16), block2); - _mm_storeu_si128((__m128i *)(CT+2*16), block3); - _mm_storeu_si128((__m128i *)(CT+3*16), block4); +static inline void AES_ecb_ccr_ks2_enc4(block128 *plaintext, + block128 *ciphertext, + ROUND_KEYS *KEYS) { + unsigned char *PT = (unsigned char *)plaintext; + unsigned char *CT = (unsigned char *)ciphertext; + ROUND_KEYS *keys = KEYS; + __m128i keyA, keyB; + + __m128i block1 = _mm_loadu_si128((__m128i const *)(0 * 16 + PT)); + __m128i block2 = _mm_loadu_si128((__m128i const *)(1 * 16 + PT)); + __m128i block3 = _mm_loadu_si128((__m128i const *)(2 * 16 + PT)); + __m128i block4 = _mm_loadu_si128((__m128i const *)(3 * 16 + PT)); + + READ_KEYS_2(0) + + block1 = _mm_xor_si128(keyA, block1); + block2 = _mm_xor_si128(keyA, block2); + block3 = _mm_xor_si128(keyB, block3); + block4 = _mm_xor_si128(keyB, block4); + + ENC_round_24(1) ENC_round_24(2) ENC_round_24(3) ENC_round_24(4) + ENC_round_24(5) ENC_round_24(6) ENC_round_24(7) ENC_round_24(8) + ENC_round_24(9) ENC_round_24_last(10) + + _mm_storeu_si128((__m128i *)(CT + 0 * 16), block1); + _mm_storeu_si128((__m128i *)(CT + 1 * 16), block2); + _mm_storeu_si128((__m128i *)(CT + 2 * 16), block3); + _mm_storeu_si128((__m128i *)(CT + 3 * 16), block4); } -static inline void AES_ecb_ccr_ks4_enc8(block128 *plaintext, block128 *ciphertext, ROUND_KEYS *KEYS) { - unsigned char* PT = (unsigned char*)plaintext; - unsigned char* CT = (unsigned char*)ciphertext; - ROUND_KEYS *keys = KEYS; - __m128i keyA, keyB, keyC, keyD; - - __m128i block1 = _mm_loadu_si128((__m128i const*)(0*16+PT)); - __m128i block2 = _mm_loadu_si128((__m128i const*)(1*16+PT)); - __m128i block3 = _mm_loadu_si128((__m128i const*)(2*16+PT)); - __m128i block4 = _mm_loadu_si128((__m128i const*)(3*16+PT)); - __m128i block5 = _mm_loadu_si128((__m128i const*)(4*16+PT)); - __m128i block6 = _mm_loadu_si128((__m128i const*)(5*16+PT)); - __m128i block7 = _mm_loadu_si128((__m128i const*)(6*16+PT)); - __m128i block8 = _mm_loadu_si128((__m128i const*)(7*16+PT)); - - READ_KEYS_4(0) - - block1 = _mm_xor_si128(keyA, block1); - block2 = _mm_xor_si128(keyA, block2); - block3 = _mm_xor_si128(keyB, block3); - block4 = _mm_xor_si128(keyB, block4); - block5 = _mm_xor_si128(keyC, block5); - block6 = _mm_xor_si128(keyC, block6); - block7 = _mm_xor_si128(keyD, block7); - block8 = _mm_xor_si128(keyD, block8); - - ENC_round_48(1) - ENC_round_48(2) - ENC_round_48(3) - ENC_round_48(4) - ENC_round_48(5) - ENC_round_48(6) - ENC_round_48(7) - ENC_round_48(8) - ENC_round_48(9) - ENC_round_48_last(10) - - _mm_storeu_si128((__m128i *)(CT+0*16), block1); - _mm_storeu_si128((__m128i *)(CT+1*16), block2); - _mm_storeu_si128((__m128i *)(CT+2*16), block3); - _mm_storeu_si128((__m128i *)(CT+3*16), block4); - _mm_storeu_si128((__m128i *)(CT+4*16), block5); - _mm_storeu_si128((__m128i *)(CT+5*16), block6); - _mm_storeu_si128((__m128i *)(CT+6*16), block7); - _mm_storeu_si128((__m128i *)(CT+7*16), block8); +static inline void AES_ecb_ccr_ks4_enc8(block128 *plaintext, + block128 *ciphertext, + ROUND_KEYS *KEYS) { + unsigned char *PT = (unsigned char *)plaintext; + unsigned char *CT = (unsigned char *)ciphertext; + ROUND_KEYS *keys = KEYS; + __m128i keyA, keyB, keyC, keyD; + + __m128i block1 = _mm_loadu_si128((__m128i const *)(0 * 16 + PT)); + __m128i block2 = _mm_loadu_si128((__m128i const *)(1 * 16 + PT)); + __m128i block3 = _mm_loadu_si128((__m128i const *)(2 * 16 + PT)); + __m128i block4 = _mm_loadu_si128((__m128i const *)(3 * 16 + PT)); + __m128i block5 = _mm_loadu_si128((__m128i const *)(4 * 16 + PT)); + __m128i block6 = _mm_loadu_si128((__m128i const *)(5 * 16 + PT)); + __m128i block7 = _mm_loadu_si128((__m128i const *)(6 * 16 + PT)); + __m128i block8 = _mm_loadu_si128((__m128i const *)(7 * 16 + PT)); + + READ_KEYS_4(0) + + block1 = _mm_xor_si128(keyA, block1); + block2 = _mm_xor_si128(keyA, block2); + block3 = _mm_xor_si128(keyB, block3); + block4 = _mm_xor_si128(keyB, block4); + block5 = _mm_xor_si128(keyC, block5); + block6 = _mm_xor_si128(keyC, block6); + block7 = _mm_xor_si128(keyD, block7); + block8 = _mm_xor_si128(keyD, block8); + + ENC_round_48(1) ENC_round_48(2) ENC_round_48(3) ENC_round_48(4) + ENC_round_48(5) ENC_round_48(6) ENC_round_48(7) ENC_round_48(8) + ENC_round_48(9) ENC_round_48_last(10) + + _mm_storeu_si128((__m128i *)(CT + 0 * 16), block1); + _mm_storeu_si128((__m128i *)(CT + 1 * 16), block2); + _mm_storeu_si128((__m128i *)(CT + 2 * 16), block3); + _mm_storeu_si128((__m128i *)(CT + 3 * 16), block4); + _mm_storeu_si128((__m128i *)(CT + 4 * 16), block5); + _mm_storeu_si128((__m128i *)(CT + 5 * 16), block6); + _mm_storeu_si128((__m128i *)(CT + 6 * 16), block7); + _mm_storeu_si128((__m128i *)(CT + 7 * 16), block8); } -static inline void AES_ecb_ccr_ks8_enc8(block128 *plaintext, block128 *ciphertext, ROUND_KEYS *KEYS) { - unsigned char* PT = (unsigned char*)plaintext; - unsigned char* CT = (unsigned char*)ciphertext; - ROUND_KEYS *keys = KEYS; - __m128i keyA, keyB, keyC, keyD, keyE, keyF, keyG, keyH; - - __m128i block1 = _mm_loadu_si128((__m128i const*)(0*16+PT)); - __m128i block2 = _mm_loadu_si128((__m128i const*)(1*16+PT)); - __m128i block3 = _mm_loadu_si128((__m128i const*)(2*16+PT)); - __m128i block4 = _mm_loadu_si128((__m128i const*)(3*16+PT)); - __m128i block5 = _mm_loadu_si128((__m128i const*)(4*16+PT)); - __m128i block6 = _mm_loadu_si128((__m128i const*)(5*16+PT)); - __m128i block7 = _mm_loadu_si128((__m128i const*)(6*16+PT)); - __m128i block8 = _mm_loadu_si128((__m128i const*)(7*16+PT)); - - READ_KEYS_8(0) - - block1 = _mm_xor_si128(keyA, block1); - block2 = _mm_xor_si128(keyB, block2); - block3 = _mm_xor_si128(keyC, block3); - block4 = _mm_xor_si128(keyD, block4); - block5 = _mm_xor_si128(keyE, block5); - block6 = _mm_xor_si128(keyF, block6); - block7 = _mm_xor_si128(keyG, block7); - block8 = _mm_xor_si128(keyH, block8); - - ENC_round_88(1) - ENC_round_88(2) - ENC_round_88(3) - ENC_round_88(4) - ENC_round_88(5) - ENC_round_88(6) - ENC_round_88(7) - ENC_round_88(8) - ENC_round_88(9) - ENC_round_88_last(10) - - _mm_storeu_si128((__m128i *)(CT+0*16), block1); - _mm_storeu_si128((__m128i *)(CT+1*16), block2); - _mm_storeu_si128((__m128i *)(CT+2*16), block3); - _mm_storeu_si128((__m128i *)(CT+3*16), block4); - _mm_storeu_si128((__m128i *)(CT+4*16), block5); - _mm_storeu_si128((__m128i *)(CT+5*16), block6); - _mm_storeu_si128((__m128i *)(CT+6*16), block7); - _mm_storeu_si128((__m128i *)(CT+7*16), block8); +static inline void AES_ecb_ccr_ks8_enc8(block128 *plaintext, + block128 *ciphertext, + ROUND_KEYS *KEYS) { + unsigned char *PT = (unsigned char *)plaintext; + unsigned char *CT = (unsigned char *)ciphertext; + ROUND_KEYS *keys = KEYS; + __m128i keyA, keyB, keyC, keyD, keyE, keyF, keyG, keyH; + + __m128i block1 = _mm_loadu_si128((__m128i const *)(0 * 16 + PT)); + __m128i block2 = _mm_loadu_si128((__m128i const *)(1 * 16 + PT)); + __m128i block3 = _mm_loadu_si128((__m128i const *)(2 * 16 + PT)); + __m128i block4 = _mm_loadu_si128((__m128i const *)(3 * 16 + PT)); + __m128i block5 = _mm_loadu_si128((__m128i const *)(4 * 16 + PT)); + __m128i block6 = _mm_loadu_si128((__m128i const *)(5 * 16 + PT)); + __m128i block7 = _mm_loadu_si128((__m128i const *)(6 * 16 + PT)); + __m128i block8 = _mm_loadu_si128((__m128i const *)(7 * 16 + PT)); + + READ_KEYS_8(0) + + block1 = _mm_xor_si128(keyA, block1); + block2 = _mm_xor_si128(keyB, block2); + block3 = _mm_xor_si128(keyC, block3); + block4 = _mm_xor_si128(keyD, block4); + block5 = _mm_xor_si128(keyE, block5); + block6 = _mm_xor_si128(keyF, block6); + block7 = _mm_xor_si128(keyG, block7); + block8 = _mm_xor_si128(keyH, block8); + + ENC_round_88(1) ENC_round_88(2) ENC_round_88(3) ENC_round_88(4) + ENC_round_88(5) ENC_round_88(6) ENC_round_88(7) ENC_round_88(8) + ENC_round_88(9) ENC_round_88_last(10) + + _mm_storeu_si128((__m128i *)(CT + 0 * 16), block1); + _mm_storeu_si128((__m128i *)(CT + 1 * 16), block2); + _mm_storeu_si128((__m128i *)(CT + 2 * 16), block3); + _mm_storeu_si128((__m128i *)(CT + 3 * 16), block4); + _mm_storeu_si128((__m128i *)(CT + 4 * 16), block5); + _mm_storeu_si128((__m128i *)(CT + 5 * 16), block6); + _mm_storeu_si128((__m128i *)(CT + 6 * 16), block7); + _mm_storeu_si128((__m128i *)(CT + 7 * 16), block8); } -//static inline void AES_256_ks2(block256* user_key, ROUND_KEYS *KEYS) { - //unsigned char *first_key = (unsigned char*)user_key; - //ROUND_KEYS *keys = KEYS; - - //__m128i keyALeft, keyAAux, keyARight, xmm14, xmm4; - //__m128i keyBLeft, keyBAux, keyBRight; - //__m128i con1, con3, mask; - //int i =0; - //mask = _mm_setr_epi32(0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d); - //con1 = _mm_setr_epi32(1,1,1,1); - //con3 = _mm_setr_epi8(-1,-1,-1,-1,-1,-1,-1,-1,4,5,6,7,4,5,6,7); - //xmm4 = _mm_setzero_si128(); - //xmm14 = _mm_setzero_si128(); - - //keys[0].nr=14; - //keys[1].nr=14; - - //keyALeft = _mm_loadu_si128((__m128i const*)(first_key)); - //keyARight = _mm_loadu_si128((__m128i const*)(first_key+16)); - - //keyBLeft = _mm_loadu_si128((__m128i const*)(first_key+32)); - //keyBRight = _mm_loadu_si128((__m128i const*)(first_key+48)); - - //_mm_storeu_si128((__m128i *)(keys[0].KEY), keyALeft); - //_mm_storeu_si128((__m128i *)(keys[0].KEY+16), keyARight); - - //_mm_storeu_si128((__m128i *)(keys[1].KEY), keyBLeft); - //_mm_storeu_si128((__m128i *)(keys[1].KEY+16), keyBRight); - - //for (i=1; i<=6; i++) - //{ - //KS_round_first_x2(2*i); - //KS_round_second_x2(2*i+1); - //} - //KS_round_last_x2(14); +// static inline void AES_256_ks2(block256* user_key, ROUND_KEYS *KEYS) { +// unsigned char *first_key = (unsigned char*)user_key; +// ROUND_KEYS *keys = KEYS; + +//__m128i keyALeft, keyAAux, keyARight, xmm14, xmm4; +//__m128i keyBLeft, keyBAux, keyBRight; +//__m128i con1, con3, mask; +// int i =0; +// mask = _mm_setr_epi32(0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d); +// con1 = _mm_setr_epi32(1,1,1,1); +// con3 = _mm_setr_epi8(-1,-1,-1,-1,-1,-1,-1,-1,4,5,6,7,4,5,6,7); +// xmm4 = _mm_setzero_si128(); +// xmm14 = _mm_setzero_si128(); + +// keys[0].nr=14; +// keys[1].nr=14; + +// keyALeft = _mm_loadu_si128((__m128i const*)(first_key)); +// keyARight = _mm_loadu_si128((__m128i const*)(first_key+16)); + +// keyBLeft = _mm_loadu_si128((__m128i const*)(first_key+32)); +// keyBRight = _mm_loadu_si128((__m128i const*)(first_key+48)); + +//_mm_storeu_si128((__m128i *)(keys[0].KEY), keyALeft); +//_mm_storeu_si128((__m128i *)(keys[0].KEY+16), keyARight); + +//_mm_storeu_si128((__m128i *)(keys[1].KEY), keyBLeft); +//_mm_storeu_si128((__m128i *)(keys[1].KEY+16), keyBRight); + +// for (i=1; i<=6; i++) +//{ +// KS_round_first_x2(2*i); +// KS_round_second_x2(2*i+1); +//} +// KS_round_last_x2(14); //} -static inline void AES_256_ks2(block256* user_key, AESNI_KEY *KEYS) { - unsigned char *first_key = (unsigned char*)user_key; - AESNI_KEY *keys = KEYS; - - __m128i keyALeft, keyAAux, keyARight, xmm14, xmm4; - __m128i keyBLeft, keyBAux, keyBRight; - __m128i con1, con3, mask; - int i =0; - mask = _mm_setr_epi32(0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d); - con1 = _mm_setr_epi32(1,1,1,1); - con3 = _mm_setr_epi8(-1,-1,-1,-1,-1,-1,-1,-1,4,5,6,7,4,5,6,7); - xmm4 = _mm_setzero_si128(); - xmm14 = _mm_setzero_si128(); - - keys[0].rounds=14; - keys[1].rounds=14; - - keyALeft = _mm_loadu_si128((__m128i const*)(first_key)); - keyARight = _mm_loadu_si128((__m128i const*)(first_key+16)); - - keyBLeft = _mm_loadu_si128((__m128i const*)(first_key+32)); - keyBRight = _mm_loadu_si128((__m128i const*)(first_key+48)); - - _mm_storeu_si128((__m128i *)(&(keys[0].rk[0])), keyALeft); - _mm_storeu_si128((__m128i *)(&(keys[0].rk[1])), keyARight); - - _mm_storeu_si128((__m128i *)(&(keys[1].rk[0])), keyBLeft); - _mm_storeu_si128((__m128i *)(&(keys[1].rk[1])), keyBRight); - - //std::cout<<"A"<<std::endl; - - for (i=1; i<=6; i++) - { - //std::cout<<2*i<<std::endl; - KS_round_first_x2(2*i); - //std::cout<<2*i+1<<std::endl; - KS_round_second_x2(2*i+1); - } - //std::cout<<"B"<<std::endl; - KS_round_last_x2(14); +static inline void AES_256_ks2(block256 *user_key, AESNI_KEY *KEYS) { + unsigned char *first_key = (unsigned char *)user_key; + AESNI_KEY *keys = KEYS; + + __m128i keyALeft, keyAAux, keyARight, xmm14, xmm4; + __m128i keyBLeft, keyBAux, keyBRight; + __m128i con1, con3, mask; + int i = 0; + mask = _mm_setr_epi32(0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d); + con1 = _mm_setr_epi32(1, 1, 1, 1); + con3 = _mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, 4, 5, 6, 7, 4, 5, 6, 7); + xmm4 = _mm_setzero_si128(); + xmm14 = _mm_setzero_si128(); + + keys[0].rounds = 14; + keys[1].rounds = 14; + + keyALeft = _mm_loadu_si128((__m128i const *)(first_key)); + keyARight = _mm_loadu_si128((__m128i const *)(first_key + 16)); + + keyBLeft = _mm_loadu_si128((__m128i const *)(first_key + 32)); + keyBRight = _mm_loadu_si128((__m128i const *)(first_key + 48)); + + _mm_storeu_si128((__m128i *)(&(keys[0].rk[0])), keyALeft); + _mm_storeu_si128((__m128i *)(&(keys[0].rk[1])), keyARight); + + _mm_storeu_si128((__m128i *)(&(keys[1].rk[0])), keyBLeft); + _mm_storeu_si128((__m128i *)(&(keys[1].rk[1])), keyBRight); + + // std::cout<<"A"<<std::endl; + + for (i = 1; i <= 6; i++) { + // std::cout<<2*i<<std::endl; + KS_round_first_x2(2 * i); + // std::cout<<2*i+1<<std::endl; + KS_round_second_x2(2 * i + 1); + } + // std::cout<<"B"<<std::endl; + KS_round_last_x2(14); } -static inline void AES_256_ks8(block256* user_key, AESNI_KEY *KEYS) { - unsigned char *first_key = (unsigned char*)user_key; - AESNI_KEY *keys = KEYS; - - __m128i keyALeft, keyAAux, keyARight, xmm14, xmm4; - __m128i keyBLeft, keyBAux, keyBRight; - __m128i keyCLeft, keyCAux, keyCRight; - __m128i keyDLeft, keyDAux, keyDRight; - __m128i keyELeft, keyEAux, keyERight; - __m128i keyFLeft, keyFAux, keyFRight; - __m128i keyGLeft, keyGAux, keyGRight; - __m128i keyHLeft, keyHAux, keyHRight; - - __m128i con1, con3, mask; - int i =0; - mask = _mm_setr_epi32(0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d); - con1 = _mm_setr_epi32(1,1,1,1); - con3 = _mm_setr_epi8(-1,-1,-1,-1,-1,-1,-1,-1,4,5,6,7,4,5,6,7); - xmm4 = _mm_setzero_si128(); - xmm14 = _mm_setzero_si128(); - - keys[0].rounds=14; - keys[1].rounds=14; - keys[2].rounds=14; - keys[3].rounds=14; - keys[4].rounds=14; - keys[5].rounds=14; - keys[6].rounds=14; - keys[7].rounds=14; - - keyALeft = _mm_loadu_si128((__m128i const*)(first_key)); - keyARight = _mm_loadu_si128((__m128i const*)(first_key+16)); - - keyBLeft = _mm_loadu_si128((__m128i const*)(first_key+32)); - keyBRight = _mm_loadu_si128((__m128i const*)(first_key+48)); - - keyCLeft = _mm_loadu_si128((__m128i const*)(first_key+64)); - keyCRight = _mm_loadu_si128((__m128i const*)(first_key+80)); - - keyDLeft = _mm_loadu_si128((__m128i const*)(first_key+96)); - keyDRight = _mm_loadu_si128((__m128i const*)(first_key+112)); - - keyELeft = _mm_loadu_si128((__m128i const*)(first_key+128)); - keyERight = _mm_loadu_si128((__m128i const*)(first_key+144)); - - keyFLeft = _mm_loadu_si128((__m128i const*)(first_key+160)); - keyFRight = _mm_loadu_si128((__m128i const*)(first_key+176)); - - keyGLeft = _mm_loadu_si128((__m128i const*)(first_key+192)); - keyGRight = _mm_loadu_si128((__m128i const*)(first_key+208)); - - keyHLeft = _mm_loadu_si128((__m128i const*)(first_key+224)); - keyHRight = _mm_loadu_si128((__m128i const*)(first_key+240)); - - _mm_storeu_si128((__m128i *)(&(keys[0].rk[0])), keyALeft); - _mm_storeu_si128((__m128i *)(&(keys[0].rk[1])), keyARight); - - _mm_storeu_si128((__m128i *)(&(keys[1].rk[0])), keyBLeft); - _mm_storeu_si128((__m128i *)(&(keys[1].rk[1])), keyBRight); - - _mm_storeu_si128((__m128i *)(&(keys[2].rk[0])), keyCLeft); - _mm_storeu_si128((__m128i *)(&(keys[2].rk[1])), keyCRight); - - _mm_storeu_si128((__m128i *)(&(keys[3].rk[0])), keyDLeft); - _mm_storeu_si128((__m128i *)(&(keys[3].rk[1])), keyDRight); - - _mm_storeu_si128((__m128i *)(&(keys[4].rk[0])), keyELeft); - _mm_storeu_si128((__m128i *)(&(keys[4].rk[1])), keyERight); - - _mm_storeu_si128((__m128i *)(&(keys[5].rk[0])), keyFLeft); - _mm_storeu_si128((__m128i *)(&(keys[5].rk[1])), keyFRight); - - _mm_storeu_si128((__m128i *)(&(keys[6].rk[0])), keyGLeft); - _mm_storeu_si128((__m128i *)(&(keys[6].rk[1])), keyGRight); - - _mm_storeu_si128((__m128i *)(&(keys[7].rk[0])), keyHLeft); - _mm_storeu_si128((__m128i *)(&(keys[7].rk[1])), keyHRight); - - for (i=1; i<=6; i++) - { - KS_round_first_x8(2*i); - KS_round_second_x8(2*i+1); - } - KS_round_last_x8(14); -} +static inline void AES_256_ks8(block256 *user_key, AESNI_KEY *KEYS) { + unsigned char *first_key = (unsigned char *)user_key; + AESNI_KEY *keys = KEYS; + + __m128i keyALeft, keyAAux, keyARight, xmm14, xmm4; + __m128i keyBLeft, keyBAux, keyBRight; + __m128i keyCLeft, keyCAux, keyCRight; + __m128i keyDLeft, keyDAux, keyDRight; + __m128i keyELeft, keyEAux, keyERight; + __m128i keyFLeft, keyFAux, keyFRight; + __m128i keyGLeft, keyGAux, keyGRight; + __m128i keyHLeft, keyHAux, keyHRight; + + __m128i con1, con3, mask; + int i = 0; + mask = _mm_setr_epi32(0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d, 0x0c0f0e0d); + con1 = _mm_setr_epi32(1, 1, 1, 1); + con3 = _mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, 4, 5, 6, 7, 4, 5, 6, 7); + xmm4 = _mm_setzero_si128(); + xmm14 = _mm_setzero_si128(); + + keys[0].rounds = 14; + keys[1].rounds = 14; + keys[2].rounds = 14; + keys[3].rounds = 14; + keys[4].rounds = 14; + keys[5].rounds = 14; + keys[6].rounds = 14; + keys[7].rounds = 14; + + keyALeft = _mm_loadu_si128((__m128i const *)(first_key)); + keyARight = _mm_loadu_si128((__m128i const *)(first_key + 16)); + + keyBLeft = _mm_loadu_si128((__m128i const *)(first_key + 32)); + keyBRight = _mm_loadu_si128((__m128i const *)(first_key + 48)); + + keyCLeft = _mm_loadu_si128((__m128i const *)(first_key + 64)); + keyCRight = _mm_loadu_si128((__m128i const *)(first_key + 80)); + keyDLeft = _mm_loadu_si128((__m128i const *)(first_key + 96)); + keyDRight = _mm_loadu_si128((__m128i const *)(first_key + 112)); + + keyELeft = _mm_loadu_si128((__m128i const *)(first_key + 128)); + keyERight = _mm_loadu_si128((__m128i const *)(first_key + 144)); + + keyFLeft = _mm_loadu_si128((__m128i const *)(first_key + 160)); + keyFRight = _mm_loadu_si128((__m128i const *)(first_key + 176)); + + keyGLeft = _mm_loadu_si128((__m128i const *)(first_key + 192)); + keyGRight = _mm_loadu_si128((__m128i const *)(first_key + 208)); + + keyHLeft = _mm_loadu_si128((__m128i const *)(first_key + 224)); + keyHRight = _mm_loadu_si128((__m128i const *)(first_key + 240)); + + _mm_storeu_si128((__m128i *)(&(keys[0].rk[0])), keyALeft); + _mm_storeu_si128((__m128i *)(&(keys[0].rk[1])), keyARight); + + _mm_storeu_si128((__m128i *)(&(keys[1].rk[0])), keyBLeft); + _mm_storeu_si128((__m128i *)(&(keys[1].rk[1])), keyBRight); + + _mm_storeu_si128((__m128i *)(&(keys[2].rk[0])), keyCLeft); + _mm_storeu_si128((__m128i *)(&(keys[2].rk[1])), keyCRight); + + _mm_storeu_si128((__m128i *)(&(keys[3].rk[0])), keyDLeft); + _mm_storeu_si128((__m128i *)(&(keys[3].rk[1])), keyDRight); + + _mm_storeu_si128((__m128i *)(&(keys[4].rk[0])), keyELeft); + _mm_storeu_si128((__m128i *)(&(keys[4].rk[1])), keyERight); + + _mm_storeu_si128((__m128i *)(&(keys[5].rk[0])), keyFLeft); + _mm_storeu_si128((__m128i *)(&(keys[5].rk[1])), keyFRight); + + _mm_storeu_si128((__m128i *)(&(keys[6].rk[0])), keyGLeft); + _mm_storeu_si128((__m128i *)(&(keys[6].rk[1])), keyGRight); + + _mm_storeu_si128((__m128i *)(&(keys[7].rk[0])), keyHLeft); + _mm_storeu_si128((__m128i *)(&(keys[7].rk[1])), keyHRight); + + for (i = 1; i <= 6; i++) { + KS_round_first_x8(2 * i); + KS_round_second_x8(2 * i + 1); + } + KS_round_last_x8(14); } + +} // namespace sci #endif diff --git a/SCI/src/utils/block.h b/SCI/src/utils/block.h index c964b9ab..009a69cb 100644 --- a/SCI/src/utils/block.h +++ b/SCI/src/utils/block.h @@ -27,214 +27,213 @@ Modified by Deevashwer Rathee #ifndef UTIL_BLOCK_H__ #define UTIL_BLOCK_H__ -#include <iostream> -#include <stdlib.h> -#include <string.h> -#include <stdint.h> -#include <stdbool.h> -#include <bitset> #include <algorithm> -#include <xmmintrin.h> +#include <assert.h> +#include <bitset> #include <emmintrin.h> +#include <immintrin.h> +#include <iostream> #include <smmintrin.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> #include <wmmintrin.h> -#include <immintrin.h> -#include <assert.h> +#include <xmmintrin.h> namespace sci { typedef __m128i block128; typedef __m256i block256; #if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) -static inline void -__attribute__((__always_inline__)) -_mm256_storeu2_m128i(__m128i* const hiaddr, __m128i* const loaddr, const __m256i a) -{ +static inline void __attribute__((__always_inline__)) +_mm256_storeu2_m128i(__m128i *const hiaddr, __m128i *const loaddr, + const __m256i a) { _mm_storeu_si128(loaddr, _mm256_castsi256_si128(a)); _mm_storeu_si128(hiaddr, _mm256_extracti128_si256(a, 1)); } -#endif /* defined(__GNUC__) */ - -inline void print(const uint64_t & value, const char* end = "\n", int len = 64, bool reverse = false) { - std::string tmp = std::bitset<64>(value).to_string(); - if (reverse) - std::reverse(tmp.begin(), tmp.end()); - if (reverse) - std::cout << tmp.substr(0, len);//std::cout << std::hex << buffer[i]; - else - std::cout << tmp.substr(64-len, len);//std::cout << std::hex << buffer[i]; - std::cout << end; -} - -inline void print(const uint8_t & value, const char* end = "\n", int len = 8, bool reverse = false) { - std::string tmp = std::bitset<8>(value).to_string(); - if (reverse) - std::reverse(tmp.begin(), tmp.end()); - if (reverse) - std::cout << tmp.substr(0, len);//std::cout << std::hex << buffer[i]; - else - std::cout << tmp.substr(8-len, len);//std::cout << std::hex << buffer[i]; - std::cout << end; -} - -inline void print(const block128 & value, const char* end = "\n") { - const size_t n = sizeof(__m128i) / sizeof(uint64_t); - uint64_t buffer[n]; - _mm_storeu_si128((__m128i*)buffer, value); - // std::cout << "0x"; - for (size_t i = 0; i < n; i++) { - std::string tmp = std::bitset<64>(buffer[i]).to_string(); - std::reverse(tmp.begin(), tmp.end()); - std::cout << tmp;//std::cout << std::hex << buffer[i]; - } - std::cout << end; -} - -inline void print(const block256 & value, const char* end = "\n") { - const size_t n = sizeof(__m256i) / sizeof(uint64_t); - uint64_t buffer[n]; - _mm256_storeu_si256((__m256i*)buffer, value); - // std::cout << "0x"; - for (size_t i = 0; i < n; i++) { - std::string tmp = std::bitset<64>(buffer[i]).to_string(); - std::reverse(tmp.begin(), tmp.end()); - std::cout << tmp;//std::cout << std::hex << buffer[i]; - } - std::cout << end; +#endif /* defined(__GNUC__) */ + +inline void print(const uint64_t &value, const char *end = "\n", int len = 64, + bool reverse = false) { + std::string tmp = std::bitset<64>(value).to_string(); + if (reverse) + std::reverse(tmp.begin(), tmp.end()); + if (reverse) + std::cout << tmp.substr(0, len); // std::cout << std::hex << buffer[i]; + else + std::cout << tmp.substr(64 - len, + len); // std::cout << std::hex << buffer[i]; + std::cout << end; +} + +inline void print(const uint8_t &value, const char *end = "\n", int len = 8, + bool reverse = false) { + std::string tmp = std::bitset<8>(value).to_string(); + if (reverse) + std::reverse(tmp.begin(), tmp.end()); + if (reverse) + std::cout << tmp.substr(0, len); // std::cout << std::hex << buffer[i]; + else + std::cout << tmp.substr(8 - len, len); // std::cout << std::hex << + // buffer[i]; + std::cout << end; +} + +inline void print(const block128 &value, const char *end = "\n") { + const size_t n = sizeof(__m128i) / sizeof(uint64_t); + uint64_t buffer[n]; + _mm_storeu_si128((__m128i *)buffer, value); + // std::cout << "0x"; + for (size_t i = 0; i < n; i++) { + std::string tmp = std::bitset<64>(buffer[i]).to_string(); + std::reverse(tmp.begin(), tmp.end()); + std::cout << tmp; // std::cout << std::hex << buffer[i]; + } + std::cout << end; +} + +inline void print(const block256 &value, const char *end = "\n") { + const size_t n = sizeof(__m256i) / sizeof(uint64_t); + uint64_t buffer[n]; + _mm256_storeu_si256((__m256i *)buffer, value); + // std::cout << "0x"; + for (size_t i = 0; i < n; i++) { + std::string tmp = std::bitset<64>(buffer[i]).to_string(); + std::reverse(tmp.begin(), tmp.end()); + std::cout << tmp; // std::cout << std::hex << buffer[i]; + } + std::cout << end; } -inline bool getLSB(const block128 & x) { - return (*((char*)&x)&1) == 1; -} -__attribute__((target("sse2"))) -inline block128 makeBlock128(int64_t x, int64_t y) { - return _mm_set_epi64x(x, y); +inline bool getLSB(const block128 &x) { return (*((char *)&x) & 1) == 1; } +__attribute__((target("sse2"))) inline block128 makeBlock128(int64_t x, + int64_t y) { + return _mm_set_epi64x(x, y); } -__attribute__((target("avx"))) -inline block256 makeBlock256(int64_t w, int64_t x, int64_t y, int64_t z) { // return w||x||y||z (MSB->LSB) - return _mm256_set_epi64x(w, x, y, z); +__attribute__((target("avx"))) inline block256 +makeBlock256(int64_t w, int64_t x, int64_t y, + int64_t z) { // return w||x||y||z (MSB->LSB) + return _mm256_set_epi64x(w, x, y, z); } -__attribute__((target("avx2,avx"))) -inline block256 makeBlock256(block128 x, block128 y) { // return x (MSB) || y (LSB) - return _mm256_inserti128_si256(_mm256_castsi128_si256(y), x, 1); - // return _mm256_loadu2_m128i(&x, &y); +__attribute__((target("avx2,avx"))) inline block256 +makeBlock256(block128 x, block128 y) { // return x (MSB) || y (LSB) + return _mm256_inserti128_si256(_mm256_castsi128_si256(y), x, 1); + // return _mm256_loadu2_m128i(&x, &y); } -__attribute__((target("sse2"))) -inline block128 zero_block() { - return _mm_setzero_si128(); +__attribute__((target("sse2"))) inline block128 zero_block() { + return _mm_setzero_si128(); } inline block128 one_block() { - return makeBlock128(0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL); + return makeBlock128(0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL); } -__attribute__((target("sse2"))) -inline block128 make_delta(const block128 & a) { - return _mm_or_si128(makeBlock128(0L, 1L), a); +__attribute__((target("sse2"))) inline block128 make_delta(const block128 &a) { + return _mm_or_si128(makeBlock128(0L, 1L), a); } typedef __m128i block_tpl[2]; -__attribute__((target("sse2"))) -inline block128 xorBlocks(block128 x, block128 y) { - return _mm_xor_si128(x,y); +__attribute__((target("sse2"))) inline block128 xorBlocks(block128 x, + block128 y) { + return _mm_xor_si128(x, y); } -__attribute__((target("avx2"))) -inline block256 xorBlocks(block256 x, block256 y) { - return _mm256_xor_si256(x, y); +__attribute__((target("avx2"))) inline block256 xorBlocks(block256 x, + block256 y) { + return _mm256_xor_si256(x, y); } -__attribute__((target("sse2"))) -inline block128 andBlocks(block128 x, block128 y) { - return _mm_and_si128(x,y); +__attribute__((target("sse2"))) inline block128 andBlocks(block128 x, + block128 y) { + return _mm_and_si128(x, y); } -__attribute__((target("avx2"))) -inline block256 andBlocks(block256 x, block256 y) { - return _mm256_and_si256(x,y); +__attribute__((target("avx2"))) inline block256 andBlocks(block256 x, + block256 y) { + return _mm256_and_si256(x, y); } -inline void xorBlocks_arr(block128* res, const block128* x, const block128* y, int nblocks) { - const block128 * dest = nblocks+x; - for (; x != dest;) { - *(res++) = xorBlocks(*(x++), *(y++)); - } +inline void xorBlocks_arr(block128 *res, const block128 *x, const block128 *y, + int nblocks) { + const block128 *dest = nblocks + x; + for (; x != dest;) { + *(res++) = xorBlocks(*(x++), *(y++)); + } } -inline void xorBlocks_arr(block128* res, const block128* x, block128 y, int nblocks) { - const block128 * dest = nblocks+x; - for (; x != dest;) { - *(res++) = xorBlocks(*(x++), y); - } +inline void xorBlocks_arr(block128 *res, const block128 *x, block128 y, + int nblocks) { + const block128 *dest = nblocks + x; + for (; x != dest;) { + *(res++) = xorBlocks(*(x++), y); + } } -inline void xorBlocks_arr(block256* res, const block256* x, const block256* y, int nblocks) { - const block256 * dest = nblocks+x; - for (; x != dest;) { - *(res++) = xorBlocks(*(x++), *(y++)); - } +inline void xorBlocks_arr(block256 *res, const block256 *x, const block256 *y, + int nblocks) { + const block256 *dest = nblocks + x; + for (; x != dest;) { + *(res++) = xorBlocks(*(x++), *(y++)); + } } -inline void xorBlocks_arr(block256* res, const block256* x, block256 y, int nblocks) { - const block256 * dest = nblocks+x; - for (; x != dest;) { - *(res++) = xorBlocks(*(x++), y); - } +inline void xorBlocks_arr(block256 *res, const block256 *x, block256 y, + int nblocks) { + const block256 *dest = nblocks + x; + for (; x != dest;) { + *(res++) = xorBlocks(*(x++), y); + } } -__attribute__((target("sse4.1,sse2"))) -inline bool cmpBlock(const block128 * x, const block128 * y, int nblocks) { - const block128 * dest = nblocks+x; - for (; x != dest;) { - __m128i vcmp = _mm_xor_si128(*(x++), *(y++)); - if(!_mm_testz_si128(vcmp, vcmp)) - return false; - } - return true; +__attribute__((target("sse4.1,sse2"))) inline bool +cmpBlock(const block128 *x, const block128 *y, int nblocks) { + const block128 *dest = nblocks + x; + for (; x != dest;) { + __m128i vcmp = _mm_xor_si128(*(x++), *(y++)); + if (!_mm_testz_si128(vcmp, vcmp)) + return false; + } + return true; } -__attribute__((target("avx2,avx"))) -inline bool cmpBlock(const block256 * x, const block256 * y, int nblocks) { - const block256 * dest = nblocks+x; - for (; x != dest;) { - __m256i vcmp = _mm256_xor_si256(*(x++), *(y++)); - if(!_mm256_testz_si256(vcmp, vcmp)) - return false; - } - return true; +__attribute__((target("avx2,avx"))) inline bool +cmpBlock(const block256 *x, const block256 *y, int nblocks) { + const block256 *dest = nblocks + x; + for (; x != dest;) { + __m256i vcmp = _mm256_xor_si256(*(x++), *(y++)); + if (!_mm256_testz_si256(vcmp, vcmp)) + return false; + } + return true; } -//deprecate soon -inline bool block_cmp(const block128 * x, const block128 * y, int nblocks) { - return cmpBlock(x,y,nblocks); +// deprecate soon +inline bool block_cmp(const block128 *x, const block128 *y, int nblocks) { + return cmpBlock(x, y, nblocks); } -inline bool block_cmp(const block256 * x, const block256 * y, int nblocks) { - return cmpBlock(x,y,nblocks); +inline bool block_cmp(const block256 *x, const block256 *y, int nblocks) { + return cmpBlock(x, y, nblocks); } -__attribute__((target("sse4.1"))) -inline bool isZero(const block128 * b) { - return _mm_testz_si128(*b,*b) > 0; +__attribute__((target("sse4.1"))) inline bool isZero(const block128 *b) { + return _mm_testz_si128(*b, *b) > 0; } -__attribute__((target("avx"))) -inline bool isZero(const block256 * b) { - return _mm256_testz_si256(*b,*b) > 0; +__attribute__((target("avx"))) inline bool isZero(const block256 *b) { + return _mm256_testz_si256(*b, *b) > 0; } -__attribute__((target("sse4.1,sse2"))) -inline bool isOne(const block128 * b) { - __m128i neq = _mm_xor_si128(*b, one_block()); - return _mm_testz_si128(neq, neq) > 0; +__attribute__((target("sse4.1,sse2"))) inline bool isOne(const block128 *b) { + __m128i neq = _mm_xor_si128(*b, one_block()); + return _mm_testz_si128(neq, neq) > 0; } - -//Modified from -//https://mischasan.wordpress.com/2011/10/03/the-full-sse2-bit-matrix-transpose-routine/ +// Modified from +// https://mischasan.wordpress.com/2011/10/03/the-full-sse2-bit-matrix-transpose-routine/ // with inner most loops changed to _mm_set_epi8 and _mm_set_epi16 #define INP(x, y) inp[(x)*ncols / 8 + (y) / 8] #define OUT(x, y) out[(y)*nrows / 8 + (x) / 8] -__attribute__((target("sse2"))) -inline void sse_trans(uint8_t *out, uint8_t const *inp, uint64_t nrows, - uint64_t ncols) { +__attribute__((target("sse2"))) inline void +sse_trans(uint8_t *out, uint8_t const *inp, uint64_t nrows, uint64_t ncols) { uint64_t rr, cc; int i, h; union { @@ -264,8 +263,8 @@ inline void sse_trans(uint8_t *out, uint8_t const *inp, uint64_t nrows, // Do a PAIR of 8x8 blocks in each step: if ((ncols % 8 == 0 && ncols % 16 != 0) || (nrows % 8 == 0 && nrows % 16 != 0)) { - // The fancy optimizations in the else-branch don't work if the above if-condition - // holds, so we use the simpler non-simd variant for that case. + // The fancy optimizations in the else-branch don't work if the above + // if-condition holds, so we use the simpler non-simd variant for that case. for (cc = 0; cc <= ncols - 16; cc += 16) { for (i = 0; i < 8; ++i) { tmp.b[i] = h = *(uint16_t const *)&INP(rr + i, cc); @@ -303,27 +302,26 @@ inline void sse_trans(uint8_t *out, uint8_t const *inp, uint64_t nrows, } const char fix_key[] = "\x61\x7e\x8d\xa2\xa0\x51\x1e\x96" -"\x5e\x41\xc2\x9b\x15\x3f\xc7\x7a"; + "\x5e\x41\xc2\x9b\x15\x3f\xc7\x7a"; /* - This file is part of JustGarble. + This file is part of JustGarble. - JustGarble is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. + JustGarble is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - JustGarble is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. + JustGarble is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with JustGarble. If not, see <http://www.gnu.org/licenses/>. + You should have received a copy of the GNU General Public License + along with JustGarble. If not, see <http://www.gnu.org/licenses/>. */ - /*------------------------------------------------------------------------ / OCB Version 3 Reference Code (Optimized C) Last modified 08-SEP-2012 /------------------------------------------------------------------------- @@ -348,29 +346,26 @@ const char fix_key[] = "\x61\x7e\x8d\xa2\xa0\x51\x1e\x96" / / Comments are welcome: Ted Krovetz <ted@krovetz.net> - Dedicated to Laurel K /------------------------------------------------------------------------- */ -__attribute__((target("sse2"))) -inline block128 double_block(block128 bl) { - const __m128i mask = _mm_set_epi32(135,1,1,1); - __m128i tmp = _mm_srai_epi32(bl, 31); - tmp = _mm_and_si128(tmp, mask); - tmp = _mm_shuffle_epi32(tmp, _MM_SHUFFLE(2,1,0,3)); - bl = _mm_slli_epi32(bl, 1); - return _mm_xor_si128(bl,tmp); -} - -__attribute__((target("sse2"))) -inline block128 LEFTSHIFT1(block128 bl) { - const __m128i mask = _mm_set_epi32(0,0, (1<<31),0); - __m128i tmp = _mm_and_si128(bl,mask); - bl = _mm_slli_epi64(bl, 1); - return _mm_xor_si128(bl,tmp); -} -__attribute__((target("sse2"))) -inline block128 RIGHTSHIFT(block128 bl) { - const __m128i mask = _mm_set_epi32(0,1,0,0); - __m128i tmp = _mm_and_si128(bl,mask); - bl = _mm_slli_epi64(bl, 1); - return _mm_xor_si128(bl,tmp); -} -} -#endif//UTIL_BLOCK_H__ +__attribute__((target("sse2"))) inline block128 double_block(block128 bl) { + const __m128i mask = _mm_set_epi32(135, 1, 1, 1); + __m128i tmp = _mm_srai_epi32(bl, 31); + tmp = _mm_and_si128(tmp, mask); + tmp = _mm_shuffle_epi32(tmp, _MM_SHUFFLE(2, 1, 0, 3)); + bl = _mm_slli_epi32(bl, 1); + return _mm_xor_si128(bl, tmp); +} + +__attribute__((target("sse2"))) inline block128 LEFTSHIFT1(block128 bl) { + const __m128i mask = _mm_set_epi32(0, 0, (1 << 31), 0); + __m128i tmp = _mm_and_si128(bl, mask); + bl = _mm_slli_epi64(bl, 1); + return _mm_xor_si128(bl, tmp); +} +__attribute__((target("sse2"))) inline block128 RIGHTSHIFT(block128 bl) { + const __m128i mask = _mm_set_epi32(0, 1, 0, 0); + __m128i tmp = _mm_and_si128(bl, mask); + bl = _mm_slli_epi64(bl, 1); + return _mm_xor_si128(bl, tmp); +} +} // namespace sci +#endif // UTIL_BLOCK_H__ diff --git a/SCI/src/utils/ccrf.h b/SCI/src/utils/ccrf.h index 506dd1c1..8e18568b 100644 --- a/SCI/src/utils/ccrf.h +++ b/SCI/src/utils/ccrf.h @@ -21,39 +21,38 @@ SOFTWARE. #ifndef CCRF_H__ #define CCRF_H__ -#include "utils/prg.h" #include "utils/aes-ni.h" #include "utils/aes_opt.h" +#include "utils/prg.h" #include <stdio.h> /** @addtogroup BP @{ */ namespace sci { - inline void CCRF(block128* y, block256* k, int n) { - AESNI_KEY aes[8]; - int r = n % 8; - if(r == 0) { - for(int i = 0; i < n/8; i++) { - AES_256_ks8(k+i*8, aes); - //AESNI_set_encrypt_key(&aes[j], k[i*8 + j]); - AESNI_ecb_encrypt_blks_ks_x8(y + i*8, 8, aes); - } - } - else { - for(int i = 0; i < (n-r)/8; i++) { - AES_256_ks8(k+i*8, aes); - //AESNI_set_encrypt_key(&aes[j], k[i*8 + j]); - AESNI_ecb_encrypt_blks_ks_x8(y + i*8, 8, aes); - } - for(int i = n-r; i < n; i++) { - y[i] = one; - AESNI_set_encrypt_key(&aes[0], k[i]); - AESNI_ecb_encrypt_blks(y + i, 1, aes); - } - } - } - +inline void CCRF(block128 *y, block256 *k, int n) { + AESNI_KEY aes[8]; + int r = n % 8; + if (r == 0) { + for (int i = 0; i < n / 8; i++) { + AES_256_ks8(k + i * 8, aes); + // AESNI_set_encrypt_key(&aes[j], k[i*8 + j]); + AESNI_ecb_encrypt_blks_ks_x8(y + i * 8, 8, aes); + } + } else { + for (int i = 0; i < (n - r) / 8; i++) { + AES_256_ks8(k + i * 8, aes); + // AESNI_set_encrypt_key(&aes[j], k[i*8 + j]); + AESNI_ecb_encrypt_blks_ks_x8(y + i * 8, 8, aes); + } + for (int i = n - r; i < n; i++) { + y[i] = one; + AESNI_set_encrypt_key(&aes[0], k[i]); + AESNI_ecb_encrypt_blks(y + i, 1, aes); + } + } } + +} // namespace sci /**@}*/ -#endif// CCRF_H__ +#endif // CCRF_H__ diff --git a/SCI/src/utils/cmake/source_of_randomness.cmake b/SCI/src/utils/cmake/source_of_randomness.cmake index 346651b2..464e0588 100644 --- a/SCI/src/utils/cmake/source_of_randomness.cmake +++ b/SCI/src/utils/cmake/source_of_randomness.cmake @@ -8,6 +8,7 @@ file(WRITE ${CMAKE_SOURCE_DIR}/rdseedtest.c "#include <stdio.h>\n#include <x86in try_run(RDSEED_RUN_RESULT RDSEED_COMPILE_RESULT ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}/rdseedtest.c CMAKE_FLAGS ${CMAKE_C_FLAGS}) file(REMOVE ${CMAKE_SOURCE_DIR}/rdseedtest.c) +cmake_policy(SET CMP0012 NEW) IF(NOT ${RDSEED_COMPILE_RESULT}) set(USE_RANDOM_DEVICE ON) ELSE(NOT ${RDSEED_COMPILE_RESULT}) diff --git a/SCI/src/utils/constants.h b/SCI/src/utils/constants.h index e6afdda4..55dacd7d 100644 --- a/SCI/src/utils/constants.h +++ b/SCI/src/utils/constants.h @@ -27,278 +27,545 @@ Modified by Deevashwer Rathee #ifndef CONFIG_H__ #define CONFIG_H__ +#include <map> + namespace sci { const static int AES_BATCH_SIZE = 2048; -//const static int AES_BATCH_SIZE = 256; -const static int HASH_BUFFER_SIZE = 1024*8; -const static int NETWORK_BUFFER_SIZE = 1024*16;//Should change depending on the network -const static int FILE_BUFFER_SIZE = 1024*16; -const static int CHECK_BUFFER_SIZE = 1024*8; +// const static int AES_BATCH_SIZE = 256; +const static int HASH_BUFFER_SIZE = 1024 * 8; +const static int NETWORK_BUFFER_SIZE = + 1024 * 16; // Should change depending on the network +const static int FILE_BUFFER_SIZE = 1024 * 16; +const static int CHECK_BUFFER_SIZE = 1024 * 8; const static int ALICE = 1; const static int BOB = 2; -const static uint64_t WH_Code[256][4] = { \ - {0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000}, \ - {0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa}, \ - {0xcccccccccccccccc, 0xcccccccccccccccc, 0xcccccccccccccccc, 0xcccccccccccccccc}, \ - {0x6666666666666666, 0x6666666666666666, 0x6666666666666666, 0x6666666666666666}, \ - {0xf0f0f0f0f0f0f0f0, 0xf0f0f0f0f0f0f0f0, 0xf0f0f0f0f0f0f0f0, 0xf0f0f0f0f0f0f0f0}, \ - {0x5a5a5a5a5a5a5a5a, 0x5a5a5a5a5a5a5a5a, 0x5a5a5a5a5a5a5a5a, 0x5a5a5a5a5a5a5a5a}, \ - {0x3c3c3c3c3c3c3c3c, 0x3c3c3c3c3c3c3c3c, 0x3c3c3c3c3c3c3c3c, 0x3c3c3c3c3c3c3c3c}, \ - {0x9696969696969696, 0x9696969696969696, 0x9696969696969696, 0x9696969696969696}, \ - {0xff00ff00ff00ff00, 0xff00ff00ff00ff00, 0xff00ff00ff00ff00, 0xff00ff00ff00ff00}, \ - {0x55aa55aa55aa55aa, 0x55aa55aa55aa55aa, 0x55aa55aa55aa55aa, 0x55aa55aa55aa55aa}, \ - {0x33cc33cc33cc33cc, 0x33cc33cc33cc33cc, 0x33cc33cc33cc33cc, 0x33cc33cc33cc33cc}, \ - {0x9966996699669966, 0x9966996699669966, 0x9966996699669966, 0x9966996699669966}, \ - {0x0ff00ff00ff00ff0, 0x0ff00ff00ff00ff0, 0x0ff00ff00ff00ff0, 0x0ff00ff00ff00ff0}, \ - {0xa55aa55aa55aa55a, 0xa55aa55aa55aa55a, 0xa55aa55aa55aa55a, 0xa55aa55aa55aa55a}, \ - {0xc33cc33cc33cc33c, 0xc33cc33cc33cc33c, 0xc33cc33cc33cc33c, 0xc33cc33cc33cc33c}, \ - {0x6996699669966996, 0x6996699669966996, 0x6996699669966996, 0x6996699669966996}, \ - {0xffff0000ffff0000, 0xffff0000ffff0000, 0xffff0000ffff0000, 0xffff0000ffff0000}, \ - {0x5555aaaa5555aaaa, 0x5555aaaa5555aaaa, 0x5555aaaa5555aaaa, 0x5555aaaa5555aaaa}, \ - {0x3333cccc3333cccc, 0x3333cccc3333cccc, 0x3333cccc3333cccc, 0x3333cccc3333cccc}, \ - {0x9999666699996666, 0x9999666699996666, 0x9999666699996666, 0x9999666699996666}, \ - {0x0f0ff0f00f0ff0f0, 0x0f0ff0f00f0ff0f0, 0x0f0ff0f00f0ff0f0, 0x0f0ff0f00f0ff0f0}, \ - {0xa5a55a5aa5a55a5a, 0xa5a55a5aa5a55a5a, 0xa5a55a5aa5a55a5a, 0xa5a55a5aa5a55a5a}, \ - {0xc3c33c3cc3c33c3c, 0xc3c33c3cc3c33c3c, 0xc3c33c3cc3c33c3c, 0xc3c33c3cc3c33c3c}, \ - {0x6969969669699696, 0x6969969669699696, 0x6969969669699696, 0x6969969669699696}, \ - {0x00ffff0000ffff00, 0x00ffff0000ffff00, 0x00ffff0000ffff00, 0x00ffff0000ffff00}, \ - {0xaa5555aaaa5555aa, 0xaa5555aaaa5555aa, 0xaa5555aaaa5555aa, 0xaa5555aaaa5555aa}, \ - {0xcc3333cccc3333cc, 0xcc3333cccc3333cc, 0xcc3333cccc3333cc, 0xcc3333cccc3333cc}, \ - {0x6699996666999966, 0x6699996666999966, 0x6699996666999966, 0x6699996666999966}, \ - {0xf00f0ff0f00f0ff0, 0xf00f0ff0f00f0ff0, 0xf00f0ff0f00f0ff0, 0xf00f0ff0f00f0ff0}, \ - {0x5aa5a55a5aa5a55a, 0x5aa5a55a5aa5a55a, 0x5aa5a55a5aa5a55a, 0x5aa5a55a5aa5a55a}, \ - {0x3cc3c33c3cc3c33c, 0x3cc3c33c3cc3c33c, 0x3cc3c33c3cc3c33c, 0x3cc3c33c3cc3c33c}, \ - {0x9669699696696996, 0x9669699696696996, 0x9669699696696996, 0x9669699696696996}, \ - {0xffffffff00000000, 0xffffffff00000000, 0xffffffff00000000, 0xffffffff00000000}, \ - {0x55555555aaaaaaaa, 0x55555555aaaaaaaa, 0x55555555aaaaaaaa, 0x55555555aaaaaaaa}, \ - {0x33333333cccccccc, 0x33333333cccccccc, 0x33333333cccccccc, 0x33333333cccccccc}, \ - {0x9999999966666666, 0x9999999966666666, 0x9999999966666666, 0x9999999966666666}, \ - {0x0f0f0f0ff0f0f0f0, 0x0f0f0f0ff0f0f0f0, 0x0f0f0f0ff0f0f0f0, 0x0f0f0f0ff0f0f0f0}, \ - {0xa5a5a5a55a5a5a5a, 0xa5a5a5a55a5a5a5a, 0xa5a5a5a55a5a5a5a, 0xa5a5a5a55a5a5a5a}, \ - {0xc3c3c3c33c3c3c3c, 0xc3c3c3c33c3c3c3c, 0xc3c3c3c33c3c3c3c, 0xc3c3c3c33c3c3c3c}, \ - {0x6969696996969696, 0x6969696996969696, 0x6969696996969696, 0x6969696996969696}, \ - {0x00ff00ffff00ff00, 0x00ff00ffff00ff00, 0x00ff00ffff00ff00, 0x00ff00ffff00ff00}, \ - {0xaa55aa5555aa55aa, 0xaa55aa5555aa55aa, 0xaa55aa5555aa55aa, 0xaa55aa5555aa55aa}, \ - {0xcc33cc3333cc33cc, 0xcc33cc3333cc33cc, 0xcc33cc3333cc33cc, 0xcc33cc3333cc33cc}, \ - {0x6699669999669966, 0x6699669999669966, 0x6699669999669966, 0x6699669999669966}, \ - {0xf00ff00f0ff00ff0, 0xf00ff00f0ff00ff0, 0xf00ff00f0ff00ff0, 0xf00ff00f0ff00ff0}, \ - {0x5aa55aa5a55aa55a, 0x5aa55aa5a55aa55a, 0x5aa55aa5a55aa55a, 0x5aa55aa5a55aa55a}, \ - {0x3cc33cc3c33cc33c, 0x3cc33cc3c33cc33c, 0x3cc33cc3c33cc33c, 0x3cc33cc3c33cc33c}, \ - {0x9669966969966996, 0x9669966969966996, 0x9669966969966996, 0x9669966969966996}, \ - {0x0000ffffffff0000, 0x0000ffffffff0000, 0x0000ffffffff0000, 0x0000ffffffff0000}, \ - {0xaaaa55555555aaaa, 0xaaaa55555555aaaa, 0xaaaa55555555aaaa, 0xaaaa55555555aaaa}, \ - {0xcccc33333333cccc, 0xcccc33333333cccc, 0xcccc33333333cccc, 0xcccc33333333cccc}, \ - {0x6666999999996666, 0x6666999999996666, 0x6666999999996666, 0x6666999999996666}, \ - {0xf0f00f0f0f0ff0f0, 0xf0f00f0f0f0ff0f0, 0xf0f00f0f0f0ff0f0, 0xf0f00f0f0f0ff0f0}, \ - {0x5a5aa5a5a5a55a5a, 0x5a5aa5a5a5a55a5a, 0x5a5aa5a5a5a55a5a, 0x5a5aa5a5a5a55a5a}, \ - {0x3c3cc3c3c3c33c3c, 0x3c3cc3c3c3c33c3c, 0x3c3cc3c3c3c33c3c, 0x3c3cc3c3c3c33c3c}, \ - {0x9696696969699696, 0x9696696969699696, 0x9696696969699696, 0x9696696969699696}, \ - {0xff0000ff00ffff00, 0xff0000ff00ffff00, 0xff0000ff00ffff00, 0xff0000ff00ffff00}, \ - {0x55aaaa55aa5555aa, 0x55aaaa55aa5555aa, 0x55aaaa55aa5555aa, 0x55aaaa55aa5555aa}, \ - {0x33cccc33cc3333cc, 0x33cccc33cc3333cc, 0x33cccc33cc3333cc, 0x33cccc33cc3333cc}, \ - {0x9966669966999966, 0x9966669966999966, 0x9966669966999966, 0x9966669966999966}, \ - {0x0ff0f00ff00f0ff0, 0x0ff0f00ff00f0ff0, 0x0ff0f00ff00f0ff0, 0x0ff0f00ff00f0ff0}, \ - {0xa55a5aa55aa5a55a, 0xa55a5aa55aa5a55a, 0xa55a5aa55aa5a55a, 0xa55a5aa55aa5a55a}, \ - {0xc33c3cc33cc3c33c, 0xc33c3cc33cc3c33c, 0xc33c3cc33cc3c33c, 0xc33c3cc33cc3c33c}, \ - {0x6996966996696996, 0x6996966996696996, 0x6996966996696996, 0x6996966996696996}, \ - {0xffffffffffffffff, 0x0000000000000000, 0xffffffffffffffff, 0x0000000000000000}, \ - {0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x5555555555555555, 0xaaaaaaaaaaaaaaaa}, \ - {0x3333333333333333, 0xcccccccccccccccc, 0x3333333333333333, 0xcccccccccccccccc}, \ - {0x9999999999999999, 0x6666666666666666, 0x9999999999999999, 0x6666666666666666}, \ - {0x0f0f0f0f0f0f0f0f, 0xf0f0f0f0f0f0f0f0, 0x0f0f0f0f0f0f0f0f, 0xf0f0f0f0f0f0f0f0}, \ - {0xa5a5a5a5a5a5a5a5, 0x5a5a5a5a5a5a5a5a, 0xa5a5a5a5a5a5a5a5, 0x5a5a5a5a5a5a5a5a}, \ - {0xc3c3c3c3c3c3c3c3, 0x3c3c3c3c3c3c3c3c, 0xc3c3c3c3c3c3c3c3, 0x3c3c3c3c3c3c3c3c}, \ - {0x6969696969696969, 0x9696969696969696, 0x6969696969696969, 0x9696969696969696}, \ - {0x00ff00ff00ff00ff, 0xff00ff00ff00ff00, 0x00ff00ff00ff00ff, 0xff00ff00ff00ff00}, \ - {0xaa55aa55aa55aa55, 0x55aa55aa55aa55aa, 0xaa55aa55aa55aa55, 0x55aa55aa55aa55aa}, \ - {0xcc33cc33cc33cc33, 0x33cc33cc33cc33cc, 0xcc33cc33cc33cc33, 0x33cc33cc33cc33cc}, \ - {0x6699669966996699, 0x9966996699669966, 0x6699669966996699, 0x9966996699669966}, \ - {0xf00ff00ff00ff00f, 0x0ff00ff00ff00ff0, 0xf00ff00ff00ff00f, 0x0ff00ff00ff00ff0}, \ - {0x5aa55aa55aa55aa5, 0xa55aa55aa55aa55a, 0x5aa55aa55aa55aa5, 0xa55aa55aa55aa55a}, \ - {0x3cc33cc33cc33cc3, 0xc33cc33cc33cc33c, 0x3cc33cc33cc33cc3, 0xc33cc33cc33cc33c}, \ - {0x9669966996699669, 0x6996699669966996, 0x9669966996699669, 0x6996699669966996}, \ - {0x0000ffff0000ffff, 0xffff0000ffff0000, 0x0000ffff0000ffff, 0xffff0000ffff0000}, \ - {0xaaaa5555aaaa5555, 0x5555aaaa5555aaaa, 0xaaaa5555aaaa5555, 0x5555aaaa5555aaaa}, \ - {0xcccc3333cccc3333, 0x3333cccc3333cccc, 0xcccc3333cccc3333, 0x3333cccc3333cccc}, \ - {0x6666999966669999, 0x9999666699996666, 0x6666999966669999, 0x9999666699996666}, \ - {0xf0f00f0ff0f00f0f, 0x0f0ff0f00f0ff0f0, 0xf0f00f0ff0f00f0f, 0x0f0ff0f00f0ff0f0}, \ - {0x5a5aa5a55a5aa5a5, 0xa5a55a5aa5a55a5a, 0x5a5aa5a55a5aa5a5, 0xa5a55a5aa5a55a5a}, \ - {0x3c3cc3c33c3cc3c3, 0xc3c33c3cc3c33c3c, 0x3c3cc3c33c3cc3c3, 0xc3c33c3cc3c33c3c}, \ - {0x9696696996966969, 0x6969969669699696, 0x9696696996966969, 0x6969969669699696}, \ - {0xff0000ffff0000ff, 0x00ffff0000ffff00, 0xff0000ffff0000ff, 0x00ffff0000ffff00}, \ - {0x55aaaa5555aaaa55, 0xaa5555aaaa5555aa, 0x55aaaa5555aaaa55, 0xaa5555aaaa5555aa}, \ - {0x33cccc3333cccc33, 0xcc3333cccc3333cc, 0x33cccc3333cccc33, 0xcc3333cccc3333cc}, \ - {0x9966669999666699, 0x6699996666999966, 0x9966669999666699, 0x6699996666999966}, \ - {0x0ff0f00f0ff0f00f, 0xf00f0ff0f00f0ff0, 0x0ff0f00f0ff0f00f, 0xf00f0ff0f00f0ff0}, \ - {0xa55a5aa5a55a5aa5, 0x5aa5a55a5aa5a55a, 0xa55a5aa5a55a5aa5, 0x5aa5a55a5aa5a55a}, \ - {0xc33c3cc3c33c3cc3, 0x3cc3c33c3cc3c33c, 0xc33c3cc3c33c3cc3, 0x3cc3c33c3cc3c33c}, \ - {0x6996966969969669, 0x9669699696696996, 0x6996966969969669, 0x9669699696696996}, \ - {0x00000000ffffffff, 0xffffffff00000000, 0x00000000ffffffff, 0xffffffff00000000}, \ - {0xaaaaaaaa55555555, 0x55555555aaaaaaaa, 0xaaaaaaaa55555555, 0x55555555aaaaaaaa}, \ - {0xcccccccc33333333, 0x33333333cccccccc, 0xcccccccc33333333, 0x33333333cccccccc}, \ - {0x6666666699999999, 0x9999999966666666, 0x6666666699999999, 0x9999999966666666}, \ - {0xf0f0f0f00f0f0f0f, 0x0f0f0f0ff0f0f0f0, 0xf0f0f0f00f0f0f0f, 0x0f0f0f0ff0f0f0f0}, \ - {0x5a5a5a5aa5a5a5a5, 0xa5a5a5a55a5a5a5a, 0x5a5a5a5aa5a5a5a5, 0xa5a5a5a55a5a5a5a}, \ - {0x3c3c3c3cc3c3c3c3, 0xc3c3c3c33c3c3c3c, 0x3c3c3c3cc3c3c3c3, 0xc3c3c3c33c3c3c3c}, \ - {0x9696969669696969, 0x6969696996969696, 0x9696969669696969, 0x6969696996969696}, \ - {0xff00ff0000ff00ff, 0x00ff00ffff00ff00, 0xff00ff0000ff00ff, 0x00ff00ffff00ff00}, \ - {0x55aa55aaaa55aa55, 0xaa55aa5555aa55aa, 0x55aa55aaaa55aa55, 0xaa55aa5555aa55aa}, \ - {0x33cc33cccc33cc33, 0xcc33cc3333cc33cc, 0x33cc33cccc33cc33, 0xcc33cc3333cc33cc}, \ - {0x9966996666996699, 0x6699669999669966, 0x9966996666996699, 0x6699669999669966}, \ - {0x0ff00ff0f00ff00f, 0xf00ff00f0ff00ff0, 0x0ff00ff0f00ff00f, 0xf00ff00f0ff00ff0}, \ - {0xa55aa55a5aa55aa5, 0x5aa55aa5a55aa55a, 0xa55aa55a5aa55aa5, 0x5aa55aa5a55aa55a}, \ - {0xc33cc33c3cc33cc3, 0x3cc33cc3c33cc33c, 0xc33cc33c3cc33cc3, 0x3cc33cc3c33cc33c}, \ - {0x6996699696699669, 0x9669966969966996, 0x6996699696699669, 0x9669966969966996}, \ - {0xffff00000000ffff, 0x0000ffffffff0000, 0xffff00000000ffff, 0x0000ffffffff0000}, \ - {0x5555aaaaaaaa5555, 0xaaaa55555555aaaa, 0x5555aaaaaaaa5555, 0xaaaa55555555aaaa}, \ - {0x3333cccccccc3333, 0xcccc33333333cccc, 0x3333cccccccc3333, 0xcccc33333333cccc}, \ - {0x9999666666669999, 0x6666999999996666, 0x9999666666669999, 0x6666999999996666}, \ - {0x0f0ff0f0f0f00f0f, 0xf0f00f0f0f0ff0f0, 0x0f0ff0f0f0f00f0f, 0xf0f00f0f0f0ff0f0}, \ - {0xa5a55a5a5a5aa5a5, 0x5a5aa5a5a5a55a5a, 0xa5a55a5a5a5aa5a5, 0x5a5aa5a5a5a55a5a}, \ - {0xc3c33c3c3c3cc3c3, 0x3c3cc3c3c3c33c3c, 0xc3c33c3c3c3cc3c3, 0x3c3cc3c3c3c33c3c}, \ - {0x6969969696966969, 0x9696696969699696, 0x6969969696966969, 0x9696696969699696}, \ - {0x00ffff00ff0000ff, 0xff0000ff00ffff00, 0x00ffff00ff0000ff, 0xff0000ff00ffff00}, \ - {0xaa5555aa55aaaa55, 0x55aaaa55aa5555aa, 0xaa5555aa55aaaa55, 0x55aaaa55aa5555aa}, \ - {0xcc3333cc33cccc33, 0x33cccc33cc3333cc, 0xcc3333cc33cccc33, 0x33cccc33cc3333cc}, \ - {0x6699996699666699, 0x9966669966999966, 0x6699996699666699, 0x9966669966999966}, \ - {0xf00f0ff00ff0f00f, 0x0ff0f00ff00f0ff0, 0xf00f0ff00ff0f00f, 0x0ff0f00ff00f0ff0}, \ - {0x5aa5a55aa55a5aa5, 0xa55a5aa55aa5a55a, 0x5aa5a55aa55a5aa5, 0xa55a5aa55aa5a55a}, \ - {0x3cc3c33cc33c3cc3, 0xc33c3cc33cc3c33c, 0x3cc3c33cc33c3cc3, 0xc33c3cc33cc3c33c}, \ - {0x9669699669969669, 0x6996966996696996, 0x9669699669969669, 0x6996966996696996}, \ - {0xffffffffffffffff, 0xffffffffffffffff, 0x0000000000000000, 0x0000000000000000}, \ - {0x5555555555555555, 0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa}, \ - {0x3333333333333333, 0x3333333333333333, 0xcccccccccccccccc, 0xcccccccccccccccc}, \ - {0x9999999999999999, 0x9999999999999999, 0x6666666666666666, 0x6666666666666666}, \ - {0x0f0f0f0f0f0f0f0f, 0x0f0f0f0f0f0f0f0f, 0xf0f0f0f0f0f0f0f0, 0xf0f0f0f0f0f0f0f0}, \ - {0xa5a5a5a5a5a5a5a5, 0xa5a5a5a5a5a5a5a5, 0x5a5a5a5a5a5a5a5a, 0x5a5a5a5a5a5a5a5a}, \ - {0xc3c3c3c3c3c3c3c3, 0xc3c3c3c3c3c3c3c3, 0x3c3c3c3c3c3c3c3c, 0x3c3c3c3c3c3c3c3c}, \ - {0x6969696969696969, 0x6969696969696969, 0x9696969696969696, 0x9696969696969696}, \ - {0x00ff00ff00ff00ff, 0x00ff00ff00ff00ff, 0xff00ff00ff00ff00, 0xff00ff00ff00ff00}, \ - {0xaa55aa55aa55aa55, 0xaa55aa55aa55aa55, 0x55aa55aa55aa55aa, 0x55aa55aa55aa55aa}, \ - {0xcc33cc33cc33cc33, 0xcc33cc33cc33cc33, 0x33cc33cc33cc33cc, 0x33cc33cc33cc33cc}, \ - {0x6699669966996699, 0x6699669966996699, 0x9966996699669966, 0x9966996699669966}, \ - {0xf00ff00ff00ff00f, 0xf00ff00ff00ff00f, 0x0ff00ff00ff00ff0, 0x0ff00ff00ff00ff0}, \ - {0x5aa55aa55aa55aa5, 0x5aa55aa55aa55aa5, 0xa55aa55aa55aa55a, 0xa55aa55aa55aa55a}, \ - {0x3cc33cc33cc33cc3, 0x3cc33cc33cc33cc3, 0xc33cc33cc33cc33c, 0xc33cc33cc33cc33c}, \ - {0x9669966996699669, 0x9669966996699669, 0x6996699669966996, 0x6996699669966996}, \ - {0x0000ffff0000ffff, 0x0000ffff0000ffff, 0xffff0000ffff0000, 0xffff0000ffff0000}, \ - {0xaaaa5555aaaa5555, 0xaaaa5555aaaa5555, 0x5555aaaa5555aaaa, 0x5555aaaa5555aaaa}, \ - {0xcccc3333cccc3333, 0xcccc3333cccc3333, 0x3333cccc3333cccc, 0x3333cccc3333cccc}, \ - {0x6666999966669999, 0x6666999966669999, 0x9999666699996666, 0x9999666699996666}, \ - {0xf0f00f0ff0f00f0f, 0xf0f00f0ff0f00f0f, 0x0f0ff0f00f0ff0f0, 0x0f0ff0f00f0ff0f0}, \ - {0x5a5aa5a55a5aa5a5, 0x5a5aa5a55a5aa5a5, 0xa5a55a5aa5a55a5a, 0xa5a55a5aa5a55a5a}, \ - {0x3c3cc3c33c3cc3c3, 0x3c3cc3c33c3cc3c3, 0xc3c33c3cc3c33c3c, 0xc3c33c3cc3c33c3c}, \ - {0x9696696996966969, 0x9696696996966969, 0x6969969669699696, 0x6969969669699696}, \ - {0xff0000ffff0000ff, 0xff0000ffff0000ff, 0x00ffff0000ffff00, 0x00ffff0000ffff00}, \ - {0x55aaaa5555aaaa55, 0x55aaaa5555aaaa55, 0xaa5555aaaa5555aa, 0xaa5555aaaa5555aa}, \ - {0x33cccc3333cccc33, 0x33cccc3333cccc33, 0xcc3333cccc3333cc, 0xcc3333cccc3333cc}, \ - {0x9966669999666699, 0x9966669999666699, 0x6699996666999966, 0x6699996666999966}, \ - {0x0ff0f00f0ff0f00f, 0x0ff0f00f0ff0f00f, 0xf00f0ff0f00f0ff0, 0xf00f0ff0f00f0ff0}, \ - {0xa55a5aa5a55a5aa5, 0xa55a5aa5a55a5aa5, 0x5aa5a55a5aa5a55a, 0x5aa5a55a5aa5a55a}, \ - {0xc33c3cc3c33c3cc3, 0xc33c3cc3c33c3cc3, 0x3cc3c33c3cc3c33c, 0x3cc3c33c3cc3c33c}, \ - {0x6996966969969669, 0x6996966969969669, 0x9669699696696996, 0x9669699696696996}, \ - {0x00000000ffffffff, 0x00000000ffffffff, 0xffffffff00000000, 0xffffffff00000000}, \ - {0xaaaaaaaa55555555, 0xaaaaaaaa55555555, 0x55555555aaaaaaaa, 0x55555555aaaaaaaa}, \ - {0xcccccccc33333333, 0xcccccccc33333333, 0x33333333cccccccc, 0x33333333cccccccc}, \ - {0x6666666699999999, 0x6666666699999999, 0x9999999966666666, 0x9999999966666666}, \ - {0xf0f0f0f00f0f0f0f, 0xf0f0f0f00f0f0f0f, 0x0f0f0f0ff0f0f0f0, 0x0f0f0f0ff0f0f0f0}, \ - {0x5a5a5a5aa5a5a5a5, 0x5a5a5a5aa5a5a5a5, 0xa5a5a5a55a5a5a5a, 0xa5a5a5a55a5a5a5a}, \ - {0x3c3c3c3cc3c3c3c3, 0x3c3c3c3cc3c3c3c3, 0xc3c3c3c33c3c3c3c, 0xc3c3c3c33c3c3c3c}, \ - {0x9696969669696969, 0x9696969669696969, 0x6969696996969696, 0x6969696996969696}, \ - {0xff00ff0000ff00ff, 0xff00ff0000ff00ff, 0x00ff00ffff00ff00, 0x00ff00ffff00ff00}, \ - {0x55aa55aaaa55aa55, 0x55aa55aaaa55aa55, 0xaa55aa5555aa55aa, 0xaa55aa5555aa55aa}, \ - {0x33cc33cccc33cc33, 0x33cc33cccc33cc33, 0xcc33cc3333cc33cc, 0xcc33cc3333cc33cc}, \ - {0x9966996666996699, 0x9966996666996699, 0x6699669999669966, 0x6699669999669966}, \ - {0x0ff00ff0f00ff00f, 0x0ff00ff0f00ff00f, 0xf00ff00f0ff00ff0, 0xf00ff00f0ff00ff0}, \ - {0xa55aa55a5aa55aa5, 0xa55aa55a5aa55aa5, 0x5aa55aa5a55aa55a, 0x5aa55aa5a55aa55a}, \ - {0xc33cc33c3cc33cc3, 0xc33cc33c3cc33cc3, 0x3cc33cc3c33cc33c, 0x3cc33cc3c33cc33c}, \ - {0x6996699696699669, 0x6996699696699669, 0x9669966969966996, 0x9669966969966996}, \ - {0xffff00000000ffff, 0xffff00000000ffff, 0x0000ffffffff0000, 0x0000ffffffff0000}, \ - {0x5555aaaaaaaa5555, 0x5555aaaaaaaa5555, 0xaaaa55555555aaaa, 0xaaaa55555555aaaa}, \ - {0x3333cccccccc3333, 0x3333cccccccc3333, 0xcccc33333333cccc, 0xcccc33333333cccc}, \ - {0x9999666666669999, 0x9999666666669999, 0x6666999999996666, 0x6666999999996666}, \ - {0x0f0ff0f0f0f00f0f, 0x0f0ff0f0f0f00f0f, 0xf0f00f0f0f0ff0f0, 0xf0f00f0f0f0ff0f0}, \ - {0xa5a55a5a5a5aa5a5, 0xa5a55a5a5a5aa5a5, 0x5a5aa5a5a5a55a5a, 0x5a5aa5a5a5a55a5a}, \ - {0xc3c33c3c3c3cc3c3, 0xc3c33c3c3c3cc3c3, 0x3c3cc3c3c3c33c3c, 0x3c3cc3c3c3c33c3c}, \ - {0x6969969696966969, 0x6969969696966969, 0x9696696969699696, 0x9696696969699696}, \ - {0x00ffff00ff0000ff, 0x00ffff00ff0000ff, 0xff0000ff00ffff00, 0xff0000ff00ffff00}, \ - {0xaa5555aa55aaaa55, 0xaa5555aa55aaaa55, 0x55aaaa55aa5555aa, 0x55aaaa55aa5555aa}, \ - {0xcc3333cc33cccc33, 0xcc3333cc33cccc33, 0x33cccc33cc3333cc, 0x33cccc33cc3333cc}, \ - {0x6699996699666699, 0x6699996699666699, 0x9966669966999966, 0x9966669966999966}, \ - {0xf00f0ff00ff0f00f, 0xf00f0ff00ff0f00f, 0x0ff0f00ff00f0ff0, 0x0ff0f00ff00f0ff0}, \ - {0x5aa5a55aa55a5aa5, 0x5aa5a55aa55a5aa5, 0xa55a5aa55aa5a55a, 0xa55a5aa55aa5a55a}, \ - {0x3cc3c33cc33c3cc3, 0x3cc3c33cc33c3cc3, 0xc33c3cc33cc3c33c, 0xc33c3cc33cc3c33c}, \ - {0x9669699669969669, 0x9669699669969669, 0x6996966996696996, 0x6996966996696996}, \ - {0x0000000000000000, 0xffffffffffffffff, 0xffffffffffffffff, 0x0000000000000000}, \ - {0xaaaaaaaaaaaaaaaa, 0x5555555555555555, 0x5555555555555555, 0xaaaaaaaaaaaaaaaa}, \ - {0xcccccccccccccccc, 0x3333333333333333, 0x3333333333333333, 0xcccccccccccccccc}, \ - {0x6666666666666666, 0x9999999999999999, 0x9999999999999999, 0x6666666666666666}, \ - {0xf0f0f0f0f0f0f0f0, 0x0f0f0f0f0f0f0f0f, 0x0f0f0f0f0f0f0f0f, 0xf0f0f0f0f0f0f0f0}, \ - {0x5a5a5a5a5a5a5a5a, 0xa5a5a5a5a5a5a5a5, 0xa5a5a5a5a5a5a5a5, 0x5a5a5a5a5a5a5a5a}, \ - {0x3c3c3c3c3c3c3c3c, 0xc3c3c3c3c3c3c3c3, 0xc3c3c3c3c3c3c3c3, 0x3c3c3c3c3c3c3c3c}, \ - {0x9696969696969696, 0x6969696969696969, 0x6969696969696969, 0x9696969696969696}, \ - {0xff00ff00ff00ff00, 0x00ff00ff00ff00ff, 0x00ff00ff00ff00ff, 0xff00ff00ff00ff00}, \ - {0x55aa55aa55aa55aa, 0xaa55aa55aa55aa55, 0xaa55aa55aa55aa55, 0x55aa55aa55aa55aa}, \ - {0x33cc33cc33cc33cc, 0xcc33cc33cc33cc33, 0xcc33cc33cc33cc33, 0x33cc33cc33cc33cc}, \ - {0x9966996699669966, 0x6699669966996699, 0x6699669966996699, 0x9966996699669966}, \ - {0x0ff00ff00ff00ff0, 0xf00ff00ff00ff00f, 0xf00ff00ff00ff00f, 0x0ff00ff00ff00ff0}, \ - {0xa55aa55aa55aa55a, 0x5aa55aa55aa55aa5, 0x5aa55aa55aa55aa5, 0xa55aa55aa55aa55a}, \ - {0xc33cc33cc33cc33c, 0x3cc33cc33cc33cc3, 0x3cc33cc33cc33cc3, 0xc33cc33cc33cc33c}, \ - {0x6996699669966996, 0x9669966996699669, 0x9669966996699669, 0x6996699669966996}, \ - {0xffff0000ffff0000, 0x0000ffff0000ffff, 0x0000ffff0000ffff, 0xffff0000ffff0000}, \ - {0x5555aaaa5555aaaa, 0xaaaa5555aaaa5555, 0xaaaa5555aaaa5555, 0x5555aaaa5555aaaa}, \ - {0x3333cccc3333cccc, 0xcccc3333cccc3333, 0xcccc3333cccc3333, 0x3333cccc3333cccc}, \ - {0x9999666699996666, 0x6666999966669999, 0x6666999966669999, 0x9999666699996666}, \ - {0x0f0ff0f00f0ff0f0, 0xf0f00f0ff0f00f0f, 0xf0f00f0ff0f00f0f, 0x0f0ff0f00f0ff0f0}, \ - {0xa5a55a5aa5a55a5a, 0x5a5aa5a55a5aa5a5, 0x5a5aa5a55a5aa5a5, 0xa5a55a5aa5a55a5a}, \ - {0xc3c33c3cc3c33c3c, 0x3c3cc3c33c3cc3c3, 0x3c3cc3c33c3cc3c3, 0xc3c33c3cc3c33c3c}, \ - {0x6969969669699696, 0x9696696996966969, 0x9696696996966969, 0x6969969669699696}, \ - {0x00ffff0000ffff00, 0xff0000ffff0000ff, 0xff0000ffff0000ff, 0x00ffff0000ffff00}, \ - {0xaa5555aaaa5555aa, 0x55aaaa5555aaaa55, 0x55aaaa5555aaaa55, 0xaa5555aaaa5555aa}, \ - {0xcc3333cccc3333cc, 0x33cccc3333cccc33, 0x33cccc3333cccc33, 0xcc3333cccc3333cc}, \ - {0x6699996666999966, 0x9966669999666699, 0x9966669999666699, 0x6699996666999966}, \ - {0xf00f0ff0f00f0ff0, 0x0ff0f00f0ff0f00f, 0x0ff0f00f0ff0f00f, 0xf00f0ff0f00f0ff0}, \ - {0x5aa5a55a5aa5a55a, 0xa55a5aa5a55a5aa5, 0xa55a5aa5a55a5aa5, 0x5aa5a55a5aa5a55a}, \ - {0x3cc3c33c3cc3c33c, 0xc33c3cc3c33c3cc3, 0xc33c3cc3c33c3cc3, 0x3cc3c33c3cc3c33c}, \ - {0x9669699696696996, 0x6996966969969669, 0x6996966969969669, 0x9669699696696996}, \ - {0xffffffff00000000, 0x00000000ffffffff, 0x00000000ffffffff, 0xffffffff00000000}, \ - {0x55555555aaaaaaaa, 0xaaaaaaaa55555555, 0xaaaaaaaa55555555, 0x55555555aaaaaaaa}, \ - {0x33333333cccccccc, 0xcccccccc33333333, 0xcccccccc33333333, 0x33333333cccccccc}, \ - {0x9999999966666666, 0x6666666699999999, 0x6666666699999999, 0x9999999966666666}, \ - {0x0f0f0f0ff0f0f0f0, 0xf0f0f0f00f0f0f0f, 0xf0f0f0f00f0f0f0f, 0x0f0f0f0ff0f0f0f0}, \ - {0xa5a5a5a55a5a5a5a, 0x5a5a5a5aa5a5a5a5, 0x5a5a5a5aa5a5a5a5, 0xa5a5a5a55a5a5a5a}, \ - {0xc3c3c3c33c3c3c3c, 0x3c3c3c3cc3c3c3c3, 0x3c3c3c3cc3c3c3c3, 0xc3c3c3c33c3c3c3c}, \ - {0x6969696996969696, 0x9696969669696969, 0x9696969669696969, 0x6969696996969696}, \ - {0x00ff00ffff00ff00, 0xff00ff0000ff00ff, 0xff00ff0000ff00ff, 0x00ff00ffff00ff00}, \ - {0xaa55aa5555aa55aa, 0x55aa55aaaa55aa55, 0x55aa55aaaa55aa55, 0xaa55aa5555aa55aa}, \ - {0xcc33cc3333cc33cc, 0x33cc33cccc33cc33, 0x33cc33cccc33cc33, 0xcc33cc3333cc33cc}, \ - {0x6699669999669966, 0x9966996666996699, 0x9966996666996699, 0x6699669999669966}, \ - {0xf00ff00f0ff00ff0, 0x0ff00ff0f00ff00f, 0x0ff00ff0f00ff00f, 0xf00ff00f0ff00ff0}, \ - {0x5aa55aa5a55aa55a, 0xa55aa55a5aa55aa5, 0xa55aa55a5aa55aa5, 0x5aa55aa5a55aa55a}, \ - {0x3cc33cc3c33cc33c, 0xc33cc33c3cc33cc3, 0xc33cc33c3cc33cc3, 0x3cc33cc3c33cc33c}, \ - {0x9669966969966996, 0x6996699696699669, 0x6996699696699669, 0x9669966969966996}, \ - {0x0000ffffffff0000, 0xffff00000000ffff, 0xffff00000000ffff, 0x0000ffffffff0000}, \ - {0xaaaa55555555aaaa, 0x5555aaaaaaaa5555, 0x5555aaaaaaaa5555, 0xaaaa55555555aaaa}, \ - {0xcccc33333333cccc, 0x3333cccccccc3333, 0x3333cccccccc3333, 0xcccc33333333cccc}, \ - {0x6666999999996666, 0x9999666666669999, 0x9999666666669999, 0x6666999999996666}, \ - {0xf0f00f0f0f0ff0f0, 0x0f0ff0f0f0f00f0f, 0x0f0ff0f0f0f00f0f, 0xf0f00f0f0f0ff0f0}, \ - {0x5a5aa5a5a5a55a5a, 0xa5a55a5a5a5aa5a5, 0xa5a55a5a5a5aa5a5, 0x5a5aa5a5a5a55a5a}, \ - {0x3c3cc3c3c3c33c3c, 0xc3c33c3c3c3cc3c3, 0xc3c33c3c3c3cc3c3, 0x3c3cc3c3c3c33c3c}, \ - {0x9696696969699696, 0x6969969696966969, 0x6969969696966969, 0x9696696969699696}, \ - {0xff0000ff00ffff00, 0x00ffff00ff0000ff, 0x00ffff00ff0000ff, 0xff0000ff00ffff00}, \ - {0x55aaaa55aa5555aa, 0xaa5555aa55aaaa55, 0xaa5555aa55aaaa55, 0x55aaaa55aa5555aa}, \ - {0x33cccc33cc3333cc, 0xcc3333cc33cccc33, 0xcc3333cc33cccc33, 0x33cccc33cc3333cc}, \ - {0x9966669966999966, 0x6699996699666699, 0x6699996699666699, 0x9966669966999966}, \ - {0x0ff0f00ff00f0ff0, 0xf00f0ff00ff0f00f, 0xf00f0ff00ff0f00f, 0x0ff0f00ff00f0ff0}, \ - {0xa55a5aa55aa5a55a, 0x5aa5a55aa55a5aa5, 0x5aa5a55aa55a5aa5, 0xa55a5aa55aa5a55a}, \ - {0xc33c3cc33cc3c33c, 0x3cc3c33cc33c3cc3, 0x3cc3c33cc33c3cc3, 0xc33c3cc33cc3c33c}, \ - {0x6996966996696996, 0x9669699669969669, 0x9669699669969669, 0x6996966996696996} +#ifdef SCI_HE +const std::map<int32_t, uint64_t> default_prime_mod{ + {32, 4293918721}, {33, 8589475841}, {34, 17179672577}, + {35, 34359410689}, {36, 68718428161}, {37, 137438822401}, + {38, 274876334081}, {39, 549755486209}, {40, 1099510054913}, + {41, 2199023190017}, }; +#endif + +const static uint64_t WH_Code[256][4] = { + {0x0000000000000000, 0x0000000000000000, 0x0000000000000000, + 0x0000000000000000}, + {0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa, + 0xaaaaaaaaaaaaaaaa}, + {0xcccccccccccccccc, 0xcccccccccccccccc, 0xcccccccccccccccc, + 0xcccccccccccccccc}, + {0x6666666666666666, 0x6666666666666666, 0x6666666666666666, + 0x6666666666666666}, + {0xf0f0f0f0f0f0f0f0, 0xf0f0f0f0f0f0f0f0, 0xf0f0f0f0f0f0f0f0, + 0xf0f0f0f0f0f0f0f0}, + {0x5a5a5a5a5a5a5a5a, 0x5a5a5a5a5a5a5a5a, 0x5a5a5a5a5a5a5a5a, + 0x5a5a5a5a5a5a5a5a}, + {0x3c3c3c3c3c3c3c3c, 0x3c3c3c3c3c3c3c3c, 0x3c3c3c3c3c3c3c3c, + 0x3c3c3c3c3c3c3c3c}, + {0x9696969696969696, 0x9696969696969696, 0x9696969696969696, + 0x9696969696969696}, + {0xff00ff00ff00ff00, 0xff00ff00ff00ff00, 0xff00ff00ff00ff00, + 0xff00ff00ff00ff00}, + {0x55aa55aa55aa55aa, 0x55aa55aa55aa55aa, 0x55aa55aa55aa55aa, + 0x55aa55aa55aa55aa}, + {0x33cc33cc33cc33cc, 0x33cc33cc33cc33cc, 0x33cc33cc33cc33cc, + 0x33cc33cc33cc33cc}, + {0x9966996699669966, 0x9966996699669966, 0x9966996699669966, + 0x9966996699669966}, + {0x0ff00ff00ff00ff0, 0x0ff00ff00ff00ff0, 0x0ff00ff00ff00ff0, + 0x0ff00ff00ff00ff0}, + {0xa55aa55aa55aa55a, 0xa55aa55aa55aa55a, 0xa55aa55aa55aa55a, + 0xa55aa55aa55aa55a}, + {0xc33cc33cc33cc33c, 0xc33cc33cc33cc33c, 0xc33cc33cc33cc33c, + 0xc33cc33cc33cc33c}, + {0x6996699669966996, 0x6996699669966996, 0x6996699669966996, + 0x6996699669966996}, + {0xffff0000ffff0000, 0xffff0000ffff0000, 0xffff0000ffff0000, + 0xffff0000ffff0000}, + {0x5555aaaa5555aaaa, 0x5555aaaa5555aaaa, 0x5555aaaa5555aaaa, + 0x5555aaaa5555aaaa}, + {0x3333cccc3333cccc, 0x3333cccc3333cccc, 0x3333cccc3333cccc, + 0x3333cccc3333cccc}, + {0x9999666699996666, 0x9999666699996666, 0x9999666699996666, + 0x9999666699996666}, + {0x0f0ff0f00f0ff0f0, 0x0f0ff0f00f0ff0f0, 0x0f0ff0f00f0ff0f0, + 0x0f0ff0f00f0ff0f0}, + {0xa5a55a5aa5a55a5a, 0xa5a55a5aa5a55a5a, 0xa5a55a5aa5a55a5a, + 0xa5a55a5aa5a55a5a}, + {0xc3c33c3cc3c33c3c, 0xc3c33c3cc3c33c3c, 0xc3c33c3cc3c33c3c, + 0xc3c33c3cc3c33c3c}, + {0x6969969669699696, 0x6969969669699696, 0x6969969669699696, + 0x6969969669699696}, + {0x00ffff0000ffff00, 0x00ffff0000ffff00, 0x00ffff0000ffff00, + 0x00ffff0000ffff00}, + {0xaa5555aaaa5555aa, 0xaa5555aaaa5555aa, 0xaa5555aaaa5555aa, + 0xaa5555aaaa5555aa}, + {0xcc3333cccc3333cc, 0xcc3333cccc3333cc, 0xcc3333cccc3333cc, + 0xcc3333cccc3333cc}, + {0x6699996666999966, 0x6699996666999966, 0x6699996666999966, + 0x6699996666999966}, + {0xf00f0ff0f00f0ff0, 0xf00f0ff0f00f0ff0, 0xf00f0ff0f00f0ff0, + 0xf00f0ff0f00f0ff0}, + {0x5aa5a55a5aa5a55a, 0x5aa5a55a5aa5a55a, 0x5aa5a55a5aa5a55a, + 0x5aa5a55a5aa5a55a}, + {0x3cc3c33c3cc3c33c, 0x3cc3c33c3cc3c33c, 0x3cc3c33c3cc3c33c, + 0x3cc3c33c3cc3c33c}, + {0x9669699696696996, 0x9669699696696996, 0x9669699696696996, + 0x9669699696696996}, + {0xffffffff00000000, 0xffffffff00000000, 0xffffffff00000000, + 0xffffffff00000000}, + {0x55555555aaaaaaaa, 0x55555555aaaaaaaa, 0x55555555aaaaaaaa, + 0x55555555aaaaaaaa}, + {0x33333333cccccccc, 0x33333333cccccccc, 0x33333333cccccccc, + 0x33333333cccccccc}, + {0x9999999966666666, 0x9999999966666666, 0x9999999966666666, + 0x9999999966666666}, + {0x0f0f0f0ff0f0f0f0, 0x0f0f0f0ff0f0f0f0, 0x0f0f0f0ff0f0f0f0, + 0x0f0f0f0ff0f0f0f0}, + {0xa5a5a5a55a5a5a5a, 0xa5a5a5a55a5a5a5a, 0xa5a5a5a55a5a5a5a, + 0xa5a5a5a55a5a5a5a}, + {0xc3c3c3c33c3c3c3c, 0xc3c3c3c33c3c3c3c, 0xc3c3c3c33c3c3c3c, + 0xc3c3c3c33c3c3c3c}, + {0x6969696996969696, 0x6969696996969696, 0x6969696996969696, + 0x6969696996969696}, + {0x00ff00ffff00ff00, 0x00ff00ffff00ff00, 0x00ff00ffff00ff00, + 0x00ff00ffff00ff00}, + {0xaa55aa5555aa55aa, 0xaa55aa5555aa55aa, 0xaa55aa5555aa55aa, + 0xaa55aa5555aa55aa}, + {0xcc33cc3333cc33cc, 0xcc33cc3333cc33cc, 0xcc33cc3333cc33cc, + 0xcc33cc3333cc33cc}, + {0x6699669999669966, 0x6699669999669966, 0x6699669999669966, + 0x6699669999669966}, + {0xf00ff00f0ff00ff0, 0xf00ff00f0ff00ff0, 0xf00ff00f0ff00ff0, + 0xf00ff00f0ff00ff0}, + {0x5aa55aa5a55aa55a, 0x5aa55aa5a55aa55a, 0x5aa55aa5a55aa55a, + 0x5aa55aa5a55aa55a}, + {0x3cc33cc3c33cc33c, 0x3cc33cc3c33cc33c, 0x3cc33cc3c33cc33c, + 0x3cc33cc3c33cc33c}, + {0x9669966969966996, 0x9669966969966996, 0x9669966969966996, + 0x9669966969966996}, + {0x0000ffffffff0000, 0x0000ffffffff0000, 0x0000ffffffff0000, + 0x0000ffffffff0000}, + {0xaaaa55555555aaaa, 0xaaaa55555555aaaa, 0xaaaa55555555aaaa, + 0xaaaa55555555aaaa}, + {0xcccc33333333cccc, 0xcccc33333333cccc, 0xcccc33333333cccc, + 0xcccc33333333cccc}, + {0x6666999999996666, 0x6666999999996666, 0x6666999999996666, + 0x6666999999996666}, + {0xf0f00f0f0f0ff0f0, 0xf0f00f0f0f0ff0f0, 0xf0f00f0f0f0ff0f0, + 0xf0f00f0f0f0ff0f0}, + {0x5a5aa5a5a5a55a5a, 0x5a5aa5a5a5a55a5a, 0x5a5aa5a5a5a55a5a, + 0x5a5aa5a5a5a55a5a}, + {0x3c3cc3c3c3c33c3c, 0x3c3cc3c3c3c33c3c, 0x3c3cc3c3c3c33c3c, + 0x3c3cc3c3c3c33c3c}, + {0x9696696969699696, 0x9696696969699696, 0x9696696969699696, + 0x9696696969699696}, + {0xff0000ff00ffff00, 0xff0000ff00ffff00, 0xff0000ff00ffff00, + 0xff0000ff00ffff00}, + {0x55aaaa55aa5555aa, 0x55aaaa55aa5555aa, 0x55aaaa55aa5555aa, + 0x55aaaa55aa5555aa}, + {0x33cccc33cc3333cc, 0x33cccc33cc3333cc, 0x33cccc33cc3333cc, + 0x33cccc33cc3333cc}, + {0x9966669966999966, 0x9966669966999966, 0x9966669966999966, + 0x9966669966999966}, + {0x0ff0f00ff00f0ff0, 0x0ff0f00ff00f0ff0, 0x0ff0f00ff00f0ff0, + 0x0ff0f00ff00f0ff0}, + {0xa55a5aa55aa5a55a, 0xa55a5aa55aa5a55a, 0xa55a5aa55aa5a55a, + 0xa55a5aa55aa5a55a}, + {0xc33c3cc33cc3c33c, 0xc33c3cc33cc3c33c, 0xc33c3cc33cc3c33c, + 0xc33c3cc33cc3c33c}, + {0x6996966996696996, 0x6996966996696996, 0x6996966996696996, + 0x6996966996696996}, + {0xffffffffffffffff, 0x0000000000000000, 0xffffffffffffffff, + 0x0000000000000000}, + {0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x5555555555555555, + 0xaaaaaaaaaaaaaaaa}, + {0x3333333333333333, 0xcccccccccccccccc, 0x3333333333333333, + 0xcccccccccccccccc}, + {0x9999999999999999, 0x6666666666666666, 0x9999999999999999, + 0x6666666666666666}, + {0x0f0f0f0f0f0f0f0f, 0xf0f0f0f0f0f0f0f0, 0x0f0f0f0f0f0f0f0f, + 0xf0f0f0f0f0f0f0f0}, + {0xa5a5a5a5a5a5a5a5, 0x5a5a5a5a5a5a5a5a, 0xa5a5a5a5a5a5a5a5, + 0x5a5a5a5a5a5a5a5a}, + {0xc3c3c3c3c3c3c3c3, 0x3c3c3c3c3c3c3c3c, 0xc3c3c3c3c3c3c3c3, + 0x3c3c3c3c3c3c3c3c}, + {0x6969696969696969, 0x9696969696969696, 0x6969696969696969, + 0x9696969696969696}, + {0x00ff00ff00ff00ff, 0xff00ff00ff00ff00, 0x00ff00ff00ff00ff, + 0xff00ff00ff00ff00}, + {0xaa55aa55aa55aa55, 0x55aa55aa55aa55aa, 0xaa55aa55aa55aa55, + 0x55aa55aa55aa55aa}, + {0xcc33cc33cc33cc33, 0x33cc33cc33cc33cc, 0xcc33cc33cc33cc33, + 0x33cc33cc33cc33cc}, + {0x6699669966996699, 0x9966996699669966, 0x6699669966996699, + 0x9966996699669966}, + {0xf00ff00ff00ff00f, 0x0ff00ff00ff00ff0, 0xf00ff00ff00ff00f, + 0x0ff00ff00ff00ff0}, + {0x5aa55aa55aa55aa5, 0xa55aa55aa55aa55a, 0x5aa55aa55aa55aa5, + 0xa55aa55aa55aa55a}, + {0x3cc33cc33cc33cc3, 0xc33cc33cc33cc33c, 0x3cc33cc33cc33cc3, + 0xc33cc33cc33cc33c}, + {0x9669966996699669, 0x6996699669966996, 0x9669966996699669, + 0x6996699669966996}, + {0x0000ffff0000ffff, 0xffff0000ffff0000, 0x0000ffff0000ffff, + 0xffff0000ffff0000}, + {0xaaaa5555aaaa5555, 0x5555aaaa5555aaaa, 0xaaaa5555aaaa5555, + 0x5555aaaa5555aaaa}, + {0xcccc3333cccc3333, 0x3333cccc3333cccc, 0xcccc3333cccc3333, + 0x3333cccc3333cccc}, + {0x6666999966669999, 0x9999666699996666, 0x6666999966669999, + 0x9999666699996666}, + {0xf0f00f0ff0f00f0f, 0x0f0ff0f00f0ff0f0, 0xf0f00f0ff0f00f0f, + 0x0f0ff0f00f0ff0f0}, + {0x5a5aa5a55a5aa5a5, 0xa5a55a5aa5a55a5a, 0x5a5aa5a55a5aa5a5, + 0xa5a55a5aa5a55a5a}, + {0x3c3cc3c33c3cc3c3, 0xc3c33c3cc3c33c3c, 0x3c3cc3c33c3cc3c3, + 0xc3c33c3cc3c33c3c}, + {0x9696696996966969, 0x6969969669699696, 0x9696696996966969, + 0x6969969669699696}, + {0xff0000ffff0000ff, 0x00ffff0000ffff00, 0xff0000ffff0000ff, + 0x00ffff0000ffff00}, + {0x55aaaa5555aaaa55, 0xaa5555aaaa5555aa, 0x55aaaa5555aaaa55, + 0xaa5555aaaa5555aa}, + {0x33cccc3333cccc33, 0xcc3333cccc3333cc, 0x33cccc3333cccc33, + 0xcc3333cccc3333cc}, + {0x9966669999666699, 0x6699996666999966, 0x9966669999666699, + 0x6699996666999966}, + {0x0ff0f00f0ff0f00f, 0xf00f0ff0f00f0ff0, 0x0ff0f00f0ff0f00f, + 0xf00f0ff0f00f0ff0}, + {0xa55a5aa5a55a5aa5, 0x5aa5a55a5aa5a55a, 0xa55a5aa5a55a5aa5, + 0x5aa5a55a5aa5a55a}, + {0xc33c3cc3c33c3cc3, 0x3cc3c33c3cc3c33c, 0xc33c3cc3c33c3cc3, + 0x3cc3c33c3cc3c33c}, + {0x6996966969969669, 0x9669699696696996, 0x6996966969969669, + 0x9669699696696996}, + {0x00000000ffffffff, 0xffffffff00000000, 0x00000000ffffffff, + 0xffffffff00000000}, + {0xaaaaaaaa55555555, 0x55555555aaaaaaaa, 0xaaaaaaaa55555555, + 0x55555555aaaaaaaa}, + {0xcccccccc33333333, 0x33333333cccccccc, 0xcccccccc33333333, + 0x33333333cccccccc}, + {0x6666666699999999, 0x9999999966666666, 0x6666666699999999, + 0x9999999966666666}, + {0xf0f0f0f00f0f0f0f, 0x0f0f0f0ff0f0f0f0, 0xf0f0f0f00f0f0f0f, + 0x0f0f0f0ff0f0f0f0}, + {0x5a5a5a5aa5a5a5a5, 0xa5a5a5a55a5a5a5a, 0x5a5a5a5aa5a5a5a5, + 0xa5a5a5a55a5a5a5a}, + {0x3c3c3c3cc3c3c3c3, 0xc3c3c3c33c3c3c3c, 0x3c3c3c3cc3c3c3c3, + 0xc3c3c3c33c3c3c3c}, + {0x9696969669696969, 0x6969696996969696, 0x9696969669696969, + 0x6969696996969696}, + {0xff00ff0000ff00ff, 0x00ff00ffff00ff00, 0xff00ff0000ff00ff, + 0x00ff00ffff00ff00}, + {0x55aa55aaaa55aa55, 0xaa55aa5555aa55aa, 0x55aa55aaaa55aa55, + 0xaa55aa5555aa55aa}, + {0x33cc33cccc33cc33, 0xcc33cc3333cc33cc, 0x33cc33cccc33cc33, + 0xcc33cc3333cc33cc}, + {0x9966996666996699, 0x6699669999669966, 0x9966996666996699, + 0x6699669999669966}, + {0x0ff00ff0f00ff00f, 0xf00ff00f0ff00ff0, 0x0ff00ff0f00ff00f, + 0xf00ff00f0ff00ff0}, + {0xa55aa55a5aa55aa5, 0x5aa55aa5a55aa55a, 0xa55aa55a5aa55aa5, + 0x5aa55aa5a55aa55a}, + {0xc33cc33c3cc33cc3, 0x3cc33cc3c33cc33c, 0xc33cc33c3cc33cc3, + 0x3cc33cc3c33cc33c}, + {0x6996699696699669, 0x9669966969966996, 0x6996699696699669, + 0x9669966969966996}, + {0xffff00000000ffff, 0x0000ffffffff0000, 0xffff00000000ffff, + 0x0000ffffffff0000}, + {0x5555aaaaaaaa5555, 0xaaaa55555555aaaa, 0x5555aaaaaaaa5555, + 0xaaaa55555555aaaa}, + {0x3333cccccccc3333, 0xcccc33333333cccc, 0x3333cccccccc3333, + 0xcccc33333333cccc}, + {0x9999666666669999, 0x6666999999996666, 0x9999666666669999, + 0x6666999999996666}, + {0x0f0ff0f0f0f00f0f, 0xf0f00f0f0f0ff0f0, 0x0f0ff0f0f0f00f0f, + 0xf0f00f0f0f0ff0f0}, + {0xa5a55a5a5a5aa5a5, 0x5a5aa5a5a5a55a5a, 0xa5a55a5a5a5aa5a5, + 0x5a5aa5a5a5a55a5a}, + {0xc3c33c3c3c3cc3c3, 0x3c3cc3c3c3c33c3c, 0xc3c33c3c3c3cc3c3, + 0x3c3cc3c3c3c33c3c}, + {0x6969969696966969, 0x9696696969699696, 0x6969969696966969, + 0x9696696969699696}, + {0x00ffff00ff0000ff, 0xff0000ff00ffff00, 0x00ffff00ff0000ff, + 0xff0000ff00ffff00}, + {0xaa5555aa55aaaa55, 0x55aaaa55aa5555aa, 0xaa5555aa55aaaa55, + 0x55aaaa55aa5555aa}, + {0xcc3333cc33cccc33, 0x33cccc33cc3333cc, 0xcc3333cc33cccc33, + 0x33cccc33cc3333cc}, + {0x6699996699666699, 0x9966669966999966, 0x6699996699666699, + 0x9966669966999966}, + {0xf00f0ff00ff0f00f, 0x0ff0f00ff00f0ff0, 0xf00f0ff00ff0f00f, + 0x0ff0f00ff00f0ff0}, + {0x5aa5a55aa55a5aa5, 0xa55a5aa55aa5a55a, 0x5aa5a55aa55a5aa5, + 0xa55a5aa55aa5a55a}, + {0x3cc3c33cc33c3cc3, 0xc33c3cc33cc3c33c, 0x3cc3c33cc33c3cc3, + 0xc33c3cc33cc3c33c}, + {0x9669699669969669, 0x6996966996696996, 0x9669699669969669, + 0x6996966996696996}, + {0xffffffffffffffff, 0xffffffffffffffff, 0x0000000000000000, + 0x0000000000000000}, + {0x5555555555555555, 0x5555555555555555, 0xaaaaaaaaaaaaaaaa, + 0xaaaaaaaaaaaaaaaa}, + {0x3333333333333333, 0x3333333333333333, 0xcccccccccccccccc, + 0xcccccccccccccccc}, + {0x9999999999999999, 0x9999999999999999, 0x6666666666666666, + 0x6666666666666666}, + {0x0f0f0f0f0f0f0f0f, 0x0f0f0f0f0f0f0f0f, 0xf0f0f0f0f0f0f0f0, + 0xf0f0f0f0f0f0f0f0}, + {0xa5a5a5a5a5a5a5a5, 0xa5a5a5a5a5a5a5a5, 0x5a5a5a5a5a5a5a5a, + 0x5a5a5a5a5a5a5a5a}, + {0xc3c3c3c3c3c3c3c3, 0xc3c3c3c3c3c3c3c3, 0x3c3c3c3c3c3c3c3c, + 0x3c3c3c3c3c3c3c3c}, + {0x6969696969696969, 0x6969696969696969, 0x9696969696969696, + 0x9696969696969696}, + {0x00ff00ff00ff00ff, 0x00ff00ff00ff00ff, 0xff00ff00ff00ff00, + 0xff00ff00ff00ff00}, + {0xaa55aa55aa55aa55, 0xaa55aa55aa55aa55, 0x55aa55aa55aa55aa, + 0x55aa55aa55aa55aa}, + {0xcc33cc33cc33cc33, 0xcc33cc33cc33cc33, 0x33cc33cc33cc33cc, + 0x33cc33cc33cc33cc}, + {0x6699669966996699, 0x6699669966996699, 0x9966996699669966, + 0x9966996699669966}, + {0xf00ff00ff00ff00f, 0xf00ff00ff00ff00f, 0x0ff00ff00ff00ff0, + 0x0ff00ff00ff00ff0}, + {0x5aa55aa55aa55aa5, 0x5aa55aa55aa55aa5, 0xa55aa55aa55aa55a, + 0xa55aa55aa55aa55a}, + {0x3cc33cc33cc33cc3, 0x3cc33cc33cc33cc3, 0xc33cc33cc33cc33c, + 0xc33cc33cc33cc33c}, + {0x9669966996699669, 0x9669966996699669, 0x6996699669966996, + 0x6996699669966996}, + {0x0000ffff0000ffff, 0x0000ffff0000ffff, 0xffff0000ffff0000, + 0xffff0000ffff0000}, + {0xaaaa5555aaaa5555, 0xaaaa5555aaaa5555, 0x5555aaaa5555aaaa, + 0x5555aaaa5555aaaa}, + {0xcccc3333cccc3333, 0xcccc3333cccc3333, 0x3333cccc3333cccc, + 0x3333cccc3333cccc}, + {0x6666999966669999, 0x6666999966669999, 0x9999666699996666, + 0x9999666699996666}, + {0xf0f00f0ff0f00f0f, 0xf0f00f0ff0f00f0f, 0x0f0ff0f00f0ff0f0, + 0x0f0ff0f00f0ff0f0}, + {0x5a5aa5a55a5aa5a5, 0x5a5aa5a55a5aa5a5, 0xa5a55a5aa5a55a5a, + 0xa5a55a5aa5a55a5a}, + {0x3c3cc3c33c3cc3c3, 0x3c3cc3c33c3cc3c3, 0xc3c33c3cc3c33c3c, + 0xc3c33c3cc3c33c3c}, + {0x9696696996966969, 0x9696696996966969, 0x6969969669699696, + 0x6969969669699696}, + {0xff0000ffff0000ff, 0xff0000ffff0000ff, 0x00ffff0000ffff00, + 0x00ffff0000ffff00}, + {0x55aaaa5555aaaa55, 0x55aaaa5555aaaa55, 0xaa5555aaaa5555aa, + 0xaa5555aaaa5555aa}, + {0x33cccc3333cccc33, 0x33cccc3333cccc33, 0xcc3333cccc3333cc, + 0xcc3333cccc3333cc}, + {0x9966669999666699, 0x9966669999666699, 0x6699996666999966, + 0x6699996666999966}, + {0x0ff0f00f0ff0f00f, 0x0ff0f00f0ff0f00f, 0xf00f0ff0f00f0ff0, + 0xf00f0ff0f00f0ff0}, + {0xa55a5aa5a55a5aa5, 0xa55a5aa5a55a5aa5, 0x5aa5a55a5aa5a55a, + 0x5aa5a55a5aa5a55a}, + {0xc33c3cc3c33c3cc3, 0xc33c3cc3c33c3cc3, 0x3cc3c33c3cc3c33c, + 0x3cc3c33c3cc3c33c}, + {0x6996966969969669, 0x6996966969969669, 0x9669699696696996, + 0x9669699696696996}, + {0x00000000ffffffff, 0x00000000ffffffff, 0xffffffff00000000, + 0xffffffff00000000}, + {0xaaaaaaaa55555555, 0xaaaaaaaa55555555, 0x55555555aaaaaaaa, + 0x55555555aaaaaaaa}, + {0xcccccccc33333333, 0xcccccccc33333333, 0x33333333cccccccc, + 0x33333333cccccccc}, + {0x6666666699999999, 0x6666666699999999, 0x9999999966666666, + 0x9999999966666666}, + {0xf0f0f0f00f0f0f0f, 0xf0f0f0f00f0f0f0f, 0x0f0f0f0ff0f0f0f0, + 0x0f0f0f0ff0f0f0f0}, + {0x5a5a5a5aa5a5a5a5, 0x5a5a5a5aa5a5a5a5, 0xa5a5a5a55a5a5a5a, + 0xa5a5a5a55a5a5a5a}, + {0x3c3c3c3cc3c3c3c3, 0x3c3c3c3cc3c3c3c3, 0xc3c3c3c33c3c3c3c, + 0xc3c3c3c33c3c3c3c}, + {0x9696969669696969, 0x9696969669696969, 0x6969696996969696, + 0x6969696996969696}, + {0xff00ff0000ff00ff, 0xff00ff0000ff00ff, 0x00ff00ffff00ff00, + 0x00ff00ffff00ff00}, + {0x55aa55aaaa55aa55, 0x55aa55aaaa55aa55, 0xaa55aa5555aa55aa, + 0xaa55aa5555aa55aa}, + {0x33cc33cccc33cc33, 0x33cc33cccc33cc33, 0xcc33cc3333cc33cc, + 0xcc33cc3333cc33cc}, + {0x9966996666996699, 0x9966996666996699, 0x6699669999669966, + 0x6699669999669966}, + {0x0ff00ff0f00ff00f, 0x0ff00ff0f00ff00f, 0xf00ff00f0ff00ff0, + 0xf00ff00f0ff00ff0}, + {0xa55aa55a5aa55aa5, 0xa55aa55a5aa55aa5, 0x5aa55aa5a55aa55a, + 0x5aa55aa5a55aa55a}, + {0xc33cc33c3cc33cc3, 0xc33cc33c3cc33cc3, 0x3cc33cc3c33cc33c, + 0x3cc33cc3c33cc33c}, + {0x6996699696699669, 0x6996699696699669, 0x9669966969966996, + 0x9669966969966996}, + {0xffff00000000ffff, 0xffff00000000ffff, 0x0000ffffffff0000, + 0x0000ffffffff0000}, + {0x5555aaaaaaaa5555, 0x5555aaaaaaaa5555, 0xaaaa55555555aaaa, + 0xaaaa55555555aaaa}, + {0x3333cccccccc3333, 0x3333cccccccc3333, 0xcccc33333333cccc, + 0xcccc33333333cccc}, + {0x9999666666669999, 0x9999666666669999, 0x6666999999996666, + 0x6666999999996666}, + {0x0f0ff0f0f0f00f0f, 0x0f0ff0f0f0f00f0f, 0xf0f00f0f0f0ff0f0, + 0xf0f00f0f0f0ff0f0}, + {0xa5a55a5a5a5aa5a5, 0xa5a55a5a5a5aa5a5, 0x5a5aa5a5a5a55a5a, + 0x5a5aa5a5a5a55a5a}, + {0xc3c33c3c3c3cc3c3, 0xc3c33c3c3c3cc3c3, 0x3c3cc3c3c3c33c3c, + 0x3c3cc3c3c3c33c3c}, + {0x6969969696966969, 0x6969969696966969, 0x9696696969699696, + 0x9696696969699696}, + {0x00ffff00ff0000ff, 0x00ffff00ff0000ff, 0xff0000ff00ffff00, + 0xff0000ff00ffff00}, + {0xaa5555aa55aaaa55, 0xaa5555aa55aaaa55, 0x55aaaa55aa5555aa, + 0x55aaaa55aa5555aa}, + {0xcc3333cc33cccc33, 0xcc3333cc33cccc33, 0x33cccc33cc3333cc, + 0x33cccc33cc3333cc}, + {0x6699996699666699, 0x6699996699666699, 0x9966669966999966, + 0x9966669966999966}, + {0xf00f0ff00ff0f00f, 0xf00f0ff00ff0f00f, 0x0ff0f00ff00f0ff0, + 0x0ff0f00ff00f0ff0}, + {0x5aa5a55aa55a5aa5, 0x5aa5a55aa55a5aa5, 0xa55a5aa55aa5a55a, + 0xa55a5aa55aa5a55a}, + {0x3cc3c33cc33c3cc3, 0x3cc3c33cc33c3cc3, 0xc33c3cc33cc3c33c, + 0xc33c3cc33cc3c33c}, + {0x9669699669969669, 0x9669699669969669, 0x6996966996696996, + 0x6996966996696996}, + {0x0000000000000000, 0xffffffffffffffff, 0xffffffffffffffff, + 0x0000000000000000}, + {0xaaaaaaaaaaaaaaaa, 0x5555555555555555, 0x5555555555555555, + 0xaaaaaaaaaaaaaaaa}, + {0xcccccccccccccccc, 0x3333333333333333, 0x3333333333333333, + 0xcccccccccccccccc}, + {0x6666666666666666, 0x9999999999999999, 0x9999999999999999, + 0x6666666666666666}, + {0xf0f0f0f0f0f0f0f0, 0x0f0f0f0f0f0f0f0f, 0x0f0f0f0f0f0f0f0f, + 0xf0f0f0f0f0f0f0f0}, + {0x5a5a5a5a5a5a5a5a, 0xa5a5a5a5a5a5a5a5, 0xa5a5a5a5a5a5a5a5, + 0x5a5a5a5a5a5a5a5a}, + {0x3c3c3c3c3c3c3c3c, 0xc3c3c3c3c3c3c3c3, 0xc3c3c3c3c3c3c3c3, + 0x3c3c3c3c3c3c3c3c}, + {0x9696969696969696, 0x6969696969696969, 0x6969696969696969, + 0x9696969696969696}, + {0xff00ff00ff00ff00, 0x00ff00ff00ff00ff, 0x00ff00ff00ff00ff, + 0xff00ff00ff00ff00}, + {0x55aa55aa55aa55aa, 0xaa55aa55aa55aa55, 0xaa55aa55aa55aa55, + 0x55aa55aa55aa55aa}, + {0x33cc33cc33cc33cc, 0xcc33cc33cc33cc33, 0xcc33cc33cc33cc33, + 0x33cc33cc33cc33cc}, + {0x9966996699669966, 0x6699669966996699, 0x6699669966996699, + 0x9966996699669966}, + {0x0ff00ff00ff00ff0, 0xf00ff00ff00ff00f, 0xf00ff00ff00ff00f, + 0x0ff00ff00ff00ff0}, + {0xa55aa55aa55aa55a, 0x5aa55aa55aa55aa5, 0x5aa55aa55aa55aa5, + 0xa55aa55aa55aa55a}, + {0xc33cc33cc33cc33c, 0x3cc33cc33cc33cc3, 0x3cc33cc33cc33cc3, + 0xc33cc33cc33cc33c}, + {0x6996699669966996, 0x9669966996699669, 0x9669966996699669, + 0x6996699669966996}, + {0xffff0000ffff0000, 0x0000ffff0000ffff, 0x0000ffff0000ffff, + 0xffff0000ffff0000}, + {0x5555aaaa5555aaaa, 0xaaaa5555aaaa5555, 0xaaaa5555aaaa5555, + 0x5555aaaa5555aaaa}, + {0x3333cccc3333cccc, 0xcccc3333cccc3333, 0xcccc3333cccc3333, + 0x3333cccc3333cccc}, + {0x9999666699996666, 0x6666999966669999, 0x6666999966669999, + 0x9999666699996666}, + {0x0f0ff0f00f0ff0f0, 0xf0f00f0ff0f00f0f, 0xf0f00f0ff0f00f0f, + 0x0f0ff0f00f0ff0f0}, + {0xa5a55a5aa5a55a5a, 0x5a5aa5a55a5aa5a5, 0x5a5aa5a55a5aa5a5, + 0xa5a55a5aa5a55a5a}, + {0xc3c33c3cc3c33c3c, 0x3c3cc3c33c3cc3c3, 0x3c3cc3c33c3cc3c3, + 0xc3c33c3cc3c33c3c}, + {0x6969969669699696, 0x9696696996966969, 0x9696696996966969, + 0x6969969669699696}, + {0x00ffff0000ffff00, 0xff0000ffff0000ff, 0xff0000ffff0000ff, + 0x00ffff0000ffff00}, + {0xaa5555aaaa5555aa, 0x55aaaa5555aaaa55, 0x55aaaa5555aaaa55, + 0xaa5555aaaa5555aa}, + {0xcc3333cccc3333cc, 0x33cccc3333cccc33, 0x33cccc3333cccc33, + 0xcc3333cccc3333cc}, + {0x6699996666999966, 0x9966669999666699, 0x9966669999666699, + 0x6699996666999966}, + {0xf00f0ff0f00f0ff0, 0x0ff0f00f0ff0f00f, 0x0ff0f00f0ff0f00f, + 0xf00f0ff0f00f0ff0}, + {0x5aa5a55a5aa5a55a, 0xa55a5aa5a55a5aa5, 0xa55a5aa5a55a5aa5, + 0x5aa5a55a5aa5a55a}, + {0x3cc3c33c3cc3c33c, 0xc33c3cc3c33c3cc3, 0xc33c3cc3c33c3cc3, + 0x3cc3c33c3cc3c33c}, + {0x9669699696696996, 0x6996966969969669, 0x6996966969969669, + 0x9669699696696996}, + {0xffffffff00000000, 0x00000000ffffffff, 0x00000000ffffffff, + 0xffffffff00000000}, + {0x55555555aaaaaaaa, 0xaaaaaaaa55555555, 0xaaaaaaaa55555555, + 0x55555555aaaaaaaa}, + {0x33333333cccccccc, 0xcccccccc33333333, 0xcccccccc33333333, + 0x33333333cccccccc}, + {0x9999999966666666, 0x6666666699999999, 0x6666666699999999, + 0x9999999966666666}, + {0x0f0f0f0ff0f0f0f0, 0xf0f0f0f00f0f0f0f, 0xf0f0f0f00f0f0f0f, + 0x0f0f0f0ff0f0f0f0}, + {0xa5a5a5a55a5a5a5a, 0x5a5a5a5aa5a5a5a5, 0x5a5a5a5aa5a5a5a5, + 0xa5a5a5a55a5a5a5a}, + {0xc3c3c3c33c3c3c3c, 0x3c3c3c3cc3c3c3c3, 0x3c3c3c3cc3c3c3c3, + 0xc3c3c3c33c3c3c3c}, + {0x6969696996969696, 0x9696969669696969, 0x9696969669696969, + 0x6969696996969696}, + {0x00ff00ffff00ff00, 0xff00ff0000ff00ff, 0xff00ff0000ff00ff, + 0x00ff00ffff00ff00}, + {0xaa55aa5555aa55aa, 0x55aa55aaaa55aa55, 0x55aa55aaaa55aa55, + 0xaa55aa5555aa55aa}, + {0xcc33cc3333cc33cc, 0x33cc33cccc33cc33, 0x33cc33cccc33cc33, + 0xcc33cc3333cc33cc}, + {0x6699669999669966, 0x9966996666996699, 0x9966996666996699, + 0x6699669999669966}, + {0xf00ff00f0ff00ff0, 0x0ff00ff0f00ff00f, 0x0ff00ff0f00ff00f, + 0xf00ff00f0ff00ff0}, + {0x5aa55aa5a55aa55a, 0xa55aa55a5aa55aa5, 0xa55aa55a5aa55aa5, + 0x5aa55aa5a55aa55a}, + {0x3cc33cc3c33cc33c, 0xc33cc33c3cc33cc3, 0xc33cc33c3cc33cc3, + 0x3cc33cc3c33cc33c}, + {0x9669966969966996, 0x6996699696699669, 0x6996699696699669, + 0x9669966969966996}, + {0x0000ffffffff0000, 0xffff00000000ffff, 0xffff00000000ffff, + 0x0000ffffffff0000}, + {0xaaaa55555555aaaa, 0x5555aaaaaaaa5555, 0x5555aaaaaaaa5555, + 0xaaaa55555555aaaa}, + {0xcccc33333333cccc, 0x3333cccccccc3333, 0x3333cccccccc3333, + 0xcccc33333333cccc}, + {0x6666999999996666, 0x9999666666669999, 0x9999666666669999, + 0x6666999999996666}, + {0xf0f00f0f0f0ff0f0, 0x0f0ff0f0f0f00f0f, 0x0f0ff0f0f0f00f0f, + 0xf0f00f0f0f0ff0f0}, + {0x5a5aa5a5a5a55a5a, 0xa5a55a5a5a5aa5a5, 0xa5a55a5a5a5aa5a5, + 0x5a5aa5a5a5a55a5a}, + {0x3c3cc3c3c3c33c3c, 0xc3c33c3c3c3cc3c3, 0xc3c33c3c3c3cc3c3, + 0x3c3cc3c3c3c33c3c}, + {0x9696696969699696, 0x6969969696966969, 0x6969969696966969, + 0x9696696969699696}, + {0xff0000ff00ffff00, 0x00ffff00ff0000ff, 0x00ffff00ff0000ff, + 0xff0000ff00ffff00}, + {0x55aaaa55aa5555aa, 0xaa5555aa55aaaa55, 0xaa5555aa55aaaa55, + 0x55aaaa55aa5555aa}, + {0x33cccc33cc3333cc, 0xcc3333cc33cccc33, 0xcc3333cc33cccc33, + 0x33cccc33cc3333cc}, + {0x9966669966999966, 0x6699996699666699, 0x6699996699666699, + 0x9966669966999966}, + {0x0ff0f00ff00f0ff0, 0xf00f0ff00ff0f00f, 0xf00f0ff00ff0f00f, + 0x0ff0f00ff00f0ff0}, + {0xa55a5aa55aa5a55a, 0x5aa5a55aa55a5aa5, 0x5aa5a55aa55a5aa5, + 0xa55a5aa55aa5a55a}, + {0xc33c3cc33cc3c33c, 0x3cc3c33cc33c3cc3, 0x3cc3c33cc33c3cc3, + 0xc33c3cc33cc3c33c}, + {0x6996966996696996, 0x9669699669969669, 0x9669699669969669, + 0x6996966996696996}}; #if defined(unix) || defined(__unix__) || defined(__unix) || defined(__APPLE__) #define UNIX_PLATFORM #endif -} -#endif// CONFIG_H__ +} // namespace sci +#endif // CONFIG_H__ diff --git a/SCI/src/utils/crh.h b/SCI/src/utils/crh.h index 3d96f14c..b33a7bfc 100644 --- a/SCI/src/utils/crh.h +++ b/SCI/src/utils/crh.h @@ -31,58 +31,54 @@ Enquiries about further applications and development opportunities are welcome. */ namespace sci { -class CRH: public PRP { +class CRH : public PRP { public: - CRH(const char * seed = fix_key):PRP(seed) { - } + CRH(const char *seed = fix_key) : PRP(seed) {} - CRH(const block128& seed): PRP(seed) { - } + CRH(const block128 &seed) : PRP(seed) {} - block128 H(block128 in) { - block128 t = in; - permute_block(&t, 1); - return xorBlocks(t, in); - } + block128 H(block128 in) { + block128 t = in; + permute_block(&t, 1); + return xorBlocks(t, in); + } #ifdef __GNUC__ - #ifndef __clang__ - #pragma GCC push_options - #pragma GCC optimize ("unroll-loops") - #endif +#ifndef __clang__ +#pragma GCC push_options +#pragma GCC optimize("unroll-loops") +#endif #endif - template<int n> - void H(block128 out[n], block128 in[n]) { - block128 tmp[n]; - for (int i = 0; i < n; ++i) - tmp[i] = in[i]; - permute_block(tmp, n); - xorBlocks_arr(out, in, tmp, n); - } + template <int n> void H(block128 out[n], block128 in[n]) { + block128 tmp[n]; + for (int i = 0; i < n; ++i) + tmp[i] = in[i]; + permute_block(tmp, n); + xorBlocks_arr(out, in, tmp, n); + } #ifdef __GNUC__ - #ifndef __clang__ - #pragma GCC pop_options - #endif +#ifndef __clang__ +#pragma GCC pop_options +#endif #endif - void Hn(block128*out, block128* in, int n, block128 * scratch = nullptr) { - bool del = false; - if(scratch == nullptr) { - del = true; - scratch = new block128[n]; - } - for(int i = 0; i < n; ++i) - scratch[i] = in[i]; - permute_block(scratch, n); - xorBlocks_arr(out, in, scratch, n); - if(del) { - delete[] scratch; - scratch = nullptr; - } - - } + void Hn(block128 *out, block128 *in, int n, block128 *scratch = nullptr) { + bool del = false; + if (scratch == nullptr) { + del = true; + scratch = new block128[n]; + } + for (int i = 0; i < n; ++i) + scratch[i] = in[i]; + permute_block(scratch, n); + xorBlocks_arr(out, in, scratch, n); + if (del) { + delete[] scratch; + scratch = nullptr; + } + } }; -} +} // namespace sci /**@}*/ -#endif// CRH_H__ +#endif // CRH_H__ diff --git a/SCI/src/utils/emp-tool.h b/SCI/src/utils/emp-tool.h index e3436b6b..31146a33 100644 --- a/SCI/src/utils/emp-tool.h +++ b/SCI/src/utils/emp-tool.h @@ -3,15 +3,15 @@ #include "utils/ArgMapping/ArgMapping.h" +#include "utils/aes-ni.h" +#include "utils/aes.h" +#include "utils/aes_opt.h" #include "utils/block.h" +#include "utils/ccrf.h" #include "utils/constants.h" +#include "utils/crh.h" +#include "utils/group.h" #include "utils/hash.h" #include "utils/prg.h" #include "utils/prp.h" -#include "utils/crh.h" -#include "utils/ccrf.h" #include "utils/utils.h" -#include "utils/group.h" -#include "utils/aes_opt.h" -#include "utils/aes.h" -#include "utils/aes-ni.h" diff --git a/SCI/src/utils/group.h b/SCI/src/utils/group.h index 09ece6b3..a3376f77 100644 --- a/SCI/src/utils/group.h +++ b/SCI/src/utils/group.h @@ -22,77 +22,78 @@ SOFTWARE. Enquiries about further applications and development opportunities are welcome. */ -#ifndef GROUP_H__ -#define GROUP_H__ +#ifndef EMP_GROUP_H__ +#define EMP_GROUP_H__ -#include <openssl/ec.h> +#include "utils/utils.h" +#include <cstring> #include <openssl/bn.h> +#include <openssl/ec.h> #include <openssl/obj_mac.h> #include <string> -#include <cstring> -#include "utils/utils.h" //#ifdef ECC_USE_OPENSSL //#else //#include "group_relic.h" //#endif -namespace sci { -class BigInt { public: - BIGNUM *n = nullptr; - BigInt(); - BigInt(const BigInt &oth); - BigInt &operator=(BigInt oth); - ~BigInt(); +namespace emp { +class BigInt { +public: + BIGNUM *n = nullptr; + BigInt(); + BigInt(const BigInt &oth); + BigInt &operator=(BigInt oth); + ~BigInt(); - int size(); - void to_bin(unsigned char * in); - void from_bin(const unsigned char * in, int length); + int size(); + void to_bin(unsigned char *in); + void from_bin(const unsigned char *in, int length); - BigInt add(const BigInt &oth); - BigInt mul(const BigInt &oth, BN_CTX *ctx = nullptr); - BigInt mod(const BigInt &oth, BN_CTX *ctx = nullptr); - BigInt add_mod(const BigInt & b, const BigInt& m, BN_CTX *ctx = nullptr); - BigInt mul_mod(const BigInt & b, const BigInt& m, BN_CTX *ctx = nullptr); + BigInt add(const BigInt &oth); + BigInt mul(const BigInt &oth, BN_CTX *ctx = nullptr); + BigInt mod(const BigInt &oth, BN_CTX *ctx = nullptr); + BigInt add_mod(const BigInt &b, const BigInt &m, BN_CTX *ctx = nullptr); + BigInt mul_mod(const BigInt &b, const BigInt &m, BN_CTX *ctx = nullptr); }; class Group; class Point { - public: - EC_POINT *point = nullptr; - Group * group = nullptr; - Point (Group * g = nullptr); - ~Point(); - Point(const Point & p); - Point& operator=(Point p); +public: + EC_POINT *point = nullptr; + Group *group = nullptr; + Point(Group *g = nullptr); + ~Point(); + Point(const Point &p); + Point &operator=(Point p); - void to_bin(unsigned char * buf, size_t buf_len); - size_t size(); - void from_bin(Group * g, const unsigned char * buf, size_t buf_len); + void to_bin(unsigned char *buf, size_t buf_len); + size_t size(); + void from_bin(Group *g, const unsigned char *buf, size_t buf_len); - Point add(Point & rhs); -// Point sub(Point & rhs); -// bool is_at_infinity(); -// bool is_on_curve(); - Point mul(const BigInt &m); - Point inv(); - bool operator==(Point & rhs); + Point add(Point &rhs); + // Point sub(Point & rhs); + // bool is_at_infinity(); + // bool is_on_curve(); + Point mul(const BigInt &m); + Point inv(); + bool operator==(Point &rhs); }; -class Group { public: - EC_GROUP *ec_group = nullptr; - BN_CTX * bn_ctx = nullptr; - BigInt order; - unsigned char * scratch; - size_t scratch_size = 256; - Group(); - ~Group(); - void resize_scratch(size_t size); - void get_rand_bn(BigInt & n); - Point get_generator(); - Point mul_gen(const BigInt &m); +class Group { +public: + EC_GROUP *ec_group = nullptr; + BN_CTX *bn_ctx = nullptr; + BigInt order; + unsigned char *scratch; + size_t scratch_size = 256; + Group(); + ~Group(); + void resize_scratch(size_t size); + void get_rand_bn(BigInt &n); + Point get_generator(); + Point mul_gen(const BigInt &m); }; -} +} // namespace emp #include "group_openssl.h" - #endif diff --git a/SCI/src/utils/group_openssl.h b/SCI/src/utils/group_openssl.h index 6f439239..42c8cb61 100644 --- a/SCI/src/utils/group_openssl.h +++ b/SCI/src/utils/group_openssl.h @@ -22,184 +22,195 @@ SOFTWARE. Enquiries about further applications and development opportunities are welcome. */ -#ifndef GROUP_OPENSSL_H__ -#define GROUP_OPENSSL_H__ +#ifndef EMP_GROUP_OPENSSL_H__ +#define EMP_GROUP_OPENSSL_H__ -namespace sci { -inline BigInt::BigInt() { - n = BN_new(); -} +namespace emp { +inline BigInt::BigInt() { n = BN_new(); } inline BigInt::BigInt(const BigInt &oth) { - n = BN_new(); - BN_copy(n, oth.n); + n = BN_new(); + BN_copy(n, oth.n); } -inline BigInt& BigInt::operator=(BigInt oth) { - std::swap(n, oth.n); - return *this; +inline BigInt &BigInt::operator=(BigInt oth) { + std::swap(n, oth.n); + return *this; } inline BigInt::~BigInt() { - if (n != nullptr) - BN_free(n); + if (n != nullptr) + BN_free(n); } -inline int BigInt::size() { - return BN_num_bytes(n); -} +inline int BigInt::size() { return BN_num_bytes(n); } -inline void BigInt::to_bin(unsigned char * in) { - BN_bn2bin(n, in); -} +inline void BigInt::to_bin(unsigned char *in) { BN_bn2bin(n, in); } -inline void BigInt::from_bin(const unsigned char * in, int length) { - BN_free(n); - n = BN_bin2bn(in, length, nullptr); +inline void BigInt::from_bin(const unsigned char *in, int length) { + BN_free(n); + n = BN_bin2bn(in, length, nullptr); } inline BigInt BigInt::add(const BigInt &oth) { - BigInt ret; - BN_add(ret.n, n, oth.n); - return ret; + BigInt ret; + BN_add(ret.n, n, oth.n); + return ret; } -inline BigInt BigInt::mul_mod(const BigInt & b, const BigInt &m, BN_CTX *ctx) { - BigInt ret; - BN_mod_mul(ret.n, n, b.n, m.n, ctx); - return ret; +inline BigInt BigInt::mul_mod(const BigInt &b, const BigInt &m, BN_CTX *ctx) { + BigInt ret; + BN_mod_mul(ret.n, n, b.n, m.n, ctx); + return ret; } -inline BigInt BigInt::add_mod(const BigInt & b, const BigInt &m, BN_CTX *ctx) { - BigInt ret; - BN_mod_add(ret.n, n, b.n, m.n, ctx); - return ret; +inline BigInt BigInt::add_mod(const BigInt &b, const BigInt &m, BN_CTX *ctx) { + BigInt ret; + BN_mod_add(ret.n, n, b.n, m.n, ctx); + return ret; } inline BigInt BigInt::mul(const BigInt &oth, BN_CTX *ctx) { - BigInt ret; - BN_mul(ret.n, n, oth.n, ctx); - return ret; + BigInt ret; + BN_mul(ret.n, n, oth.n, ctx); + return ret; } inline BigInt BigInt::mod(const BigInt &oth, BN_CTX *ctx) { - BigInt ret; - BN_mod(ret.n, n, oth.n, ctx); - return ret; + BigInt ret; + BN_mod(ret.n, n, oth.n, ctx); + return ret; } -inline Point::Point (Group * g) { - if (g == nullptr) return; - this->group = g; - point = EC_POINT_new(group->ec_group); +inline Point::Point(Group *g) { + if (g == nullptr) + return; + this->group = g; + point = EC_POINT_new(group->ec_group); } inline Point::~Point() { - if(point != nullptr) - EC_POINT_free(point); + if (point != nullptr) + EC_POINT_free(point); } -inline Point::Point(const Point & p) { - if (p.group == nullptr) return; - this->group = p.group; - point = EC_POINT_new(group->ec_group); - int ret = EC_POINT_copy(point, p.point); - if(ret == 0) error("ECC COPY"); +inline Point::Point(const Point &p) { + if (p.group == nullptr) + return; + this->group = p.group; + point = EC_POINT_new(group->ec_group); + int ret = EC_POINT_copy(point, p.point); + if (ret == 0) + sci::error("ECC COPY"); } -inline Point& Point::operator=(Point p) { - std::swap(p.point, point); - std::swap(p.group, group); - return *this; +inline Point &Point::operator=(Point p) { + std::swap(p.point, point); + std::swap(p.group, group); + return *this; } -inline void Point::to_bin(unsigned char * buf, size_t buf_len) { - int ret = EC_POINT_point2oct(group->ec_group, point, POINT_CONVERSION_UNCOMPRESSED, buf, buf_len, group->bn_ctx); - if(ret == 0) error("ECC TO_BIN"); +inline void Point::to_bin(unsigned char *buf, size_t buf_len) { + int ret = + EC_POINT_point2oct(group->ec_group, point, POINT_CONVERSION_UNCOMPRESSED, + buf, buf_len, group->bn_ctx); + if (ret == 0) + sci::error("ECC TO_BIN"); } inline size_t Point::size() { - size_t ret = EC_POINT_point2oct(group->ec_group, point, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, group->bn_ctx); - if(ret == 0) error("ECC SIZE_BIN"); - return ret; -} - -inline void Point::from_bin(Group * g, const unsigned char * buf, size_t buf_len) { - if (point == nullptr) { - group = g; - point = EC_POINT_new(group->ec_group); - } - int ret = EC_POINT_oct2point(group->ec_group, point, buf, buf_len, group->bn_ctx); - if(ret == 0) error("ECC FROM_BIN"); -} - -inline Point Point::add(Point & rhs) { - Point ret(group); - int res = EC_POINT_add(group->ec_group, ret.point, point, rhs.point, group->bn_ctx); - if(res == 0) error("ECC ADD"); - return ret; + size_t ret = + EC_POINT_point2oct(group->ec_group, point, POINT_CONVERSION_UNCOMPRESSED, + NULL, 0, group->bn_ctx); + if (ret == 0) + sci::error("ECC SIZE_BIN"); + return ret; +} + +inline void Point::from_bin(Group *g, const unsigned char *buf, + size_t buf_len) { + if (point == nullptr) { + group = g; + point = EC_POINT_new(group->ec_group); + } + int ret = + EC_POINT_oct2point(group->ec_group, point, buf, buf_len, group->bn_ctx); + if (ret == 0) + sci::error("ECC FROM_BIN"); +} + +inline Point Point::add(Point &rhs) { + Point ret(group); + int res = + EC_POINT_add(group->ec_group, ret.point, point, rhs.point, group->bn_ctx); + if (res == 0) + sci::error("ECC ADD"); + return ret; } inline Point Point::mul(const BigInt &m) { - Point ret (group); - int res = EC_POINT_mul(group->ec_group, ret.point, NULL, point, m.n, group->bn_ctx); - if(res == 0) error("ECC MUL"); - return ret; + Point ret(group); + int res = + EC_POINT_mul(group->ec_group, ret.point, NULL, point, m.n, group->bn_ctx); + if (res == 0) + sci::error("ECC MUL"); + return ret; } inline Point Point::inv() { - Point ret (*this); - int res = EC_POINT_invert(group->ec_group, ret.point, group->bn_ctx); - if(res == 0) error("ECC INV"); - return ret; + Point ret(*this); + int res = EC_POINT_invert(group->ec_group, ret.point, group->bn_ctx); + if (res == 0) + sci::error("ECC INV"); + return ret; } -inline bool Point::operator==(Point & rhs) { - int ret = EC_POINT_cmp(group->ec_group, point, rhs.point, group->bn_ctx); - if(ret == -1) error("ECC CMP"); - return (ret == 0); +inline bool Point::operator==(Point &rhs) { + int ret = EC_POINT_cmp(group->ec_group, point, rhs.point, group->bn_ctx); + if (ret == -1) + sci::error("ECC CMP"); + return (ret == 0); } - inline Group::Group() { - ec_group = EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1);//NIST P-256 - bn_ctx = BN_CTX_new(); - EC_GROUP_precompute_mult(ec_group, bn_ctx); - EC_GROUP_get_order(ec_group, order.n, bn_ctx); - scratch = new unsigned char[scratch_size]; + ec_group = EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1); // NIST P-256 + bn_ctx = BN_CTX_new(); + EC_GROUP_precompute_mult(ec_group, bn_ctx); + EC_GROUP_get_order(ec_group, order.n, bn_ctx); + scratch = new unsigned char[scratch_size]; } -inline Group::~Group(){ - if(ec_group != nullptr) - EC_GROUP_free(ec_group); +inline Group::~Group() { + if (ec_group != nullptr) + EC_GROUP_free(ec_group); - if(bn_ctx != nullptr) - BN_CTX_free(bn_ctx); + if (bn_ctx != nullptr) + BN_CTX_free(bn_ctx); - if(scratch != nullptr) - delete[] scratch; + if (scratch != nullptr) + delete[] scratch; } inline void Group::resize_scratch(size_t size) { - if (size > scratch_size) { - delete[] scratch; - scratch_size = size; - scratch = new unsigned char[scratch_size]; - } + if (size > scratch_size) { + delete[] scratch; + scratch_size = size; + scratch = new unsigned char[scratch_size]; + } } -inline void Group::get_rand_bn(BigInt & n) { - BN_rand_range(n.n, order.n); -} +inline void Group::get_rand_bn(BigInt &n) { BN_rand_range(n.n, order.n); } inline Point Group::get_generator() { - Point res(this); - int ret = EC_POINT_copy(res.point, EC_GROUP_get0_generator(ec_group)); - if(ret == 0) error("ECC GEN"); - return res; + Point res(this); + int ret = EC_POINT_copy(res.point, EC_GROUP_get0_generator(ec_group)); + if (ret == 0) + sci::error("ECC GEN"); + return res; } inline Point Group::mul_gen(const BigInt &m) { - Point res(this); - int ret = EC_POINT_mul(ec_group, res.point, m.n ,NULL, NULL, bn_ctx); - if(ret == 0) error("ECC GEN MUL"); - return res; -} + Point res(this); + int ret = EC_POINT_mul(ec_group, res.point, m.n, NULL, NULL, bn_ctx); + if (ret == 0) + sci::error("ECC GEN MUL"); + return res; } +} // namespace emp #endif diff --git a/SCI/src/utils/hash.h b/SCI/src/utils/hash.h index ac078eaa..5499535e 100644 --- a/SCI/src/utils/hash.h +++ b/SCI/src/utils/hash.h @@ -37,80 +37,79 @@ Modified by Deevashwer Rathee @{ */ namespace sci { -class Hash { public: - SHA256_CTX hash; - char buffer[HASH_BUFFER_SIZE]; - int size = 0; - static const int DIGEST_SIZE = 32; - Hash() { - SHA256_Init(&hash); - } - ~Hash() { - } - void put(const void * data, int nbyte) { - if (nbyte > HASH_BUFFER_SIZE) - SHA256_Update(&hash, data, nbyte); - else if(size + nbyte < HASH_BUFFER_SIZE) { - memcpy(buffer+size, data, nbyte); - size+=nbyte; - } else { - SHA256_Update(&hash, (char*)buffer, size); - memcpy(buffer, data, nbyte); - size = nbyte; - } - } - void put_block(const block128* block128, int nblock=1){ - put(block128, sizeof(block128)*nblock); - } - void digest(char * a) { - if(size > 0) { - SHA256_Update(&hash, (char*)buffer, size); - size=0; - } - SHA256_Final((unsigned char *)a, &hash); - } - void reset() { - SHA256_Init(&hash); - size=0; - } - static void hash_once(void * digest, const void * data, int nbyte) { - (void )SHA256((const unsigned char *)data, nbyte, (unsigned char *)digest); - } - __attribute__((target("sse2"))) - static block128 hash_for_block128(const void * data, int nbyte) { - // even though stack is aligned to 16 byte, we don't know the order of locals. - char digest[DIGEST_SIZE] __attribute__ ((aligned (16))); - hash_once(digest, data, nbyte); - return _mm_load_si128((__m128i*)&digest[0]); - } +class Hash { +public: + SHA256_CTX hash; + char buffer[HASH_BUFFER_SIZE]; + int size = 0; + static const int DIGEST_SIZE = 32; + Hash() { SHA256_Init(&hash); } + ~Hash() {} + void put(const void *data, int nbyte) { + if (nbyte > HASH_BUFFER_SIZE) + SHA256_Update(&hash, data, nbyte); + else if (size + nbyte < HASH_BUFFER_SIZE) { + memcpy(buffer + size, data, nbyte); + size += nbyte; + } else { + SHA256_Update(&hash, (char *)buffer, size); + memcpy(buffer, data, nbyte); + size = nbyte; + } + } + void put_block(const block128 *block128, int nblock = 1) { + put(block128, sizeof(block128) * nblock); + } + void digest(char *a) { + if (size > 0) { + SHA256_Update(&hash, (char *)buffer, size); + size = 0; + } + SHA256_Final((unsigned char *)a, &hash); + } + void reset() { + SHA256_Init(&hash); + size = 0; + } + static void hash_once(void *digest, const void *data, int nbyte) { + (void)SHA256((const unsigned char *)data, nbyte, (unsigned char *)digest); + } + __attribute__((target("sse2"))) static block128 + hash_for_block128(const void *data, int nbyte) { + // even though stack is aligned to 16 byte, we don't know the order of + // locals. + alignas(16) char digest[DIGEST_SIZE]; + hash_once(digest, data, nbyte); + return _mm_load_si128((__m128i *)&digest[0]); + } - __attribute__((target("avx"))) - static block256 hash_for_block256(const void * data, int nbyte) { - char digest[DIGEST_SIZE] __attribute__ ((aligned (32))); - hash_once(digest, data, nbyte); - return _mm256_load_si256((__m256i*)&digest[0]); - } + __attribute__((target("avx"))) static block256 + hash_for_block256(const void *data, int nbyte) { + alignas(32) char digest[DIGEST_SIZE]; + hash_once(digest, data, nbyte); + return _mm256_load_si256((__m256i *)&digest[0]); + } - static block128 KDF128(Point &in, uint64_t id = 1) { - size_t len = in.size(); - in.group->resize_scratch(len+8); - unsigned char * tmp = in.group->scratch; - in.to_bin(tmp, len); - memcpy(tmp+len, &id, 8); - block128 ret = hash_for_block128(tmp, len+8); - return ret; - } + static block128 KDF128(emp::Point &in, uint64_t id = 1) { + size_t len = in.size(); + in.group->resize_scratch(len + 8); + unsigned char *tmp = in.group->scratch; + in.to_bin(tmp, len); + memcpy(tmp + len, &id, 8); + block128 ret = hash_for_block128(tmp, len + 8); + return ret; + } - static block256 KDF256(Point &in, uint64_t id = 1) { - size_t len = in.size(); - in.group->resize_scratch(len+8); - unsigned char * tmp = in.group->scratch; - in.to_bin(tmp, len); - memcpy(tmp+len, &id, 8); - block256 ret = hash_for_block256(tmp, len+8); - return ret; - } + static block256 KDF256(emp::Point &in, uint64_t id = 1) { + size_t len = in.size(); + in.group->resize_scratch(len + 8); + unsigned char *tmp = in.group->scratch; + in.to_bin(tmp, len); + memcpy(tmp + len, &id, 8); + alignas(32) block256 ret = hash_for_block256(tmp, len + 8); + return ret; + } }; -} +} // namespace sci /**@}*/ -#endif// HASH_H__ +#endif // HASH_H__ diff --git a/SCI/src/utils/io_channel.h b/SCI/src/utils/io_channel.h index eb05d346..a73d12ec 100644 --- a/SCI/src/utils/io_channel.h +++ b/SCI/src/utils/io_channel.h @@ -35,55 +35,50 @@ Modified by Deevashwer Rathee */ namespace sci { -template<typename T> -class IOChannel { +template <typename T> class IOChannel { public: - void send_data(const void * data, int nbyte) { - derived().send_data(data, nbyte); - } - void recv_data(void * data, int nbyte) { - derived().recv_data(data, nbyte); - } + void send_data(const void *data, int nbyte) { + derived().send_data(data, nbyte); + } + void recv_data(void *data, int nbyte) { derived().recv_data(data, nbyte); } - void send_block(const block128* data, int nblock) { - send_data(data, nblock*sizeof(block128)); - } + void send_block(const block128 *data, int nblock) { + send_data(data, nblock * sizeof(block128)); + } - void send_block(const block256* data, int nblock) { - send_data(data, nblock*sizeof(block256)); - } + void send_block(const block256 *data, int nblock) { + send_data(data, nblock * sizeof(block256)); + } - void recv_block(block128* data, int nblock) { - recv_data(data, nblock*sizeof(block128)); - } + void recv_block(block128 *data, int nblock) { + recv_data(data, nblock * sizeof(block128)); + } - void send_pt(Point *A, int num_pts = 1) { - for(int i = 0; i < num_pts; ++i) { - size_t len = A[i].size(); - A[i].group->resize_scratch(len); - unsigned char * tmp = A[i].group->scratch; - send_data(&len, 4); - A[i].to_bin(tmp, len); - send_data(tmp, len); - } - } + void send_pt(emp::Point *A, int num_pts = 1) { + for (int i = 0; i < num_pts; ++i) { + size_t len = A[i].size(); + A[i].group->resize_scratch(len); + unsigned char *tmp = A[i].group->scratch; + send_data(&len, 4); + A[i].to_bin(tmp, len); + send_data(tmp, len); + } + } - void recv_pt(Group * g, Point *A, int num_pts = 1) { - size_t len = 0; - for(int i = 0; i < num_pts; ++i) { - recv_data(&len, 4); - g->resize_scratch(len); - unsigned char * tmp = g->scratch; - recv_data(tmp, len); - A[i].from_bin(g, tmp, len); - } - } + void recv_pt(emp::Group *g, emp::Point *A, int num_pts = 1) { + size_t len = 0; + for (int i = 0; i < num_pts; ++i) { + recv_data(&len, 4); + g->resize_scratch(len); + unsigned char *tmp = g->scratch; + recv_data(tmp, len); + A[i].from_bin(g, tmp, len); + } + } private: - T& derived() { - return *static_cast<T*>(this); - } + T &derived() { return *static_cast<T *>(this); } }; /**@}*/ -} -#endif// IO_CHANNEL_H__ +} // namespace sci +#endif // IO_CHANNEL_H__ diff --git a/SCI/src/utils/net_io_channel.h b/SCI/src/utils/net_io_channel.h index 819e52ca..1e0c9e42 100644 --- a/SCI/src/utils/net_io_channel.h +++ b/SCI/src/utils/net_io_channel.h @@ -25,151 +25,175 @@ Enquiries about further applications and development opportunities are welcome. #ifndef NETWORK_IO_CHANNEL #define NETWORK_IO_CHANNEL +#include "utils/io_channel.h" #include <iostream> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <string> -#include "utils/io_channel.h" using std::string; -#include <unistd.h> #include <arpa/inet.h> -#include <sys/types.h> -#include <netinet/tcp.h> #include <netinet/in.h> +#include <netinet/tcp.h> #include <sys/socket.h> +#include <sys/types.h> +#include <unistd.h> + +enum class LastCall { None, Send, Recv }; namespace sci { /** @addtogroup IO @{ */ -class NetIO: public IOChannel<NetIO> { public: - bool is_server; - int mysocket = -1; - int consocket = -1; - FILE * stream = nullptr; - char * buffer = nullptr; - bool has_sent = false; - string addr; - int port; - uint64_t counter = 0; - NetIO(const char * address, int port, bool quiet = false) { - this->port = port; - is_server = (address == nullptr); - if (address == nullptr) { - struct sockaddr_in dest; - struct sockaddr_in serv; - socklen_t socksize = sizeof(struct sockaddr_in); - memset(&serv, 0, sizeof(serv)); - serv.sin_family = AF_INET; - serv.sin_addr.s_addr = htonl(INADDR_ANY); /* set our address to any interface */ - serv.sin_port = htons(port); /* set the server port number */ - mysocket = socket(AF_INET, SOCK_STREAM, 0); - int reuse = 1; - setsockopt(mysocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse, sizeof(reuse)); - if(bind(mysocket, (struct sockaddr *)&serv, sizeof(struct sockaddr)) < 0) { - perror("error: bind"); - exit(1); - } - if(listen(mysocket, 1) < 0) { - perror("error: listen"); - exit(1); - } - consocket = accept(mysocket, (struct sockaddr *)&dest, &socksize); - close(mysocket); - } - else { - addr = string(address); - - struct sockaddr_in dest; - memset(&dest, 0, sizeof(dest)); - dest.sin_family = AF_INET; - dest.sin_addr.s_addr = inet_addr(address); - dest.sin_port = htons(port); - - while(1) { - consocket = socket(AF_INET, SOCK_STREAM, 0); - - if (connect(consocket, (struct sockaddr *)&dest, sizeof(struct sockaddr)) == 0) { - break; - } - - close(consocket); - usleep(1000); - } - } - set_nodelay(); - stream = fdopen(consocket, "wb+"); - buffer = new char[NETWORK_BUFFER_SIZE]; - memset(buffer, 0, NETWORK_BUFFER_SIZE); - //setvbuf(stream, buffer, _IOFBF, NETWORK_BUFFER_SIZE); - setvbuf(stream, buffer, _IONBF, NETWORK_BUFFER_SIZE); - if(!quiet) - std::cout << "connected\n"; - } - - void sync() { - int tmp = 0; - if(is_server) { - send_data(&tmp, 1); - recv_data(&tmp, 1); - } else { - recv_data(&tmp, 1); - send_data(&tmp, 1); - flush(); - } - } - - ~NetIO(){ - fflush(stream); - close(consocket); - delete[] buffer; - } - - void set_nodelay() { - const int one=1; - setsockopt(consocket,IPPROTO_TCP,TCP_NODELAY,&one,sizeof(one)); - } - - void set_delay() { - const int zero = 0; - setsockopt(consocket,IPPROTO_TCP,TCP_NODELAY,&zero,sizeof(zero)); - } - - void flush() { - fflush(stream); - } - - void send_data(const void * data, int len) { - counter += len; - int sent = 0; - while(sent < len) { - int res = fwrite(sent + (char*)data, 1, len - sent, stream); - if (res >= 0) - sent+=res; - else - fprintf(stderr,"error: net_send_data %d\n", res); - } - has_sent = true; - } - - void recv_data(void * data, int len) { - if(has_sent) - fflush(stream); - has_sent = false; - int sent = 0; - while(sent < len) { - int res = fread(sent + (char*)data, 1, len - sent, stream); - if (res >= 0) - sent += res; - else - fprintf(stderr,"error: net_send_data %d\n", res); - } - } +class NetIO : public IOChannel<NetIO> { +public: + bool is_server; + int mysocket = -1; + int consocket = -1; + FILE *stream = nullptr; + char *buffer = nullptr; + bool has_sent = false; + string addr; + int port; + uint64_t counter = 0; + uint64_t num_rounds = 0; + LastCall last_call = LastCall::None; + NetIO(const char *address, int port, bool quiet = false) { + this->port = port; + is_server = (address == nullptr); + if (address == nullptr) { + struct sockaddr_in dest; + struct sockaddr_in serv; + socklen_t socksize = sizeof(struct sockaddr_in); + memset(&serv, 0, sizeof(serv)); + serv.sin_family = AF_INET; + serv.sin_addr.s_addr = + htonl(INADDR_ANY); /* set our address to any interface */ + serv.sin_port = htons(port); /* set the server port number */ + mysocket = socket(AF_INET, SOCK_STREAM, 0); + int reuse = 1; + setsockopt(mysocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuse, + sizeof(reuse)); + if (bind(mysocket, (struct sockaddr *)&serv, sizeof(struct sockaddr)) < + 0) { + perror("error: bind"); + exit(1); + } + if (listen(mysocket, 1) < 0) { + perror("error: listen"); + exit(1); + } + consocket = accept(mysocket, (struct sockaddr *)&dest, &socksize); + close(mysocket); + } else { + addr = string(address); + + struct sockaddr_in dest; + memset(&dest, 0, sizeof(dest)); + dest.sin_family = AF_INET; + dest.sin_addr.s_addr = inet_addr(address); + dest.sin_port = htons(port); + + while (1) { + consocket = socket(AF_INET, SOCK_STREAM, 0); + + if (connect(consocket, (struct sockaddr *)&dest, + sizeof(struct sockaddr)) == 0) { + break; + } + + close(consocket); + usleep(1000); + } + } + set_nodelay(); + stream = fdopen(consocket, "wb+"); + buffer = new char[NETWORK_BUFFER_SIZE]; + memset(buffer, 0, NETWORK_BUFFER_SIZE); + // setvbuf(stream, buffer, _IOFBF, NETWORK_BUFFER_SIZE); + setvbuf(stream, buffer, _IONBF, NETWORK_BUFFER_SIZE); + if (!quiet) + std::cout << "connected\n"; + } + + void sync() { + int tmp = 0; + if (is_server) { + send_data(&tmp, 1); + recv_data(&tmp, 1); + } else { + recv_data(&tmp, 1); + send_data(&tmp, 1); + flush(); + } + } + + ~NetIO() { + fflush(stream); + close(consocket); + delete[] buffer; + } + + void set_FBF() { + flush(); + setvbuf(stream, buffer, _IOFBF, NETWORK_BUFFER_SIZE); + } + + void set_NBF() { + flush(); + setvbuf(stream, buffer, _IONBF, NETWORK_BUFFER_SIZE); + } + + void set_nodelay() { + const int one = 1; + setsockopt(consocket, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)); + } + + void set_delay() { + const int zero = 0; + setsockopt(consocket, IPPROTO_TCP, TCP_NODELAY, &zero, sizeof(zero)); + } + + void flush() { fflush(stream); } + + void send_data(const void *data, int len) { + if (last_call != LastCall::Send) { + num_rounds++; + last_call = LastCall::Send; + } + counter += len; + int sent = 0; + while (sent < len) { + int res = fwrite(sent + (char *)data, 1, len - sent, stream); + if (res >= 0) + sent += res; + else + fprintf(stderr, "error: net_send_data %d\n", res); + } + has_sent = true; + } + + void recv_data(void *data, int len) { + if (last_call != LastCall::Recv) { + num_rounds++; + last_call = LastCall::Recv; + } + if (has_sent) + fflush(stream); + has_sent = false; + int sent = 0; + while (sent < len) { + int res = fread(sent + (char *)data, 1, len - sent, stream); + if (res >= 0) + sent += res; + else + fprintf(stderr, "error: net_send_data %d\n", res); + } + } }; /**@}*/ -} -#endif //NETWORK_IO_CHANNEL +} // namespace sci +#endif // NETWORK_IO_CHANNEL diff --git a/SCI/src/utils/prg.h b/SCI/src/utils/prg.h index 6699b2a0..00337321 100644 --- a/SCI/src/utils/prg.h +++ b/SCI/src/utils/prg.h @@ -27,9 +27,9 @@ Modified by Deevashwer Rathee #ifndef PRG_H__ #define PRG_H__ -#include "utils/block.h" -#include "utils/aes.h" #include "utils/aes-ni.h" +#include "utils/aes.h" +#include "utils/block.h" #include "utils/constants.h" #include <gmp.h> #include <random> @@ -39,249 +39,262 @@ Modified by Deevashwer Rathee #include <x86intrin.h> #endif - /** @addtogroup BP @{ */ namespace sci { -class PRG128 { public: - uint64_t counter = 0; - AES_KEY aes; - PRG128(const void * seed = nullptr, int id = 0) { - if (seed != nullptr) { - reseed(seed, id); - } else { - block128 v; +class PRG128 { +public: + uint64_t counter = 0; + AES_KEY aes; + PRG128(const void *seed = nullptr, int id = 0) { + if (seed != nullptr) { + reseed(seed, id); + } else { + block128 v; #ifdef EMP_USE_RANDOM_DEVICE - int * data = (int *)(&v); - std::random_device rand_div; - for (size_t i = 0; i < sizeof(block128) / sizeof(int); ++i) - data[i] = rand_div(); + int *data = (int *)(&v); + std::random_device rand_div; + for (size_t i = 0; i < sizeof(block128) / sizeof(int); ++i) + data[i] = rand_div(); #else - unsigned long long r0, r1; - _rdseed64_step(&r0); - _rdseed64_step(&r1); - v = makeBlock128(r0, r1); + unsigned long long r0, r1; + _rdseed64_step(&r0); + _rdseed64_step(&r1); + v = makeBlock128(r0, r1); #endif - reseed(&v); - } - } - void reseed(const void * key, uint64_t id = 0) { - block128 v = _mm_loadu_si128((block128*)key); - v = xorBlocks(v, makeBlock128(0LL, id)); - AES_set_encrypt_key(v, &aes); - counter = 0; - } + reseed(&v); + } + } + void reseed(const void *key, uint64_t id = 0) { + block128 v = _mm_loadu_si128((block128 *)key); + v = xorBlocks(v, makeBlock128(0LL, id)); + AES_set_encrypt_key(v, &aes); + counter = 0; + } - void random_data(void *data, int nbytes) { - random_block((block128 *)data, nbytes/16); - if (nbytes % 16 != 0) { - block128 extra; - random_block(&extra, 1); - memcpy((nbytes/16*16)+(char *) data, &extra, nbytes%16); - } - } + void random_data(void *data, int nbytes) { + random_block((block128 *)data, nbytes / 16); + if (nbytes % 16 != 0) { + block128 extra; + random_block(&extra, 1); + memcpy((nbytes / 16 * 16) + (char *)data, &extra, nbytes % 16); + } + } - void random_bool(bool * data, int length) { - uint8_t * uint_data = (uint8_t*)data; - random_data(uint_data, length); - for(int i = 0; i < length; ++i) - data[i] = uint_data[i] & 1; - } + void random_bool(bool *data, int length) { + uint8_t *uint_data = (uint8_t *)data; + random_data(uint_data, length); + for (int i = 0; i < length; ++i) + data[i] = uint_data[i] & 1; + } - void random_data_unaligned(void *data, int nbytes) { - block128 tmp[AES_BATCH_SIZE]; - for(int i = 0; i < nbytes/(AES_BATCH_SIZE*16); i++) { - random_block(tmp, AES_BATCH_SIZE); - memcpy((16*i*AES_BATCH_SIZE)+(uint8_t*)data, tmp, 16*AES_BATCH_SIZE); - } - if (nbytes % (16*AES_BATCH_SIZE) != 0) { - random_block(tmp, AES_BATCH_SIZE); - memcpy((nbytes/(16*AES_BATCH_SIZE)*(16*AES_BATCH_SIZE))+(uint8_t*) data, tmp, nbytes%(16*AES_BATCH_SIZE)); - } - } + void random_data_unaligned(void *data, int nbytes) { + block128 tmp[AES_BATCH_SIZE]; + for (int i = 0; i < nbytes / (AES_BATCH_SIZE * 16); i++) { + random_block(tmp, AES_BATCH_SIZE); + memcpy((16 * i * AES_BATCH_SIZE) + (uint8_t *)data, tmp, + 16 * AES_BATCH_SIZE); + } + if (nbytes % (16 * AES_BATCH_SIZE) != 0) { + random_block(tmp, AES_BATCH_SIZE); + memcpy((nbytes / (16 * AES_BATCH_SIZE) * (16 * AES_BATCH_SIZE)) + + (uint8_t *)data, + tmp, nbytes % (16 * AES_BATCH_SIZE)); + } + } - void random_block(block128 * data, int nblocks=1) { - for (int i = 0; i < nblocks; ++i) { - data[i] = makeBlock128(0LL, counter++); - } - int i = 0; - for(; i < nblocks-AES_BATCH_SIZE; i+=AES_BATCH_SIZE) { - AES_ecb_encrypt_blks(data+i, AES_BATCH_SIZE, &aes); - } - AES_ecb_encrypt_blks(data+i, (AES_BATCH_SIZE > nblocks-i) ? nblocks-i:AES_BATCH_SIZE, &aes); - } + void random_block(block128 *data, int nblocks = 1) { + for (int i = 0; i < nblocks; ++i) { + data[i] = makeBlock128(0LL, counter++); + } + int i = 0; + for (; i < nblocks - AES_BATCH_SIZE; i += AES_BATCH_SIZE) { + AES_ecb_encrypt_blks(data + i, AES_BATCH_SIZE, &aes); + } + AES_ecb_encrypt_blks( + data + i, (AES_BATCH_SIZE > nblocks - i) ? nblocks - i : AES_BATCH_SIZE, + &aes); + } - void random_block(block256 * data, int nblocks=1) { - nblocks = nblocks * 2; - block128 tmp[nblocks]; - for (int i = 0; i < nblocks; ++i) { - tmp[i] = makeBlock128(0LL, counter++); - } - int i = 0; - for(; i < nblocks-AES_BATCH_SIZE; i+=AES_BATCH_SIZE) { - AES_ecb_encrypt_blks(tmp+i, AES_BATCH_SIZE, &aes); - } - AES_ecb_encrypt_blks(tmp+i, (AES_BATCH_SIZE > nblocks-i) ? nblocks-i:AES_BATCH_SIZE, &aes); - for (int i = 0; i < nblocks/2; ++i) { - data[i] = makeBlock256(tmp[2*i], tmp[2 * i + 1]); - } - } + void random_block(block256 *data, int nblocks = 1) { + nblocks = nblocks * 2; + block128 tmp[nblocks]; + for (int i = 0; i < nblocks; ++i) { + tmp[i] = makeBlock128(0LL, counter++); + } + int i = 0; + for (; i < nblocks - AES_BATCH_SIZE; i += AES_BATCH_SIZE) { + AES_ecb_encrypt_blks(tmp + i, AES_BATCH_SIZE, &aes); + } + AES_ecb_encrypt_blks( + tmp + i, (AES_BATCH_SIZE > nblocks - i) ? nblocks - i : AES_BATCH_SIZE, + &aes); + for (int i = 0; i < nblocks / 2; ++i) { + data[i] = makeBlock256(tmp[2 * i], tmp[2 * i + 1]); + } + } - void random_mpz(mpz_t out, int nbits) { - int nbytes = (nbits+7)/8; - uint8_t * data = (uint8_t *)new block128[(nbytes+15)/16]; - random_data(data, nbytes); - if (nbits % 8 != 0) - data[0] %= (1 << (nbits % 8)); - mpz_import(out, nbytes, 1, 1, 0, 0, data); - delete [] data; - } + void random_mpz(mpz_t out, int nbits) { + int nbytes = (nbits + 7) / 8; + uint8_t *data = (uint8_t *)new block128[(nbytes + 15) / 16]; + random_data(data, nbytes); + if (nbits % 8 != 0) + data[0] %= (1 << (nbits % 8)); + mpz_import(out, nbytes, 1, 1, 0, 0, data); + delete[] data; + } - void random_mpz(mpz_t rop, const mpz_t n) { - auto size = mpz_sizeinbase(n, 2); - while (1) { - random_mpz(rop, (int)size); - if (mpz_cmp(rop, n) < 0) { - break; - } - } - } - - template<typename T> - void random_mod_p(T* arr, uint64_t size, T prime_mod){ - T boundary = (((-1*prime_mod)/prime_mod)+1)*prime_mod; //prime_mod*floor((2^l)/prime_mod) - int tries_before_resampling = 2; - uint64_t size_total = tries_before_resampling*size; - T* randomness = new T[size_total]; - uint64_t rptr = 0, arrptr = 0; - while(arrptr<size){ - this->random_data(randomness, sizeof(T)*size_total); - rptr = 0; - for(;(arrptr<size) && (rptr<size_total);arrptr++,rptr++){ - while(randomness[rptr]>boundary){ - rptr++; - if(rptr >= size_total){ - this->random_data(randomness, sizeof(T)*size_total); - rptr = 0; - } - } - arr[arrptr] = randomness[rptr]%prime_mod; - } - } - delete[] randomness; - } + void random_mpz(mpz_t rop, const mpz_t n) { + auto size = mpz_sizeinbase(n, 2); + while (1) { + random_mpz(rop, (int)size); + if (mpz_cmp(rop, n) < 0) { + break; + } + } + } + template <typename T> void random_mod_p(T *arr, uint64_t size, T prime_mod) { + T boundary = (((-1 * prime_mod) / prime_mod) + 1) * + prime_mod; // prime_mod*floor((2^l)/prime_mod) + int tries_before_resampling = 2; + uint64_t size_total = tries_before_resampling * size; + T *randomness = new T[size_total]; + uint64_t rptr = 0, arrptr = 0; + while (arrptr < size) { + this->random_data(randomness, sizeof(T) * size_total); + rptr = 0; + for (; (arrptr < size) && (rptr < size_total); arrptr++, rptr++) { + while (randomness[rptr] > boundary) { + rptr++; + if (rptr >= size_total) { + this->random_data(randomness, sizeof(T) * size_total); + rptr = 0; + } + } + arr[arrptr] = randomness[rptr] % prime_mod; + } + } + delete[] randomness; + } }; -class PRG256 { public: - uint64_t counter = 0; - AESNI_KEY aes; - PRG256(const void * seed = nullptr, int id = 0) { - if (seed != nullptr) { - reseed(seed, id); - } else { - block256 v; +class PRG256 { +public: + uint64_t counter = 0; + AESNI_KEY aes; + PRG256(const void *seed = nullptr, int id = 0) { + if (seed != nullptr) { + reseed(seed, id); + } else { + alignas(32) block256 v; #ifdef EMP_USE_RANDOM_DEVICE - int * data = (int *)(&v); - std::random_device rand_div; - for (size_t i = 0; i < sizeof(block256) / sizeof(int); ++i) - data[i] = rand_div(); + int *data = (int *)(&v); + std::random_device rand_div; + for (size_t i = 0; i < sizeof(block256) / sizeof(int); ++i) + data[i] = rand_div(); #else - unsigned long long r0, r1, r2, r3; - _rdseed64_step(&r0); - _rdseed64_step(&r1); - _rdseed64_step(&r2); - _rdseed64_step(&r3); - v = makeBlock256(r0, r1, r2, r3); + unsigned long long r0, r1, r2, r3; + _rdseed64_step(&r0); + _rdseed64_step(&r1); + _rdseed64_step(&r2); + _rdseed64_step(&r3); + v = makeBlock256(r0, r1, r2, r3); #endif - reseed(&v); - } - } - void reseed(const void * key, uint64_t id = 0) { - block256 v = _mm256_load_si256((block256*)key); - v = xorBlocks(v, makeBlock256(0LL, 0LL, 0LL, id)); - AESNI_set_encrypt_key(&aes, v); - counter = 0; - } - - void random_data(void *data, int nbytes) { - random_block((block128 *)data, nbytes/16); - if (nbytes % 16 != 0) { - block128 extra; - random_block(&extra, 1); - memcpy((nbytes/16*16)+(char *) data, &extra, nbytes%16); - } - } + reseed(&v); + } + } + void reseed(const void *key, uint64_t id = 0) { + alignas(32) block256 v = _mm256_load_si256((block256 *)key); + v = xorBlocks(v, makeBlock256(0LL, 0LL, 0LL, id)); + AESNI_set_encrypt_key(&aes, v); + counter = 0; + } - void random_bool(bool * data, int length) { - uint8_t * uint_data = (uint8_t*)data; - random_data(uint_data, length); - for(int i = 0; i < length; ++i) - data[i] = uint_data[i] & 1; - } + void random_data(void *data, int nbytes) { + random_block((block128 *)data, nbytes / 16); + if (nbytes % 16 != 0) { + block128 extra; + random_block(&extra, 1); + memcpy((nbytes / 16 * 16) + (char *)data, &extra, nbytes % 16); + } + } - void random_data_unaligned(void *data, int nbytes) { - block128 tmp[AES_BATCH_SIZE]; - for(int i = 0; i < nbytes/(AES_BATCH_SIZE*16); i++) { - random_block(tmp, AES_BATCH_SIZE); - memcpy((16*i*AES_BATCH_SIZE)+(uint8_t*)data, tmp, 16*AES_BATCH_SIZE); - } - if (nbytes % (16*AES_BATCH_SIZE) != 0) { - random_block(tmp, AES_BATCH_SIZE); - memcpy((nbytes/(16*AES_BATCH_SIZE)*(16*AES_BATCH_SIZE))+(uint8_t*) data, tmp, nbytes%(16*AES_BATCH_SIZE)); - } - } + void random_bool(bool *data, int length) { + uint8_t *uint_data = (uint8_t *)data; + random_data(uint_data, length); + for (int i = 0; i < length; ++i) + data[i] = uint_data[i] & 1; + } - void random_block(block128 * data, int nblocks=1) { - for (int i = 0; i < nblocks; ++i) { - data[i] = makeBlock128(0LL, counter++); - } - int i = 0; - for(; i < nblocks-AES_BATCH_SIZE; i+=AES_BATCH_SIZE) { - AESNI_ecb_encrypt_blks(data+i, AES_BATCH_SIZE, &aes); - } - AESNI_ecb_encrypt_blks(data+i, (AES_BATCH_SIZE > nblocks-i) ? nblocks-i:AES_BATCH_SIZE, &aes); - } + void random_data_unaligned(void *data, int nbytes) { + block128 tmp[AES_BATCH_SIZE]; + for (int i = 0; i < nbytes / (AES_BATCH_SIZE * 16); i++) { + random_block(tmp, AES_BATCH_SIZE); + memcpy((16 * i * AES_BATCH_SIZE) + (uint8_t *)data, tmp, + 16 * AES_BATCH_SIZE); + } + if (nbytes % (16 * AES_BATCH_SIZE) != 0) { + random_block(tmp, AES_BATCH_SIZE); + memcpy((nbytes / (16 * AES_BATCH_SIZE) * (16 * AES_BATCH_SIZE)) + + (uint8_t *)data, + tmp, nbytes % (16 * AES_BATCH_SIZE)); + } + } - void random_block(block256 * data, int nblocks=1) { - nblocks = nblocks * 2; - block128 tmp[nblocks]; - for (int i = 0; i < nblocks; ++i) { - tmp[i] = makeBlock128(0LL, counter++); - } - int i = 0; - for(; i < nblocks-AES_BATCH_SIZE; i+=AES_BATCH_SIZE) { - AESNI_ecb_encrypt_blks(tmp+i, AES_BATCH_SIZE, &aes); - } - AESNI_ecb_encrypt_blks(tmp+i, (AES_BATCH_SIZE > nblocks-i) ? nblocks-i:AES_BATCH_SIZE, &aes); - for (int i = 0; i < nblocks/2; ++i) { - data[i] = makeBlock256(tmp[2*i], tmp[2 * i + 1]); - } - } + void random_block(block128 *data, int nblocks = 1) { + for (int i = 0; i < nblocks; ++i) { + data[i] = makeBlock128(0LL, counter++); + } + int i = 0; + for (; i < nblocks - AES_BATCH_SIZE; i += AES_BATCH_SIZE) { + AESNI_ecb_encrypt_blks(data + i, AES_BATCH_SIZE, &aes); + } + AESNI_ecb_encrypt_blks( + data + i, (AES_BATCH_SIZE > nblocks - i) ? nblocks - i : AES_BATCH_SIZE, + &aes); + } - void random_mpz(mpz_t out, int nbits) { - int nbytes = (nbits+7)/8; - uint8_t * data = (uint8_t *)new block128[(nbytes+15)/16]; - random_data(data, nbytes); - if (nbits % 8 != 0) - data[0] %= (1 << (nbits % 8)); - mpz_import(out, nbytes, 1, 1, 0, 0, data); - delete [] data; - } + void random_block(block256 *data, int nblocks = 1) { + nblocks = nblocks * 2; + block128 tmp[nblocks]; + for (int i = 0; i < nblocks; ++i) { + tmp[i] = makeBlock128(0LL, counter++); + } + int i = 0; + for (; i < nblocks - AES_BATCH_SIZE; i += AES_BATCH_SIZE) { + AESNI_ecb_encrypt_blks(tmp + i, AES_BATCH_SIZE, &aes); + } + AESNI_ecb_encrypt_blks( + tmp + i, (AES_BATCH_SIZE > nblocks - i) ? nblocks - i : AES_BATCH_SIZE, + &aes); + for (int i = 0; i < nblocks / 2; ++i) { + data[i] = makeBlock256(tmp[2 * i], tmp[2 * i + 1]); + } + } - void random_mpz(mpz_t rop, const mpz_t n) { - auto size = mpz_sizeinbase(n, 2); - while (1) { - random_mpz(rop, (int)size); - if (mpz_cmp(rop, n) < 0) { - break; - } - } - } + void random_mpz(mpz_t out, int nbits) { + int nbytes = (nbits + 7) / 8; + uint8_t *data = (uint8_t *)new block128[(nbytes + 15) / 16]; + random_data(data, nbytes); + if (nbits % 8 != 0) + data[0] %= (1 << (nbits % 8)); + mpz_import(out, nbytes, 1, 1, 0, 0, data); + delete[] data; + } + void random_mpz(mpz_t rop, const mpz_t n) { + auto size = mpz_sizeinbase(n, 2); + while (1) { + random_mpz(rop, (int)size); + if (mpz_cmp(rop, n) < 0) { + break; + } + } + } }; -} -#endif// PRG_H__ +} // namespace sci +#endif // PRG_H__ diff --git a/SCI/src/utils/prp.h b/SCI/src/utils/prp.h index b0182ba3..5611220d 100644 --- a/SCI/src/utils/prp.h +++ b/SCI/src/utils/prp.h @@ -24,90 +24,90 @@ Enquiries about further applications and development opportunities are welcome. #ifndef PRP_H__ #define PRP_H__ +#include "utils/aes.h" #include "utils/block.h" #include "utils/constants.h" -#include "utils/aes.h" #include <stdio.h> /** @addtogroup BP @{ */ namespace sci { -class PRP { public: - AES_KEY aes; +class PRP { +public: + AES_KEY aes; - PRP(const char * seed = fix_key) { - aes_set_key(seed); - } + PRP(const char *seed = fix_key) { aes_set_key(seed); } - PRP(const block128& seed): PRP((const char *)&seed) { - } + PRP(const block128 &seed) : PRP((const char *)&seed) {} - void aes_set_key(const char * key) { - aes_set_key(_mm_loadu_si128((block128*)key)); - } + void aes_set_key(const char *key) { + aes_set_key(_mm_loadu_si128((block128 *)key)); + } - void aes_set_key(const block128& v) { - AES_set_encrypt_key(v, &aes); - } + void aes_set_key(const block128 &v) { AES_set_encrypt_key(v, &aes); } - void permute_block(block128 *data, int nblocks) { - int i = 0; - for(; i < nblocks-AES_BATCH_SIZE; i+=AES_BATCH_SIZE) { - AES_ecb_encrypt_blks(data+i, AES_BATCH_SIZE, &aes); - } - AES_ecb_encrypt_blks(data+i, (AES_BATCH_SIZE > nblocks-i) ? nblocks-i:AES_BATCH_SIZE, &aes); - } + void permute_block(block128 *data, int nblocks) { + int i = 0; + for (; i < nblocks - AES_BATCH_SIZE; i += AES_BATCH_SIZE) { + AES_ecb_encrypt_blks(data + i, AES_BATCH_SIZE, &aes); + } + AES_ecb_encrypt_blks( + data + i, (AES_BATCH_SIZE > nblocks - i) ? nblocks - i : AES_BATCH_SIZE, + &aes); + } - void permute_data(void*data, int nbytes) { - permute_block((block128 *)data, nbytes/16); - if (nbytes % 16 != 0) { - uint8_t extra[16]; - memset(extra, 0, 16); - memcpy(extra, (nbytes/16*16)+(char *) data, nbytes%16); - permute_block((block128*)extra, 1); - memcpy((nbytes/16*16)+(char *) data, &extra, nbytes%16); - } - } + void permute_data(void *data, int nbytes) { + permute_block((block128 *)data, nbytes / 16); + if (nbytes % 16 != 0) { + uint8_t extra[16]; + memset(extra, 0, 16); + memcpy(extra, (nbytes / 16 * 16) + (char *)data, nbytes % 16); + permute_block((block128 *)extra, 1); + memcpy((nbytes / 16 * 16) + (char *)data, &extra, nbytes % 16); + } + } - block128 H(block128 in, uint64_t id) { - in = double_block(in); - __m128i k_128 = _mm_loadl_epi64( (__m128i const *) (&id)); - in = xorBlocks(in, k_128); - block128 t = in; - permute_block(&t, 1); - in = xorBlocks(in, t); - return in; - } - template<int n> - void H(block128 out[n], block128 in[n], uint64_t id) { - block128 scratch[n]; - for(int i = 0; i < n; ++i) { - out[i] = scratch[i] = xorBlocks(double_block(in[i]), _mm_loadl_epi64( (__m128i const *) (&id))); - ++id; - } - permute_block(scratch, n); - xorBlocks_arr(out, scratch, out, n); - } + block128 H(block128 in, uint64_t id) { + in = double_block(in); + __m128i k_128 = _mm_loadl_epi64((__m128i const *)(&id)); + in = xorBlocks(in, k_128); + block128 t = in; + permute_block(&t, 1); + in = xorBlocks(in, t); + return in; + } + template <int n> void H(block128 out[n], block128 in[n], uint64_t id) { + block128 scratch[n]; + for (int i = 0; i < n; ++i) { + out[i] = scratch[i] = xorBlocks(double_block(in[i]), + _mm_loadl_epi64((__m128i const *)(&id))); + ++id; + } + permute_block(scratch, n); + xorBlocks_arr(out, scratch, out, n); + } - void Hn(block128*out, block128* in, uint64_t id, int length, block128 * scratch = nullptr) { - bool del = false; - if(scratch == nullptr) { - del = true; - scratch = new block128[length]; - } - for(int i = 0; i < length; ++i){ - out[i] = scratch[i] = xorBlocks(double_block(in[i]), _mm_loadl_epi64( (__m128i const *) (&id))); - ++id; - } - permute_block(scratch, length); - xorBlocks_arr(out, scratch, out, length); - if(del) { - delete[] scratch; - scratch = nullptr; - } - } + void Hn(block128 *out, block128 *in, uint64_t id, int length, + block128 *scratch = nullptr) { + bool del = false; + if (scratch == nullptr) { + del = true; + scratch = new block128[length]; + } + for (int i = 0; i < length; ++i) { + out[i] = scratch[i] = xorBlocks(double_block(in[i]), + _mm_loadl_epi64((__m128i const *)(&id))); + ++id; + } + permute_block(scratch, length); + xorBlocks_arr(out, scratch, out, length); + if (del) { + delete[] scratch; + scratch = nullptr; + } + } }; -} +} // namespace sci /**@}*/ -#endif// PRP_H__ +#endif // PRP_H__ diff --git a/SCI/src/utils/ubuntu_terminal_colors.h b/SCI/src/utils/ubuntu_terminal_colors.h index 15c78ba7..10d6cba9 100644 --- a/SCI/src/utils/ubuntu_terminal_colors.h +++ b/SCI/src/utils/ubuntu_terminal_colors.h @@ -1,5 +1,5 @@ /* -Authors: Mayank Rathee +Authors: Mayank Rathee, Deevashwer Rathee Copyright: Copyright (c) 2020 Microsoft Research Permission is hereby granted, free of charge, to any person obtaining a copy @@ -19,21 +19,21 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -//the following are UBUNTU/LINUX, and MacOS ONLY terminal color codes. -#define RESET "\033[0m" -#define BLACK "\033[30m" /* Black */ -#define RED "\033[31m" /* Red */ -#define GREEN "\033[32m" /* Green */ -#define YELLOW "\033[33m" /* Yellow */ -#define BLUE "\033[34m" /* Blue */ -#define MAGENTA "\033[35m" /* Magenta */ -#define CYAN "\033[36m" /* Cyan */ -#define WHITE "\033[37m" /* White */ -#define BOLDBLACK "\033[1m\033[30m" /* Bold Black */ -#define BOLDRED "\033[1m\033[31m" /* Bold Red */ -#define BOLDGREEN "\033[1m\033[32m" /* Bold Green */ -#define BOLDYELLOW "\033[1m\033[33m" /* Bold Yellow */ -#define BOLDBLUE "\033[1m\033[34m" /* Bold Blue */ -#define BOLDMAGENTA "\033[1m\033[35m" /* Bold Magenta */ -#define BOLDCYAN "\033[1m\033[36m" /* Bold Cyan */ -#define BOLDWHITE "\033[1m\033[37m" /* Bold White */ +// the following are UBUNTU/LINUX, and MacOS ONLY terminal color codes. +#define RESET "\033[0m" +#define BLACK "\033[30m" /* Black */ +#define RED "\033[31m" /* Red */ +#define GREEN "\033[32m" /* Green */ +#define YELLOW "\033[33m" /* Yellow */ +#define BLUE "\033[34m" /* Blue */ +#define MAGENTA "\033[35m" /* Magenta */ +#define CYAN "\033[36m" /* Cyan */ +#define WHITE "\033[37m" /* White */ +#define BOLDBLACK "\033[1m\033[30m" /* Bold Black */ +#define BOLDRED "\033[1m\033[31m" /* Bold Red */ +#define BOLDGREEN "\033[1m\033[32m" /* Bold Green */ +#define BOLDYELLOW "\033[1m\033[33m" /* Bold Yellow */ +#define BOLDBLUE "\033[1m\033[34m" /* Bold Blue */ +#define BOLDMAGENTA "\033[1m\033[35m" /* Bold Magenta */ +#define BOLDCYAN "\033[1m\033[36m" /* Bold Cyan */ +#define BOLDWHITE "\033[1m\033[37m" /* Bold White */ diff --git a/SCI/src/utils/utils.h b/SCI/src/utils/utils.h index e094d2b2..ada221e2 100644 --- a/SCI/src/utils/utils.h +++ b/SCI/src/utils/utils.h @@ -27,53 +27,49 @@ Modified by Deevashwer Rathee #ifndef UTILS_H__ #define UTILS_H__ -#include <string> #include "utils/block.h" -#include <sstream> -#include <cstddef> -#include <gmp.h> #include "utils/prg.h" #include <chrono> +#include <cstddef> +#include <gmp.h> +#include <sstream> +#include <string> #define macro_xstr(a) macro_str(a) #define macro_str(a) #a using std::string; -using std::chrono::time_point; using std::chrono::high_resolution_clock; +using std::chrono::time_point; namespace sci { -template<typename T> -void inline delete_array_null(T * ptr); +template <typename T> void inline delete_array_null(T *ptr); -inline void error(const char * s, int line = 0, const char * file = nullptr); +inline void error(const char *s, int line = 0, const char *file = nullptr); -template<class... Ts> -void run_function(void *function, const Ts&... args); +template <class... Ts> void run_function(void *function, const Ts &... args); -inline void parse_party_and_port(char ** arg, int argc, int * party, int * port); +inline void parse_party_and_port(char **arg, int argc, int *party, int *port); std::string Party(int p); // Timing related inline time_point<high_resolution_clock> clock_start(); -inline double time_from(const time_point<high_resolution_clock>& s); - -//block128 conversions -template <typename T = uint64_t> -std::string m128i_to_string(const __m128i var); -block128 bool_to128(const bool * data); -void int64_to_bool(bool * data, uint64_t input, int length); -inline void uint8_to_bool(uint8_t * data, uint8_t input, int length); - -//Other conversions -template<typename T> -T bool_to_int(const bool * data, size_t len = 0); -inline uint8_t bool_to_uint8(const uint8_t * data, size_t len = 0); +inline double time_from(const time_point<high_resolution_clock> &s); + +// block128 conversions +template <typename T = uint64_t> std::string m128i_to_string(const __m128i var); +block128 bool_to128(const bool *data); +void int64_to_bool(bool *data, uint64_t input, int length); +inline void uint8_to_bool(uint8_t *data, uint8_t input, int length); + +// Other conversions +template <typename T> T bool_to_int(const bool *data, size_t len = 0); +inline uint8_t bool_to_uint8(const uint8_t *data, size_t len = 0); std::string hex_to_binary(std::string hex); inline string change_base(string str, int old_base, int new_base); -inline string dec_to_bin(const string& dec); -inline string bin_to_dec(const string& bin2); -inline const char* hex_char_to_bin(char c); +inline string dec_to_bin(const string &dec); +inline string bin_to_dec(const string &bin2); +inline const char *hex_char_to_bin(char c); inline int bitlen(int x); inline int bitlen_true(int x); @@ -81,11 +77,11 @@ inline int bitlen_true(int x); inline int64_t neg_mod(int64_t val, int64_t mod); inline int8_t neg_mod(int8_t val, int8_t mod); -//deprecate soon -inline void parse_party_and_port(char ** arg, int * party, int * port) { - parse_party_and_port(arg, 2, party, port); +// deprecate soon +inline void parse_party_and_port(char **arg, int *party, int *port) { + parse_party_and_port(arg, 2, party, port); } #include "utils/utils.hpp" -} -#endif// UTILS_H__ +} // namespace sci +#endif // UTILS_H__ diff --git a/SCI/src/utils/utils.hpp b/SCI/src/utils/utils.hpp index 16d2bcb9..5283da14 100644 --- a/SCI/src/utils/utils.hpp +++ b/SCI/src/utils/utils.hpp @@ -260,16 +260,16 @@ inline uint64_t all1Mask(int x){ #define IO_TILL_NOW (io->counter - dataSentCtr__1); #define RESET_IO dataSentCtr__1 = io->counter; -#define INIT_ALL_IO_DATA_SENT uint64_t __ioStartTracker[::numThreads];\ - for(int __thrdCtr = 0; __thrdCtr < ::numThreads; __thrdCtr++){\ +#define INIT_ALL_IO_DATA_SENT uint64_t __ioStartTracker[::num_threads];\ + for(int __thrdCtr = 0; __thrdCtr < ::num_threads; __thrdCtr++){\ __ioStartTracker[__thrdCtr] = ::ioArr[__thrdCtr]->counter;\ } #define FIND_ALL_IO_TILL_NOW(var) uint64_t __curComm = 0;\ - for(int __thrdCtr = 0; __thrdCtr < ::numThreads; __thrdCtr++){\ + for(int __thrdCtr = 0; __thrdCtr < ::num_threads; __thrdCtr++){\ __curComm += ((::ioArr[__thrdCtr]->counter) - __ioStartTracker[__thrdCtr]);\ }\ var = __curComm; -#define RESET_ALL_IO for(int __thrdCtr = 0; __thrdCtr < ::numThreads; __thrdCtr++){\ +#define RESET_ALL_IO for(int __thrdCtr = 0; __thrdCtr < ::num_threads; __thrdCtr++){\ __ioStartTracker[__thrdCtr] = ::ioArr[__thrdCtr]->counter;\ } @@ -423,3 +423,15 @@ static void writeToPackedArr(uint8_t* arr, int arrLen, uint64_t bitIdx, uint64_t uint64_t valIter = (val >> freeBitsInFirstByte); //Since val is unsigned, this is unsigned right shift (*((uint64_t*)(arr+firstByteIdx+1))) = valIter; } + +inline int64_t unsigned_val(uint64_t x, int bw_x) { + uint64_t mask_x = (bw_x == 64 ? -1: ((1ULL << bw_x) - 1)); + return x & mask_x; +} + +inline int64_t signed_val(uint64_t x, int bw_x) { + uint64_t pow_x = (bw_x == 64? 0ULL: (1ULL << bw_x)); + uint64_t mask_x = pow_x - 1; + x = x & mask_x; + return int64_t(x - ((x >= (pow_x/2)) * pow_x)); +} diff --git a/SCI/tests/CMakeLists.txt b/SCI/tests/CMakeLists.txt index e10a12b0..ec1a9260 100644 --- a/SCI/tests/CMakeLists.txt +++ b/SCI/tests/CMakeLists.txt @@ -1,18 +1,30 @@ -set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) +macro (add_test_OT _name) + add_executable(${_name}-OT "test_ring_${_name}.cpp") + target_link_libraries(${_name}-OT SCI-OT) +endmacro() -macro (add_test _name) - add_executable(${_name} "test_${_name}.cpp") - target_link_libraries(${_name} SCI-Protocols) +macro (add_test_HE _name) + add_executable(${_name}-HE "test_field_${_name}.cpp") + target_link_libraries(${_name}-HE SCI-HE) endmacro() -# Tests -add_test(HE_conv) -add_test(HE_fc) -add_test(HE_elemwise_prod) -add_test(ring_relu) -add_test(argmax) -add_test(ring_argmax) -add_test(field_maxpool) -add_test(ring_maxpool) -add_test(linear) -add_test(functionalities) +add_test_OT(hadamard_product) +add_test_OT(matmul) +add_test_OT(value_extension) +add_test_OT(truncation) +add_test_OT(exp) +add_test_OT(sigmoid) +add_test_OT(relu) +add_test_OT(argmax) +add_test_OT(tanh) +add_test_OT(sqrt) +add_test_OT(aux_protocols) +add_test_OT(maxpool) +add_test_OT(library_fixed) + +add_test_HE(relu) +add_test_HE(maxpool) +add_test_HE(argmax) +add_test_HE(conv) +add_test_HE(fc) +add_test_HE(elemwise_prod) diff --git a/SCI/tests/test_HE_conv.cpp b/SCI/tests/test_HE_conv.cpp deleted file mode 100644 index 353e8443..00000000 --- a/SCI/tests/test_HE_conv.cpp +++ /dev/null @@ -1,154 +0,0 @@ -/* -Authors: Deevashwer Rathee -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#define SCI_HE -#define BITLEN_41 - -#include "LinearHE/conv-field.h" -#include "globals.h" - -using namespace std; -using namespace seal; -using namespace sci; - -int port = 8000; -string address; -bool localhost = true; -int image_h = 56; -int inp_chans = 64; -int filter_h = 3; -int out_chans = 64; -int pad_l = 0; -int pad_r = 0; -int stride = 2; -int filter_precision = 12; - -void Conv( - ConvField &he_conv, - int32_t H, - int32_t CI, - int32_t FH, - int32_t CO, - int32_t zPadHLeft, - int32_t zPadHRight, - int32_t strideH) -{ - int newH = 1 + (H+zPadHLeft+zPadHRight-FH)/strideH; - int N = 1; - int W = H; - int FW = FH; - int zPadWLeft = zPadHLeft; - int zPadWRight = zPadHRight; - int strideW = strideH; - int newW = newH; - vector<vector<vector<vector<uint64_t>>>> inputArr(N); - vector<vector<vector<vector<uint64_t>>>> filterArr(FH); - vector<vector<vector<vector<uint64_t>>>> outArr(N); - - PRG128 prg; - for(int i = 0; i < N; i++){ - outArr[i].resize(newH); - for(int j = 0; j < newH; j++) { - outArr[i][j].resize(newW); - for(int k = 0; k < newW; k++) { - outArr[i][j][k].resize(CO); - } - } - } - if(party == SERVER) { - for(int i = 0; i < FH; i++){ - filterArr[i].resize(FW); - for(int j = 0; j < FW; j++) { - filterArr[i][j].resize(CI); - for(int k = 0; k < CI; k++) { - filterArr[i][j][k].resize(CO); - prg.random_data(filterArr[i][j][k].data(), CO*sizeof(uint64_t)); - for(int h = 0; h < CO; h++) { - filterArr[i][j][k][h] - = ((int64_t) filterArr[i][j][k][h]) >> (64 - filter_precision); - } - } - } - } - } - for(int i = 0; i < N; i++){ - inputArr[i].resize(H); - for(int j = 0; j < H; j++) { - inputArr[i][j].resize(W); - for(int k = 0; k < W; k++) { - inputArr[i][j][k].resize(CI); - prg.random_mod_p<uint64_t>(inputArr[i][j][k].data(), CI, prime_mod); - } - } - } - uint64_t comm_start = he_conv.io->counter; - INIT_TIMER; - START_TIMER; - he_conv.convolution(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, - zPadWRight, strideH, strideW, inputArr, filterArr, outArr, true, true); - STOP_TIMER("Total Time for Conv"); - uint64_t comm_end = he_conv.io->counter; - cout << "Total Comm: " << (comm_end - comm_start)/(1.0*(1ULL << 20)) << endl; -} - -int main(int argc, char** argv) { - ArgMapping amap; - amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("h", image_h, "Image Height/Width"); - amap.arg("f", filter_h, "Filter Height/Width"); - amap.arg("i", inp_chans, "Input Channels"); - amap.arg("o", out_chans, "Ouput Channels"); - amap.arg("s", stride, "stride"); - amap.arg("pl", pad_l, "Left Padding"); - amap.arg("pr", pad_r, "Right Padding"); - amap.arg("fp", filter_precision, "Filter Precision"); - amap.arg("lo", localhost, "Localhost Run?"); - amap.parse(argc, argv); - - if(not localhost) { -#if defined(LAN_EXEC) - address = "40.118.124.169"; // SGX4 -#elif defined(WAN_EXEC) - address = "40.117.40.111"; // SGX2 -#endif - } else { - address = "127.0.0.1"; - } - - cout << "==================================================================" << endl; - cout << "Role: " << party << " - Bitlength: " << bitlength - << " - Image: " << image_h << "x" << image_h << "x" << inp_chans - << " - Filter: " << filter_h << "x" << filter_h << "x" << out_chans - << "\n- Stride: " << stride << "x" << stride - << " - Padding: " << pad_l << "x" << pad_r - << " - # Threads: " << numThreads << endl; - cout << "==================================================================" << endl; - - io = new NetIO(party==1 ? nullptr:address.c_str(), port); - - ConvField he_conv(party, io); - - Conv(he_conv, image_h, inp_chans, filter_h, out_chans, pad_l, pad_r, stride); - - io->flush(); - return 0; -} diff --git a/SCI/tests/test_HE_elemwise_prod.cpp b/SCI/tests/test_HE_elemwise_prod.cpp deleted file mode 100644 index 2bb5c207..00000000 --- a/SCI/tests/test_HE_elemwise_prod.cpp +++ /dev/null @@ -1,90 +0,0 @@ -/* -Authors: Deevashwer Rathee -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#define SCI_HE -#define BITLEN_41 - -#include "LinearHE/elemwise-prod-field.h" -#include "globals.h" - -using namespace std; -using namespace seal; -using namespace sci; - -int port = 8000; -string address; -bool localhost = true; -int vec_size = 56*56; -int filter_precision = 15; - -void ElemWiseProd( - ElemWiseProdField &he_prod, - int32_t size) -{ - vector<uint64_t> inArr(size); - vector<uint64_t> multArr(size); - vector<uint64_t> outArr(size); - PRG128 prg; - if (party == SERVER) { - prg.random_data(multArr.data(), size*sizeof(uint64_t)); - for(int i = 0; i < size; i++) { - multArr[i] = ((int64_t) multArr[i]) >> (64 - filter_precision); - } - } - prg.random_mod_p<uint64_t>(inArr.data(), size, prime_mod); - - INIT_TIMER; - START_TIMER; - he_prod.elemwise_product(size, inArr, multArr, outArr, true, true); - STOP_TIMER("Total Time for ElemWiseProduct"); -} - -int main(int argc, char** argv) { - ArgMapping amap; - amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("s", vec_size, "Size of Vectors"); - amap.arg("fp", filter_precision, "Filter Precision"); - amap.arg("lo", localhost, "Localhost Run?"); - amap.parse(argc, argv); - - if(not localhost) { -#if defined(LAN_EXEC) - address = "40.118.124.169"; // SGX4 -#elif defined(WAN_EXEC) - address = "40.117.40.111"; // SGX2 -#endif - } else { - address = "127.0.0.1"; - } - - cout << "========================================================================" << endl; - cout << "Role: " << party << " - Bitlength: " << bitlength << " - Vector Size: " - << vec_size << " - # Threads: " << numThreads << endl; - cout << "========================================================================" << endl; - - io = new NetIO(party==1 ? nullptr:address.c_str(), port); - - ElemWiseProdField he_prod(party, io); - - ElemWiseProd(he_prod, vec_size); - return 0; -} diff --git a/SCI/tests/test_HE_fc.cpp b/SCI/tests/test_HE_fc.cpp deleted file mode 100644 index 03d0734b..00000000 --- a/SCI/tests/test_HE_fc.cpp +++ /dev/null @@ -1,102 +0,0 @@ -/* -Authors: Deevashwer Rathee -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#define SCI_HE -#define BITLEN_41 - -#include "LinearHE/fc-field.h" -#include "globals.h" - -using namespace std; -using namespace seal; -using namespace sci; - -int port = 8000; -string address; -bool localhost = true; -int num_rows = 1001; -int common_dim = 512; -int filter_precision = 15; - -void MatMul( - FCField &he_fc, - int32_t num_rows, - int32_t common_dim) -{ - int num_cols = 1; - vector<vector<uint64_t>> A(num_rows); // Weights - vector<vector<uint64_t>> B(common_dim); // Image - vector<vector<uint64_t>> C(num_rows); - PRG128 prg; - for(int i = 0; i < num_rows; i++){ - A[i].resize(common_dim); - C[i].resize(num_cols); - if (party == SERVER) { - prg.random_data(A[i].data(), common_dim*sizeof(uint64_t)); - for(int j = 0; j < common_dim; j++) { - A[i][j] = ((int64_t) A[i][j]) >> (64 - filter_precision); - } - } - } - for(int i = 0; i < common_dim; i++){ - B[i].resize(1); - prg.random_mod_p<uint64_t>(B[i].data(), num_cols, prime_mod); - } - INIT_TIMER; - START_TIMER; - he_fc.matrix_multiplication(num_rows, common_dim, num_cols, A, B, C, true, true); - STOP_TIMER("Total Time for FC"); -} - -int main(int argc, char** argv) { - ArgMapping amap; - amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("n", num_rows, "Rows in Weight Matrix"); - amap.arg("c", common_dim, "Image Length / Columns in Weight Matrix"); - amap.arg("fp", filter_precision, "Filter Precision"); - amap.arg("lo", localhost, "Localhost Run?"); - amap.parse(argc, argv); - - if(not localhost) { -#if defined(LAN_EXEC) - address = "40.118.124.169"; // SGX4 -#elif defined(WAN_EXEC) - address = "40.117.40.111"; // SGX2 -#endif - } else { - address = "127.0.0.1"; - } - - cout << "====================================================================" << endl; - cout << "Role: " << party << " - Bitlength: " << bitlength << " - Rows: " << num_rows - << " - Cols: " << common_dim << " - # Threads: " << numThreads << endl; - cout << "====================================================================" << endl; - - io = new NetIO(party==1 ? nullptr:address.c_str(), port); - - FCField he_fc(party, io); - - MatMul(he_fc, num_rows, common_dim); - - io->flush(); - return 0; -} diff --git a/SCI/tests/test_argmax.cpp b/SCI/tests/test_argmax.cpp deleted file mode 100644 index 11c74a70..00000000 --- a/SCI/tests/test_argmax.cpp +++ /dev/null @@ -1,208 +0,0 @@ -/* -Authors: Mayank Rathee, Deevashwer Rathee -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#define BITLEN_41 -#define SCI_HE - -#include "globals.h" -#include "NonLinear/relu-field.h" -#include "NonLinear/relu-ring.h" -#include "NonLinear/argmax.h" - -using namespace std; -using namespace sci; - -int l = 41, b = 4; - -int main(int argc, char** argv){ - int port=32000, party=1, num_argmax = 1000; - string address; - bool localhost = true; - ArgMapping amap; - amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("l", l, "Bitlength of inputs"); - amap.arg("N", num_argmax, "Number of elements"); - amap.arg("b", b, "Radix base"); - amap.arg("lo", localhost, "Localhost Run?"); - - amap.parse(argc, argv); - - if(not localhost) { - address = "40.118.124.169"; - } else { - address = "127.0.0.1"; - } - - NetIO * io = new NetIO(party==ALICE ? nullptr:"127.0.0.1", port); - uint64_t prime_mod = 0; - if(l == 41){ - prime_mod = 2061584302081; - } - else if(l == 32){ - prime_mod = 4294967279; - } - else{ - prime_mod = 149; - } - uint64_t magnitude_bound = prime_mod/8; - OTPack otpack(io, party, b, l); - ArgMaxProtocol<NetIO, uint64_t> argmax_oracle(party, FIELD, io, l, b, prime_mod, &otpack); - - PRG128 prg; - uint64_t *input_share1, *input_share2, *input_share_uncorrected; - uint8_t *input_share_sign; - input_share_uncorrected = new uint64_t[num_argmax]; - input_share1 = new uint64_t[num_argmax]; - input_share2 = new uint64_t[num_argmax]; - input_share_sign = new uint8_t[num_argmax]; - - uint64_t* argmax_output_protocol = new uint64_t[1]; - uint64_t* argmax_output_protocol_share_other = new uint64_t[1]; - uint64_t* argmax_output_protocol_arg = new uint64_t[1]; - uint64_t* argmax_output_protocol_share_other_arg = new uint64_t[1]; - uint64_t* argmax_output_actual = new uint64_t[1]; - switch (party){ - case ALICE: { - prg.random_data(input_share_uncorrected, sizeof(uint64_t)*num_argmax); - prg.random_data(input_share_sign, num_argmax); - uint64_t comm_start = io->counter; - auto start = clock_start(); - for(int i=0; i<num_argmax; i++){ - input_share_uncorrected[i] %= magnitude_bound; - } - for(int i=0; i<num_argmax; i++){ - if(input_share_sign[i] & 1){ - input_share1[i] = sci::neg_mod(-1*(int64_t)input_share_uncorrected[i], prime_mod); - //cin>>input_share1[i]; - } - else{ - input_share1[i] = input_share_uncorrected[i]; - //cin>>input_share1[i]; - } - } - argmax_oracle.ArgMaxMPC(num_argmax, input_share1, argmax_output_protocol_arg, true, argmax_output_protocol); - - long long t = time_from(start); - uint64_t comm_end = io->counter; - cout <<"Comparison Time\t"<<RED<<(double(num_argmax)/t)*1e6<<" ArgMax/sec" <<RESET<< endl; - cout << "ALICE communication\t" <<BLUE<< ((double)(comm_end - comm_start)*8)/(l*num_argmax) << "*" << l << " bits/ArgMax"<<RESET<< endl; - std::cout<<"ALICE: Done MaxPool protocol execution"<<std::endl; - io->recv_data(input_share2, sizeof(uint64_t)*num_argmax); - io->recv_data(argmax_output_protocol_share_other, sizeof(uint64_t)*1); - io->recv_data(argmax_output_protocol_share_other_arg, sizeof(uint64_t)*1); - - cout<<"Checking correctness of ArgMax now..."<<endl; - // Check correctness - //for(int i=0; i<num_argmax; i++){ - //std::cout<<"Shares are #"<<i<<"\t is: "<<(int32_t)input_share1[i]<<"\t and: "<<(int32_t)input_share2[i]<<"\t | bound is: "<<(int32_t)(1<<(l-2))<<std::endl; - //} - - argmax_output_protocol[0] = (argmax_output_protocol[0] + argmax_output_protocol_share_other[0]) % prime_mod; - argmax_output_protocol_arg[0] = (argmax_output_protocol_arg[0] + argmax_output_protocol_share_other_arg[0]) % prime_mod; - uint64_t max_mag = 0; - uint64_t max_mag_2 = 0; - for(int i=0; i<num_argmax; i++){ - input_share1[i] = (input_share1[i] + input_share2[i]) % prime_mod; - if(input_share1[i] < (prime_mod/2)){ - if(input_share1[i] > max_mag){ - max_mag_2 = max_mag; - max_mag = input_share1[i]; - } - else if(input_share1[i] > max_mag_2){ - max_mag_2 = input_share1[i]; - } - } - else{ - uint64_t v = prime_mod - input_share1[i]; - if(v > max_mag){ - max_mag_2 = max_mag; - max_mag = v; - } - else if(v > max_mag_2){ - max_mag_2 = v; - } - } - } - if((max_mag + max_mag) >= (prime_mod/2)){ - cout<<RED<<"Shares exceed their magnitude bound!"<<RESET<<endl; - assert(false); - } - argmax_output_actual[0] = input_share1[0]; - for(int i=1; i<num_argmax; i++){ - argmax_output_actual[0] = ((sci::neg_mod(argmax_output_actual[0] - input_share1[i], (int64_t)prime_mod) - > (prime_mod/2))?input_share1[i]:argmax_output_actual[0]); - } - //std::cout<<"Prime : "<<prime_mod<<std::endl; - //for(int i=0; i<num_argmax; i++){ - //if(argmax_output_protocol[0] == input_share1[i]){ - //assert(argmax_output_protocol_arg[0] == i); - //cout<<"Protocol answer exists in inputs at index "<<i<<endl; - //} - //if(argmax_output_actual[0] == input_share1[i]){ - //assert(argmax_output_protocol_arg[0] == i); - //cout<<"Ideal answer exists in inputs at index "<<i<<endl; - //} - //std::cout<<"Inputs: "<<input_share1[i]<<std::endl; - //} - std::cout<<"Max Protocol: "<<argmax_output_protocol[0]<<std::endl; - std::cout<<"Max Actual: "<<argmax_output_actual[0]<<std::endl; - std::cout<<"ArgMax Protocol: "<<argmax_output_protocol_arg[0]<<std::endl; - - assert(argmax_output_actual[0] == argmax_output_protocol[0] && "ArgMax output is incorrect"); - - cout<<"ArgMax answer is: "<<GREEN<<"CORRECT!"<<RESET<<endl; - break; - } - case BOB: { - // These are written so that overall time excludes these. - prg.random_data(input_share_uncorrected, sizeof(uint64_t)*num_argmax); - prg.random_data(input_share_sign, num_argmax); - uint64_t comm_start = io->counter; - - for(int i=0; i<num_argmax; i++){ - input_share_uncorrected[i] %= magnitude_bound; - } - for(int i=0; i<num_argmax; i++){ - if(input_share_sign[i] & 1){ - input_share2[i] = sci::neg_mod(-1*(int64_t)input_share_uncorrected[i], prime_mod); - //input_share2[i] = 0; - } - else{ - input_share2[i] = input_share_uncorrected[i]; - //input_share2[i] = 0; - } - } - argmax_oracle.ArgMaxMPC(num_argmax, input_share2, argmax_output_protocol_arg, true, argmax_output_protocol); - - uint64_t comm_end = io->counter; - cout << "BOB communication\t" <<BLUE<< ((double)(comm_end - comm_start)*8)/(l*num_argmax) << "*" << l << " bits/ArgMax" <<RESET<< endl; - - std::cout<<"BOB: Done MaxPool protocol execution"<<std::endl; - io->send_data(input_share2, sizeof(uint64_t)*num_argmax); - io->send_data(argmax_output_protocol, sizeof(uint64_t)*1); - io->send_data(argmax_output_protocol_arg, sizeof(uint64_t)*1); - break; - } - } - return 0; -} - diff --git a/SCI/tests/test_field_argmax.cpp b/SCI/tests/test_field_argmax.cpp new file mode 100644 index 00000000..e8c06af2 --- /dev/null +++ b/SCI/tests/test_field_argmax.cpp @@ -0,0 +1,184 @@ +/* +Authors: Mayank Rathee, Deevashwer Rathee +Copyright: +Copyright (c) 2020 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "NonLinear/argmax.h" + +using namespace std; +using namespace sci; + +int party = 0; +int32_t bitlength = 32; +int num_threads = 1; +int port = 32000; +string address = "127.0.0.1"; +int num_argmax = 1000; + +int main(int argc, char **argv) { + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("N", num_argmax, "Number of elements"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + amap.arg("l", bitlength, "Bitlength of inputs"); + + amap.parse(argc, argv); + uint64_t prime_mod = sci::default_prime_mod.at(bitlength); + + NetIO *io = new NetIO(party == ALICE ? nullptr : address.c_str(), port); + uint64_t magnitude_bound = prime_mod / 8; + OTPack otpack(io, party); + ArgMaxProtocol<NetIO, uint64_t> argmax_oracle(party, FIELD, io, bitlength, + MILL_PARAM, prime_mod, &otpack); + + PRG128 prg; + uint64_t *input_share1, *input_share2, *input_share_uncorrected; + uint8_t *input_share_sign; + input_share_uncorrected = new uint64_t[num_argmax]; + input_share1 = new uint64_t[num_argmax]; + input_share2 = new uint64_t[num_argmax]; + input_share_sign = new uint8_t[num_argmax]; + + uint64_t *argmax_output_protocol = new uint64_t[1]; + uint64_t *argmax_output_protocol_share_other = new uint64_t[1]; + uint64_t *argmax_output_protocol_arg = new uint64_t[1]; + uint64_t *argmax_output_protocol_share_other_arg = new uint64_t[1]; + uint64_t *argmax_output_actual = new uint64_t[1]; + switch (party) { + case ALICE: { + prg.random_data(input_share_uncorrected, sizeof(uint64_t) * num_argmax); + prg.random_data(input_share_sign, num_argmax); + uint64_t comm_start = io->counter; + auto start = clock_start(); + for (int i = 0; i < num_argmax; i++) { + input_share_uncorrected[i] %= magnitude_bound; + } + for (int i = 0; i < num_argmax; i++) { + if (input_share_sign[i] & 1) { + input_share1[i] = + sci::neg_mod(-1 * (int64_t)input_share_uncorrected[i], prime_mod); + } else { + input_share1[i] = input_share_uncorrected[i]; + } + } + argmax_oracle.ArgMaxMPC(num_argmax, input_share1, + argmax_output_protocol_arg, true, + argmax_output_protocol); + + long long t = time_from(start); + uint64_t comm_end = io->counter; + cout << "Comparison Time\t" << RED << (double(num_argmax) / t) * 1e6 + << " ArgMax/sec" << RESET << endl; + cout << "ALICE communication\t" << BLUE + << ((double)(comm_end - comm_start) * 8) / (bitlength * num_argmax) + << "*" << bitlength << " bits/ArgMax" << RESET << endl; + std::cout << "ALICE: Done MaxPool protocol execution" << std::endl; + io->recv_data(input_share2, sizeof(uint64_t) * num_argmax); + io->recv_data(argmax_output_protocol_share_other, sizeof(uint64_t) * 1); + io->recv_data(argmax_output_protocol_share_other_arg, sizeof(uint64_t) * 1); + + cout << "Checking correctness of ArgMax now..." << endl; + + argmax_output_protocol[0] = + (argmax_output_protocol[0] + argmax_output_protocol_share_other[0]) % + prime_mod; + argmax_output_protocol_arg[0] = + (argmax_output_protocol_arg[0] + + argmax_output_protocol_share_other_arg[0]) % + prime_mod; + uint64_t max_mag = 0; + uint64_t max_mag_2 = 0; + for (int i = 0; i < num_argmax; i++) { + input_share1[i] = (input_share1[i] + input_share2[i]) % prime_mod; + if (input_share1[i] < (prime_mod / 2)) { + if (input_share1[i] > max_mag) { + max_mag_2 = max_mag; + max_mag = input_share1[i]; + } else if (input_share1[i] > max_mag_2) { + max_mag_2 = input_share1[i]; + } + } else { + uint64_t v = prime_mod - input_share1[i]; + if (v > max_mag) { + max_mag_2 = max_mag; + max_mag = v; + } else if (v > max_mag_2) { + max_mag_2 = v; + } + } + } + if ((max_mag + max_mag) >= (prime_mod / 2)) { + cout << RED << "Shares exceed their magnitude bound!" << RESET << endl; + assert(false); + } + argmax_output_actual[0] = input_share1[0]; + for (int i = 1; i < num_argmax; i++) { + argmax_output_actual[0] = + ((sci::neg_mod(argmax_output_actual[0] - input_share1[i], + (int64_t)prime_mod) > (prime_mod / 2)) + ? input_share1[i] + : argmax_output_actual[0]); + } + std::cout << "Max Protocol: " << argmax_output_protocol[0] << std::endl; + std::cout << "Max Actual: " << argmax_output_actual[0] << std::endl; + std::cout << "ArgMax Protocol: " << argmax_output_protocol_arg[0] + << std::endl; + + assert(argmax_output_actual[0] == argmax_output_protocol[0] && + "ArgMax output is incorrect"); + + cout << "ArgMax answer is: " << GREEN << "CORRECT!" << RESET << endl; + break; + } + case BOB: { + // These are written so that overall time excludes these. + prg.random_data(input_share_uncorrected, sizeof(uint64_t) * num_argmax); + prg.random_data(input_share_sign, num_argmax); + uint64_t comm_start = io->counter; + + for (int i = 0; i < num_argmax; i++) { + input_share_uncorrected[i] %= magnitude_bound; + } + for (int i = 0; i < num_argmax; i++) { + if (input_share_sign[i] & 1) { + input_share2[i] = + sci::neg_mod(-1 * (int64_t)input_share_uncorrected[i], prime_mod); + } else { + input_share2[i] = input_share_uncorrected[i]; + } + } + argmax_oracle.ArgMaxMPC(num_argmax, input_share2, + argmax_output_protocol_arg, true, + argmax_output_protocol); + + uint64_t comm_end = io->counter; + cout << "BOB communication\t" << BLUE + << ((double)(comm_end - comm_start) * 8) / (bitlength * num_argmax) + << "*" << bitlength << " bits/ArgMax" << RESET << endl; + + std::cout << "BOB: Done MaxPool protocol execution" << std::endl; + io->send_data(input_share2, sizeof(uint64_t) * num_argmax); + io->send_data(argmax_output_protocol, sizeof(uint64_t) * 1); + io->send_data(argmax_output_protocol_arg, sizeof(uint64_t) * 1); + break; + } + } + return 0; +} diff --git a/SCI/tests/test_field_conv.cpp b/SCI/tests/test_field_conv.cpp new file mode 100644 index 00000000..9785ab97 --- /dev/null +++ b/SCI/tests/test_field_conv.cpp @@ -0,0 +1,141 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2020 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "LinearHE/conv-field.h" + +using namespace std; +using namespace seal; +using namespace sci; + +int party = 0; +int bitlength = 32; +int num_threads = 4; +int port = 8000; +string address = "127.0.0.1"; +int image_h = 56; +int inp_chans = 64; +int filter_h = 3; +int out_chans = 64; +int pad_l = 0; +int pad_r = 0; +int stride = 2; +int filter_precision = 12; + +void Conv(ConvField &he_conv, int32_t H, int32_t CI, int32_t FH, int32_t CO, + int32_t zPadHLeft, int32_t zPadHRight, int32_t strideH) { + int newH = 1 + (H + zPadHLeft + zPadHRight - FH) / strideH; + int N = 1; + int W = H; + int FW = FH; + int zPadWLeft = zPadHLeft; + int zPadWRight = zPadHRight; + int strideW = strideH; + int newW = newH; + vector<vector<vector<vector<uint64_t>>>> inputArr(N); + vector<vector<vector<vector<uint64_t>>>> filterArr(FH); + vector<vector<vector<vector<uint64_t>>>> outArr(N); + + PRG128 prg; + for (int i = 0; i < N; i++) { + outArr[i].resize(newH); + for (int j = 0; j < newH; j++) { + outArr[i][j].resize(newW); + for (int k = 0; k < newW; k++) { + outArr[i][j][k].resize(CO); + } + } + } + if (party == ALICE) { + for (int i = 0; i < FH; i++) { + filterArr[i].resize(FW); + for (int j = 0; j < FW; j++) { + filterArr[i][j].resize(CI); + for (int k = 0; k < CI; k++) { + filterArr[i][j][k].resize(CO); + prg.random_data(filterArr[i][j][k].data(), CO * sizeof(uint64_t)); + for (int h = 0; h < CO; h++) { + filterArr[i][j][k][h] = + ((int64_t)filterArr[i][j][k][h]) >> (64 - filter_precision); + } + } + } + } + } + for (int i = 0; i < N; i++) { + inputArr[i].resize(H); + for (int j = 0; j < H; j++) { + inputArr[i][j].resize(W); + for (int k = 0; k < W; k++) { + inputArr[i][j][k].resize(CI); + prg.random_mod_p<uint64_t>(inputArr[i][j][k].data(), CI, prime_mod); + } + } + } + uint64_t comm_start = he_conv.io->counter; + INIT_TIMER; + START_TIMER; + he_conv.convolution(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft, + zPadWRight, strideH, strideW, inputArr, filterArr, outArr, + true, true); + STOP_TIMER("Total Time for Conv"); + uint64_t comm_end = he_conv.io->counter; + cout << "Total Comm: " << (comm_end - comm_start) / (1.0 * (1ULL << 20)) + << endl; +} + +int main(int argc, char **argv) { + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("nt", num_threads, "Number of Threads"); + amap.arg("l", bitlength, "Bitlength"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + amap.arg("p", port, "Port Number"); + amap.arg("h", image_h, "Image Height/Width"); + amap.arg("f", filter_h, "Filter Height/Width"); + amap.arg("i", inp_chans, "Input Channels"); + amap.arg("o", out_chans, "Ouput Channels"); + amap.arg("s", stride, "stride"); + amap.arg("pl", pad_l, "Left Padding"); + amap.arg("pr", pad_r, "Right Padding"); + amap.arg("fp", filter_precision, "Filter Precision"); + amap.parse(argc, argv); + prime_mod = sci::default_prime_mod.at(bitlength); + + cout << "==================================================================" + << endl; + cout << "Role: " << party << " - Bitlength: " << bitlength + << " - Mod: " << prime_mod << " - Image: " << image_h << "x" << image_h + << "x" << inp_chans << " - Filter: " << filter_h << "x" << filter_h + << "x" << out_chans << "\n- Stride: " << stride << "x" << stride + << " - Padding: " << pad_l << "x" << pad_r + << " - # Threads: " << num_threads << endl; + cout << "==================================================================" + << endl; + + NetIO *io = new NetIO(party == 1 ? nullptr : address.c_str(), port); + + ConvField he_conv(party, io); + + Conv(he_conv, image_h, inp_chans, filter_h, out_chans, pad_l, pad_r, stride); + + io->flush(); + return 0; +} diff --git a/SCI/tests/test_field_elemwise_prod.cpp b/SCI/tests/test_field_elemwise_prod.cpp new file mode 100644 index 00000000..697634ca --- /dev/null +++ b/SCI/tests/test_field_elemwise_prod.cpp @@ -0,0 +1,80 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2020 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ +#include "LinearHE/elemwise-prod-field.h" + +using namespace std; +using namespace seal; +using namespace sci; + +int party = 0; +int bitlength = 32; +int num_threads = 1; +int port = 8000; +string address = "127.0.0.1"; +int vec_size = 56 * 56; +int filter_precision = 15; + +void ElemWiseProd(ElemWiseProdField &he_prod, int32_t size) { + vector<uint64_t> inArr(size); + vector<uint64_t> multArr(size); + vector<uint64_t> outArr(size); + PRG128 prg; + if (party == ALICE) { + prg.random_data(multArr.data(), size * sizeof(uint64_t)); + for (int i = 0; i < size; i++) { + multArr[i] = ((int64_t)multArr[i]) >> (64 - filter_precision); + } + } + prg.random_mod_p<uint64_t>(inArr.data(), size, prime_mod); + + INIT_TIMER; + START_TIMER; + he_prod.elemwise_product(size, inArr, multArr, outArr, true, true); + STOP_TIMER("Total Time for ElemWiseProduct"); +} + +int main(int argc, char **argv) { + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("s", vec_size, "Size of Vectors"); + amap.arg("fp", filter_precision, "Filter Precision"); + amap.arg("l", bitlength, "Bitlength of inputs"); + amap.parse(argc, argv); + prime_mod = sci::default_prime_mod.at(bitlength); + + cout << "====================================================================" + "====" + << endl; + cout << "Role: " << party << " - Bitlength: " << bitlength + << " - Mod: " << prime_mod << " - Vector Size: " << vec_size + << " - # Threads: " << num_threads << endl; + cout << "====================================================================" + "====" + << endl; + + NetIO *io = new NetIO(party == 1 ? nullptr : address.c_str(), port); + + ElemWiseProdField he_prod(party, io); + + ElemWiseProd(he_prod, vec_size); + return 0; +} diff --git a/SCI/tests/test_field_fc.cpp b/SCI/tests/test_field_fc.cpp new file mode 100644 index 00000000..a25e14fb --- /dev/null +++ b/SCI/tests/test_field_fc.cpp @@ -0,0 +1,91 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2020 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ +#include "LinearHE/fc-field.h" + +using namespace std; +using namespace seal; +using namespace sci; + +int party = 0; +int bitlength = 32; +int num_threads = 4; +int port = 8000; +string address = "127.0.0.1"; +int num_rows = 1001; +int common_dim = 512; +int filter_precision = 15; + +void MatMul(FCField &he_fc, int32_t num_rows, int32_t common_dim) { + int num_cols = 1; + vector<vector<uint64_t>> A(num_rows); // Weights + vector<vector<uint64_t>> B(common_dim); // Image + vector<vector<uint64_t>> C(num_rows); + PRG128 prg; + for (int i = 0; i < num_rows; i++) { + A[i].resize(common_dim); + C[i].resize(num_cols); + if (party == ALICE) { + prg.random_data(A[i].data(), common_dim * sizeof(uint64_t)); + for (int j = 0; j < common_dim; j++) { + A[i][j] = ((int64_t)A[i][j]) >> (64 - filter_precision); + } + } + } + for (int i = 0; i < common_dim; i++) { + B[i].resize(1); + prg.random_mod_p<uint64_t>(B[i].data(), num_cols, prime_mod); + } + INIT_TIMER; + START_TIMER; + he_fc.matrix_multiplication(num_rows, common_dim, num_cols, A, B, C, true, + true); + STOP_TIMER("Total Time for FC"); +} + +int main(int argc, char **argv) { + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("n", num_rows, "Rows in Weight Matrix"); + amap.arg("c", common_dim, "Image Length / Columns in Weight Matrix"); + amap.arg("fp", filter_precision, "Filter Precision"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + amap.arg("l", bitlength, "Bitlength of inputs"); + amap.parse(argc, argv); + prime_mod = sci::default_prime_mod.at(bitlength); + + cout << "====================================================================" + << endl; + cout << "Role: " << party << " - Bitlength: " << bitlength + << " - Mod: " << prime_mod << " - Rows: " << num_rows + << " - Cols: " << common_dim << " - # Threads: " << num_threads << endl; + cout << "====================================================================" + << endl; + + NetIO *io = new NetIO(party == 1 ? nullptr : address.c_str(), port); + + FCField he_fc(party, io); + + MatMul(he_fc, num_rows, common_dim); + + io->flush(); + return 0; +} diff --git a/SCI/tests/test_field_maxpool.cpp b/SCI/tests/test_field_maxpool.cpp index 10d11733..7c5d454b 100644 --- a/SCI/tests/test_field_maxpool.cpp +++ b/SCI/tests/test_field_maxpool.cpp @@ -19,209 +19,183 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#define BITLEN_41 -#define SCI_HE -#include "globals.h" -#include "NonLinear/relu-field.h" -#include "NonLinear/relu-ring.h" -#include "NonLinear/maxpool.h" +#include "library_fixed.h" #include <fstream> #include <thread> using namespace std; using namespace sci; +#define MAX_THREADS 4 + +int party = 0; int port = 32000; -int num_rows = 1<<15, num_cols = 1<<6; -int l = 41, b = 5; +int num_rows = 1 << 10, num_cols = 1 << 6; +int bitlength = 32, b = 4; int batch_size = 0; -string address; -bool localhost = true; - -void field_maxpool_thread(int tid, uint64_t* z, uint64_t* x, int lnum_rows, int lnum_cols) { - MaxPoolProtocol<NetIO, uint64_t>* maxpool_oracle; - if(tid & 1) { - maxpool_oracle = new MaxPoolProtocol<NetIO, uint64_t>(3-party, FIELD, ioArr[tid], l, b, prime_mod, otpackArr[tid]); - } else { - maxpool_oracle = new MaxPoolProtocol<NetIO, uint64_t>(party, FIELD, ioArr[tid], l, b, prime_mod, otpackArr[tid]); - } - if (batch_size) { - for (int j = 0; j < lnum_rows; j += batch_size) { - if (batch_size <= lnum_rows - j) { - maxpool_oracle->funcMaxMPC(batch_size, lnum_cols, x+j, z+j, nullptr); - } else { - maxpool_oracle->funcMaxMPC(lnum_rows-j, lnum_cols, x+j, z+j, nullptr); - } - } - } else { - maxpool_oracle->funcMaxMPC(lnum_rows, lnum_cols, x, z, nullptr); +string address = "127.0.0.1"; +int num_threads = 1; + +void field_maxpool_thread(int tid, uint64_t *z, uint64_t *x, int lnum_rows, + int lnum_cols) { + MaxPoolProtocol<NetIO, uint64_t> *maxpool_oracle; + if (tid & 1) { + maxpool_oracle = new MaxPoolProtocol<NetIO, uint64_t>( + 3 - party, FIELD, ioArr[tid], bitlength, b, prime_mod, otpackArr[tid]); + } else { + maxpool_oracle = new MaxPoolProtocol<NetIO, uint64_t>( + party, FIELD, ioArr[tid], bitlength, b, prime_mod, otpackArr[tid]); + } + if (batch_size) { + for (int j = 0; j < lnum_rows; j += batch_size) { + if (batch_size <= lnum_rows - j) { + maxpool_oracle->funcMaxMPC(batch_size, lnum_cols, x + j, z + j, + nullptr); + } else { + maxpool_oracle->funcMaxMPC(lnum_rows - j, lnum_cols, x + j, z + j, + nullptr); + } } + } else { + maxpool_oracle->funcMaxMPC(lnum_rows, lnum_cols, x, z, nullptr); + } - delete maxpool_oracle; - return; + delete maxpool_oracle; + return; } -int main(int argc, char** argv){ - /************* Argument Parsing ************/ - /********************************************/ - - ArgMapping amap; - amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("l", l, "Bitlength of inputs"); - amap.arg("b", b, "Radix base"); - amap.arg("Nr", num_rows, "Number of rows"); - amap.arg("Nc", num_cols, "Number of cols"); - amap.arg("lo", localhost, "Localhost Run?"); - amap.arg("bt", batch_size, "Batch size as a power of 2 (No batching = 0)"); - - amap.parse(argc, argv); - if (batch_size > 0) { - batch_size = 1 << batch_size; - } - if(not localhost) { - address = "40.118.124.169"; +int main(int argc, char **argv) { + /************* Argument Parsing ************/ + /********************************************/ + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("l", bitlength, "Bitlength of inputs"); + amap.arg("b", b, "Radix base"); + amap.arg("Nr", num_rows, "Number of rows"); + amap.arg("Nc", num_cols, "Number of cols"); + amap.arg("bt", batch_size, "Batch size as a power of 2 (No batching = 0)"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + prime_mod = sci::default_prime_mod.at(bitlength); + + if (batch_size > 0) { + batch_size = 1 << batch_size; + } + num_rows = ((num_rows + 7) / 8) * 8; + + cout << "========================================================" << endl; + cout << "Role: " << party << " - Bitlength: " << bitlength + << " - Radix Base: " << b << "\n#rows: " << num_rows + << " - #cols: " << num_cols << " - Batch Size: " << batch_size + << " - # Threads: " << num_threads << endl; + cout << "========================================================" << endl; + + /************ Generate Test Data ************/ + /********************************************/ + PRG128 prg; + uint64_t *x = new uint64_t[num_rows * num_cols]; + uint64_t *z = new uint64_t[num_rows]; + prg.random_data(x, sizeof(uint64_t) * num_rows * num_cols); + for (int i = 0; i < num_rows * num_cols; i++) { + x[i] = x[i] % prime_mod; + } + + /********** Setup IO and Base OTs ***********/ + /********************************************/ + + for (int i = 0; i < num_threads; i++) { + ioArr[i] = new NetIO(party == 1 ? nullptr : address.c_str(), port + i); + if (i == 0) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); } else { - address = "127.0.0.1"; - } - num_rows = ((num_rows + 7)/8)*8; - - cout << "========================================================" << endl; - cout << "Role: " << party << " - Bitlength: " << l << " - Radix Base: " << b - << "\n#rows: " << num_rows << " - #cols: " << num_cols << " - Batch Size: " - << batch_size << " - # Threads: " << numThreads << endl; - cout << "========================================================" << endl; - - /************ Generate Test Data ************/ - /********************************************/ - uint64_t magnitude_bound = prime_mod/8; - PRG128 prg; - uint64_t *x = new uint64_t[num_rows*num_cols]; - uint8_t *x_sign = new uint8_t[num_rows*num_cols]; - uint64_t *z = new uint64_t[num_rows]; - prg.random_data(x, sizeof(uint64_t)*num_rows*num_cols); - prg.random_bool((bool*) x_sign, num_rows*num_cols); - for(int i = 0; i < num_rows*num_cols; i++) { - x[i] = x[i] % magnitude_bound; - if (x_sign[i]) { - x[i] = prime_mod - x[i]; - } - } - delete[] x_sign; - - /********** Setup IO and Base OTs ***********/ - /********************************************/ - - for(int i = 0; i < numThreads; i++) { - ioArr[i] = new NetIO(party==1 ? nullptr:address.c_str(), port+i); - if (i == 0) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, b, l); - } else if (i == 1) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3-party, b, l); - } else if (i & 1) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3-party, b, l, false); - otpackArr[i]->copy(otpackArr[1]); - } else { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, b, l, false); - otpackArr[i]->copy(otpackArr[0]); - } - } - std::cout << "All Base OTs Done" << std::endl; - - /************** Fork Threads ****************/ - /********************************************/ - - auto start = clock_start(); - std::thread maxpool_threads[numThreads]; - int chunk_size = (num_rows/(8*numThreads))*8; - for (int i = 0; i < numThreads; ++i) { - int offset = i*chunk_size; - int lnum_rows; - if (i == (numThreads - 1)) { - lnum_rows = num_rows - offset; - } else { - lnum_rows = chunk_size; - } - maxpool_threads[i] = std::thread(field_maxpool_thread, i, z+offset, x+offset*num_cols, lnum_rows, num_cols); + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); } - for (int i = 0; i < numThreads; ++i) { - maxpool_threads[i].join(); - } - long long t = time_from(start); - - /************** Verification ****************/ - /********************************************/ - - switch (party) { - case sci::ALICE: { - ioArr[0]->send_data(x, sizeof(uint64_t)*num_rows*num_cols); - ioArr[0]->send_data(z, sizeof(uint64_t)*num_rows); - break; - } - case sci::BOB: { - uint64_t *xi = new uint64_t[num_rows*num_cols]; - uint64_t *zi = new uint64_t[num_rows]; - ioArr[0]->recv_data(xi, sizeof(uint64_t)*num_rows*num_cols); - ioArr[0]->recv_data(zi, sizeof(uint64_t)*num_rows); - - for(int i=0; i<num_rows; i++){ - zi[i] = (zi[i] + z[i]) % prime_mod; - for(int c=0; c<num_cols; c++){ - xi[i*num_cols + c] = (xi[i*num_cols + c] + x[i*num_cols + c]) % prime_mod; - } - uint64_t maxpool_output = xi[i*num_cols]; - for(int c=1; c<num_cols; c++){ - maxpool_output = sci::neg_mod((int64_t) maxpool_output - xi[i*num_cols + c], (int64_t) prime_mod) - > (prime_mod/2) ? xi[i*num_cols + c]:maxpool_output; - } - assert((zi[i] == maxpool_output) && "MaxPool output is incorrect"); - } - delete[] xi; - delete[] zi; - break; - } - } - delete[] x; - delete[] z; - - /**** Process & Write Benchmarking Data *****/ - /********************************************/ - - cout << "Number of Maxpool rows (num_cols=" << num_cols << ")/s:\t" - << (double(num_rows)/t)*1e6<< std::endl; - cout <<"Maxpool Time (l=" << l << "; b=" << b << ")\t" << t <<" mus"<< endl; - string file_addr; - switch (party) { - case 1: { - file_addr = "our-ring-maxpool-P0.csv"; - break; - } - case 2: { - file_addr = "our-ring-maxpool-P1.csv"; - break; - } - } - bool write_title = true; { - fstream result(file_addr.c_str(), fstream::in); - if(result.is_open()) - write_title = false; - result.close(); - } - fstream result(file_addr.c_str(), fstream::out|fstream::app); - if(write_title){ - result << "Bitlen,Base,Batch Size,#Threads,Maxpool Size,Time (mus),Throughput/sec" << endl; + } + std::cout << "All Base OTs Done" << std::endl; + + /************** Fork Threads ****************/ + /********************************************/ + + auto start = clock_start(); + std::thread maxpool_threads[num_threads]; + int chunk_size = (num_rows / (8 * num_threads)) * 8; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_rows; + if (i == (num_threads - 1)) { + lnum_rows = num_rows - offset; + } else { + lnum_rows = chunk_size; } - result << l << "," << b << "," << batch_size << "," << numThreads << "," << num_rows << "x" << num_cols - << "," << t << "," << (double(num_rows)/t)*1e6 << endl; - result.close(); - - /******************* Cleanup ****************/ - /********************************************/ - - for (int i = 0; i < numThreads; i++) { - delete ioArr[i]; - delete otpackArr[i]; + maxpool_threads[i] = + std::thread(field_maxpool_thread, i, z + offset, x + offset * num_cols, + lnum_rows, num_cols); + } + for (int i = 0; i < num_threads; ++i) { + maxpool_threads[i].join(); + } + long long t = time_from(start); + + /************** Verification ****************/ + /********************************************/ + + switch (party) { + case sci::ALICE: { + ioArr[0]->send_data(x, sizeof(uint64_t) * num_rows * num_cols); + ioArr[0]->send_data(z, sizeof(uint64_t) * num_rows); + break; + } + case sci::BOB: { + uint64_t *xi = new uint64_t[num_rows * num_cols]; + uint64_t *zi = new uint64_t[num_rows]; + ioArr[0]->recv_data(xi, sizeof(uint64_t) * num_rows * num_cols); + ioArr[0]->recv_data(zi, sizeof(uint64_t) * num_rows); + + for (int i = 0; i < num_rows; i++) { + zi[i] = (zi[i] + z[i]) % prime_mod; + for (int c = 0; c < num_cols; c++) { + xi[i * num_cols + c] = + (xi[i * num_cols + c] + x[i * num_cols + c]) % prime_mod; + } + uint64_t maxpool_output = xi[i * num_cols]; + for (int c = 1; c < num_cols; c++) { + maxpool_output = + sci::neg_mod((int64_t)maxpool_output - xi[i * num_cols + c], + (int64_t)prime_mod) > (prime_mod / 2) + ? xi[i * num_cols + c] + : maxpool_output; + } + assert((zi[i] == maxpool_output) && "MaxPool output is incorrect"); } - - return 0; + delete[] xi; + delete[] zi; + cout << "Maxpool Tests Passed" << endl; + break; + } + } + delete[] x; + delete[] z; + + cout << "Number of Maxpool rows (num_cols=" << num_cols << ")/s:\t" + << (double(num_rows) / t) * 1e6 << std::endl; + cout << "Maxpool Time (bitlength=" << bitlength << "; b=" << b << ")\t" << t + << " mus" << endl; + + /******************* Cleanup ****************/ + /********************************************/ + + for (int i = 0; i < num_threads; i++) { + delete ioArr[i]; + delete otpackArr[i]; + } + + return 0; } diff --git a/SCI/tests/test_field_relu.cpp b/SCI/tests/test_field_relu.cpp index 163d3f4a..c8b32817 100644 --- a/SCI/tests/test_field_relu.cpp +++ b/SCI/tests/test_field_relu.cpp @@ -19,262 +19,261 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#define BITLEN_32 -#define SCI_HE -#include <iostream> +#include "NonLinear/relu-field.h" +#include "library_fixed.h" #include <fstream> +#include <iostream> #include <thread> -#include "globals.h" -#include "NonLinear/relu-field.h" #define LAN_EXEC +#define MAX_THREADS 4 using namespace sci; using namespace std; -int num_relu = 1<<20, port = 32000; +int party = 0; +int num_relu = 1 << 10, port = 32000; int num_relu_orig = 0; -int l = 32, b = 4; +int b = 4; int batch_size = 0; -string address; -bool localhost = true; +string address = "127.0.0.1"; +int num_threads = 1; string network = "none"; vector<int> network_layer_sizes; +int32_t bitlength = 32; -const std::map<std::string, std::vector<int>> layer_sizes { - {"sq", - vector<int>({ 200704, 50176, 200704, 200704, 50176, 200704, 200704, 23328, 93312, 93312, 23328, 93312, 93312, 8112, 32448, 32448, 8112, 32448, 32448, 10816, 43264, 43264, 10816, 43264, 43264, 169000 }) - }, +const std::map<std::string, std::vector<int>> layer_sizes{ + {"sq", vector<int>({200704, 50176, 200704, 200704, 50176, 200704, 200704, + 23328, 93312, 93312, 23328, 93312, 93312, 8112, + 32448, 32448, 8112, 32448, 32448, 10816, 43264, + 43264, 10816, 43264, 43264, 169000})}, {"res", - vector<int>({ 200704, 200704, 200704, 802816, 200704, 200704, 802816, 200704, 200704, 802816, 401408, 100352, 401408, 100352, 100352, 401408, 100352, 100352, 401408, 100352, 100352, 401408, 200704, 50176, 200704, 50176, 50176, 200704, 50176, 50176, 200704, 50176, 50176, 200704, 50176, 50176, 200704, 50176, 50176, 200704, 100352, 25088, 100352, 25088, 25088, 100352, 25088, 25088, 100352 }) - }, + vector<int>({200704, 200704, 200704, 802816, 200704, 200704, 802816, + 200704, 200704, 802816, 401408, 100352, 401408, 100352, + 100352, 401408, 100352, 100352, 401408, 100352, 100352, + 401408, 200704, 50176, 200704, 50176, 50176, 200704, + 50176, 50176, 200704, 50176, 50176, 200704, 50176, + 50176, 200704, 50176, 50176, 200704, 100352, 25088, + 100352, 25088, 25088, 100352, 25088, 25088, 100352})}, {"dense", - vector<int>({ 200704, 200704, 401408, 301056, 401408, 401408, 401408, 501760, 401408, 602112, 401408, 702464, 401408, 802816, 100352, 100352, 125440, 100352, 150528, 100352, 175616, 100352, 200704, 100352, 225792, 100352, 250880, 100352, 275968, 100352, 301056, 100352, 326144, 100352, 351232, 100352, 376320, 100352, 401408, 50176, 25088, 56448, 25088, 62720, 25088, 68992, 25088, 75264, 25088, 81536, 25088, 87808, 25088, 94080, 25088, 100352, 25088, 106624, 25088, 112896, 25088, 119168, 25088, 125440, 25088, 131712, 25088, 137984, 25088, 144256, 25088, 150528, 25088, 156800, 25088, 163072, 25088, 169344, 25088, 175616, 25088, 181888, 25088, 188160, 25088, 194432, 25088, 200704, 25088, 6272, 26656, 6272, 28224, 6272, 29792, 6272, 31360, 6272, 32928, 6272, 34496, 6272, 36064, 6272, 37632, 6272, 39200, 6272, 40768, 6272, 42336, 6272, 43904, 6272, 45472, 6272, 47040, 6272, 48608, 6272, 50176 }) - }, + vector<int>( + {200704, 200704, 401408, 301056, 401408, 401408, 401408, 501760, + 401408, 602112, 401408, 702464, 401408, 802816, 100352, 100352, + 125440, 100352, 150528, 100352, 175616, 100352, 200704, 100352, + 225792, 100352, 250880, 100352, 275968, 100352, 301056, 100352, + 326144, 100352, 351232, 100352, 376320, 100352, 401408, 50176, + 25088, 56448, 25088, 62720, 25088, 68992, 25088, 75264, + 25088, 81536, 25088, 87808, 25088, 94080, 25088, 100352, + 25088, 106624, 25088, 112896, 25088, 119168, 25088, 125440, + 25088, 131712, 25088, 137984, 25088, 144256, 25088, 150528, + 25088, 156800, 25088, 163072, 25088, 169344, 25088, 175616, + 25088, 181888, 25088, 188160, 25088, 194432, 25088, 200704, + 25088, 6272, 26656, 6272, 28224, 6272, 29792, 6272, + 31360, 6272, 32928, 6272, 34496, 6272, 36064, 6272, + 37632, 6272, 39200, 6272, 40768, 6272, 42336, 6272, + 43904, 6272, 45472, 6272, 47040, 6272, 48608, 6272, + 50176})}, }; -void field_relu_thread(int tid, uint64_t* z, uint64_t* x, int lnum_relu) { - ReLUFieldProtocol<NetIO, uint64_t>* relu_oracle; - if(tid & 1) { - relu_oracle = new ReLUFieldProtocol<NetIO, uint64_t>(3-party, FIELD, ioArr[tid], l, b, prime_mod, otpackArr[tid]); - } else { - relu_oracle = new ReLUFieldProtocol<NetIO, uint64_t>(party, FIELD, ioArr[tid], l, b, prime_mod, otpackArr[tid]); - } - if (batch_size) { - for (int j = 0; j < lnum_relu; j += batch_size) { - if (batch_size <= lnum_relu - j) { - relu_oracle->relu(z+j, x+j, batch_size); - } else { - relu_oracle->relu(z+j, x+j, lnum_relu-j); - } - } - } else { - relu_oracle->relu(z, x, lnum_relu); +void field_relu_thread(int tid, uint64_t *z, uint64_t *x, int lnum_relu) { + ReLUFieldProtocol<NetIO, uint64_t> *relu_oracle; + if (tid & 1) { + relu_oracle = new ReLUFieldProtocol<NetIO, uint64_t>( + 3 - party, FIELD, ioArr[tid], bitlength, b, prime_mod, otpackArr[tid]); + } else { + relu_oracle = new ReLUFieldProtocol<NetIO, uint64_t>( + party, FIELD, ioArr[tid], bitlength, b, prime_mod, otpackArr[tid]); + } + if (batch_size) { + for (int j = 0; j < lnum_relu; j += batch_size) { + if (batch_size <= lnum_relu - j) { + relu_oracle->relu(z + j, x + j, batch_size); + } else { + relu_oracle->relu(z + j, x + j, lnum_relu - j); + } } + } else { + relu_oracle->relu(z, x, lnum_relu); + } - delete relu_oracle; - return; + delete relu_oracle; + return; } -int main(int argc, char** argv) { - /************* Argument Parsing ************/ - /********************************************/ +int main(int argc, char **argv) { + /************* Argument Parsing ************/ + /********************************************/ - ArgMapping amap; - amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("l", l, "Bitlength of inputs"); - amap.arg("N", num_relu, "Number of ReLUs"); - amap.arg("b", b, "Radix base"); - amap.arg("lo", localhost, "Localhost Run?"); - amap.arg("bt", batch_size, "Batch size as a power of 2 (No batching = 0)"); - amap.arg("network", network, "Network Type: sq - SqNet, res - ResNet50, dense - DenseNet121"); + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("N", num_relu, "Number of ReLUs"); + amap.arg("b", b, "Radix base"); + amap.arg("bt", batch_size, "Batch size as a power of 2 (No batching = 0)"); + amap.arg("network", network, + "Network Type: sq - SqNet, res - ResNet50, dense - DenseNet121"); + amap.arg("l", bitlength, "Bitlength of inputs"); + amap.parse(argc, argv); + prime_mod = sci::default_prime_mod.at(bitlength); - amap.parse(argc, argv); - - if (batch_size > 0) { - batch_size = 1 << batch_size; - } - if(not localhost) { -#if defined(LAN_EXEC) - address = "40.118.124.169"; // SGX4 -#elif defined(WAN_EXEC) - address = "40.117.40.111"; // SGX2 -#endif - } else { - address = "127.0.0.1"; - } - if (network != "none") { - num_relu = 0; - network_layer_sizes = layer_sizes.at(network); - for(size_t i = 0; i < network_layer_sizes.size(); i++) { - num_relu_orig += network_layer_sizes[i]; - num_relu += ((network_layer_sizes[i] + 7)/8)*8; - } - if (network == "res") l = 37; - else l = 32; - } else { - num_relu_orig = num_relu; - num_relu = ((num_relu + 7)/8)*8; + if (batch_size > 0) { + batch_size = 1 << batch_size; + } + if (network != "none") { + num_relu = 0; + network_layer_sizes = layer_sizes.at(network); + for (size_t i = 0; i < network_layer_sizes.size(); i++) { + num_relu_orig += network_layer_sizes[i]; + num_relu += ((network_layer_sizes[i] + 7) / 8) * 8; } + if (network == "res") + bitlength = 37; + else + bitlength = 32; + } else { + num_relu_orig = num_relu; + num_relu = ((num_relu + 7) / 8) * 8; + } - cout << "========================================================" << endl; - cout << "Role: " << party << " - Bitlength: " << l << " - Radix Base: " << b - << "\n# ReLUs: " << num_relu_orig << " - Batch Size: " - << batch_size << " - # Threads: " << numThreads << endl; - cout << "========================================================" << endl; + cout << "========================================================" << endl; + cout << "Role: " << party << " - Bitlength: " << bitlength + << " - Radix Base: " << b << "\n# ReLUs: " << num_relu_orig + << " - Batch Size: " << batch_size << " - # Threads: " << num_threads + << endl; + cout << "========================================================" << endl; - /************ Generate Test Data ************/ - /********************************************/ + /************ Generate Test Data ************/ + /********************************************/ - sci::PRG128 prg; - uint64_t mask_l; - if (l == 64) mask_l = -1; - else mask_l = (1ULL << l) - 1; - uint64_t *x = new uint64_t[num_relu]; - uint64_t *z = new uint64_t[num_relu]; - prg.random_mod_p<uint64_t>(x, num_relu, prime_mod); + sci::PRG128 prg; + uint64_t mask_l; + if (bitlength == 64) + mask_l = -1; + else + mask_l = (1ULL << bitlength) - 1; + uint64_t *x = new uint64_t[num_relu]; + uint64_t *z = new uint64_t[num_relu]; + prg.random_mod_p<uint64_t>(x, num_relu, prime_mod); - /********** Setup IO and Base OTs ***********/ - /********************************************/ - - for(int i = 0; i < numThreads; i++) { - ioArr[i] = new NetIO(party==1 ? nullptr:address.c_str(), port+i); - if (i == 0) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, b, l); - } else if (i == 1) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3-party, b, l); - } else if (i & 1) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3-party, b, l, false); - otpackArr[i]->copy(otpackArr[1]); - } else { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, b, l, false); - otpackArr[i]->copy(otpackArr[0]); - } - } - std::cout << "All Base OTs Done" << std::endl; - - /************** Fork Threads ****************/ - /********************************************/ + /********** Setup IO and Base OTs ***********/ + /********************************************/ - uint64_t comm_sent = 0; - uint64_t multiThreadedIOStart[numThreads]; - for(int i=0;i<numThreads;i++){ - multiThreadedIOStart[i] = ioArr[i]->counter; - } - auto start = clock_start(); - if (network != "none") { - int layer_offset = 0; - for(size_t layer_idx = 0; layer_idx < network_layer_sizes.size(); layer_idx++) { - std::thread relu_threads[numThreads]; - int layer_size = ((network_layer_sizes[layer_idx] + 7)/8)*8; - int chunk_size = (layer_size/(8*numThreads))*8; - cout << "Layer_idx: " << layer_idx << "; Layer_size: " << layer_size << endl; - for (int i = 0; i < numThreads; ++i) { - int offset = i*chunk_size + layer_offset; - int lnum_relu; - if (i == (numThreads - 1)) { - lnum_relu = (layer_offset + layer_size) - offset; - } else { - lnum_relu = chunk_size; - } - relu_threads[i] = std::thread(field_relu_thread, i, z+offset, x+offset, lnum_relu); - } - for (int i = 0; i < numThreads; ++i) { - relu_threads[i].join(); - } - layer_offset += layer_size; - } + for (int i = 0; i < num_threads; i++) { + ioArr[i] = new NetIO(party == 1 ? nullptr : address.c_str(), port + i); + if (i == 0) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); } else { - std::thread relu_threads[numThreads]; - int chunk_size = (num_relu/(8*numThreads))*8; - for (int i = 0; i < numThreads; ++i) { - int offset = i*chunk_size; - int lnum_relu; - if (i == (numThreads - 1)) { - lnum_relu = num_relu - offset; - } else { - lnum_relu = chunk_size; - } - relu_threads[i] = std::thread(field_relu_thread, i, z+offset, x+offset, lnum_relu); - } - for (int i = 0; i < numThreads; ++i) { - relu_threads[i].join(); - } + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); } - long long t = time_from(start); - for(int i=0;i<numThreads;i++){ - auto curComm = (ioArr[i]->counter) - multiThreadedIOStart[i]; - comm_sent += curComm; - } - std::cout << "Comm. Sent/ell: " << double(comm_sent*8)/(l*num_relu) << std::endl; - - /************** Verification ****************/ - /********************************************/ + } + std::cout << "All Base OTs Done" << std::endl; - switch (party) { - case sci::ALICE: { - ioArr[0]->send_data(x, sizeof(uint64_t)*num_relu); - ioArr[0]->send_data(z, sizeof(uint64_t)*num_relu); - break; - } - case sci::BOB: { - uint64_t *xi = new uint64_t[num_relu]; - uint64_t *zi = new uint64_t[num_relu]; - ioArr[0]->recv_data(xi, sizeof(uint64_t)*num_relu); - ioArr[0]->recv_data(zi, sizeof(uint64_t)*num_relu); + /************** Fork Threads ****************/ + /********************************************/ - for(int i=0; i<num_relu; i++){ - xi[i] = (xi[i] + x[i]) % prime_mod; - zi[i] = (zi[i] + z[i]) % prime_mod; - assert((zi[i] == ((xi[i] <= prime_mod/2) * xi[i])) - && "ReLU protocol's answer is incorrect!"); - } - delete[] xi; - delete[] zi; - break; + uint64_t comm_sent = 0; + uint64_t multiThreadedIOStart[num_threads]; + for (int i = 0; i < num_threads; i++) { + multiThreadedIOStart[i] = ioArr[i]->counter; + } + auto start = clock_start(); + if (network != "none") { + int layer_offset = 0; + for (size_t layer_idx = 0; layer_idx < network_layer_sizes.size(); + layer_idx++) { + std::thread relu_threads[num_threads]; + int layer_size = ((network_layer_sizes[layer_idx] + 7) / 8) * 8; + int chunk_size = (layer_size / (8 * num_threads)) * 8; + cout << "Layer_idx: " << layer_idx << "; Layer_size: " << layer_size + << endl; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size + layer_offset; + int lnum_relu; + if (i == (num_threads - 1)) { + lnum_relu = (layer_offset + layer_size) - offset; + } else { + lnum_relu = chunk_size; } + relu_threads[i] = std::thread(field_relu_thread, i, z + offset, + x + offset, lnum_relu); + } + for (int i = 0; i < num_threads; ++i) { + relu_threads[i].join(); + } + layer_offset += layer_size; } - delete[] x; - delete[] z; + } else { + std::thread relu_threads[num_threads]; + int chunk_size = (num_relu / (8 * num_threads)) * 8; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_relu; + if (i == (num_threads - 1)) { + lnum_relu = num_relu - offset; + } else { + lnum_relu = chunk_size; + } + relu_threads[i] = + std::thread(field_relu_thread, i, z + offset, x + offset, lnum_relu); + } + for (int i = 0; i < num_threads; ++i) { + relu_threads[i].join(); + } + } + long long t = time_from(start); + for (int i = 0; i < num_threads; i++) { + auto curComm = (ioArr[i]->counter) - multiThreadedIOStart[i]; + comm_sent += curComm; + } + std::cout << "Comm. Sent/ell: " + << double(comm_sent * 8) / (bitlength * num_relu) << std::endl; - /**** Process & Write Benchmarking Data *****/ - /********************************************/ + /************** Verification ****************/ + /********************************************/ - cout <<"Number of ReLU/s:\t" <<(double(num_relu)/t)*1e6<< std::endl; - cout <<"ReLU Time (l=" << l << "; b=" << b << ")\t" << t <<" mus"<< endl; + switch (party) { + case sci::ALICE: { + ioArr[0]->send_data(x, sizeof(uint64_t) * num_relu); + ioArr[0]->send_data(z, sizeof(uint64_t) * num_relu); + break; + } + case sci::BOB: { + uint64_t *xi = new uint64_t[num_relu]; + uint64_t *zi = new uint64_t[num_relu]; + ioArr[0]->recv_data(xi, sizeof(uint64_t) * num_relu); + ioArr[0]->recv_data(zi, sizeof(uint64_t) * num_relu); - string file_addr; - switch (party) { - case 1: { - file_addr = "our-field-relu-P0.csv"; - break; - } - case 2: { - file_addr = "our-field-relu-P1.csv"; - break; - } + for (int i = 0; i < num_relu; i++) { + xi[i] = (xi[i] + x[i]) % prime_mod; + zi[i] = (zi[i] + z[i]) % prime_mod; + assert((zi[i] == ((xi[i] <= prime_mod / 2) * xi[i])) && + "ReLU protocol's answer is incorrect!"); } - bool write_title = true; { - fstream result(file_addr.c_str(), fstream::in); - if(result.is_open()) - write_title = false; - result.close(); - } - fstream result(file_addr.c_str(), fstream::out|fstream::app); - if(write_title){ - result << "Bitlen,Base,Batch Size,#Threads,#ReLU,Time (mus),Throughput/sec,Data Sent (MiB)" << endl; - } - result << l << "," << b << "," << batch_size << "," << numThreads << "," << num_relu_orig - << "," << t << "," << (double(num_relu)/t)*1e6 << "," << comm_sent/(1.0*(1ULL<<20)) << endl; - result.close(); + delete[] xi; + delete[] zi; + cout << "ReLU Tests Passing" << endl; + break; + } + } + delete[] x; + delete[] z; - /******************* Cleanup ****************/ - /********************************************/ + cout << "Number of ReLU/s:\t" << (double(num_relu) / t) * 1e6 << std::endl; + cout << "ReLU Time (bitlength=" << bitlength << "; b=" << b << ")\t" << t + << " mus" << endl; - for (int i = 0; i < numThreads; i++) { - delete ioArr[i]; - delete otpackArr[i]; - } - return 0; + /******************* Cleanup ****************/ + /********************************************/ + + for (int i = 0; i < num_threads; i++) { + delete ioArr[i]; + delete otpackArr[i]; + } + return 0; } diff --git a/SCI/tests/test_functionalities.cpp b/SCI/tests/test_functionalities.cpp deleted file mode 100644 index b55486ae..00000000 --- a/SCI/tests/test_functionalities.cpp +++ /dev/null @@ -1,259 +0,0 @@ -/* -Authors: Nishant Kumar -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#define BITLEN_64 -#define SCI_OT - -#include "functionalities.h" -#include <iostream> -#include <cstdlib> -using namespace std; - -/* - Contains test cases for ring based truncation and avgpool + field based division. - The three functions can be found at the bottom of main. - Change the args defined below to vary parameters. - When switching from ring to field or vice-versa, switch the bitlen and SCI_OT/SCI_HE flag. -*/ - -const int N = 8000; -const int sf = 12; -const uint32_t divisor = 11; -const int server_random_seed = 84342; -const int client_random_seed = 32243; - -#ifdef SCI_OT -void test_ring_truncation(){ - if (party==SERVER){ - srand(server_random_seed); - } - else{ - srand(client_random_seed); - } - intType inp[N]; - uint8_t msbShare[N]; - intType outp[N]; - uint64_t moduloMask = sci::all1Mask(bitlength); - for(int i=0;i<N;i++){ - if (party==SERVER) inp[i] = rand() & moduloMask; - else inp[i] = rand() & moduloMask; - } - funcTruncateTwoPowerRingWrapper(N,inp,outp,sf,nullptr); - funcTruncationIdeal(N,inp,sf); - bool anythingFailed = false; - for(int i=0;i<N;i++){ - signedIntType ans = funcReconstruct2PCCons(inp[i],2); - auto ansigot = funcReconstruct2PCCons(outp[i],2); - if (party==sci::BOB){ - if(!((ans==ansigot))) { - cout<<RED<<"Error "<<i<<" ans,ansigot = "<<ans<<" "<<ansigot<<endl; - anythingFailed = true; - } - else { - // cout<<GREEN<<"right ans "<<i<<" ans,ansigot = "<<ans<<" "<<ansigot<<endl; - } - } - } - cout<<"anythingFailed? = "<<anythingFailed<<endl; -} - -void test_ring_avgpool(){ - if (party==SERVER){ - srand(server_random_seed); - } - else{ - srand(client_random_seed); - } - intType inp[N]; - intType outp[N]; - uint64_t moduloMask = sci::all1Mask(bitlength); - for(int i=0;i<N;i++){ - if (party==SERVER) inp[i] = rand() & moduloMask; - else inp[i] = rand() & moduloMask; - } - - funcAvgPoolTwoPowerRingWrapper(N,inp,outp,divisor); - bool anythingFailed = false; - for(int i=0;i<N;i++){ - signedIntType inpClear = funcReconstruct2PCCons(inp[i],2); - auto ans = div_floor(inpClear,divisor); - auto ansigot = funcReconstruct2PCCons(outp[i],2); - if (party==sci::BOB){ - if(ans!=ansigot) { - cout<<RED<<"Error ans, ansigot :: "<<ans<<" "<<ansigot<<endl; - anythingFailed = true; - } - else{ - // cout<<GREEN<<"right ans "<<i<<endl; - } - } - } - cout<<"anythingFailed? = "<<anythingFailed<<endl; -} -#endif - -#ifdef SCI_HE -void test_field_div(){ - if (party==SERVER){ - srand(server_random_seed); - } - else{ - srand(client_random_seed); - } - int N = 32; - int consSF = 3; - uint32_t divisor = 1<<consSF; - intType inp[N]; - intType outp[N]; - for(int i=0;i<N;i++){ - if (party==SERVER) inp[i] = rand()%prime_mod; - else inp[i] = rand()%prime_mod; - } - - cout<<"IO counter before === "<<io->counter<<" bytes"<<endl; - funcFieldDivWrapper<intType>(N,inp,outp,divisor,nullptr); - cout<<"IO counter after === "<<io->counter<<" bytes"<<endl; - funcTruncationIdeal(N, inp, consSF); - bool anythingFailed = false; - for(int i=0;i<N;i++){ - auto ans = funcReconstruct2PCCons(inp[i],2); - auto ansigot = funcReconstruct2PCCons(outp[i],2); - if (party==sci::BOB){ - if(ans!=ansigot){ - cout<<RED<<"Error "<<i<<" ans,ansigot = "<<ans<<" "<<ansigot<<endl; - anythingFailed = true; - } - else { - // cout<<GREEN<<"right ans "<<i<<" ans,ansigot = "<<ans<<" "<<ansigot<<endl; - } - } - } - cout<<"anythingFailed? = "<<anythingFailed<<endl; -} -#endif - -int main(int argc, char** argv) -{ - ArgMapping amap; - int port = 32000; - string serverAddr = "127.0.0.1"; - - amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); - amap.parse(argc, argv); - - assert(party==sci::ALICE || party==sci::BOB); - - checkIfUsingEigen(); - for(int i=0;i<numThreads;i++){ - ioArr[i] = new sci::NetIO(party==sci::ALICE ? nullptr : serverAddr.c_str(), port+i); - otInstanceArr[i] = new sci::IKNP<sci::NetIO>(ioArr[i]); - prgInstanceArr[i] = new sci::PRG128(); - kkotInstanceArr[i] = new sci::KKOT < sci::NetIO > (ioArr[i]); - matmulInstanceArr[i] = new Matmul<sci::NetIO, intType, sci::IKNP<sci::NetIO>>(party, bitlength, ioArr[i], otInstanceArr[i], nullptr); - if (i == 0) { - otpackArr[i] = new sci::OTPack<sci::NetIO>(ioArr[i], party, baseForRelu, bitlength); - } - else if (i == 1) { - otpackArr[i] = new sci::OTPack<sci::NetIO>(ioArr[i], 3-party, baseForRelu, bitlength); - } - else if (i & 1) { - otpackArr[i] = new sci::OTPack<sci::NetIO>(ioArr[i], 3-party, baseForRelu, bitlength, false); - otpackArr[i]->copy(otpackArr[1]); - } - else { - otpackArr[i] = new sci::OTPack<sci::NetIO>(ioArr[i], party, baseForRelu, bitlength, false); - otpackArr[i]->copy(otpackArr[0]); - } - } - - io = ioArr[0]; - iknpOT = new sci::IKNP<sci::NetIO>(io); - iknpOTRoleReversed = new sci::IKNP<sci::NetIO>(io); //TCP is full duplex -- so both side OT on same TCP should be good - kkot = new sci::KKOT<sci::NetIO>(io); - prg128Instance = new sci::PRG128(); - otpack = new sci::OTPack<sci::NetIO>(io, party, baseForRelu, bitlength); - - matmulImpl = new Matmul<sci::NetIO, intType, sci::IKNP<sci::NetIO>>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - - #ifdef SCI_OT - reluImpl = new ReLURingProtocol<sci::NetIO, intType>(party,RING,io,bitlength,baseForRelu,otpack); - maxpoolImpl = new MaxPoolProtocol<sci::NetIO, intType>(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); - argmaxImpl = new ArgMaxProtocol<sci::NetIO, intType>(party,RING,io,bitlength,baseForRelu,0,otpack,reluImpl); - #endif - - #ifdef SCI_HE - reluImpl = new ReLUFieldProtocol<sci::NetIO, intType>(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack); - maxpoolImpl = new MaxPoolProtocol<sci::NetIO, intType>(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); - argmaxImpl = new ArgMaxProtocol<sci::NetIO, intType>(party,FIELD,io,bitlength,baseForRelu,prime_mod,otpack,reluImpl); - heConvImpl = new ConvField(party,io); - heFCImpl = new FCField(party,io); - heProdImpl = new ElemWiseProdField(party, io); - assertFieldRun(); - #endif - #ifdef MULTITHREADED_NONLIN - #ifdef SCI_OT - for(int i = 0; i < numThreads; i++) { - if (i & 1) { - reluImplArr[i] = new ReLURingProtocol<sci::NetIO, intType>(3-party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); - maxpoolImplArr[i] = new MaxPoolProtocol<sci::NetIO, intType>(3-party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); - } - else { - reluImplArr[i] = new ReLURingProtocol<sci::NetIO, intType>(party,RING,ioArr[i],bitlength,baseForRelu,otpackArr[i]); - maxpoolImplArr[i] = new MaxPoolProtocol<sci::NetIO, intType>(party,RING,ioArr[i],bitlength,baseForRelu,0,otpackArr[i],reluImplArr[i]); - } - } - #endif - #ifdef SCI_HE - for(int i = 0; i < numThreads; i++) { - if (i & 1) { - reluImplArr[i] = new ReLUFieldProtocol<sci::NetIO, intType>(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); - maxpoolImplArr[i] = new MaxPoolProtocol<sci::NetIO, intType>(3-party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); - } - else { - reluImplArr[i] = new ReLUFieldProtocol<sci::NetIO, intType>(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i]); - maxpoolImplArr[i] = new MaxPoolProtocol<sci::NetIO, intType>(party,FIELD,ioArr[i],bitlength,baseForRelu,prime_mod,otpackArr[i],reluImplArr[i]); - } - } - #endif - #endif - - if (party==sci::ALICE){ - iknpOT->setup_send(); - iknpOTRoleReversed->setup_recv(); - } - else if (party==sci::BOB){ - iknpOT->setup_recv(); - iknpOTRoleReversed->setup_send(); - } - cout<<"After base ots, communication = "<<(io->counter)<<" bytes"<<endl; - - #ifdef SCI_OT - test_ring_truncation(); - test_ring_avgpool(); - #else - test_field_div(); - #endif - - cout<<"After function call, communication = "<<(io->counter)<<" bytes"<<endl; -} diff --git a/SCI/tests/test_linear.cpp b/SCI/tests/test_linear.cpp deleted file mode 100644 index afa6a237..00000000 --- a/SCI/tests/test_linear.cpp +++ /dev/null @@ -1,192 +0,0 @@ -/* -Authors: Nishant Kumar -Copyright: -Copyright (c) 2020 Microsoft Research -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#define BITLEN_35 -#define SCI_OT - -#include "globals.h" -#include "linear-primary.h" -using namespace std; -using namespace sci; - -const int s1 = 2, s2 = 2, s3 = 2; - -void testCOT_matmul(NetIO* io, IKNP<NetIO>* iknp, int party, OTIdeal<NetIO>* otIdeal){ - int numOTs = 3; - intType corr[numOTs]; - uint32_t chunkSizes[numOTs]; - uint32_t numChunks[numOTs]; - intType data[numOTs]; - uint8_t choices[numOTs]; - for(int i=0;i<numOTs;i++) numChunks[i] = 1; - for(int i=0;i<numOTs;i++) chunkSizes[i] = 64; - for(int i=0;i<numOTs;i++) corr[i] = 0; - for(int i=0;i<numOTs;i++) choices[i] = 0; - corr[0] = 1; - choices[0] = 1; - if (party==ALICE){ - // otIdeal->send_cot_matmul(data, corr, chunkSizes, numChunks, numOTs); - iknp->send_cot_matmul<intType>(data, corr, chunkSizes, numChunks, numOTs, 100); - } - else{ - // otIdeal->recv_cot_matmul(data, choices, chunkSizes, numChunks, numOTs); - iknp->recv_cot_matmul<intType>(data, choices, chunkSizes, numChunks, numOTs, 100); - } - for(int i=0;i<numOTs;i++){ - cout<<"OT# = "<<i<<", data[i] = "<<data[i]<<endl; - } -} - -int main(int argc, char** argv){ - ArgMapping amap; - int port = 32000; - string serverAddr = "127.0.0.1"; - - amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("ip", serverAddr, "IP Address of server (ALICE)"); - amap.parse(argc, argv); - - assert(party==sci::ALICE || party==sci::BOB); - - checkIfUsingEigen(); - int numThreads=4; - - NetIO* io = new NetIO(party==ALICE ? nullptr : serverAddr.c_str(), port); - NetIO* io1 = new NetIO(party==ALICE ? nullptr : serverAddr.c_str(), port+500); - IKNP<NetIO>* iknpOT = new IKNP<NetIO>(io); - IKNP<NetIO>* iknpOTRoleReversed = new IKNP<NetIO>(io1); - - Matmul<NetIO, intType, IKNP<NetIO>>* matmulImpl = - new Matmul<NetIO, intType, IKNP<NetIO>>(party, bitlength, io, iknpOT, iknpOTRoleReversed); - - // Following is the ideal ot declaration -- use if in doubt of OT implementation - // OTIdeal<NetIO>* otIdeal = new OTIdeal<NetIO>(io); - // Matmul<NetIO, intType, OTIdeal<NetIO>>* matmulImpl = - // new Matmul<NetIO, intType, OTIdeal<NetIO>>(party, bitlength, io, otIdeal, otIdeal); - - // testCOT_matmul(io, iknpOT, party, otIdeal); - - if (party==ALICE){ - iknpOT->setup_send(); - iknpOTRoleReversed->setup_recv(); - } - else if (party==BOB){ - iknpOT->setup_recv(); - iknpOTRoleReversed->setup_send(); - } - cout<<"After base ots, communication bytes = "<<(io->counter)<<endl; - - INIT_TIMER; - intType* A = new intType[s1*s2]; - intType* B = new intType[s2*s3]; - intType* C = new intType[s1*s3]; - for(int i=0;i<s1;i++){ - for(int j=0;j<s2;j++){ - Arr2DIdxRowM(A,s1,s2,i,j) = (i+j+1)<<(bitlength-1); - } - } - for(int i=0;i<s2;i++){ - for(int j=0;j<s3;j++){ - Arr2DIdxRowM(B,s2,s3,i,j) = (i+j+1)<<(bitlength-1); - } - } - - matmulImpl->ideal_func(s1,s2,s3,A,B,C); - cout<<"Printing A : "<<endl; - print2DArr<intType>(s1,s2,A); - cout<<"Printing B : "<<endl; - print2DArr<intType>(s2,s3,B); - cout<<"Printing C : "<<endl; - print2DArr<intType>(s1,s3,C); - - intType* C_share = new intType[s1*s3]; - cout<<"Starting single matmul test"<<endl; - START_TIMER; - if (party==ALICE){ - matmulImpl->funcOTSenderInputA(s1,s2,s3,A,C_share,iknpOT); - // matmulImpl->funcOTReceiverInputA(s1,s2,s3,A,C_share,iknpOTRoleReversed); - // matmulImpl->funcOTReceiverInputA(s1,s2,s3,A,C_share,otIdeal); - } - else if (party==BOB){ - matmulImpl->funcOTReceiverInputB(s1,s2,s3,B,C_share,iknpOT); - // matmulImpl->funcOTSenderInputB(s1,s2,s3,B,C_share,iknpOTRoleReversed); - // matmulImpl->funcOTSenderInputB(s1,s2,s3,B,C_share,otIdeal); - } - else{ - assert(false); - } - io->flush(); - PAUSE_TIMER("after single matmul"); - cout<<"Comm bytes till now = "<<(io->counter)<<endl; - cout<<"Myshare for mult of A*B: "<<endl; - print2DArr<intType>(s1,s3,C_share); - - intType* C_temp_share = new intType[s1*s3]; - intType* C_clear = new intType[s1*s3]; - if (party==ALICE){ - io->recv_data(C_temp_share,sizeof(intType)*s1*s3); - } - else if (party==BOB){ - io->send_data(C_share,sizeof(intType)*s1*s3); - } - - // assert for equality - if (party==ALICE){ - elemWiseAdd<intType>(s1*s3,C_share,C_temp_share,C_clear); - for(int i=0;i<s1;i++){ - for(int j=0;j<s3;j++){ - Arr2DIdxRowM(C_clear,s1,s3,i,j) = Arr2DIdxRowM(C_clear,s1,s3,i,j) & ((1ULL<<bitlength)-1); - assert((Arr2DIdxRowM(C_clear,s1,s3,i,j)==Arr2DIdxRowM(C,s1,s3,i,j)) && "equality failed"); - } - } - } - - // ------------------------------------------ - // beaver testing code - - cout<<"Beaver matmul test "<<endl; - PRG128 prg; - intType* bv_a = new intType[s1*s2]; - intType* bv_b = new intType[s2*s3]; - intType* bv_c = new intType[s1*s3]; - cout<<"Beaver starting timer"<<endl; - START_TIMER - matmulImpl->generateBeaverMatrixTriplet(s1,s2,s3,prg,bv_a,bv_b,bv_c); - PAUSE_TIMER("Done with beaver triplets") - matmulImpl->verifyMatmulShares(s1,s2,s3,bv_a,bv_b,bv_c); - cout<<"Beaver triplets verified"<<endl; - - cout<<"Testing beaver online phase"<<endl; - intType* bvo_x = new intType[s1*s2]; - intType* bvo_y = new intType[s2*s3]; - intType* bvo_z = new intType[s1*s3]; - prg.random_data(bvo_x,sizeof(intType)*s1*s2); - prg.random_data(bvo_y,sizeof(intType)*s2*s3); - cout<<"starting online phase"<<endl; - START_TIMER - matmulImpl->runBeaverOnlinePhase(s1,s2,s3,bvo_x,bvo_y,bvo_z,bv_a,bv_b,bv_c); - PAUSE_TIMER("done with beaver online") - matmulImpl->verifyMatmulShares(s1,s2,s3,bvo_x,bvo_y,bvo_z); - - cout<<"Beaver online phase testing done"<<endl; - STOP_TIMER("foo") -} diff --git a/SCI/tests/test_ring_argmax.cpp b/SCI/tests/test_ring_argmax.cpp index 94a3caf7..fda7b97e 100644 --- a/SCI/tests/test_ring_argmax.cpp +++ b/SCI/tests/test_ring_argmax.cpp @@ -19,158 +19,144 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#define BITLEN_64 -#define SCI_OT - -#include "globals.h" -#include "NonLinear/relu-field.h" -#include "NonLinear/relu-ring.h" #include "NonLinear/argmax.h" using namespace std; using namespace sci; -int l = 64, b = 4; - -int main(int argc, char** argv){ - int port=32000, party=1, num_argmax = 1000; - string address; - bool localhost = true; - ArgMapping amap; - amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("l", l, "Bitlength of inputs"); - amap.arg("N", num_argmax, "Number of elements"); - amap.arg("b", b, "Radix base"); - amap.arg("lo", localhost, "Localhost Run?"); - - amap.parse(argc, argv); - - if(not localhost) { - address = "40.118.124.169"; - } else { - address = "127.0.0.1"; +int party = 0; +int32_t bitlength = 32; +int num_threads = 1; +int port = 32000; +string address = "127.0.0.1"; +int num_argmax = 1000; + +int main(int argc, char **argv) { + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("l", bitlength, "Bitlength of inputs"); + amap.arg("N", num_argmax, "Number of elements"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + + NetIO *io = new NetIO(party == ALICE ? nullptr : "127.0.0.1", port); + uint64_t magnitude_bound = (1 << (bitlength - 3)); + uint64_t mask_l = -1ULL; + if (bitlength != 64) { + mask_l = (1ULL << bitlength) - 1ULL; + } + OTPack otpack(io, party); + ArgMaxProtocol<NetIO, uint64_t> argmax_oracle(party, RING, io, bitlength, + MILL_PARAM, 0, &otpack); + PRG128 prg; + uint64_t *input_share1, *input_share2, *input_share_uncorrected; + uint8_t *input_share_sign; + input_share_uncorrected = new uint64_t[num_argmax]; + input_share1 = new uint64_t[num_argmax]; + input_share2 = new uint64_t[num_argmax]; + input_share_sign = new uint8_t[num_argmax]; + + uint64_t *argmax_output_protocol = new uint64_t[1]; + uint64_t *argmax_output_protocol_share_other = new uint64_t[1]; + uint64_t *argmax_output_protocol_arg = new uint64_t[1]; + uint64_t *argmax_output_protocol_share_other_arg = new uint64_t[1]; + uint64_t *argmax_output_actual = new uint64_t[1]; + switch (party) { + case ALICE: { + prg.random_data(input_share_uncorrected, sizeof(uint64_t) * num_argmax); + prg.random_data(input_share_sign, num_argmax); + uint64_t comm_start = io->counter; + auto start = clock_start(); + for (int i = 0; i < num_argmax; i++) { + input_share_uncorrected[i] %= magnitude_bound; + } + for (int i = 0; i < num_argmax; i++) { + if (input_share_sign[i] & 1) { + input_share1[i] = -1 * input_share_uncorrected[i]; + } else { + input_share1[i] = input_share_uncorrected[i]; + } + } + argmax_oracle.ArgMaxMPC(num_argmax, input_share1, + argmax_output_protocol_arg, true, + argmax_output_protocol); + + long long t = time_from(start); + uint64_t comm_end = io->counter; + cout << "Comparison Time\t" << RED << (double(num_argmax) / t) * 1e6 + << " ArgMax/sec" << RESET << endl; + cout << "ALICE communication\t" << BLUE + << ((double)(comm_end - comm_start) * 8) / (bitlength * num_argmax) + << "*" << bitlength << " bits/ArgMax" << RESET << endl; + std::cout << "ALICE: Done MaxPool protocol execution" << std::endl; + io->recv_data(input_share2, sizeof(uint64_t) * num_argmax); + io->recv_data(argmax_output_protocol_share_other, sizeof(uint64_t) * 1); + io->recv_data(argmax_output_protocol_share_other_arg, sizeof(uint64_t) * 1); + + cout << "Checking correctness of ArgMax now..." << endl; + argmax_output_protocol[0] = + (argmax_output_protocol[0] + argmax_output_protocol_share_other[0]) & + mask_l; + argmax_output_protocol_arg[0] = + (argmax_output_protocol_arg[0] + + argmax_output_protocol_share_other_arg[0]) & + mask_l; + + for (int i = 0; i < num_argmax; i++) { + input_share1[i] = input_share1[i] + input_share2[i]; + } + + argmax_output_actual[0] = input_share1[0]; + for (int i = 1; i < num_argmax; i++) { + argmax_output_actual[0] = (((argmax_output_actual[0] - input_share1[i]) >= + (1 << (bitlength - 1))) + ? input_share1[i] + : argmax_output_actual[0]); } + std::cout << "Max Protocol: " << argmax_output_protocol[0] << std::endl; + std::cout << "Max Actual: " << argmax_output_actual[0] << std::endl; + std::cout << "ArgMax Protocol: " << argmax_output_protocol_arg[0] + << std::endl; + + assert(argmax_output_actual[0] == argmax_output_protocol[0] && + "ArgMax output is incorrect"); + + cout << "ArgMax answer is: " << GREEN << "CORRECT!" << RESET << endl; + break; + } + case BOB: { + // These are written so that overall time excludes these. + prg.random_data(input_share_uncorrected, sizeof(uint64_t) * num_argmax); + prg.random_data(input_share_sign, num_argmax); + uint64_t comm_start = io->counter; - NetIO * io = new NetIO(party==ALICE ? nullptr:"127.0.0.1", port); - uint64_t magnitude_bound = (1<<(l-3)); - uint64_t mask_l = -1ULL; - if(l != 64){ - mask_l = (1ULL<<l)-1ULL; - } - OTPack otpack(io, party, b, l); - ArgMaxProtocol<NetIO, uint64_t> argmax_oracle(party, RING, io, l, b, 0, &otpack); - PRG128 prg; - uint64_t *input_share1, *input_share2, *input_share_uncorrected; - uint8_t *input_share_sign; - input_share_uncorrected = new uint64_t[num_argmax]; - input_share1 = new uint64_t[num_argmax]; - input_share2 = new uint64_t[num_argmax]; - input_share_sign = new uint8_t[num_argmax]; - - uint64_t* argmax_output_protocol = new uint64_t[1]; - uint64_t* argmax_output_protocol_share_other = new uint64_t[1]; - uint64_t* argmax_output_protocol_arg = new uint64_t[1]; - uint64_t* argmax_output_protocol_share_other_arg = new uint64_t[1]; - uint64_t* argmax_output_actual = new uint64_t[1]; - switch (party){ - case ALICE: { - prg.random_data(input_share_uncorrected, sizeof(uint64_t)*num_argmax); - prg.random_data(input_share_sign, num_argmax); - uint64_t comm_start = io->counter; - auto start = clock_start(); - for(int i=0; i<num_argmax; i++){ - input_share_uncorrected[i] %= magnitude_bound; - } - for(int i=0; i<num_argmax; i++){ - if(input_share_sign[i] & 1){ - input_share1[i] = -1*input_share_uncorrected[i]; - //cin>>input_share1[i]; - } - else{ - input_share1[i] = input_share_uncorrected[i]; - //cin>>input_share1[i]; - } - } - argmax_oracle.ArgMaxMPC(num_argmax, input_share1, argmax_output_protocol_arg, true, argmax_output_protocol); - - long long t = time_from(start); - uint64_t comm_end = io->counter; - cout <<"Comparison Time\t"<<RED<<(double(num_argmax)/t)*1e6<<" ArgMax/sec" <<RESET<< endl; - cout << "ALICE communication\t" <<BLUE<< ((double)(comm_end - comm_start)*8)/(l*num_argmax) << "*" << l << " bits/ArgMax"<<RESET<< endl; - std::cout<<"ALICE: Done MaxPool protocol execution"<<std::endl; - io->recv_data(input_share2, sizeof(uint64_t)*num_argmax); - io->recv_data(argmax_output_protocol_share_other, sizeof(uint64_t)*1); - io->recv_data(argmax_output_protocol_share_other_arg, sizeof(uint64_t)*1); - - cout<<"Checking correctness of ArgMax now..."<<endl; - // Check correctness - //for(int i=0; i<num_argmax; i++){ - //std::cout<<"Shares are #"<<i<<"\t is: "<<(int32_t)input_share1[i]<<"\t and: "<<(int32_t)input_share2[i]<<"\t | bound is: "<<(int32_t)(1<<(l-2))<<std::endl; - //} - - argmax_output_protocol[0] = (argmax_output_protocol[0] + argmax_output_protocol_share_other[0]) & mask_l; - argmax_output_protocol_arg[0] = (argmax_output_protocol_arg[0] + argmax_output_protocol_share_other_arg[0]) & mask_l; - - for(int i=0; i<num_argmax; i++){ - input_share1[i] = input_share1[i] + input_share2[i]; + for (int i = 0; i < num_argmax; i++) { + input_share_uncorrected[i] %= magnitude_bound; + } + for (int i = 0; i < num_argmax; i++) { + if (input_share_sign[i] & 1) { + input_share2[i] = -1 * input_share_uncorrected[i]; + } else { + input_share2[i] = input_share_uncorrected[i]; } - - argmax_output_actual[0] = input_share1[0]; - for(int i=1; i<num_argmax; i++){ - argmax_output_actual[0] = (((argmax_output_actual[0] - input_share1[i]) >= (1<<(l-1)))?input_share1[i]:argmax_output_actual[0]); - } - //for(int i=0; i<num_argmax; i++){ - //if(argmax_output_protocol[0] == input_share1[i]){ - //assert(argmax_output_protocol_arg[0] == i); - //cout<<"Protocol answer exists in inputs at index "<<i<<endl; - //} - //if(argmax_output_actual[0] == input_share1[i]){ - //assert(argmax_output_protocol_arg[0] == i); - //cout<<"Ideal answer exists in inputs at index "<<i<<endl; - //} - //std::cout<<"Inputs: "<<input_share1[i]<<std::endl; - //} - std::cout<<"Max Protocol: "<<argmax_output_protocol[0]<<std::endl; - std::cout<<"Max Actual: "<<argmax_output_actual[0]<<std::endl; - std::cout<<"ArgMax Protocol: "<<argmax_output_protocol_arg[0]<<std::endl; - - assert(argmax_output_actual[0] == argmax_output_protocol[0] && "ArgMax output is incorrect"); - - cout<<"ArgMax answer is: "<<GREEN<<"CORRECT!"<<RESET<<endl; - break; - } - case BOB: { - // These are written so that overall time excludes these. - prg.random_data(input_share_uncorrected, sizeof(uint64_t)*num_argmax); - prg.random_data(input_share_sign, num_argmax); - uint64_t comm_start = io->counter; - - for(int i=0; i<num_argmax; i++){ - input_share_uncorrected[i] %= magnitude_bound; - } - for(int i=0; i<num_argmax; i++){ - if(input_share_sign[i] & 1){ - input_share2[i] = -1*input_share_uncorrected[i]; - //input_share2[i] = 0; - } - else{ - input_share2[i] = input_share_uncorrected[i]; - //input_share2[i] = 0; - } - } - argmax_oracle.ArgMaxMPC(num_argmax, input_share2, argmax_output_protocol_arg, true, argmax_output_protocol); - - uint64_t comm_end = io->counter; - cout << "BOB communication\t" <<BLUE<< ((double)(comm_end - comm_start)*8)/(l*num_argmax) << "*" << l << " bits/ArgMax" <<RESET<< endl; - - std::cout<<"BOB: Done MaxPool protocol execution"<<std::endl; - io->send_data(input_share2, sizeof(uint64_t)*num_argmax); - io->send_data(argmax_output_protocol, sizeof(uint64_t)*1); - io->send_data(argmax_output_protocol_arg, sizeof(uint64_t)*1); - break; - } - } - return 0; -} + } + argmax_oracle.ArgMaxMPC(num_argmax, input_share2, + argmax_output_protocol_arg, true, + argmax_output_protocol); + uint64_t comm_end = io->counter; + cout << "BOB communication\t" << BLUE + << ((double)(comm_end - comm_start) * 8) / (bitlength * num_argmax) + << "*" << bitlength << " bits/ArgMax" << RESET << endl; + + std::cout << "BOB: Done MaxPool protocol execution" << std::endl; + io->send_data(input_share2, sizeof(uint64_t) * num_argmax); + io->send_data(argmax_output_protocol, sizeof(uint64_t) * 1); + io->send_data(argmax_output_protocol_arg, sizeof(uint64_t) * 1); + break; + } + } + return 0; +} diff --git a/SCI/tests/test_ring_aux_protocols.cpp b/SCI/tests/test_ring_aux_protocols.cpp new file mode 100644 index 00000000..2c0a10c4 --- /dev/null +++ b/SCI/tests/test_ring_aux_protocols.cpp @@ -0,0 +1,483 @@ +/* +Authors: Deevashwer Rathee, Mayank Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "BuildingBlocks/aux-protocols.h" +#include "utils/emp-tool.h" +#include <iostream> +using namespace sci; +using namespace std; + +int party, port = 8000, dim = 1 << 16; +string address = "127.0.0.1"; +NetIO *io; +OTPack<NetIO> *otpack; +AuxProtocols *aux; + +void test_wrap_computation() { + int bw_x = 32; + PRG128 prg; + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + + uint64_t *x = new uint64_t[dim]; + uint8_t *y = new uint8_t[dim]; + + prg.random_data(x, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + x[i] = x[i] & mask_x; + } + + aux->wrap_computation(x, y, dim, bw_x); + + if (party == ALICE) { + io->send_data(x, dim * sizeof(uint64_t)); + io->send_data(y, dim * sizeof(uint8_t)); + } else { + uint64_t *x0 = new uint64_t[dim]; + uint8_t *y0 = new uint8_t[dim]; + io->recv_data(x0, dim * sizeof(uint64_t)); + io->recv_data(y0, dim * sizeof(uint8_t)); + + for (int i = 0; i < dim; i++) { + assert((x0[i] > (mask_x - x[i])) == (y0[i] ^ y[i])); + } + cout << "Wrap Computation Tests passed" << endl; + + delete[] x0; + delete[] y0; + } + delete[] x; + delete[] y; +} + +void test_mux() { + int bw_x = 32, bw_y = 32; + PRG128 prg; + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + + uint8_t *sel = new uint8_t[dim]; + uint64_t *x = new uint64_t[dim]; + uint64_t *y = new uint64_t[dim]; + + prg.random_data(sel, dim * sizeof(uint8_t)); + prg.random_data(x, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + sel[i] = sel[i] & 1; + x[i] = x[i] & mask_x; + } + + aux->multiplexer(sel, x, y, dim, bw_x, bw_y); + + if (party == ALICE) { + io->send_data(sel, dim * sizeof(uint8_t)); + io->send_data(x, dim * sizeof(uint64_t)); + io->send_data(y, dim * sizeof(uint64_t)); + } else { + uint8_t *sel0 = new uint8_t[dim]; + uint64_t *x0 = new uint64_t[dim]; + uint64_t *y0 = new uint64_t[dim]; + io->recv_data(sel0, dim * sizeof(uint8_t)); + io->recv_data(x0, dim * sizeof(uint64_t)); + io->recv_data(y0, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + assert(((uint64_t(sel0[i] ^ sel[i]) * (x0[i] + x[i])) & mask_y) == + ((y0[i] + y[i]) & mask_y)); + } + cout << "MUX Tests passed" << endl; + + delete[] sel0; + delete[] x0; + delete[] y0; + } + delete[] sel; + delete[] x; + delete[] y; +} + +void test_B2A() { + int bw_y = 32; + PRG128 prg; + uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + + uint8_t *x = new uint8_t[dim]; + uint64_t *y = new uint64_t[dim]; + + prg.random_data(x, dim * sizeof(uint8_t)); + for (int i = 0; i < dim; i++) { + x[i] = x[i] & 1; + } + + aux->B2A(x, y, dim, bw_y); + + if (party == ALICE) { + io->send_data(x, dim * sizeof(uint8_t)); + io->send_data(y, dim * sizeof(uint64_t)); + } else { + uint8_t *x0 = new uint8_t[dim]; + uint64_t *y0 = new uint64_t[dim]; + io->recv_data(x0, dim * sizeof(uint8_t)); + io->recv_data(y0, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + assert(((uint64_t(x0[i] ^ x[i])) & mask_y) == ((y0[i] + y[i]) & mask_y)); + } + cout << "B2A Tests passed" << endl; + + delete[] x0; + delete[] y0; + } + delete[] x; + delete[] y; +} + +template <typename T> void test_lookup_table() { + int32_t T_size = sizeof(T) * 8; + int bw_x = 8; + int bw_y; + if (T_size == 8) + bw_y = 7; + else + bw_y = 29; + PRG128 prg; + uint64_t N = 1ULL << bw_x; + T mask_x = (bw_x == T_size ? -1 : ((1ULL << bw_x) - 1)); + T mask_y = (bw_y == T_size ? -1 : ((1ULL << bw_y) - 1)); + + T **spec = new T *[dim]; + T *x = new T[dim]; + T *y = new T[dim]; + + for (int i = 0; i < dim; i++) { + spec[i] = new T[N]; + prg.random_data(spec[i], N * sizeof(T)); + } + prg.random_data(x, dim * sizeof(T)); + for (int i = 0; i < dim; i++) { + x[i] = x[i] & mask_x; + for (int j = 0; j < N; j++) { + spec[i][j] = spec[i][j] & mask_y; + } + } + + if (party == ALICE) { + aux->lookup_table<T>(spec, nullptr, nullptr, dim, bw_x, bw_y); + } else { // party == BOB + aux->lookup_table<T>(nullptr, x, y, dim, bw_x, bw_y); + } + + if (party == BOB) { + io->send_data(x, dim * sizeof(T)); + io->send_data(y, dim * sizeof(T)); + } else { // ALICE knows the correct spec + T *x0 = new T[dim]; + T *y0 = new T[dim]; + io->recv_data(x0, dim * sizeof(T)); + io->recv_data(y0, dim * sizeof(T)); + + for (int i = 0; i < dim; i++) { + assert((spec[i][x0[i] & mask_x]) == (y0[i] & mask_y)); + } + if (T_size == 8) + cout << "Lookup Table <uint8_t> Tests passed" << endl; + else + cout << "Lookup Table <uint64_t> Tests passed" << endl; + + delete[] x0; + delete[] y0; + } + delete[] x; + delete[] y; + for (int i = 0; i < dim; i++) + delete[] spec[i]; + delete[] spec; +} + +void test_MSB_computation() { + int bw_x = 32; + PRG128 prg; + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + + uint64_t *x = new uint64_t[dim]; + uint8_t *y = new uint8_t[dim]; + + prg.random_data(x, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + x[i] = x[i] & mask_x; + } + + aux->MSB(x, y, dim, bw_x); + + if (party == ALICE) { + io->send_data(x, dim * sizeof(uint64_t)); + io->send_data(y, dim * sizeof(uint8_t)); + } else { + uint64_t *x0 = new uint64_t[dim]; + uint8_t *y0 = new uint8_t[dim]; + io->recv_data(x0, dim * sizeof(uint64_t)); + io->recv_data(y0, dim * sizeof(uint8_t)); + + for (int i = 0; i < dim; i++) { + assert((((x0[i] + x[i]) & mask_x) >= (1ULL << (bw_x - 1))) == + (y0[i] ^ y[i])); + } + cout << "MSB Computation Tests passed" << endl; + + delete[] x0; + delete[] y0; + } + delete[] x; + delete[] y; +} + +void test_MSB_to_Wrap() { + int bw_x = 32; + PRG128 prg; + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + + uint64_t *x = new uint64_t[dim]; + uint8_t *msb_x = new uint8_t[dim]; + uint8_t *y = new uint8_t[dim]; + + prg.random_data(x, dim * sizeof(uint64_t)); + prg.random_data(msb_x, dim * sizeof(uint8_t)); + for (int i = 0; i < dim; i++) { + x[i] = x[i] & mask_x; + msb_x[i] = msb_x[i] & 1; + } + if (party == ALICE) { + uint64_t *x_bob = new uint64_t[dim]; + uint8_t *msb_x_bob = new uint8_t[dim]; + io->recv_data(x_bob, dim * sizeof(uint64_t)); + io->recv_data(msb_x_bob, dim * sizeof(uint8_t)); + + for (int i = 0; i < dim; i++) { + msb_x[i] = + (((x_bob[i] + x[i]) & mask_x) >= (1ULL << (bw_x - 1))) ^ msb_x_bob[i]; + } + + delete[] x_bob; + delete[] msb_x_bob; + } else { + io->send_data(x, dim * sizeof(uint64_t)); + io->send_data(msb_x, dim * sizeof(uint8_t)); + } + + aux->MSB_to_Wrap(x, msb_x, y, dim, bw_x); + + if (party == ALICE) { + io->send_data(x, dim * sizeof(uint64_t)); + io->send_data(y, dim * sizeof(uint8_t)); + } else { + uint64_t *x0 = new uint64_t[dim]; + uint8_t *y0 = new uint8_t[dim]; + io->recv_data(x0, dim * sizeof(uint64_t)); + io->recv_data(y0, dim * sizeof(uint8_t)); + + for (int i = 0; i < dim; i++) { + assert((x0[i] > (mask_x - x[i])) == (y0[i] ^ y[i])); + } + cout << "MSB to Wrap Tests passed" << endl; + + delete[] x0; + delete[] y0; + } + delete[] x; + delete[] y; +} + +void test_AND() { + int bw_in = 32; + PRG128 prg; + uint64_t mask_in = (bw_in == 64 ? -1 : ((1ULL << bw_in) - 1)); + + uint8_t *x = new uint8_t[dim]; + uint8_t *y = new uint8_t[dim]; + uint8_t *z = new uint8_t[dim]; + + prg.random_data(x, dim * sizeof(uint8_t)); + prg.random_data(y, dim * sizeof(uint8_t)); + + for (int i = 0; i < dim; i++) { + x[i] = x[i] & 1; + y[i] = y[i] & 1; + } + + aux->AND(x, y, z, dim); + + if (party == ALICE) { + uint8_t *x_bob = new uint8_t[dim]; + uint8_t *y_bob = new uint8_t[dim]; + uint8_t *z_bob = new uint8_t[dim]; + io->recv_data(x_bob, dim * sizeof(uint8_t)); + io->recv_data(y_bob, dim * sizeof(uint8_t)); + io->recv_data(z_bob, dim * sizeof(uint8_t)); + + for (int i = 0; i < dim; i++) { + x_bob[i] ^= x[i]; + y_bob[i] ^= y[i]; + z_bob[i] ^= z[i]; + assert((x_bob[i] & y_bob[i]) == z_bob[i]); + } + cout << "AND Computation Tests passed" << endl; + + } else { + io->send_data(x, dim * sizeof(uint8_t)); + io->send_data(y, dim * sizeof(uint8_t)); + io->send_data(z, dim * sizeof(uint8_t)); + } + + delete[] x; + delete[] y; + delete[] z; +} + +void test_digit_decomposition() { + int bw_x = 29; + int digit_size = 9; + int num_digits = ceil((1.0 * bw_x) / digit_size); + int last_digit_size = bw_x - (num_digits - 1) * digit_size; + PRG128 prg; + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + uint64_t digit_mask = (digit_size == 64 ? -1 : (1ULL << digit_size) - 1); + uint64_t last_digit_mask = + (last_digit_size == 64 ? -1 : (1ULL << last_digit_size) - 1); + + uint64_t *x = new uint64_t[dim]; + uint64_t *xprime = new uint64_t[dim]; + uint64_t *y = new uint64_t[dim * num_digits]; + + prg.random_data(x, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + x[i] = x[i] & mask_x; + } + + aux->digit_decomposition_sci(dim, x, y, bw_x, digit_size); + + if (party == ALICE) { + io->send_data(x, dim * sizeof(uint64_t)); + io->send_data(y, dim * num_digits * sizeof(uint64_t)); + } else { + uint64_t *x0 = new uint64_t[dim]; + uint64_t *y0 = new uint64_t[dim * num_digits]; + io->recv_data(x0, dim * sizeof(uint64_t)); + io->recv_data(y0, dim * num_digits * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + for (int j = 0; j < num_digits - 1; j++) { + y0[j * dim + i] += y[j * dim + i]; + y0[j * dim + i] &= digit_mask; + } + y0[(num_digits - 1) * dim + i] += y[(num_digits - 1) * dim + i]; + y0[(num_digits - 1) * dim + i] &= last_digit_mask; + xprime[i] = 0; + for (int j = 0; j < num_digits; j++) { + xprime[i] += y0[j * dim + i] * (1ULL << (j * digit_size)); + } + xprime[i] &= mask_x; + x0[i] += x[i]; + x0[i] &= mask_x; + for (int j = 0; j < num_digits; j++) { + uint64_t temp_mask = + (j == (num_digits - 1)) ? last_digit_mask : digit_mask; + } + assert(xprime[i] == x0[i]); + } + cout << "Digit Decomposition Tests Passed" << endl; + + delete[] x0; + delete[] y0; + } + delete[] x; + delete[] y; +} + +void test_msnzb_one_hot() { + int bw_x = 32; + int digit_size = 5; + PRG128 prg; + uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); + + uint64_t *x = new uint64_t[dim]; + uint8_t *y = new uint8_t[dim * bw_x]; + + prg.random_data(x, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + x[i] = x[i] & mask_x; + } + + aux->msnzb_one_hot(x, y, bw_x, dim, digit_size); + + if (party == ALICE) { + io->send_data(x, dim * sizeof(uint64_t)); + io->send_data(y, dim * bw_x * sizeof(uint8_t)); + } else { + uint64_t *x0 = new uint64_t[dim]; + uint8_t *y0 = new uint8_t[dim * bw_x]; + io->recv_data(x0, dim * sizeof(uint64_t)); + io->recv_data(y0, dim * bw_x * sizeof(uint8_t)); + + for (int i = 0; i < dim; i++) { + uint64_t secure_val = 0ULL; + for (int j = 0; j < bw_x; j++) { + secure_val += (1ULL << j) * int(y[i * bw_x + j] ^ y0[i * bw_x + j]); + } + if (unsigned_val(x0[i] + x[i], bw_x) == 0) { + continue; + } + assert((unsigned_val(x0[i] + x[i], bw_x) >= + unsigned_val(secure_val, bw_x)) && + (unsigned_val(x0[i] + x[i], bw_x) < + 2 * unsigned_val(secure_val, bw_x))); + } + std::cout << "MSNZB One Hot Tests Passed" << std::endl; + delete[] x0; + delete[] y0; + } + delete[] x; + delete[] y; +} + +int main(int argc, char **argv) { + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("d", dim, "Size of vector"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + amap.parse(argc, argv); + + io = new NetIO(party == 1 ? nullptr : address.c_str(), port); + otpack = new OTPack<NetIO>(io, party); + + aux = new AuxProtocols(party, io, otpack); + + test_MSB_computation(); + test_wrap_computation(); + test_digit_decomposition(); + test_msnzb_one_hot(); + test_mux(); + test_B2A(); + test_lookup_table<uint8_t>(); + test_lookup_table<uint64_t>(); + test_MSB_to_Wrap(); + test_AND(); + + return 0; +} diff --git a/SCI/tests/test_ring_exp.cpp b/SCI/tests/test_ring_exp.cpp new file mode 100644 index 00000000..5e805e61 --- /dev/null +++ b/SCI/tests/test_ring_exp.cpp @@ -0,0 +1,198 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "Math/math-functions.h" +#include <fstream> +#include <iostream> +#include <thread> + +using namespace sci; +using namespace std; + +#define MAX_THREADS 4 + +int party, port = 32000; +int num_threads = 4; +string address = "127.0.0.1"; + +int dim = 1ULL << 16; +int bw_x = 16; +int bw_y = 16; +int s_x = 12; +int s_y = 12; + +uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); +uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + +sci::NetIO *ioArr[MAX_THREADS]; +sci::OTPack<sci::NetIO> *otpackArr[MAX_THREADS]; + +uint64_t computeULPErr(double calc, double actual, int SCALE) { + int64_t calc_fixed = (double(calc) * (1ULL << SCALE)); + int64_t actual_fixed = (double(actual) * (1ULL << SCALE)); + uint64_t ulp_err = (calc_fixed - actual_fixed) > 0 + ? (calc_fixed - actual_fixed) + : (actual_fixed - calc_fixed); + return ulp_err; +} + +void exp_thread(int tid, uint64_t *x, uint64_t *y, int num_exp) { + MathFunctions *math; + if (tid & 1) { + math = new MathFunctions(3 - party, ioArr[tid], otpackArr[tid]); + } else { + math = new MathFunctions(party, ioArr[tid], otpackArr[tid]); + } + math->lookup_table_exp(num_exp, x, y, bw_x, bw_y, s_x, s_y); + + delete math; +} + +int main(int argc, char **argv) { + /************* Argument Parsing ************/ + /********************************************/ + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("N", dim, "Number of exponentiations"); + amap.arg("nt", num_threads, "Number of threads"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + + assert(num_threads <= MAX_THREADS); + + /********** Setup IO and Base OTs ***********/ + /********************************************/ + for (int i = 0; i < num_threads; i++) { + ioArr[i] = new NetIO(party == 1 ? nullptr : address.c_str(), port + i); + if (i == 0) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); + } else { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); + } + } + std::cout << "All Base OTs Done" << std::endl; + + /************ Generate Test Data ************/ + /********************************************/ + PRG128 prg; + + uint64_t *x = new uint64_t[dim]; + uint64_t *y = new uint64_t[dim]; + + prg.random_data(x, dim * sizeof(uint64_t)); + + if (party == ALICE) { + ioArr[0]->send_data(x, dim * sizeof(uint64_t)); + } else { + uint64_t *x0 = new uint64_t[dim]; + ioArr[0]->recv_data(x0, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + // x is always negative + x[i] = ((1ULL << (bw_x - 1)) + (x[i] & (mask_x >> 1))) - x0[i]; + } + delete[] x0; + } + for (int i = 0; i < dim; i++) { + x[i] &= mask_x; + } + + /************** Fork Threads ****************/ + /********************************************/ + uint64_t total_comm = 0; + uint64_t thread_comm[num_threads]; + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter; + } + + auto start = clock_start(); + std::thread exp_threads[num_threads]; + int chunk_size = dim / num_threads; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_exp; + if (i == (num_threads - 1)) { + lnum_exp = dim - offset; + } else { + lnum_exp = chunk_size; + } + exp_threads[i] = + std::thread(exp_thread, i, x + offset, y + offset, lnum_exp); + } + for (int i = 0; i < num_threads; ++i) { + exp_threads[i].join(); + } + long long t = time_from(start); + + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter - thread_comm[i]; + total_comm += thread_comm[i]; + } + + /************** Verification ****************/ + /********************************************/ + if (party == ALICE) { + ioArr[0]->send_data(x, dim * sizeof(uint64_t)); + ioArr[0]->send_data(y, dim * sizeof(uint64_t)); + } else { // party == BOB + uint64_t *x0 = new uint64_t[dim]; + uint64_t *y0 = new uint64_t[dim]; + ioArr[0]->recv_data(x0, dim * sizeof(uint64_t)); + ioArr[0]->recv_data(y0, dim * sizeof(uint64_t)); + + uint64_t total_err = 0; + uint64_t max_ULP_err = 0; + for (int i = 0; i < dim; i++) { + double dbl_x = (signed_val(x0[i] + x[i], bw_x)) / double(1LL << s_x); + double dbl_y = (signed_val(y0[i] + y[i], bw_y)) / double(1ULL << s_y); + double exp_x = exp(dbl_x); + uint64_t err = computeULPErr(dbl_y, exp_x, s_y); + total_err += err; + max_ULP_err = std::max(max_ULP_err, err); + } + + cerr << "Average ULP error: " << total_err / dim << endl; + cerr << "Max ULP error: " << max_ULP_err << endl; + cerr << "Number of tests: " << dim << endl; + + delete[] x0; + delete[] y0; + } + cout << "Number of Exp/s:\t" << (double(dim) / t) * 1e6 << std::endl; + cout << "Exp Time\t" << t / (1000.0) << " ms" << endl; + cout << "Exp Bytes Sent\t" << total_comm << " bytes" << endl; + + /******************* Cleanup ****************/ + /********************************************/ + delete[] x; + delete[] y; + for (int i = 0; i < num_threads; i++) { + delete ioArr[i]; + delete otpackArr[i]; + } +} diff --git a/SCI/tests/test_ring_hadamard_product.cpp b/SCI/tests/test_ring_hadamard_product.cpp new file mode 100644 index 00000000..e6584aed --- /dev/null +++ b/SCI/tests/test_ring_hadamard_product.cpp @@ -0,0 +1,120 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "LinearOT/linear-ot.h" +#include "utils/emp-tool.h" +#include <iostream> + +using namespace sci; +using namespace std; + +int party, port = 32000; +string address = "127.0.0.1"; +NetIO *io; +OTPack<NetIO> *otpack; +LinearOT *prod; + +int dim = 1 << 16; +int bwA = 32; +int bwB = 32; +int bwC = 32; + +uint64_t maskA = (bwA == 64 ? -1 : ((1ULL << bwA) - 1)); +uint64_t maskB = (bwB == 64 ? -1 : ((1ULL << bwB) - 1)); +uint64_t maskC = (bwC == 64 ? -1 : ((1ULL << bwC) - 1)); + +void test_hadamard_product(uint64_t *inA, uint64_t *inB, + bool signed_arithmetic = true) { + uint64_t *outC = new uint64_t[dim]; + + prod->hadamard_product(dim, inA, inB, outC, bwA, bwB, bwC, signed_arithmetic); + + if (party == ALICE) { + io->send_data(inA, dim * sizeof(uint64_t)); + io->send_data(inB, dim * sizeof(uint64_t)); + io->send_data(outC, dim * sizeof(uint64_t)); + } else { // party == BOB + uint64_t *inA0 = new uint64_t[dim]; + uint64_t *inB0 = new uint64_t[dim]; + uint64_t *outC0 = new uint64_t[dim]; + io->recv_data(inA0, dim * sizeof(uint64_t)); + io->recv_data(inB0, dim * sizeof(uint64_t)); + io->recv_data(outC0, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + if (signed_arithmetic) { + assert(signed_val(outC[i] + outC0[i], bwC) == + (signed_val(signed_val(inA[i] + inA0[i], bwA) * + signed_val(inB[i] + inB0[i], bwB), + bwC))); + } else { + assert(unsigned_val(outC[i] + outC0[i], bwC) == + (unsigned_val(unsigned_val(inA[i] + inA0[i], bwA) * + unsigned_val(inB[i] + inB0[i], bwB), + bwC))); + } + } + if (signed_arithmetic) + cout << "SMult Tests Passed" << endl; + else + cout << "UMult Tests Passed" << endl; + + delete[] inA0; + delete[] inB0; + delete[] outC0; + } + + delete[] outC; +} + +int main(int argc, char **argv) { + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + + io = new NetIO(party == 1 ? nullptr : address.c_str(), port); + otpack = new OTPack<NetIO>(io, party); + + prod = new LinearOT(party, io, otpack); + + PRG128 prg; + + uint64_t *inA = new uint64_t[dim]; + uint64_t *inB = new uint64_t[dim]; + + prg.random_data(inA, dim * sizeof(uint64_t)); + prg.random_data(inB, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + inA[i] &= maskA; + inB[i] &= maskB; + } + + test_hadamard_product(inA, inB, false); + test_hadamard_product(inA, inB, true); + + delete[] inA; + delete[] inB; + delete prod; +} diff --git a/SCI/tests/test_ring_library_fixed.cpp b/SCI/tests/test_ring_library_fixed.cpp new file mode 100644 index 00000000..0279194c --- /dev/null +++ b/SCI/tests/test_ring_library_fixed.cpp @@ -0,0 +1,735 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2020 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "library_fixed.h" +#include <fstream> +#include <iostream> +#include <random> +#include <thread> + +using namespace std; + +#define MAX_THREADS 4 + +int party = 1; +string address = "127.0.0.1"; +int port = 8000; +int num_threads = 4; +int bitlength = 32; + +void test_matmul() { + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + int I = 1024; + int K = 4; + int J = 16; + int shrA = 4; + int shrB = 8; + int H1 = 2; + int H2 = 0; + int demote = 1; + int64_t *A = new int64_t[I * K]; + for (int i = 0; i < I * K; i++) { + A[i] = (int16_t)generator(); + } + int64_t *B = new int64_t[K * J]; + for (int i = 0; i < K * J; i++) { + B[i] = (int16_t)(party == 1 ? generator() : 0); + } + int64_t *C = new int64_t[I * J]; + initialize(); + // int64_t* tmp = new int64_t[K]; + + MatMul(I, K, J, shrA, shrB, H1, H2, demote, 16, 16, 32, 16, A, B, C, nullptr); + + finalize(); +} +// + +void test_convolution() { + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + int N = 1; + int H = 230; + int W = 230; + int CIN = 3; + int HF = 7; + int WF = 7; + int CINF = 3; + int COUTF = 64; + int HOUT = 112; + int WOUT = 112; + int HPADL = 0; + int HPADR = 0; + int WPADL = 0; + int WPADR = 0; + int HSTR = 2; + int WSTR = 2; + int HDL = 1; + int WDL = 1; + int G = 1; + int shrA = 1; + int shrB = 1; + int H1 = 18; + int H2 = 0; + int demote = 1; + int64_t *A = new int64_t[N * H * W * CIN]; + for (int i = 0; i < N * H * W * CIN; i++) { + A[i] = (int16_t)generator(); + } + int64_t *B = new int64_t[G * HF * WF * CINF * COUTF]; + for (int i = 0; i < G * HF * WF * CINF * COUTF; i++) { + B[i] = (party == 1 ? (int16_t)generator() : 0); + } + int64_t *C = new int64_t[N * HOUT * WOUT * COUTF * G]; + // for (int i = 0; i < N*HOUT*WOUT*COUTF*G; i++) { + // C[i] = (int16_t)generator(); + // } + // int64_t* tmp = new int64_t[HF*WF*CINF + 100]; + initialize(); + Convolution(N, H, W, CIN, HF, WF, CINF, COUTF, HOUT, WOUT, HPADL, HPADR, + WPADL, WPADR, HSTR, WSTR, HDL, WDL, G, shrA, shrB, H1, H2, demote, + 16, 16, 32, 16, A, B, C, nullptr); + + finalize(); +} +// + +void test_BNorm() { + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + int32_t I = 1 * 30 * 40; + int32_t J = 128; + int32_t shA = 1; + int32_t shBNB = 0; + int32_t shB = 14; + int64_t *A = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + A[i] = (int16_t)generator(); + } + int64_t *BNW = new int64_t[J]; + int64_t *BNB = new int64_t[J]; + for (int i = 0; i < J; i++) { + BNW[i] = party == 1 ? (int16_t)generator() : 0; + BNB[i] = party == 1 ? (int16_t)generator() : 0; + } + int64_t *B = new int64_t[I * J]; + + initialize(); + + BNorm(I, J, shA, shBNB, shB, 16, 16, 16, 32, 16, A, BNW, BNB, B); + + finalize(); + + delete[] A; + delete[] BNW; + delete[] BNB; + delete[] B; +} + +// MBConv<int16_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, +// int8_t, int8_t, int16_t, int16_t, int16_t, int32_t, int32_t, int32_t, +// int32_t>(&tmp378_16[0][0][0][0], &L9F1[0][0][0][0][0], &L9W1[0], &L9B1[0], +// &L9F2[0][0][0][0][0], &L9W2[0], &L9B2[0], &L9F3[0][0][0][0][0], &L9W3[0], +// &L9B3[0], &tmp391_16[0][0][0][0], &tmp392_16[0][0][0], &tmp393_16[0], +// &tmp390_32[0], 1, 15, 20, 96, 192, 3, 3, 96, 15, 20, 1, 1, 1, 1, 1, 1, 7, 4, +// 8, 1572864L, 393216L, 1, 1, 64, 8, 1, 16, 1, 1, 64, 1, 8, 1, 1, 16, 1, 2, 64, +// 1); + +void test_MBConv() { + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + int N = 1; + int H = 15; + int W = 20; + int Cin = 96; + int Ct = 192; + int HF = 3; + int WF = 3; + int Cout = 96; + int Hout = 15; + int Wout = 20; + int HPADL = 1; + int HPADR = 1; + int WPADL = 1; + int WPADR = 1; + int HSTR = 1; + int WSTR = 1; + int D1 = 7; + int D2 = 4; + int D3 = 8; + int32_t SIX_1 = 1572864L; + int32_t SIX_2 = 393216L; + int shr1 = 1; + int shr2 = 1; + int shr3 = 64; + int shr4 = 8; + int shr5 = 1; + int shr6 = 16; + int shr7 = 1; + int shr8 = 1; + int shr9 = 64; + int shl1 = 1; + int shl2 = 8; + int shl3 = 1; + int shl4 = 1; + int shl5 = 16; + int shl6 = 1; + int shl7 = 2; + int shl8 = 64; + int shl9 = 1; + + int64_t *A = new int64_t[N * H * W * Cin]; + int64_t *F1 = new int64_t[Cin * Ct]; + int64_t *BN1W = new int64_t[Ct]; + int64_t *BN1B = new int64_t[Ct]; + int64_t *F2 = new int64_t[Ct * HF * WF]; + int64_t *BN2W = new int64_t[Ct]; + int64_t *BN2B = new int64_t[Ct]; + int64_t *F3 = new int64_t[Ct * Cout]; + int64_t *BN3W = new int64_t[Cout]; + int64_t *BN3B = new int64_t[Cout]; + + for (int i = 0; i < N * H * W * Cin; i++) { + A[i] = (int16_t)generator(); + } + for (int i = 0; i < Cin * Ct; i++) { + F1[i] = (int8_t)(party == 1 ? generator() : 0); + } + for (int i = 0; i < Ct * HF * WF; i++) { + F2[i] = (int8_t)(party == 1 ? generator() : 0); + } + for (int i = 0; i < Ct * Cout; i++) { + F3[i] = (int8_t)(party == 1 ? generator() : 0); + } + for (int i = 0; i < Ct; i++) { + BN1W[i] = (int8_t)(party == 1 ? generator() : 0); + BN1B[i] = (int8_t)(party == 1 ? generator() : 0); + BN2W[i] = (int8_t)(party == 1 ? generator() : 0); + BN2B[i] = (int8_t)(party == 1 ? generator() : 0); + } + for (int i = 0; i < Cout; i++) { + BN3W[i] = (int8_t)(party == 1 ? generator() : 0); + BN3B[i] = (int8_t)(party == 1 ? generator() : 0); + } + + int64_t *C = new int64_t[N * Hout * Wout * Cout]; + // int64_t* C_layerwise = new int64_t[N*Hout*Wout*Cout]; + // int64_t* C_seedot = new int64_t[N*Hout*Wout*Cout]; + + initialize(); + + MBConv(N, H, W, Cin, Ct, HF, WF, Cout, Hout, Wout, HPADL, HPADR, WPADL, WPADR, + HSTR, WSTR, D1, D2, D3, SIX_1, SIX_2, shr1, shr2, shr3, shr4, shr5, + shr6, shr7, shr8, shr9, shl1, shl2, shl3, shl4, shl5, shl6, shl7, shl8, + shl9, 16, 8, 8, 8, 8, 8, 8, 8, 8, 8, 16, 16, 16, 16, 32, 32, 32, A, F1, + BN1W, BN1B, F2, BN2W, BN2B, F3, BN3W, BN3B, C, nullptr, nullptr, + nullptr); + // cleartext_MBConv<int16_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, + // int8_t, int8_t, int8_t, int16_t, int16_t, int16_t, int16_t, int32_t, + // int32_t, int32_t>(A, F1, BN1W, BN1B, F2, BN2W, BN2B, F3, BN3W, BN3B, C, + // nullptr, nullptr, nullptr, N, H, W, Cin, Ct, HF, WF, Cout, Hout, Wout, + // HPADL, HPADR, WPADL, WPADR, HSTR, WSTR, D1, D2, D3, SIX_1, SIX_2, shr1, + // shr2, shr3, shr4, shr5, shr6, shr7, shr8, shr9, shl1, shl2, shl3, shl4, + // shl5, shl6, shl7, shl8, shl9); cleartext_MBConv_layerwise<int16_t, int8_t, + // int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int16_t, + // int16_t, int16_t, int16_t, int32_t, int32_t, int32_t>(A, F1, BN1W, BN1B, + // F2, BN2W, BN2B, F3, BN3W, BN3B, C_layerwise, nullptr, nullptr, nullptr, N, + // H, W, Cin, Ct, HF, WF, Cout, Hout, Wout, HPADL, HPADR, WPADL, WPADR, HSTR, + // WSTR, D1, D2, D3, SIX_1, SIX_2, shr1, shr2, shr3, shr4, shr5, shr6, shr7, + // shr8, shr9, shl1, shl2, shl3, shl4, shl5, shl6, shl7, shl8, shl9); + // cleartext_MBConv_seedot<int16_t, int8_t, int8_t, int8_t, int8_t, int8_t, + // int8_t, int8_t, int8_t, int8_t, int16_t, int16_t, int16_t, int16_t, + // int32_t, int32_t, int32_t>(A, F1, BN1W, BN1B, F2, BN2W, BN2B, F3, BN3W, + // BN3B, C_seedot, nullptr, nullptr, nullptr, N, H, W, Cin, Ct, HF, WF, Cout, + // Hout, Wout, HPADL, HPADR, WPADL, WPADR, HSTR, WSTR, D1, D2, D3, SIX_1, + // SIX_2, shr1, shr2, shr3, shr4, shr5, shr6, shr7, shr8, shr9, shl1, shl2, + // shl3, shl4, shl5, shl6, shl7, shl8, shl9); + + finalize(); + + delete[] A; + delete[] F1; + delete[] BN1W; + delete[] BN1B; + delete[] F2; + delete[] BN2W; + delete[] BN2B; + delete[] F3; + delete[] BN3W; + delete[] BN3B; + + delete[] C; + // delete[] C_layerwise; + // delete[] C_seedot; +} +// + +// + +void test_NormaliseL2() { + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + int32_t N = 1; + int32_t H = 30; + int32_t W = 40; + int32_t C = 32; + int32_t scaleA = -12; + int32_t shrA = 8; + int32_t bwA = 16; + int64_t *A = new int64_t[N * H * W * C]; + // int64_t* calcB = new int64_t[N*H*W*C]; + // int64_t* calcCorrectB = new int64_t[N*H*W*C]; + // ifstream infile("norminfile"); + for (int i = 0; i < N * H * W * C; i++) { + // cin>>A[i]; + // infile>>calcB[i]; + // infile>>calcB[i]; + // infile>> calcCorrectB[i]; + A[i] = party == 1 ? (int16_t)generator() : 0; + } + int64_t *B = new int64_t[N * H * W * C]; + + initialize(); + + NormaliseL2(N, H, W, C, scaleA, shrA, 16, A, B); + + finalize(); + + delete[] A; + delete[] B; +} + +void test_exp() { + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + int32_t I = 1; + int32_t J = 16; + int32_t scale_in = 1LL << 26; + int32_t scale_out = 1LL << 26; + int32_t bwA = sizeof(int16_t) * 8; + int64_t *A = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + A[i] = (int16_t)(party == 1 ? (generator() | (1LL << (bwA - 1))) : 0); + } + int64_t *B = new int64_t[I * J]; + + initialize(); + + Exp(I, J, scale_in, scale_out, 32, A, B); + + finalize(); + + delete[] A; + delete[] B; +} +// + +void test_div() { + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + int32_t I = 1; + int32_t J = 16; + int32_t scale_in = 1LL << 26; + int32_t scale_out = 1LL << 26; + int32_t bwA = sizeof(int16_t) * 8; + int64_t *A = new int64_t[I * J]; + int64_t *B = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + A[i] = (int32_t)generator(); + B[i] = + (int32_t)(party == 1 ? ((generator() & (scale_in - 1)) | scale_in) : 0); + } + int64_t *C = new int64_t[I * J]; + + initialize(); + + Div(I, J, scale_in, scale_in, scale_out, 32, A, B, C); + + finalize(); + + delete[] A; + delete[] B; + delete[] C; +} +// + +void test_sigmoid() { + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + int32_t I = 1131; + int32_t J = 16; + int32_t scale_in = 1LL << 11; + int32_t scale_out = 1LL << 14; + int64_t *A = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + A[i] = (int16_t)generator(); + } + int64_t *B = new int64_t[I * J]; + + initialize(); + + Sigmoid(I, J, scale_in, scale_out, 16, 16, A, B); + + finalize(); + + delete[] A; + delete[] B; +} +// + +void test_TanH() { + + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + int32_t I = 1131; + int32_t J = 16; + int32_t scale_in = 1LL << 11; + int32_t scale_out = 1LL << 14; + + int64_t *A = new int64_t[I * J]; + for (int i = 0; i < I * J; i++) { + A[i] = (int16_t)generator(); + } + + int64_t *B = new int64_t[I * J]; + + initialize(); + + TanH(I, J, scale_in, scale_out, 16, 16, A, B); + + finalize(); + + delete[] A; + delete[] B; +} +// + +void test_sqrt() { + + std::random_device rand_div; + std::mt19937 generator(rand_div()); + // std::mt19937 generator(0); + + int32_t I = 1131; + int32_t J = 16; + + int32_t scale_in = 12; + int32_t scale_out = 14; + + uint64_t *A = new uint64_t[I * J]; + + for (int i = 0; i < I * J; i++) { + A[i] = party == 1 ? (int16_t)generator() : 0; + A[i] = A[i] < 0 ? -1 * A[i] : 0; + assert(A[i] >= 0); + } + + uint64_t *B1 = new uint64_t[I * J]; + uint64_t *B2 = new uint64_t[I * J]; + + initialize(); + + Sqrt(I, J, scale_in, scale_out, 16, 16, true, A, B1); + + finalize(); + + initialize(); + + Sqrt(I, J, scale_in, scale_out, 16, 16, false, A, B2); + + finalize(); + + delete[] A; + delete[] B1; + delete[] B2; +} +// + +void test_AddOrSubCir4D() { + random_device rand_div; + mt19937 generator(rand_div()); + // mt19937 generator(0); + + int N, H, W, C, shrA, shrB, shrC, demote; + bool add = true; + + N = 4; + H = 10; // Height of Array + W = 2; // Width of Array + C = 5; + + shrA = 4; // Scale down 1 + shrB = 2; // Scale down 2 + shrC = 8; // Scale down final + demote = 2; + + int64_t *A = new int64_t[N * C * H * W]; + int64_t *B = new int64_t[C]; + int64_t *X1 = new int64_t[N * C * H * W]; + int64_t *X2 = new int64_t[N * C * H * W]; + + for (int i = 0; i < N * C * H * W; i++) { + A[i] = (int16_t)generator(); + } + for (int i = 0; i < C; i++) { + B[i] = (int16_t)(party == 2 ? generator() : 0); + } + + initialize(); + AddOrSubCir4D(N, H, W, C, shrA, shrB, shrC, add, demote, 16, 16, 32, 16, A, B, + X1); + finalize(); + add = false; + + // initialize(); + // AddOrSubCir4D(N, H, W, C, shrA, shrB, shrC, add, demote, 16, 16, 32, 16, A, + // B, X2); finalize(); + + delete[] A; + delete[] B; + delete[] X1; + delete[] X2; +} + +void test_MatAdd() { + random_device rand_div; + mt19937 generator(rand_div()); + + // mt19937 generator(0); + + int I, J, shrA, shrB, shrC, demote; + + I = 10; + J = 5; + shrA = 4; + shrB = 8; + shrC = 16; + demote = 2; + + int64_t *A = new int64_t[I * J]; + int64_t *B = new int64_t[I * J]; + int64_t *C1 = new int64_t[I * J]; + int64_t *C2 = new int64_t[I * J]; + int64_t *C3 = new int64_t[I * J]; + + for (int i = 0; i < I * J; i++) { + A[i] = (int16_t)generator(); + B[i] = (int16_t)(party == 1 ? generator() : 0); + } + + initialize(); + + MatAdd(I, J, shrA, shrB, shrC, demote, 16, 16, 32, 16, A, B, C1); + finalize(); + + initialize(); + MatAddBroadCastA(I, J, shrA, shrB, shrC, demote, 16, 16, 32, 16, int64_t(10), + B, C2); + finalize(); + + initialize(); + MatAddBroadCastB(I, J, shrA, shrB, shrC, demote, 16, 16, 32, 16, A, + int64_t(11), C3); + finalize(); + + int64_t N, H, W, X; + N = 2; + H = 4; + W = 3; + X = 4; + + int64_t *A4_s = new int64_t[N * H * W * X]; + int64_t *B4_s = new int64_t[N * H * W * X]; + int64_t *C4_s = new int64_t[N * H * W * X]; + + for (int i = 0; i < N * H * W * X; i++) { + A4_s[i] = (int8_t)generator(); + B4_s[i] = (int8_t)(party == 1 ? generator() : 0); + } + + initialize(); + + MatAdd4(N, H, W, X, shrA, shrB, shrC, demote, 8, 8, 16, 8, A4_s, B4_s, C4_s); + + finalize(); + + delete[] A; + delete[] B; + delete[] C1; + delete[] C2; + delete[] C3; + delete[] A4_s; + delete[] B4_s; + delete[] C4_s; +} + +void test_MatSub() { + random_device rand_div; + mt19937 generator(rand_div()); + // mt19937 generator(0); + + int I, J, shrA, shrB, shrC, demote; + + I = 10; + J = 5; + shrA = 4; + shrB = 8; + shrC = 16; + demote = 2; + + int64_t *A = new int64_t[I * J]; + int64_t *B = new int64_t[I * J]; + int64_t *C1 = new int64_t[I * J]; + int64_t *C2 = new int64_t[I * J]; + int64_t *C3 = new int64_t[I * J]; + + for (int i = 0; i < I * J; i++) { + A[i] = (int16_t)generator(); + B[i] = (int16_t)(party == 1 ? generator() : 0); + } + + initialize(); + MatSub(I, J, shrA, shrB, shrC, demote, 16, 16, 32, 16, A, B, C1); + finalize(); + + initialize(); + MatSubBroadCastA(I, J, shrA, shrB, shrC, demote, 16, 16, 32, 16, 10, B, C2); + finalize(); + + initialize(); + MatSubBroadCastB(I, J, shrA, shrB, shrC, demote, 16, 16, 32, 16, A, 11, C3); + finalize(); + + delete[] A; + delete[] B; + delete[] C1; + delete[] C2; + delete[] C3; +} + +void test_MulCir() { + random_device rand_div; + mt19937 generator(rand_div()); + // mt19937 generator(0); + + int I, J, shrA, shrB, demote; + + I = 10; + J = 5; + + shrA = 4; + shrB = 8; + demote = 2; + + int64_t *A = new int64_t[I * J]; + int64_t *B = new int64_t[I * J]; + int64_t *C = new int64_t[I * J]; + + for (int i = 0; i < I * J; i++) { + A[i] = (int16_t)generator(); + } + for (int i = 0; i < I * J; i++) { + B[i] = (int16_t)(party == 1 ? generator() : 0); + } + + initialize(); + MulCir(I, J, shrA, shrB, demote, 16, 16, 32, 16, A, B, C); + finalize(); + + delete[] A; + delete[] B; + delete[] C; +} + +void test_ScalarMul() { + random_device rand_div; + mt19937 generator(rand_div()); + // mt19937 generator(0); + + int I, J, shrA, shrB, demote; + + I = 10; + J = 5; + + shrA = 4; + shrB = 8; + demote = 2; + + int64_t A = 777; + int64_t *B = new int64_t[I * J]; + int64_t *C = new int64_t[I * J]; + + for (int i = 0; i < I * J; i++) { + B[i] = (int16_t)(party == 1 ? generator() : 0); + } + + initialize(); + ScalarMul(I, J, shrA, shrB, demote, 16, 16, 32, 16, A, B, C); + finalize(); + + delete[] B; + delete[] C; +} + +int main(int argc, char **argv) { + if (argc >= 2) { + party = atoi(argv[1]); + } + if (argc >= 3) { + address = argv[2]; + } + if (argc >= 4) { + port = atoi(argv[3]); + } + if (argc >= 5) { + num_threads = atoi(argv[4]); + } + assert(party == 1 || party == 2); + + cout << "Party: " << party << endl; + + // test_convolution(); + // test_BNorm(); + // test_MBConv(); + // test_NormaliseL2(); + // test_AddOrSubCir4D(); + + // test_matmul(); + // test_sigmoid(); + // test_TanH(); + // test_exp(); + // test_div(); + // test_MatAdd(); + // test_MatSub(); + // test_MulCir(); + // test_ScalarMul(); + // test_sqrt(); +} diff --git a/SCI/tests/test_ring_matmul.cpp b/SCI/tests/test_ring_matmul.cpp new file mode 100644 index 00000000..c5c730b9 --- /dev/null +++ b/SCI/tests/test_ring_matmul.cpp @@ -0,0 +1,205 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "LinearOT/linear-ot.h" +#include "utils/emp-tool.h" +#include <iostream> + +using namespace sci; +using namespace std; + +int party, port = 32000; +string address = "127.0.0.1"; +NetIO *io; +OTPack<NetIO> *otpack; +LinearOT *prod; + +int dim1 = 100; +int dim2 = 1000; // 53; +int dim3 = 100; +int bwA = 8; +int bwB = 8; +int bwC = bwA + bwB; +bool signed_B = true; +bool accumulate = true; +bool precomputed_MSBs = false; +MultMode mode = MultMode::None; + +uint64_t maskA = (bwA == 64 ? -1 : ((1ULL << bwA) - 1)); +uint64_t maskB = (bwB == 64 ? -1 : ((1ULL << bwB) - 1)); +uint64_t maskC = (bwC == 64 ? -1 : ((1ULL << bwC) - 1)); + +void test_matrix_multiplication(uint64_t *inA, uint64_t *inB, + bool signed_arithmetic = true) { + int dim = (::accumulate ? dim1 * dim3 : dim1 * dim2 * dim3); + uint64_t *outC = new uint64_t[dim]; + + INIT_TIMER; + START_TIMER; + uint8_t *msbA = nullptr; + uint8_t *msbB = nullptr; + if (precomputed_MSBs) { + msbA = new uint8_t[dim1 * dim2]; + msbB = new uint8_t[dim2 * dim3]; + prod->aux->MSB(inA, msbA, dim1 * dim2, bwA); + prod->aux->MSB(inB, msbB, dim2 * dim3, bwB); + } + uint64_t comm_start = io->counter; + prod->matrix_multiplication(dim1, dim2, dim3, inA, inB, outC, bwA, bwB, bwC, + signed_arithmetic, signed_B, ::accumulate, mode, + msbA, msbB); + if (precomputed_MSBs) { + delete[] msbA; + delete[] msbB; + } + uint64_t comm_end = io->counter; + cout << "Bytes Sent: " << (comm_end - comm_start) << endl; + STOP_TIMER("Total time for matmul"); + + if (party == ALICE) { + io->send_data(inA, dim1 * dim2 * sizeof(uint64_t)); + io->send_data(inB, dim2 * dim3 * sizeof(uint64_t)); + io->send_data(outC, dim * sizeof(uint64_t)); + } else { // party == BOB + uint64_t *inA0 = new uint64_t[dim1 * dim2]; + uint64_t *inB0 = new uint64_t[dim2 * dim3]; + uint64_t *outC0 = new uint64_t[dim]; + io->recv_data(inA0, dim1 * dim2 * sizeof(uint64_t)); + io->recv_data(inB0, dim2 * dim3 * sizeof(uint64_t)); + io->recv_data(outC0, dim * sizeof(uint64_t)); + + int extra_bits = (::accumulate ? ceil(log2(dim2)) : 0); + uint64_t *res = new uint64_t[dim]; + for (int i = 0; i < dim1 * dim2; i++) { + if (signed_arithmetic) { + if (mode == MultMode::Alice_has_A) { + inA0[i] = signed_val(inA0[i], bwA); + } else if (mode == MultMode::Bob_has_A) { + inA0[i] = signed_val(inA[i], bwA); + } else { + inA0[i] = signed_val(inA0[i] + inA[i], bwA); + } + } else { + if (mode == MultMode::Alice_has_A) { + inA0[i] = unsigned_val(inA0[i], bwA); + } else if (mode == MultMode::Bob_has_A) { + inA0[i] = unsigned_val(inA[i], bwA); + } else { + inA0[i] = unsigned_val(inA0[i] + inA[i], bwA); + } + } + } + for (int i = 0; i < dim2 * dim3; i++) { + if (signed_arithmetic && signed_B) { + if (mode == MultMode::Alice_has_B) { + inB0[i] = signed_val(inB0[i], bwB); + } else if (mode == MultMode::Bob_has_B) { + inB0[i] = signed_val(inB[i], bwB); + } else { + inB0[i] = signed_val(inB0[i] + inB[i], bwB); + } + } else { + if (mode == MultMode::Alice_has_B) { + inB0[i] = unsigned_val(inB0[i], bwB); + } else if (mode == MultMode::Bob_has_B) { + inB0[i] = unsigned_val(inB[i], bwB); + } else { + inB0[i] = unsigned_val(inB0[i] + inB[i], bwB); + } + } + } + prod->matmul_cleartext(dim1, dim2, dim3, inA0, inB0, res, ::accumulate); + + for (int i = 0; i < dim; i++) { + if (signed_arithmetic) { + assert(signed_val(res[i] >> extra_bits, bwC) == + signed_val(outC[i] + outC0[i], bwC)); + } else { + assert(unsigned_val(res[i] >> extra_bits, bwC) == + unsigned_val(outC[i] + outC0[i], bwC)); + } + } + if (signed_arithmetic) + cout << "SMult Tests Passed" << endl; + else + cout << "UMult Tests Passed" << endl; + + delete[] inA0; + delete[] inB0; + delete[] outC0; + delete[] res; + } + delete[] outC; +} + +int main(int argc, char **argv) { + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + + io = new NetIO(party == 1 ? nullptr : "127.0.0.1", port); + otpack = new OTPack<NetIO>(io, party); + + prod = new LinearOT(party, io, otpack); + + PRG128 prg; //(fix_key); + + uint64_t *inA = new uint64_t[dim1 * dim2]; + uint64_t *inB = new uint64_t[dim2 * dim3]; + + prg.random_data(inA, dim1 * dim2 * sizeof(uint64_t)); + prg.random_data(inB, dim2 * dim3 * sizeof(uint64_t)); + + for (int i = 0; i < dim1 * dim2; i++) { + inA[i] &= maskA; + } + for (int i = 0; i < dim2 * dim3; i++) { + inB[i] &= maskB; + } + + mode = MultMode::None; + cout << "Mode: None" << endl; + test_matrix_multiplication(inA, inB, false); + test_matrix_multiplication(inA, inB, true); + mode = MultMode::Alice_has_A; + cout << "Mode: Alice_has_A" << endl; + test_matrix_multiplication(inA, inB, false); + test_matrix_multiplication(inA, inB, true); + mode = MultMode::Alice_has_B; + cout << "Mode: Alice_has_B" << endl; + test_matrix_multiplication(inA, inB, false); + test_matrix_multiplication(inA, inB, true); + mode = MultMode::Bob_has_A; + cout << "Mode: Bob_has_A" << endl; + test_matrix_multiplication(inA, inB, false); + test_matrix_multiplication(inA, inB, true); + mode = MultMode::Bob_has_B; + cout << "Mode: Bob_has_B" << endl; + test_matrix_multiplication(inA, inB, false); + test_matrix_multiplication(inA, inB, true); + + delete[] inA; + delete[] inB; + delete prod; +} diff --git a/SCI/tests/test_ring_maxpool.cpp b/SCI/tests/test_ring_maxpool.cpp index 01cb7c17..3a237ebb 100644 --- a/SCI/tests/test_ring_maxpool.cpp +++ b/SCI/tests/test_ring_maxpool.cpp @@ -19,11 +19,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#define BITLEN_41 -#define SCI_OT -#include "globals.h" -#include "NonLinear/relu-field.h" -#include "NonLinear/relu-ring.h" #include "NonLinear/maxpool.h" #include <fstream> #include <thread> @@ -31,204 +26,183 @@ SOFTWARE. using namespace std; using namespace sci; +#define MAX_THREADS 4 + +int party = 0; int port = 32000; -int num_rows = 1<<15, num_cols = 1<<7; -int l = 41, b = 4; +int num_rows = 1 << 10, num_cols = 1 << 6; +int l = 32, b = 4; int batch_size = 0; -string address; -bool localhost = true; - -void ring_maxpool_thread(int tid, uint64_t* z, uint64_t* x, int lnum_rows, int lnum_cols) { - MaxPoolProtocol<NetIO, uint64_t>* maxpool_oracle; - if(tid & 1) { - maxpool_oracle = new MaxPoolProtocol<NetIO, uint64_t>(3-party, RING, ioArr[tid], l, b, 0, otpackArr[tid]); - } else { - maxpool_oracle = new MaxPoolProtocol<NetIO, uint64_t>(party, RING, ioArr[tid], l, b, 0, otpackArr[tid]); - } - if (batch_size) { - for (int j = 0; j < lnum_rows; j += batch_size) { - if (batch_size <= lnum_rows - j) { - maxpool_oracle->funcMaxMPC(batch_size, lnum_cols, x+j, z+j, nullptr); - } else { - maxpool_oracle->funcMaxMPC(lnum_rows-j, lnum_cols, x+j, z+j, nullptr); - } - } - } else { - maxpool_oracle->funcMaxMPC(lnum_rows, lnum_cols, x, z, nullptr); +string address = "127.0.0.1"; +int num_threads = 1; +int32_t bitlength = 32; + +sci::NetIO *ioArr[MAX_THREADS]; +sci::OTPack<sci::NetIO> *otpackArr[MAX_THREADS]; + +void ring_maxpool_thread(int tid, uint64_t *z, uint64_t *x, int lnum_rows, + int lnum_cols) { + MaxPoolProtocol<NetIO, uint64_t> *maxpool_oracle; + if (tid & 1) { + maxpool_oracle = new MaxPoolProtocol<NetIO, uint64_t>( + 3 - party, RING, ioArr[tid], l, b, 0, otpackArr[tid]); + } else { + maxpool_oracle = new MaxPoolProtocol<NetIO, uint64_t>( + party, RING, ioArr[tid], l, b, 0, otpackArr[tid]); + } + if (batch_size) { + for (int j = 0; j < lnum_rows; j += batch_size) { + if (batch_size <= lnum_rows - j) { + maxpool_oracle->funcMaxMPC(batch_size, lnum_cols, x + j, z + j, + nullptr); + } else { + maxpool_oracle->funcMaxMPC(lnum_rows - j, lnum_cols, x + j, z + j, + nullptr); + } } + } else { + maxpool_oracle->funcMaxMPC(lnum_rows, lnum_cols, x, z, nullptr); + } - delete maxpool_oracle; - return; + delete maxpool_oracle; + return; } -int main(int argc, char** argv){ - /************* Argument Parsing ************/ - /********************************************/ - - ArgMapping amap; - amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("l", l, "Bitlength of inputs"); - amap.arg("b", b, "Radix base"); - amap.arg("Nr", num_rows, "Number of rows"); - amap.arg("Nc", num_cols, "Number of cols"); - amap.arg("lo", localhost, "Localhost Run?"); - amap.arg("bt", batch_size, "Batch size as a power of 2 (No batching = 0)"); - - amap.parse(argc, argv); - if (batch_size > 0) { - batch_size = 1 << batch_size; - } - if(not localhost) { - address = "40.118.124.169"; +int main(int argc, char **argv) { + /************* Argument Parsing ************/ + /********************************************/ + + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("l", l, "Bitlength of inputs"); + amap.arg("b", b, "Radix base"); + amap.arg("Nr", num_rows, "Number of rows"); + amap.arg("Nc", num_cols, "Number of cols"); + amap.arg("bt", batch_size, "Batch size as a power of 2 (No batching = 0)"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + if (batch_size > 0) { + batch_size = 1 << batch_size; + } + num_rows = ((num_rows + 7) / 8) * 8; + + cout << "========================================================" << endl; + cout << "Role: " << party << " - Bitlength: " << l << " - Radix Base: " << b + << "\n#rows: " << num_rows << " - #cols: " << num_cols + << " - Batch Size: " << batch_size << " - # Threads: " << num_threads + << endl; + cout << "========================================================" << endl; + + /************ Generate Test Data ************/ + /********************************************/ + uint64_t mask_l; + if (l == 64) + mask_l = -1; + else + mask_l = (1ULL << l) - 1; + PRG128 prg; + uint64_t *x = new uint64_t[num_rows * num_cols]; + uint64_t *z = new uint64_t[num_rows]; + prg.random_data(x, sizeof(uint64_t) * num_rows * num_cols); + for (int i = 0; i < num_rows * num_cols; i++) { + x[i] = x[i] & mask_l; + } + + /********** Setup IO and Base OTs ***********/ + /********************************************/ + + for (int i = 0; i < num_threads; i++) { + ioArr[i] = new NetIO(party == 1 ? nullptr : address.c_str(), port + i); + if (i == 0) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); } else { - address = "127.0.0.1"; - } - // assert(l == 32); - num_rows = ((num_rows + 7)/8)*8; - - cout << "========================================================" << endl; - cout << "Role: " << party << " - Bitlength: " << l << " - Radix Base: " << b - << "\n#rows: " << num_rows << " - #cols: " << num_cols << " - Batch Size: " - << batch_size << " - # Threads: " << numThreads << endl; - cout << "========================================================" << endl; - - /************ Generate Test Data ************/ - /********************************************/ - uint64_t mask_l; - if (l == 64) mask_l = -1; - else mask_l = (1ULL << l) - 1; - PRG128 prg; - uint64_t *x = new uint64_t[num_rows*num_cols]; - // uint8_t *x_sign = new uint8_t[num_rows*num_cols]; - uint64_t *z = new uint64_t[num_rows]; - prg.random_data(x, sizeof(uint64_t)*num_rows*num_cols); - // prg.random_bool((bool*) x_sign, num_rows*num_cols); - for(int i = 0; i < num_rows*num_cols; i++) { - x[i] = x[i] & mask_l;//(magnitude_bound-1); - // if (x_sign[i]) { - // x[i] = (-1 * x[i]) & mask_l; - // } - } - // delete[] x_sign; - - /********** Setup IO and Base OTs ***********/ - /********************************************/ - - for(int i = 0; i < numThreads; i++) { - ioArr[i] = new NetIO(party==1 ? nullptr:address.c_str(), port+i); - if (i == 0) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, b, l); - } else if (i == 1) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3-party, b, l); - } else if (i & 1) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3-party, b, l, false); - otpackArr[i]->copy(otpackArr[1]); - } else { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, b, l, false); - otpackArr[i]->copy(otpackArr[0]); - } - } - std::cout << "All Base OTs Done" << std::endl; - - /************** Fork Threads ****************/ - /********************************************/ - - auto start = clock_start(); - std::thread maxpool_threads[numThreads]; - int chunk_size = (num_rows/(8*numThreads))*8; - for (int i = 0; i < numThreads; ++i) { - int offset = i*chunk_size; - int lnum_rows; - if (i == (numThreads - 1)) { - lnum_rows = num_rows - offset; - } else { - lnum_rows = chunk_size; - } - maxpool_threads[i] = std::thread(ring_maxpool_thread, i, z+offset, x+offset*num_cols, lnum_rows, num_cols); + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); } - for (int i = 0; i < numThreads; ++i) { - maxpool_threads[i].join(); - } - long long t = time_from(start); - - /************** Verification ****************/ - /********************************************/ - - switch (party) { - case sci::ALICE: { - ioArr[0]->send_data(x, sizeof(uint64_t)*num_rows*num_cols); - ioArr[0]->send_data(z, sizeof(uint64_t)*num_rows); - break; - } - case sci::BOB: { - uint64_t *xi = new uint64_t[num_rows*num_cols]; - uint64_t *zi = new uint64_t[num_rows]; - ioArr[0]->recv_data(xi, sizeof(uint64_t)*num_rows*num_cols); - ioArr[0]->recv_data(zi, sizeof(uint64_t)*num_rows); - - for(int i=0; i<num_rows; i++){ - zi[i] = (zi[i] + z[i]) & mask_l; - for(int c=0; c<num_cols; c++){ - xi[i*num_cols + c] = (xi[i*num_cols + c] + x[i*num_cols + c]) & mask_l; - } - uint64_t maxpool_output = xi[i*num_cols]; - // cout << xi[i*num_cols] << "\t"; - for(int c=1; c<num_cols; c++){ - maxpool_output = ((maxpool_output - xi[i*num_cols + c]) & mask_l) >= (1ULL << (l-1)) ? - xi[i*num_cols + c]:maxpool_output; - // cout << xi[i*num_cols + c] << "\t"; - } - // cout << maxpool_output << "\t"; - // cout << zi[i] << endl; - assert((zi[i] == maxpool_output) && "MaxPool output is incorrect"); - } - delete[] xi; - delete[] zi; - break; - } - } - delete[] x; - delete[] z; - - /**** Process & Write Benchmarking Data *****/ - /********************************************/ - - cout << "Number of Maxpool rows (num_cols=" << num_cols << ")/s:\t" - << (double(num_rows)/t)*1e6<< std::endl; - cout <<"Maxpool Time (l=" << l << "; b=" << b << ")\t" << t <<" mus"<< endl; - string file_addr; - switch (party) { - case 1: { - file_addr = "our-ring-maxpool-P0.csv"; - break; - } - case 2: { - file_addr = "our-ring-maxpool-P1.csv"; - break; - } - } - bool write_title = true; { - fstream result(file_addr.c_str(), fstream::in); - if(result.is_open()) - write_title = false; - result.close(); - } - fstream result(file_addr.c_str(), fstream::out|fstream::app); - if(write_title){ - result << "Bitlen,Base,Batch Size,#Threads,Maxpool Size,Time (mus),Throughput/sec" << endl; + } + std::cout << "All Base OTs Done" << std::endl; + + /************** Fork Threads ****************/ + /********************************************/ + + auto start = clock_start(); + std::thread maxpool_threads[num_threads]; + int chunk_size = (num_rows / (8 * num_threads)) * 8; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_rows; + if (i == (num_threads - 1)) { + lnum_rows = num_rows - offset; + } else { + lnum_rows = chunk_size; } - result << l << "," << b << "," << batch_size << "," << numThreads << "," << num_rows << "x" << num_cols - << "," << t << "," << (double(num_rows)/t)*1e6 << endl; - result.close(); - - /******************* Cleanup ****************/ - /********************************************/ - - for (int i = 0; i < numThreads; i++) { - delete ioArr[i]; - delete otpackArr[i]; + maxpool_threads[i] = + std::thread(ring_maxpool_thread, i, z + offset, x + offset * num_cols, + lnum_rows, num_cols); + } + for (int i = 0; i < num_threads; ++i) { + maxpool_threads[i].join(); + } + long long t = time_from(start); + + /************** Verification ****************/ + /********************************************/ + + switch (party) { + case sci::ALICE: { + ioArr[0]->send_data(x, sizeof(uint64_t) * num_rows * num_cols); + ioArr[0]->send_data(z, sizeof(uint64_t) * num_rows); + break; + } + case sci::BOB: { + uint64_t *xi = new uint64_t[num_rows * num_cols]; + uint64_t *zi = new uint64_t[num_rows]; + ioArr[0]->recv_data(xi, sizeof(uint64_t) * num_rows * num_cols); + ioArr[0]->recv_data(zi, sizeof(uint64_t) * num_rows); + + for (int i = 0; i < num_rows; i++) { + zi[i] = (zi[i] + z[i]) & mask_l; + for (int c = 0; c < num_cols; c++) { + xi[i * num_cols + c] = + (xi[i * num_cols + c] + x[i * num_cols + c]) & mask_l; + } + uint64_t maxpool_output = xi[i * num_cols]; + for (int c = 1; c < num_cols; c++) { + maxpool_output = ((maxpool_output - xi[i * num_cols + c]) & mask_l) >= + (1ULL << (l - 1)) + ? xi[i * num_cols + c] + : maxpool_output; + } + assert((zi[i] == maxpool_output) && "MaxPool output is incorrect"); } - - return 0; + delete[] xi; + delete[] zi; + cout << "Maxpool Tests Passed" << endl; + break; + } + } + delete[] x; + delete[] z; + + cout << "Number of Maxpool rows (num_cols=" << num_cols << ")/s:\t" + << (double(num_rows) / t) * 1e6 << std::endl; + cout << "Maxpool Time (l=" << l << "; b=" << b << ")\t" << t << " mus" + << endl; + + /******************* Cleanup ****************/ + /********************************************/ + + for (int i = 0; i < num_threads; i++) { + delete ioArr[i]; + delete otpackArr[i]; + } + + return 0; } diff --git a/SCI/tests/test_ring_relu.cpp b/SCI/tests/test_ring_relu.cpp index f1853030..0071c551 100644 --- a/SCI/tests/test_ring_relu.cpp +++ b/SCI/tests/test_ring_relu.cpp @@ -1,7 +1,7 @@ /* -Authors: Mayank Rathee, Deevashwer Rathee +Authors: Deevashwer Rathee Copyright: -Copyright (c) 2020 Microsoft Research +Copyright (c) 2021 Microsoft Research Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights @@ -19,271 +19,168 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#define BITLEN_32 -#define SCI_OT -#include <iostream> +#include "Math/math-functions.h" #include <fstream> +#include <iostream> #include <thread> -#include "globals.h" -#include "NonLinear/relu-ring.h" - -#define LAN_EXEC using namespace sci; using namespace std; -int num_relu = 1<<20, port = 32000; -int num_relu_orig = 0; -int l = 32, b = 4; -int batch_size = 0; -string address; -bool localhost = true; -string network = "none"; -vector<int> network_layer_sizes; +#define MAX_THREADS 4 -const std::map<std::string, std::vector<int>> layer_sizes { - {"sq", - vector<int>({ 200704, 50176, 200704, 200704, 50176, 200704, 200704, 23328, 93312, 93312, 23328, 93312, 93312, 8112, 32448, 32448, 8112, 32448, 32448, 10816, 43264, 43264, 10816, 43264, 43264, 169000 }) - }, - {"res", - vector<int>({ 200704, 200704, 200704, 802816, 200704, 200704, 802816, 200704, 200704, 802816, 401408, 100352, 401408, 100352, 100352, 401408, 100352, 100352, 401408, 100352, 100352, 401408, 200704, 50176, 200704, 50176, 50176, 200704, 50176, 50176, 200704, 50176, 50176, 200704, 50176, 50176, 200704, 50176, 50176, 200704, 100352, 25088, 100352, 25088, 25088, 100352, 25088, 25088, 100352 }) - }, - {"dense", - vector<int>({ 200704, 200704, 401408, 301056, 401408, 401408, 401408, 501760, 401408, 602112, 401408, 702464, 401408, 802816, 100352, 100352, 125440, 100352, 150528, 100352, 175616, 100352, 200704, 100352, 225792, 100352, 250880, 100352, 275968, 100352, 301056, 100352, 326144, 100352, 351232, 100352, 376320, 100352, 401408, 50176, 25088, 56448, 25088, 62720, 25088, 68992, 25088, 75264, 25088, 81536, 25088, 87808, 25088, 94080, 25088, 100352, 25088, 106624, 25088, 112896, 25088, 119168, 25088, 125440, 25088, 131712, 25088, 137984, 25088, 144256, 25088, 150528, 25088, 156800, 25088, 163072, 25088, 169344, 25088, 175616, 25088, 181888, 25088, 188160, 25088, 194432, 25088, 200704, 25088, 6272, 26656, 6272, 28224, 6272, 29792, 6272, 31360, 6272, 32928, 6272, 34496, 6272, 36064, 6272, 37632, 6272, 39200, 6272, 40768, 6272, 42336, 6272, 43904, 6272, 45472, 6272, 47040, 6272, 48608, 6272, 50176 }) - }, -}; +int party, port = 32000; +int num_threads = 4; +string address = "127.0.0.1"; +bool six_comparison = true; -void ring_relu_thread(int tid, uint64_t* z, uint64_t* x, int lnum_relu) { - ReLURingProtocol<NetIO, uint64_t>* relu_oracle; - if(tid & 1) { - relu_oracle = new ReLURingProtocol<NetIO, uint64_t>(3-party, RING, ioArr[tid], l, b, otpackArr[tid]); - } else { - relu_oracle = new ReLURingProtocol<NetIO, uint64_t>(party, RING, ioArr[tid], l, b, otpackArr[tid]); - } - if (batch_size) { - for (int j = 0; j < lnum_relu; j += batch_size) { - if (batch_size <= lnum_relu - j) { - relu_oracle->relu(z+j, x+j, batch_size); - } else { - relu_oracle->relu(z+j, x+j, lnum_relu-j); - } - } - } else { - relu_oracle->relu(z, x, lnum_relu); - } +int dim = 1ULL << 16; +int bw_x = 32; +int s_x = 28; - delete relu_oracle; - return; -} +uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); -int main(int argc, char** argv) { - /************* Argument Parsing ************/ - /********************************************/ +sci::NetIO *ioArr[MAX_THREADS]; +sci::OTPack<sci::NetIO> *otpackArr[MAX_THREADS]; - ArgMapping amap; - amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); - amap.arg("p", port, "Port Number"); - amap.arg("l", l, "Bitlength of inputs"); - amap.arg("N", num_relu, "Number of ReLUs"); - amap.arg("b", b, "Radix base"); - amap.arg("lo", localhost, "Localhost Run?"); - amap.arg("bt", batch_size, "Batch size as a power of 2 (No batching = 0)"); - amap.arg("network", network, "Network Type: sq - SqNet, res - ResNet50, dense - DenseNet121"); +void relu_thread(int tid, uint64_t *x, uint64_t *y, int num_ops, uint64_t six) { + MathFunctions *math; + if (tid & 1) { + math = new MathFunctions(3 - party, ioArr[tid], otpackArr[tid]); + } else { + math = new MathFunctions(party, ioArr[tid], otpackArr[tid]); + } + math->ReLU(num_ops, x, y, bw_x, six); - amap.parse(argc, argv); + delete math; +} - if (batch_size > 0) { - batch_size = 1 << batch_size; - } - if(not localhost) { -#if defined(LAN_EXEC) - address = "40.118.124.169"; // SGX4 -#elif defined(WAN_EXEC) - address = "40.117.40.111"; // SGX2 -#endif +int main(int argc, char **argv) { + /************* Argument Parsing ************/ + /********************************************/ + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("N", dim, "Number of ReLU operations"); + amap.arg("nt", num_threads, "Number of threads"); + amap.arg("six", six_comparison, "ReLU6?"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + + assert(num_threads <= MAX_THREADS); + + /********** Setup IO and Base OTs ***********/ + /********************************************/ + for (int i = 0; i < num_threads; i++) { + ioArr[i] = new NetIO(party == 1 ? nullptr : address.c_str(), port + i); + if (i == 0) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); } else { - address = "127.0.0.1"; + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); } - if (network != "none") { - num_relu = 0; - network_layer_sizes = layer_sizes.at(network); - for(size_t i = 0; i < network_layer_sizes.size(); i++) { - num_relu_orig += network_layer_sizes[i]; - num_relu += ((network_layer_sizes[i] + 7)/8)*8; - } - if (network == "res") l = 37; - else l = 32; + } + std::cout << "All Base OTs Done" << std::endl; + + /************ Generate Test Data ************/ + /********************************************/ + PRG128 prg; + + uint64_t *x = new uint64_t[dim]; + uint64_t *y = new uint64_t[dim]; + + prg.random_data(x, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + x[i] &= mask_x; + } + uint64_t six; + if (six_comparison) + six = (6ULL << s_x); + else + six = 0; + + /************** Fork Threads ****************/ + /********************************************/ + uint64_t total_comm = 0; + uint64_t thread_comm[num_threads]; + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter; + } + + auto start = clock_start(); + std::thread relu_threads[num_threads]; + int chunk_size = dim / num_threads; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_ops; + if (i == (num_threads - 1)) { + lnum_ops = dim - offset; } else { - num_relu_orig = num_relu; - num_relu = ((num_relu + 7)/8)*8; - } - - cout << "========================================================" << endl; - cout << "Role: " << party << " - Bitlength: " << l << " - Radix Base: " << b - << "\n# ReLUs: " << num_relu_orig << " - Batch Size: " - << batch_size << " - # Threads: " << numThreads << endl; - cout << "========================================================" << endl; - - /************ Generate Test Data ************/ - /********************************************/ - - sci::PRG128 prg; - uint64_t mask_l; - if (l == 64) mask_l = -1; - else mask_l = (1ULL << l) - 1; - uint64_t *x = new uint64_t[num_relu]; - uint64_t *z = new uint64_t[num_relu]; - prg.random_data(x, sizeof(uint64_t)*num_relu); - for(int i = 0; i < num_relu; i++) { - x[i] = x[i] & mask_l; + lnum_ops = chunk_size; } - - /********** Setup IO and Base OTs ***********/ - /********************************************/ - - for(int i = 0; i < numThreads; i++) { - ioArr[i] = new NetIO(party==1 ? nullptr:address.c_str(), port+i); - if (i == 0) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, b, l); - } else if (i == 1) { - otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3-party, b, l); - } else if (i & 1) { - // otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3-party, b, l); - otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3-party, b, l, false); - // *otpackArr[i] = otpackArr[1]; - otpackArr[i]->copy(otpackArr[1]); - } else { - // otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, b, l); - otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, b, l, false); - // *otpackArr[i] = otpackArr[0]; - otpackArr[i]->copy(otpackArr[0]); - } + relu_threads[i] = + std::thread(relu_thread, i, x + offset, y + offset, lnum_ops, six); + } + for (int i = 0; i < num_threads; ++i) { + relu_threads[i].join(); + } + long long t = time_from(start); + + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter - thread_comm[i]; + total_comm += thread_comm[i]; + } + + /************** Verification ****************/ + /********************************************/ + if (party == ALICE) { + ioArr[0]->send_data(x, dim * sizeof(uint64_t)); + ioArr[0]->send_data(y, dim * sizeof(uint64_t)); + } else { // party == BOB + uint64_t *x0 = new uint64_t[dim]; + uint64_t *y0 = new uint64_t[dim]; + ioArr[0]->recv_data(x0, dim * sizeof(uint64_t)); + ioArr[0]->recv_data(y0, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + int64_t X = signed_val(x[i] + x0[i], bw_x); + int64_t Y = signed_val(y[i] + y0[i], bw_x); + int64_t expectedY = X; + if (X < 0) + expectedY = 0; + if (six != 0) { + if (X > int64_t(six)) + expectedY = six; + } + // cout << X << "\t" << Y << "\t" << expectedY << endl; + assert(Y == expectedY); } - std::cout << "All Base OTs Done" << std::endl; - - /************** Fork Threads ****************/ - /********************************************/ - uint64_t comm_sent = 0; - uint64_t multiThreadedIOStart[numThreads]; - for(int i=0;i<numThreads;i++){ - multiThreadedIOStart[i] = ioArr[i]->counter; - } - auto start = clock_start(); - if (network != "none") { - int layer_offset = 0; - for(size_t layer_idx = 0; layer_idx < network_layer_sizes.size(); layer_idx++) { - std::thread relu_threads[numThreads]; - int layer_size = ((network_layer_sizes[layer_idx] + 7)/8)*8; - int chunk_size = (layer_size/(8*numThreads))*8; - cout << "Layer_idx: " << layer_idx << "; Layer_size: " << layer_size << endl; - for (int i = 0; i < numThreads; ++i) { - int offset = i*chunk_size + layer_offset; - int lnum_relu; - if (i == (numThreads - 1)) { - lnum_relu = (layer_offset + layer_size) - offset; - } else { - lnum_relu = chunk_size; - } - relu_threads[i] = std::thread(ring_relu_thread, i, z+offset, x+offset, lnum_relu); - } - for (int i = 0; i < numThreads; ++i) { - relu_threads[i].join(); - } - layer_offset += layer_size; - } - } else { - std::thread relu_threads[numThreads]; - int chunk_size = (num_relu/(8*numThreads))*8; - for (int i = 0; i < numThreads; ++i) { - int offset = i*chunk_size; - int lnum_relu; - if (i == (numThreads - 1)) { - lnum_relu = num_relu - offset; - } else { - lnum_relu = chunk_size; - } - relu_threads[i] = std::thread(ring_relu_thread, i, z+offset, x+offset, lnum_relu); - } - for (int i = 0; i < numThreads; ++i) { - relu_threads[i].join(); - } - } - long long t = time_from(start); - for(int i=0;i<numThreads;i++){ - auto curComm = (ioArr[i]->counter) - multiThreadedIOStart[i]; - comm_sent += curComm; - } - std::cout << "Comm. Sent/ell: " << double(comm_sent*8)/(l*num_relu) << std::endl; - - /************** Verification ****************/ - /********************************************/ - - switch (party) { - case sci::ALICE: { - ioArr[0]->send_data(x, sizeof(uint64_t)*num_relu); - ioArr[0]->send_data(z, sizeof(uint64_t)*num_relu); - break; - } - case sci::BOB: { - uint64_t *xi = new uint64_t[num_relu]; - uint64_t *zi = new uint64_t[num_relu]; - ioArr[0]->recv_data(xi, sizeof(uint64_t)*num_relu); - ioArr[0]->recv_data(zi, sizeof(uint64_t)*num_relu); - // relu_oracle.drelu_ring_ideal_func(drelu_output_share, input_share1, input_share2, num_relu); - - for(int i=0; i<num_relu; i++){ - xi[i] = (xi[i] + x[i]) & mask_l; - zi[i] = (zi[i] + z[i]) & mask_l; - // cout << zi[i] << "\t" << xi[i] << "\t" << (xi[i] < (1ULL<<(l-1))) << "\t" << ((xi[i] < (1ULL<<(l-1))) * xi[i]) << endl; - assert((zi[i] == ((xi[i] < (1ULL<<(l-1))) * xi[i])) - && "ReLU protocol's answer is incorrect!"); - } - delete[] xi; - delete[] zi; - break; - } - } - delete[] x; - delete[] z; - - /**** Process & Write Benchmarking Data *****/ - /********************************************/ - - cout <<"Number of ReLU/s:\t" <<(double(num_relu)/t)*1e6<< std::endl; - cout <<"ReLU Time (l=" << l << "; b=" << b << ")\t" << t <<" mus"<< endl; - - string file_addr; - switch (party) { - case 1: { - file_addr = "our-ring-relu-P0.csv"; - break; - } - case 2: { - file_addr = "our-ring-relu-P1.csv"; - break; - } - } - bool write_title = true; { - fstream result(file_addr.c_str(), fstream::in); - if(result.is_open()) - write_title = false; - result.close(); - } - fstream result(file_addr.c_str(), fstream::out|fstream::app); - if(write_title){ - result << "Bitlen,Base,Batch Size,#Threads,#ReLU,Time (mus),Throughput/sec,Data Sent (MiB)" << endl; - } - result << l << "," << b << "," << batch_size << "," << numThreads << "," << num_relu_orig - << "," << t << "," << (double(num_relu)/t)*1e6 << "," << comm_sent/(1.0*(1ULL<<20)) << endl; - result.close(); - - /******************* Cleanup ****************/ - /********************************************/ - - for (int i = 0; i < numThreads; i++) { - delete ioArr[i]; - delete otpackArr[i]; - } - return 0; + cout << "ReLU" << (six == 0 ? "" : "6") << " Tests Passed" << endl; + + delete[] x0; + delete[] y0; + } + + /**** Process & Write Benchmarking Data *****/ + /********************************************/ + cout << "Number of ReLU/s:\t" << (double(dim) / t) * 1e6 << std::endl; + cout << "ReLU Time\t" << t / (1000.0) << " ms" << endl; + cout << "ReLU Bytes Sent\t" << total_comm << " bytes" << endl; + + /******************* Cleanup ****************/ + /********************************************/ + delete[] x; + delete[] y; + for (int i = 0; i < num_threads; i++) { + delete ioArr[i]; + delete otpackArr[i]; + } } diff --git a/SCI/tests/test_ring_sigmoid.cpp b/SCI/tests/test_ring_sigmoid.cpp new file mode 100644 index 00000000..3a34fe0c --- /dev/null +++ b/SCI/tests/test_ring_sigmoid.cpp @@ -0,0 +1,190 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "Math/math-functions.h" +#include <fstream> +#include <iostream> +#include <thread> + +using namespace sci; +using namespace std; + +#define MAX_THREADS 4 + +int party, port = 32000; +int num_threads = 4; +string address = "127.0.0.1"; + +int dim = 10000; +int bw_x = 16; +int bw_y = 16; +int s_x = 12; +int s_y = 12; + +uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); +uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + +sci::NetIO *ioArr[MAX_THREADS]; +sci::OTPack<sci::NetIO> *otpackArr[MAX_THREADS]; + +uint64_t computeULPErr(double calc, double actual, int SCALE) { + int64_t calc_fixed = (double(calc) * (1ULL << SCALE)); + int64_t actual_fixed = (double(actual) * (1ULL << SCALE)); + uint64_t ulp_err = (calc_fixed - actual_fixed) > 0 + ? (calc_fixed - actual_fixed) + : (actual_fixed - calc_fixed); + return ulp_err; +} + +void sigmoid_thread(int tid, uint64_t *x, uint64_t *y, int num_ops) { + MathFunctions *math; + if (tid & 1) { + math = new MathFunctions(3 - party, ioArr[tid], otpackArr[tid]); + } else { + math = new MathFunctions(party, ioArr[tid], otpackArr[tid]); + } + math->sigmoid(num_ops, x, y, bw_x, bw_y, s_x, s_y); + + delete math; +} + +int main(int argc, char **argv) { + /************* Argument Parsing ************/ + /********************************************/ + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("N", dim, "Number of sigmoid operations"); + amap.arg("nt", num_threads, "Number of threads"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + + assert(num_threads <= MAX_THREADS); + + /********** Setup IO and Base OTs ***********/ + /********************************************/ + for (int i = 0; i < num_threads; i++) { + ioArr[i] = new NetIO(party == 1 ? nullptr : address.c_str(), port + i); + if (i == 0) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); + } else { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); + } + } + std::cout << "All Base OTs Done" << std::endl; + + /************ Generate Test Data ************/ + /********************************************/ + PRG128 prg; + + uint64_t *x = new uint64_t[dim]; + uint64_t *y = new uint64_t[dim]; + + prg.random_data(x, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + x[i] &= mask_x; + } + + /************** Fork Threads ****************/ + /********************************************/ + uint64_t total_comm = 0; + uint64_t thread_comm[num_threads]; + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter; + } + + auto start = clock_start(); + std::thread sig_threads[num_threads]; + int chunk_size = dim / num_threads; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_ops; + if (i == (num_threads - 1)) { + lnum_ops = dim - offset; + } else { + lnum_ops = chunk_size; + } + sig_threads[i] = + std::thread(sigmoid_thread, i, x + offset, y + offset, lnum_ops); + } + for (int i = 0; i < num_threads; ++i) { + sig_threads[i].join(); + } + long long t = time_from(start); + + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter - thread_comm[i]; + total_comm += thread_comm[i]; + } + + /************** Verification ****************/ + /********************************************/ + if (party == ALICE) { + ioArr[0]->send_data(x, dim * sizeof(uint64_t)); + ioArr[0]->send_data(y, dim * sizeof(uint64_t)); + } else { // party == BOB + uint64_t *x0 = new uint64_t[dim]; + uint64_t *y0 = new uint64_t[dim]; + ioArr[0]->recv_data(x0, dim * sizeof(uint64_t)); + ioArr[0]->recv_data(y0, dim * sizeof(uint64_t)); + + uint64_t total_err = 0; + uint64_t max_ULP_err = 0; + for (int i = 0; i < dim; i++) { + double dbl_x = (signed_val(x0[i] + x[i], bw_x)) / double(1LL << s_x); + double dbl_y = (unsigned_val(y0[i] + y[i], bw_y)) / double(1ULL << s_y); + double sig_x = 1.0 / (1 + exp(-1 * dbl_x)); + uint64_t err = computeULPErr(dbl_y, sig_x, s_y); + // cout << "ULP Error: " << dbl_x << "," << dbl_y << "," << sig_x << "," + // << err << endl; + total_err += err; + max_ULP_err = std::max(max_ULP_err, err); + } + + cerr << "Average ULP error: " << total_err / dim << endl; + cerr << "Max ULP error: " << max_ULP_err << endl; + cerr << "Number of tests: " << dim << endl; + + delete[] x0; + delete[] y0; + } + + cout << "Number of sigmoid ops/s:\t" << (double(dim) / t) * 1e6 << std::endl; + cout << "Sigmoid Time\t" << t / (1000.0) << " ms" << endl; + cout << "Sigmoid Bytes Sent\t" << total_comm << " bytes" << endl; + + /******************* Cleanup ****************/ + /********************************************/ + delete[] x; + delete[] y; + for (int i = 0; i < num_threads; i++) { + delete ioArr[i]; + delete otpackArr[i]; + } +} diff --git a/SCI/tests/test_ring_sqrt.cpp b/SCI/tests/test_ring_sqrt.cpp new file mode 100644 index 00000000..c3c8cd60 --- /dev/null +++ b/SCI/tests/test_ring_sqrt.cpp @@ -0,0 +1,212 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "Math/math-functions.h" +#include <fstream> +#include <iostream> +#include <thread> + +using namespace sci; +using namespace std; + +#define MAX_THREADS 4 + +int party, port = 32000; +int num_threads = 4; +string address = "127.0.0.1"; + +int dim = 100000; +int bw_x = 16; +int bw_y = 16; +int s_x = 12; +int s_y = 12; +bool inverse = true; + +uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); +uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + +sci::NetIO *ioArr[MAX_THREADS]; +sci::OTPack<sci::NetIO> *otpackArr[MAX_THREADS]; + +uint64_t computeULPErr(double calc, double actual, int SCALE) { + int64_t calc_fixed = (double(calc) * (1ULL << SCALE)); + int64_t actual_fixed = (double(actual) * (1ULL << SCALE)); + uint64_t ulp_err = (calc_fixed - actual_fixed) > 0 + ? (calc_fixed - actual_fixed) + : (actual_fixed - calc_fixed); + return ulp_err; +} + +void sqrt_thread(int tid, uint64_t *x, uint64_t *y, int num_ops) { + MathFunctions *math; + if (tid & 1) { + math = new MathFunctions(3 - party, ioArr[tid], otpackArr[tid]); + } else { + math = new MathFunctions(party, ioArr[tid], otpackArr[tid]); + } + math->sqrt(num_ops, x, y, bw_x, bw_y, s_x, s_y, inverse); + + delete math; +} + +int main(int argc, char **argv) { + /************* Argument Parsing ************/ + /********************************************/ + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("N", dim, "Number of sqrt operations"); + amap.arg("nt", num_threads, "Number of threads"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + + assert(num_threads <= MAX_THREADS); + + /********** Setup IO and Base OTs ***********/ + /********************************************/ + for (int i = 0; i < num_threads; i++) { + ioArr[i] = new NetIO(party == 1 ? nullptr : address.c_str(), port + i); + if (i == 0) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); + } else { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); + } + } + std::cout << "All Base OTs Done" << std::endl; + + /************ Generate Test Data ************/ + /********************************************/ + PRG128 prg(fix_key); + + uint64_t *x = new uint64_t[dim]; + uint64_t *y = new uint64_t[dim]; + + prg.random_data(x, dim * sizeof(uint64_t)); + + // x is always positive + if (party == ALICE) { + ioArr[0]->send_data(x, dim * sizeof(uint64_t)); + } else { + uint64_t *x0 = new uint64_t[dim]; + ioArr[0]->recv_data(x0, dim * sizeof(uint64_t)); + for (int i = 0; i < dim; i++) { + x[i] &= (mask_x >> 1); + // dn is always of the form 1.xxxx + x[i] = (x[i] - x0[i]); + } + delete[] x0; + } + for (int i = 0; i < dim; i++) { + x[i] &= mask_x; + } + + /************** Fork Threads ****************/ + /********************************************/ + uint64_t total_comm = 0; + uint64_t thread_comm[num_threads]; + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter; + } + + auto start = clock_start(); + std::thread sqrt_threads[num_threads]; + int chunk_size = dim / num_threads; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_ops; + if (i == (num_threads - 1)) { + lnum_ops = dim - offset; + } else { + lnum_ops = chunk_size; + } + sqrt_threads[i] = + std::thread(sqrt_thread, i, x + offset, y + offset, lnum_ops); + } + for (int i = 0; i < num_threads; ++i) { + sqrt_threads[i].join(); + } + long long t = time_from(start); + + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter - thread_comm[i]; + total_comm += thread_comm[i]; + } + + /************** Verification ****************/ + /********************************************/ + if (party == ALICE) { + ioArr[0]->send_data(x, dim * sizeof(uint64_t)); + ioArr[0]->send_data(y, dim * sizeof(uint64_t)); + } else { // party == BOB + uint64_t *x0 = new uint64_t[dim]; + uint64_t *y0 = new uint64_t[dim]; + ioArr[0]->recv_data(x0, dim * sizeof(uint64_t)); + ioArr[0]->recv_data(y0, dim * sizeof(uint64_t)); + + uint64_t total_err = 0; + uint64_t max_ULP_err = 0; + for (int i = 0; i < dim; i++) { + double dbl_x = (signed_val(x0[i] + x[i], bw_x)) / double(1LL << s_x); + double dbl_y = (signed_val(y0[i] + y[i], bw_y)) / double(1LL << s_y); + double sqrt_x; + if (inverse) { + sqrt_x = signed_val((1.0 / sqrt(dbl_x)) * (1LL << s_y), bw_y) / + double(1LL << s_y); + } else { + sqrt_x = sqrt(dbl_x); + } + uint64_t err = computeULPErr(dbl_y, sqrt_x, s_y); + if (err > 4) { + cout << "ULP Error: " << dbl_x << "," << dbl_y << "," << sqrt_x << "," + << err << endl; + } + total_err += err; + max_ULP_err = std::max(max_ULP_err, err); + } + + cerr << "Average ULP error: " << total_err / dim << endl; + cerr << "Max ULP error: " << max_ULP_err << endl; + cerr << "Number of tests: " << dim << endl; + + delete[] x0; + delete[] y0; + } + + cout << "Number of sqrt/s:\t" << (double(dim) / t) * 1e6 << std::endl; + cout << "Sqrt Time\t" << t / (1000.0) << " ms" << endl; + cout << "Sqrt Bytes Sent\t" << total_comm << " bytes" << endl; + + /******************* Cleanup ****************/ + /********************************************/ + delete[] x; + delete[] y; + for (int i = 0; i < num_threads; i++) { + delete ioArr[i]; + delete otpackArr[i]; + } +} diff --git a/SCI/tests/test_ring_tanh.cpp b/SCI/tests/test_ring_tanh.cpp new file mode 100644 index 00000000..3adfa571 --- /dev/null +++ b/SCI/tests/test_ring_tanh.cpp @@ -0,0 +1,190 @@ +/* +Authors: Deevashwer Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "Math/math-functions.h" +#include <fstream> +#include <iostream> +#include <thread> + +using namespace sci; +using namespace std; + +#define MAX_THREADS 4 + +int party, port = 32000; +int num_threads = 4; +string address = "127.0.0.1"; + +int dim = 1ULL << 16; +int bw_x = 16; +int bw_y = 16; +int s_x = 12; +int s_y = 12; + +uint64_t mask_x = (bw_x == 64 ? -1 : ((1ULL << bw_x) - 1)); +uint64_t mask_y = (bw_y == 64 ? -1 : ((1ULL << bw_y) - 1)); + +sci::NetIO *ioArr[MAX_THREADS]; +sci::OTPack<sci::NetIO> *otpackArr[MAX_THREADS]; + +uint64_t computeULPErr(double calc, double actual, int SCALE) { + int64_t calc_fixed = (double(calc) * (1ULL << SCALE)); + int64_t actual_fixed = (double(actual) * (1ULL << SCALE)); + uint64_t ulp_err = (calc_fixed - actual_fixed) > 0 + ? (calc_fixed - actual_fixed) + : (actual_fixed - calc_fixed); + return ulp_err; +} + +void tanh_thread(int tid, uint64_t *x, uint64_t *y, int num_ops) { + MathFunctions *math; + if (tid & 1) { + math = new MathFunctions(3 - party, ioArr[tid], otpackArr[tid]); + } else { + math = new MathFunctions(party, ioArr[tid], otpackArr[tid]); + } + math->tanh(num_ops, x, y, bw_x, bw_y, s_x, s_y); + + delete math; +} + +int main(int argc, char **argv) { + /************* Argument Parsing ************/ + /********************************************/ + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("N", dim, "Number of tanh operations"); + amap.arg("nt", num_threads, "Number of threads"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + + assert(num_threads <= MAX_THREADS); + + /********** Setup IO and Base OTs ***********/ + /********************************************/ + for (int i = 0; i < num_threads; i++) { + ioArr[i] = new NetIO(party == 1 ? nullptr : address.c_str(), port + i); + if (i == 0) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party); + } else if (i == 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party); + } else if (i & 1) { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], 3 - party, false); + otpackArr[i]->copy(otpackArr[1]); + } else { + otpackArr[i] = new OTPack<NetIO>(ioArr[i], party, false); + otpackArr[i]->copy(otpackArr[0]); + } + } + std::cout << "All Base OTs Done" << std::endl; + + /************ Generate Test Data ************/ + /********************************************/ + PRG128 prg; + + uint64_t *x = new uint64_t[dim]; + uint64_t *y = new uint64_t[dim]; + + prg.random_data(x, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + x[i] &= mask_x; + } + + /************** Fork Threads ****************/ + /********************************************/ + uint64_t total_comm = 0; + uint64_t thread_comm[num_threads]; + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter; + } + + auto start = clock_start(); + std::thread tanh_threads[num_threads]; + int chunk_size = dim / num_threads; + for (int i = 0; i < num_threads; ++i) { + int offset = i * chunk_size; + int lnum_ops; + if (i == (num_threads - 1)) { + lnum_ops = dim - offset; + } else { + lnum_ops = chunk_size; + } + tanh_threads[i] = + std::thread(tanh_thread, i, x + offset, y + offset, lnum_ops); + } + for (int i = 0; i < num_threads; ++i) { + tanh_threads[i].join(); + } + long long t = time_from(start); + + for (int i = 0; i < num_threads; i++) { + thread_comm[i] = ioArr[i]->counter - thread_comm[i]; + total_comm += thread_comm[i]; + } + + /************** Verification ****************/ + /********************************************/ + if (party == ALICE) { + ioArr[0]->send_data(x, dim * sizeof(uint64_t)); + ioArr[0]->send_data(y, dim * sizeof(uint64_t)); + } else { // party == BOB + uint64_t *x0 = new uint64_t[dim]; + uint64_t *y0 = new uint64_t[dim]; + ioArr[0]->recv_data(x0, dim * sizeof(uint64_t)); + ioArr[0]->recv_data(y0, dim * sizeof(uint64_t)); + + uint64_t total_err = 0; + uint64_t max_ULP_err = 0; + for (int i = 0; i < dim; i++) { + double dbl_x = (signed_val(x0[i] + x[i], bw_x)) / double(1LL << s_x); + double dbl_y = (signed_val(y0[i] + y[i], bw_y)) / double(1LL << s_y); + double tanh_x = tanh(dbl_x); + uint64_t err = computeULPErr(dbl_y, tanh_x, s_y); + // cout << "ULP Error: " << dbl_x << "," << dbl_y << "," << tanh_x << "," + // << err << endl; + total_err += err; + max_ULP_err = std::max(max_ULP_err, err); + } + + cerr << "Average ULP error: " << total_err / dim << endl; + cerr << "Max ULP error: " << max_ULP_err << endl; + cerr << "Number of tests: " << dim << endl; + + delete[] x0; + delete[] y0; + } + + cout << "Number of tanh/s:\t" << (double(dim) / t) * 1e6 << std::endl; + cout << "Tanh Time\t" << t / (1000.0) << " ms" << endl; + cout << "Tanh Bytes Sent\t" << total_comm << " bytes" << endl; + + /******************* Cleanup ****************/ + /********************************************/ + delete[] x; + delete[] y; + for (int i = 0; i < num_threads; i++) { + delete ioArr[i]; + delete otpackArr[i]; + } +} diff --git a/SCI/tests/test_ring_truncation.cpp b/SCI/tests/test_ring_truncation.cpp new file mode 100644 index 00000000..f1a22418 --- /dev/null +++ b/SCI/tests/test_ring_truncation.cpp @@ -0,0 +1,177 @@ +/* +Authors: Mayank Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "BuildingBlocks/truncation.h" +#include <iostream> + +using namespace sci; +using namespace std; + +int dim = 1 << 8; +int bw = 16; +int shift = 6; +int shift_bnd = 17; + +uint64_t mask_bw = (bw == 64 ? -1 : ((1ULL << bw) - 1)); +uint64_t mask_shift = (shift == 64 ? -1 : ((1ULL << shift) - 1)); +uint64_t mask_out = ((bw - shift) == 64 ? -1 : ((1ULL << (bw - shift)) - 1)); + +// vars +int party, port = 32000; +string address = "127.0.0.1"; +NetIO *io; +OTPack<NetIO> *otpack; +Truncation *trunc_oracle; +PRG128 prg; + +void trunc_reduce() { + uint64_t *inA = new uint64_t[dim]; + uint64_t *outB = new uint64_t[dim]; + + prg.random_data(inA, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + inA[i] &= mask_bw; + outB[i] = 0; + } + + trunc_oracle->truncate_and_reduce(dim, inA, outB, shift, bw); + + if (party == ALICE) { + uint64_t *inA_bob = new uint64_t[dim]; + uint64_t *outB_bob = new uint64_t[dim]; + io->recv_data(inA_bob, sizeof(uint64_t) * dim); + io->recv_data(outB_bob, sizeof(uint64_t) * dim); + for (int i = 0; i < dim; i++) { + inA[i] = (inA[i] + inA_bob[i]) & mask_bw; + outB[i] = (outB[i] + outB_bob[i]) & mask_out; + } + cout << "Testing for correctness..." << endl; + for (int i = 0; i < dim; i++) { + assert((inA[i] >> shift) == outB[i]); + } + cout << "Correct!" << endl; + } else { // BOB + io->send_data(inA, sizeof(uint64_t) * dim); + io->send_data(outB, sizeof(uint64_t) * dim); + } +} + +void trunc(bool signed_arithmetic = true) { + uint64_t *inA = new uint64_t[dim]; + uint64_t *outB = new uint64_t[dim]; + + prg.random_data(inA, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + inA[i] &= mask_bw; + outB[i] = 0; + } + + trunc_oracle->truncate(dim, inA, outB, shift, bw, signed_arithmetic, nullptr); + + if (party == ALICE) { + uint64_t *inA_bob = new uint64_t[dim]; + uint64_t *outB_bob = new uint64_t[dim]; + io->recv_data(inA_bob, sizeof(uint64_t) * dim); + io->recv_data(outB_bob, sizeof(uint64_t) * dim); + for (int i = 0; i < dim; i++) { + inA[i] = (inA[i] + inA_bob[i]) & mask_bw; + outB[i] = (outB[i] + outB_bob[i]) & mask_bw; + } + cout << "Testing for correctness..." << endl; + for (int i = 0; i < dim; i++) { + if (signed_arithmetic) { + assert((signed_val(inA[i], bw) >> shift) == signed_val(outB[i], bw)); + } else { + assert((inA[i] >> shift) == outB[i]); + } + } + cout << "Correct!" << endl; + } else { // BOB + io->send_data(inA, sizeof(uint64_t) * dim); + io->send_data(outB, sizeof(uint64_t) * dim); + } +} + +void div_pow2(bool signed_arithmetic = true) { + uint64_t *inA = new uint64_t[dim]; + uint64_t *outB = new uint64_t[dim]; + + prg.random_data(inA, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + inA[i] &= mask_bw; + outB[i] = 0; + } + + trunc_oracle->div_pow2(dim, inA, outB, shift, bw, signed_arithmetic, nullptr); + + if (party == ALICE) { + uint64_t *inA_bob = new uint64_t[dim]; + uint64_t *outB_bob = new uint64_t[dim]; + io->recv_data(inA_bob, sizeof(uint64_t) * dim); + io->recv_data(outB_bob, sizeof(uint64_t) * dim); + for (int i = 0; i < dim; i++) { + inA[i] = (inA[i] + inA_bob[i]) & mask_bw; + outB[i] = (outB[i] + outB_bob[i]) & mask_bw; + } + cout << "Testing for correctness..." << endl; + for (int i = 0; i < dim; i++) { + if (signed_arithmetic) { + assert((signed_val(inA[i], bw) / (1LL << shift)) == + signed_val(outB[i], bw)); + } else { + assert((inA[i] / (1ULL << shift)) == outB[i]); + } + } + cout << "Correct!" << endl; + } else { // BOB + io->send_data(inA, sizeof(uint64_t) * dim); + io->send_data(outB, sizeof(uint64_t) * dim); + } +} + +int main(int argc, char **argv) { + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("p", port, "Port Number"); + amap.arg("N", dim, "Number of ReLU operations"); + amap.arg("l", bw, "Bitlength of inputs"); + amap.arg("ip", address, "IP Address of server (ALICE)"); + + amap.parse(argc, argv); + + io = new NetIO(party == 1 ? nullptr : address.c_str(), port); + otpack = new OTPack<NetIO>(io, party); + trunc_oracle = new Truncation(party, io, otpack); + + cout << "<><><><> Truncate & Reduce <><><><>" << endl; + trunc_reduce(); + cout << "<><><><> (Unsigned) Truncate <><><><>" << endl; + trunc(false); + cout << "<><><><> (Signed) Truncate <><><><>" << endl; + trunc(true); + cout << "<><><><> (Unsigned) Division by power of 2 <><><><>" << endl; + div_pow2(false); + cout << "<><><><> (Signed) Division by power of 2 <><><><>" << endl; + div_pow2(true); +} diff --git a/SCI/tests/test_ring_value_extension.cpp b/SCI/tests/test_ring_value_extension.cpp new file mode 100644 index 00000000..1145fce9 --- /dev/null +++ b/SCI/tests/test_ring_value_extension.cpp @@ -0,0 +1,123 @@ +/* +Authors: Mayank Rathee +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "BuildingBlocks/value-extension.h" +#include <iostream> + +using namespace sci; +using namespace std; + +int dim = 1024; +int bwA = 4; +int bwB = 64; + +uint64_t maskA = (bwA == 64 ? -1 : ((1ULL << bwA) - 1)); +uint64_t maskB = (bwB == 64 ? -1 : ((1ULL << bwB) - 1)); + +// vars +int party, port = 32000; +NetIO *io; +OTPack<NetIO> *otpack; +XTProtocol *ext; +PRG128 prg; + +void z_ext() { + uint64_t *inA = new uint64_t[dim]; + uint64_t *outB = new uint64_t[dim]; + + prg.random_data(inA, dim * sizeof(uint64_t)); + prg.random_data(outB, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + inA[i] &= maskA; + outB[i] = 0; + } + + ext->z_extend(dim, inA, outB, bwA, bwB); + + if (party == ALICE) { + uint64_t *inA_bob = new uint64_t[dim]; + uint64_t *outB_bob = new uint64_t[dim]; + io->recv_data(inA_bob, sizeof(uint64_t) * dim); + io->recv_data(outB_bob, sizeof(uint64_t) * dim); + for (int i = 0; i < dim; i++) { + inA[i] = (inA[i] + inA_bob[i]) & maskA; + outB[i] = (outB[i] + outB_bob[i]) & maskB; + } + cout << "Testing for correctness..." << endl; + for (int i = 0; i < dim; i++) { + // cout << inA[i] << " " << outB[i] << endl; + assert(inA[i] == outB[i]); + } + cout << "Correct!" << endl; + } else { // BOB + io->send_data(inA, sizeof(uint64_t) * dim); + io->send_data(outB, sizeof(uint64_t) * dim); + } +} + +void s_ext() { + uint64_t *inA = new uint64_t[dim]; + uint64_t *outB = new uint64_t[dim]; + + prg.random_data(inA, dim * sizeof(uint64_t)); + prg.random_data(outB, dim * sizeof(uint64_t)); + + for (int i = 0; i < dim; i++) { + inA[i] &= maskA; + outB[i] = 0; + } + + ext->s_extend(dim, inA, outB, bwA, bwB); + + if (party == ALICE) { + uint64_t *inA_bob = new uint64_t[dim]; + uint64_t *outB_bob = new uint64_t[dim]; + io->recv_data(inA_bob, sizeof(uint64_t) * dim); + io->recv_data(outB_bob, sizeof(uint64_t) * dim); + for (int i = 0; i < dim; i++) { + inA[i] = (inA[i] + inA_bob[i]) & maskA; + outB[i] = (outB[i] + outB_bob[i]) & maskB; + } + cout << "Testing for correctness..." << endl; + for (int i = 0; i < dim; i++) { + // cout << inA[i] << " " << outB[i] << endl; + assert(signed_val(inA[i], bwA) == signed_val(outB[i], bwB)); + } + cout << "Correct!" << endl; + } else { // BOB + io->send_data(inA, sizeof(uint64_t) * dim); + io->send_data(outB, sizeof(uint64_t) * dim); + } +} + +int main(int argc, char **argv) { + party = atoi(argv[1]); + + io = new NetIO(party == 1 ? nullptr : "127.0.0.1", port); + otpack = new OTPack<NetIO>(io, party); + ext = new XTProtocol(party, io, otpack); + + cout << "<><><><> Zero Extension <><><><>" << endl; + z_ext(); + cout << "<><><><> Signed Extension <><><><>" << endl; + s_ext(); +} diff --git a/SIRNN/Library_SIRNN.ezpc b/SIRNN/Library_SIRNN.ezpc new file mode 100644 index 00000000..3f8acc60 --- /dev/null +++ b/SIRNN/Library_SIRNN.ezpc @@ -0,0 +1,36563 @@ +(* + +Authors: Mayank Rathee, Deevashwer Rathee, G Rahul Kranti Kiran. + +Copyright: +Copyright (c) 2021 Microsoft Research +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +*) + + +(* <><><><><><><> Auto-generated code <><><><><><><> *) +def void fillLUTINVSQRT(int32_pl[1020] inp) +{ +inp[0] = 4; +inp[1] = 2; +inp[2] = 3; +inp[3] = 2; +inp[4] = 8; +inp[5] = 5; +inp[6] = 7; +inp[7] = 5; +inp[8] = 6; +inp[9] = 4; +inp[10] = 6; +inp[11] = 4; +inp[12] = 16; +inp[13] = 11; +inp[14] = 15; +inp[15] = 10; +inp[16] = 14; +inp[17] = 10; +inp[18] = 13; +inp[19] = 9; +inp[20] = 13; +inp[21] = 9; +inp[22] = 12; +inp[23] = 8; +inp[24] = 12; +inp[25] = 8; +inp[26] = 11; +inp[27] = 8; +inp[28] = 32; +inp[29] = 22; +inp[30] = 31; +inp[31] = 21; +inp[32] = 30; +inp[33] = 21; +inp[34] = 29; +inp[35] = 20; +inp[36] = 28; +inp[37] = 20; +inp[38] = 27; +inp[39] = 19; +inp[40] = 27; +inp[41] = 19; +inp[42] = 26; +inp[43] = 18; +inp[44] = 26; +inp[45] = 18; +inp[46] = 25; +inp[47] = 18; +inp[48] = 25; +inp[49] = 17; +inp[50] = 24; +inp[51] = 17; +inp[52] = 24; +inp[53] = 17; +inp[54] = 23; +inp[55] = 16; +inp[56] = 23; +inp[57] = 16; +inp[58] = 22; +inp[59] = 16; +inp[60] = 64; +inp[61] = 45; +inp[62] = 63; +inp[63] = 44; +inp[64] = 62; +inp[65] = 43; +inp[66] = 61; +inp[67] = 43; +inp[68] = 60; +inp[69] = 42; +inp[70] = 59; +inp[71] = 42; +inp[72] = 58; +inp[73] = 41; +inp[74] = 57; +inp[75] = 40; +inp[76] = 57; +inp[77] = 40; +inp[78] = 56; +inp[79] = 39; +inp[80] = 55; +inp[81] = 39; +inp[82] = 55; +inp[83] = 39; +inp[84] = 54; +inp[85] = 38; +inp[86] = 53; +inp[87] = 38; +inp[88] = 53; +inp[89] = 37; +inp[90] = 52; +inp[91] = 37; +inp[92] = 52; +inp[93] = 36; +inp[94] = 51; +inp[95] = 36; +inp[96] = 51; +inp[97] = 36; +inp[98] = 50; +inp[99] = 35; +inp[100] = 50; +inp[101] = 35; +inp[102] = 49; +inp[103] = 35; +inp[104] = 49; +inp[105] = 34; +inp[106] = 48; +inp[107] = 34; +inp[108] = 48; +inp[109] = 34; +inp[110] = 47; +inp[111] = 33; +inp[112] = 47; +inp[113] = 33; +inp[114] = 47; +inp[115] = 33; +inp[116] = 46; +inp[117] = 33; +inp[118] = 46; +inp[119] = 32; +inp[120] = 45; +inp[121] = 32; +inp[122] = 45; +inp[123] = 32; +inp[124] = 128; +inp[125] = 90; +inp[126] = 127; +inp[127] = 89; +inp[128] = 126; +inp[129] = 89; +inp[130] = 125; +inp[131] = 88; +inp[132] = 124; +inp[133] = 87; +inp[134] = 123; +inp[135] = 87; +inp[136] = 122; +inp[137] = 86; +inp[138] = 121; +inp[139] = 85; +inp[140] = 120; +inp[141] = 85; +inp[142] = 119; +inp[143] = 84; +inp[144] = 119; +inp[145] = 84; +inp[146] = 118; +inp[147] = 83; +inp[148] = 117; +inp[149] = 83; +inp[150] = 116; +inp[151] = 82; +inp[152] = 115; +inp[153] = 81; +inp[154] = 115; +inp[155] = 81; +inp[156] = 114; +inp[157] = 80; +inp[158] = 113; +inp[159] = 80; +inp[160] = 113; +inp[161] = 79; +inp[162] = 112; +inp[163] = 79; +inp[164] = 111; +inp[165] = 79; +inp[166] = 111; +inp[167] = 78; +inp[168] = 110; +inp[169] = 78; +inp[170] = 109; +inp[171] = 77; +inp[172] = 109; +inp[173] = 77; +inp[174] = 108; +inp[175] = 76; +inp[176] = 107; +inp[177] = 76; +inp[178] = 107; +inp[179] = 75; +inp[180] = 106; +inp[181] = 75; +inp[182] = 106; +inp[183] = 75; +inp[184] = 105; +inp[185] = 74; +inp[186] = 105; +inp[187] = 74; +inp[188] = 104; +inp[189] = 73; +inp[190] = 103; +inp[191] = 73; +inp[192] = 103; +inp[193] = 73; +inp[194] = 102; +inp[195] = 72; +inp[196] = 102; +inp[197] = 72; +inp[198] = 101; +inp[199] = 72; +inp[200] = 101; +inp[201] = 71; +inp[202] = 100; +inp[203] = 71; +inp[204] = 100; +inp[205] = 71; +inp[206] = 99; +inp[207] = 70; +inp[208] = 99; +inp[209] = 70; +inp[210] = 98; +inp[211] = 69; +inp[212] = 98; +inp[213] = 69; +inp[214] = 98; +inp[215] = 69; +inp[216] = 97; +inp[217] = 69; +inp[218] = 97; +inp[219] = 68; +inp[220] = 96; +inp[221] = 68; +inp[222] = 96; +inp[223] = 68; +inp[224] = 95; +inp[225] = 67; +inp[226] = 95; +inp[227] = 67; +inp[228] = 95; +inp[229] = 67; +inp[230] = 94; +inp[231] = 66; +inp[232] = 94; +inp[233] = 66; +inp[234] = 93; +inp[235] = 66; +inp[236] = 93; +inp[237] = 66; +inp[238] = 93; +inp[239] = 65; +inp[240] = 92; +inp[241] = 65; +inp[242] = 92; +inp[243] = 65; +inp[244] = 91; +inp[245] = 65; +inp[246] = 91; +inp[247] = 64; +inp[248] = 91; +inp[249] = 64; +inp[250] = 90; +inp[251] = 64; +inp[252] = 256; +inp[253] = 181; +inp[254] = 255; +inp[255] = 180; +inp[256] = 254; +inp[257] = 179; +inp[258] = 253; +inp[259] = 178; +inp[260] = 252; +inp[261] = 178; +inp[262] = 251; +inp[263] = 177; +inp[264] = 250; +inp[265] = 176; +inp[266] = 249; +inp[267] = 176; +inp[268] = 248; +inp[269] = 175; +inp[270] = 247; +inp[271] = 174; +inp[272] = 246; +inp[273] = 174; +inp[274] = 245; +inp[275] = 173; +inp[276] = 244; +inp[277] = 173; +inp[278] = 243; +inp[279] = 172; +inp[280] = 243; +inp[281] = 171; +inp[282] = 242; +inp[283] = 171; +inp[284] = 241; +inp[285] = 170; +inp[286] = 240; +inp[287] = 170; +inp[288] = 239; +inp[289] = 169; +inp[290] = 238; +inp[291] = 168; +inp[292] = 238; +inp[293] = 168; +inp[294] = 237; +inp[295] = 167; +inp[296] = 236; +inp[297] = 167; +inp[298] = 235; +inp[299] = 166; +inp[300] = 234; +inp[301] = 166; +inp[302] = 234; +inp[303] = 165; +inp[304] = 233; +inp[305] = 165; +inp[306] = 232; +inp[307] = 164; +inp[308] = 231; +inp[309] = 163; +inp[310] = 231; +inp[311] = 163; +inp[312] = 230; +inp[313] = 162; +inp[314] = 229; +inp[315] = 162; +inp[316] = 228; +inp[317] = 161; +inp[318] = 228; +inp[319] = 161; +inp[320] = 227; +inp[321] = 160; +inp[322] = 226; +inp[323] = 160; +inp[324] = 226; +inp[325] = 159; +inp[326] = 225; +inp[327] = 159; +inp[328] = 224; +inp[329] = 158; +inp[330] = 224; +inp[331] = 158; +inp[332] = 223; +inp[333] = 158; +inp[334] = 222; +inp[335] = 157; +inp[336] = 222; +inp[337] = 157; +inp[338] = 221; +inp[339] = 156; +inp[340] = 220; +inp[341] = 156; +inp[342] = 220; +inp[343] = 155; +inp[344] = 219; +inp[345] = 155; +inp[346] = 218; +inp[347] = 154; +inp[348] = 218; +inp[349] = 154; +inp[350] = 217; +inp[351] = 153; +inp[352] = 217; +inp[353] = 153; +inp[354] = 216; +inp[355] = 153; +inp[356] = 215; +inp[357] = 152; +inp[358] = 215; +inp[359] = 152; +inp[360] = 214; +inp[361] = 151; +inp[362] = 214; +inp[363] = 151; +inp[364] = 213; +inp[365] = 150; +inp[366] = 212; +inp[367] = 150; +inp[368] = 212; +inp[369] = 150; +inp[370] = 211; +inp[371] = 149; +inp[372] = 211; +inp[373] = 149; +inp[374] = 210; +inp[375] = 148; +inp[376] = 210; +inp[377] = 148; +inp[378] = 209; +inp[379] = 148; +inp[380] = 209; +inp[381] = 147; +inp[382] = 208; +inp[383] = 147; +inp[384] = 207; +inp[385] = 147; +inp[386] = 207; +inp[387] = 146; +inp[388] = 206; +inp[389] = 146; +inp[390] = 206; +inp[391] = 145; +inp[392] = 205; +inp[393] = 145; +inp[394] = 205; +inp[395] = 145; +inp[396] = 204; +inp[397] = 144; +inp[398] = 204; +inp[399] = 144; +inp[400] = 203; +inp[401] = 144; +inp[402] = 203; +inp[403] = 143; +inp[404] = 202; +inp[405] = 143; +inp[406] = 202; +inp[407] = 143; +inp[408] = 201; +inp[409] = 142; +inp[410] = 201; +inp[411] = 142; +inp[412] = 200; +inp[413] = 142; +inp[414] = 200; +inp[415] = 141; +inp[416] = 199; +inp[417] = 141; +inp[418] = 199; +inp[419] = 140; +inp[420] = 198; +inp[421] = 140; +inp[422] = 198; +inp[423] = 140; +inp[424] = 197; +inp[425] = 139; +inp[426] = 197; +inp[427] = 139; +inp[428] = 197; +inp[429] = 139; +inp[430] = 196; +inp[431] = 139; +inp[432] = 196; +inp[433] = 138; +inp[434] = 195; +inp[435] = 138; +inp[436] = 195; +inp[437] = 138; +inp[438] = 194; +inp[439] = 137; +inp[440] = 194; +inp[441] = 137; +inp[442] = 193; +inp[443] = 137; +inp[444] = 193; +inp[445] = 136; +inp[446] = 193; +inp[447] = 136; +inp[448] = 192; +inp[449] = 136; +inp[450] = 192; +inp[451] = 135; +inp[452] = 191; +inp[453] = 135; +inp[454] = 191; +inp[455] = 135; +inp[456] = 190; +inp[457] = 135; +inp[458] = 190; +inp[459] = 134; +inp[460] = 190; +inp[461] = 134; +inp[462] = 189; +inp[463] = 134; +inp[464] = 189; +inp[465] = 133; +inp[466] = 188; +inp[467] = 133; +inp[468] = 188; +inp[469] = 133; +inp[470] = 188; +inp[471] = 133; +inp[472] = 187; +inp[473] = 132; +inp[474] = 187; +inp[475] = 132; +inp[476] = 186; +inp[477] = 132; +inp[478] = 186; +inp[479] = 131; +inp[480] = 186; +inp[481] = 131; +inp[482] = 185; +inp[483] = 131; +inp[484] = 185; +inp[485] = 131; +inp[486] = 185; +inp[487] = 130; +inp[488] = 184; +inp[489] = 130; +inp[490] = 184; +inp[491] = 130; +inp[492] = 183; +inp[493] = 130; +inp[494] = 183; +inp[495] = 129; +inp[496] = 183; +inp[497] = 129; +inp[498] = 182; +inp[499] = 129; +inp[500] = 182; +inp[501] = 129; +inp[502] = 182; +inp[503] = 128; +inp[504] = 181; +inp[505] = 128; +inp[506] = 181; +inp[507] = 128; +inp[508] = 512; +inp[509] = 362; +inp[510] = 511; +inp[511] = 361; +inp[512] = 510; +inp[513] = 360; +inp[514] = 509; +inp[515] = 359; +inp[516] = 508; +inp[517] = 359; +inp[518] = 507; +inp[519] = 358; +inp[520] = 506; +inp[521] = 357; +inp[522] = 505; +inp[523] = 357; +inp[524] = 504; +inp[525] = 356; +inp[526] = 503; +inp[527] = 355; +inp[528] = 502; +inp[529] = 355; +inp[530] = 501; +inp[531] = 354; +inp[532] = 500; +inp[533] = 353; +inp[534] = 499; +inp[535] = 353; +inp[536] = 498; +inp[537] = 352; +inp[538] = 497; +inp[539] = 351; +inp[540] = 496; +inp[541] = 351; +inp[542] = 495; +inp[543] = 350; +inp[544] = 494; +inp[545] = 349; +inp[546] = 493; +inp[547] = 349; +inp[548] = 493; +inp[549] = 348; +inp[550] = 492; +inp[551] = 348; +inp[552] = 491; +inp[553] = 347; +inp[554] = 490; +inp[555] = 346; +inp[556] = 489; +inp[557] = 346; +inp[558] = 488; +inp[559] = 345; +inp[560] = 487; +inp[561] = 344; +inp[562] = 486; +inp[563] = 344; +inp[564] = 486; +inp[565] = 343; +inp[566] = 485; +inp[567] = 343; +inp[568] = 484; +inp[569] = 342; +inp[570] = 483; +inp[571] = 341; +inp[572] = 482; +inp[573] = 341; +inp[574] = 481; +inp[575] = 340; +inp[576] = 481; +inp[577] = 340; +inp[578] = 480; +inp[579] = 339; +inp[580] = 479; +inp[581] = 338; +inp[582] = 478; +inp[583] = 338; +inp[584] = 477; +inp[585] = 337; +inp[586] = 476; +inp[587] = 337; +inp[588] = 476; +inp[589] = 336; +inp[590] = 475; +inp[591] = 336; +inp[592] = 474; +inp[593] = 335; +inp[594] = 473; +inp[595] = 334; +inp[596] = 472; +inp[597] = 334; +inp[598] = 472; +inp[599] = 333; +inp[600] = 471; +inp[601] = 333; +inp[602] = 470; +inp[603] = 332; +inp[604] = 469; +inp[605] = 332; +inp[606] = 469; +inp[607] = 331; +inp[608] = 468; +inp[609] = 331; +inp[610] = 467; +inp[611] = 330; +inp[612] = 466; +inp[613] = 330; +inp[614] = 466; +inp[615] = 329; +inp[616] = 465; +inp[617] = 328; +inp[618] = 464; +inp[619] = 328; +inp[620] = 463; +inp[621] = 327; +inp[622] = 463; +inp[623] = 327; +inp[624] = 462; +inp[625] = 326; +inp[626] = 461; +inp[627] = 326; +inp[628] = 460; +inp[629] = 325; +inp[630] = 460; +inp[631] = 325; +inp[632] = 459; +inp[633] = 324; +inp[634] = 458; +inp[635] = 324; +inp[636] = 457; +inp[637] = 323; +inp[638] = 457; +inp[639] = 323; +inp[640] = 456; +inp[641] = 322; +inp[642] = 455; +inp[643] = 322; +inp[644] = 455; +inp[645] = 321; +inp[646] = 454; +inp[647] = 321; +inp[648] = 453; +inp[649] = 320; +inp[650] = 453; +inp[651] = 320; +inp[652] = 452; +inp[653] = 319; +inp[654] = 451; +inp[655] = 319; +inp[656] = 450; +inp[657] = 318; +inp[658] = 450; +inp[659] = 318; +inp[660] = 449; +inp[661] = 317; +inp[662] = 448; +inp[663] = 317; +inp[664] = 448; +inp[665] = 316; +inp[666] = 447; +inp[667] = 316; +inp[668] = 446; +inp[669] = 316; +inp[670] = 446; +inp[671] = 315; +inp[672] = 445; +inp[673] = 315; +inp[674] = 444; +inp[675] = 314; +inp[676] = 444; +inp[677] = 314; +inp[678] = 443; +inp[679] = 313; +inp[680] = 442; +inp[681] = 313; +inp[682] = 442; +inp[683] = 312; +inp[684] = 441; +inp[685] = 312; +inp[686] = 441; +inp[687] = 311; +inp[688] = 440; +inp[689] = 311; +inp[690] = 439; +inp[691] = 310; +inp[692] = 439; +inp[693] = 310; +inp[694] = 438; +inp[695] = 310; +inp[696] = 437; +inp[697] = 309; +inp[698] = 437; +inp[699] = 309; +inp[700] = 436; +inp[701] = 308; +inp[702] = 436; +inp[703] = 308; +inp[704] = 435; +inp[705] = 307; +inp[706] = 434; +inp[707] = 307; +inp[708] = 434; +inp[709] = 307; +inp[710] = 433; +inp[711] = 306; +inp[712] = 432; +inp[713] = 306; +inp[714] = 432; +inp[715] = 305; +inp[716] = 431; +inp[717] = 305; +inp[718] = 431; +inp[719] = 304; +inp[720] = 430; +inp[721] = 304; +inp[722] = 429; +inp[723] = 304; +inp[724] = 429; +inp[725] = 303; +inp[726] = 428; +inp[727] = 303; +inp[728] = 428; +inp[729] = 302; +inp[730] = 427; +inp[731] = 302; +inp[732] = 427; +inp[733] = 301; +inp[734] = 426; +inp[735] = 301; +inp[736] = 425; +inp[737] = 301; +inp[738] = 425; +inp[739] = 300; +inp[740] = 424; +inp[741] = 300; +inp[742] = 424; +inp[743] = 299; +inp[744] = 423; +inp[745] = 299; +inp[746] = 423; +inp[747] = 299; +inp[748] = 422; +inp[749] = 298; +inp[750] = 421; +inp[751] = 298; +inp[752] = 421; +inp[753] = 297; +inp[754] = 420; +inp[755] = 297; +inp[756] = 420; +inp[757] = 297; +inp[758] = 419; +inp[759] = 296; +inp[760] = 419; +inp[761] = 296; +inp[762] = 418; +inp[763] = 295; +inp[764] = 418; +inp[765] = 295; +inp[766] = 417; +inp[767] = 295; +inp[768] = 416; +inp[769] = 294; +inp[770] = 416; +inp[771] = 294; +inp[772] = 415; +inp[773] = 294; +inp[774] = 415; +inp[775] = 293; +inp[776] = 414; +inp[777] = 293; +inp[778] = 414; +inp[779] = 292; +inp[780] = 413; +inp[781] = 292; +inp[782] = 413; +inp[783] = 292; +inp[784] = 412; +inp[785] = 291; +inp[786] = 412; +inp[787] = 291; +inp[788] = 411; +inp[789] = 291; +inp[790] = 411; +inp[791] = 290; +inp[792] = 410; +inp[793] = 290; +inp[794] = 410; +inp[795] = 289; +inp[796] = 409; +inp[797] = 289; +inp[798] = 409; +inp[799] = 289; +inp[800] = 408; +inp[801] = 288; +inp[802] = 408; +inp[803] = 288; +inp[804] = 407; +inp[805] = 288; +inp[806] = 407; +inp[807] = 287; +inp[808] = 406; +inp[809] = 287; +inp[810] = 406; +inp[811] = 287; +inp[812] = 405; +inp[813] = 286; +inp[814] = 405; +inp[815] = 286; +inp[816] = 404; +inp[817] = 286; +inp[818] = 404; +inp[819] = 285; +inp[820] = 403; +inp[821] = 285; +inp[822] = 403; +inp[823] = 285; +inp[824] = 402; +inp[825] = 284; +inp[826] = 402; +inp[827] = 284; +inp[828] = 401; +inp[829] = 284; +inp[830] = 401; +inp[831] = 283; +inp[832] = 400; +inp[833] = 283; +inp[834] = 400; +inp[835] = 282; +inp[836] = 399; +inp[837] = 282; +inp[838] = 399; +inp[839] = 282; +inp[840] = 398; +inp[841] = 281; +inp[842] = 398; +inp[843] = 281; +inp[844] = 397; +inp[845] = 281; +inp[846] = 397; +inp[847] = 280; +inp[848] = 396; +inp[849] = 280; +inp[850] = 396; +inp[851] = 280; +inp[852] = 395; +inp[853] = 279; +inp[854] = 395; +inp[855] = 279; +inp[856] = 395; +inp[857] = 279; +inp[858] = 394; +inp[859] = 279; +inp[860] = 394; +inp[861] = 278; +inp[862] = 393; +inp[863] = 278; +inp[864] = 393; +inp[865] = 278; +inp[866] = 392; +inp[867] = 277; +inp[868] = 392; +inp[869] = 277; +inp[870] = 391; +inp[871] = 277; +inp[872] = 391; +inp[873] = 276; +inp[874] = 390; +inp[875] = 276; +inp[876] = 390; +inp[877] = 276; +inp[878] = 390; +inp[879] = 275; +inp[880] = 389; +inp[881] = 275; +inp[882] = 389; +inp[883] = 275; +inp[884] = 388; +inp[885] = 274; +inp[886] = 388; +inp[887] = 274; +inp[888] = 387; +inp[889] = 274; +inp[890] = 387; +inp[891] = 273; +inp[892] = 387; +inp[893] = 273; +inp[894] = 386; +inp[895] = 273; +inp[896] = 386; +inp[897] = 273; +inp[898] = 385; +inp[899] = 272; +inp[900] = 385; +inp[901] = 272; +inp[902] = 384; +inp[903] = 272; +inp[904] = 384; +inp[905] = 271; +inp[906] = 384; +inp[907] = 271; +inp[908] = 383; +inp[909] = 271; +inp[910] = 383; +inp[911] = 270; +inp[912] = 382; +inp[913] = 270; +inp[914] = 382; +inp[915] = 270; +inp[916] = 381; +inp[917] = 270; +inp[918] = 381; +inp[919] = 269; +inp[920] = 381; +inp[921] = 269; +inp[922] = 380; +inp[923] = 269; +inp[924] = 380; +inp[925] = 268; +inp[926] = 379; +inp[927] = 268; +inp[928] = 379; +inp[929] = 268; +inp[930] = 379; +inp[931] = 268; +inp[932] = 378; +inp[933] = 267; +inp[934] = 378; +inp[935] = 267; +inp[936] = 377; +inp[937] = 267; +inp[938] = 377; +inp[939] = 266; +inp[940] = 377; +inp[941] = 266; +inp[942] = 376; +inp[943] = 266; +inp[944] = 376; +inp[945] = 266; +inp[946] = 375; +inp[947] = 265; +inp[948] = 375; +inp[949] = 265; +inp[950] = 375; +inp[951] = 265; +inp[952] = 374; +inp[953] = 264; +inp[954] = 374; +inp[955] = 264; +inp[956] = 373; +inp[957] = 264; +inp[958] = 373; +inp[959] = 264; +inp[960] = 373; +inp[961] = 263; +inp[962] = 372; +inp[963] = 263; +inp[964] = 372; +inp[965] = 263; +inp[966] = 371; +inp[967] = 263; +inp[968] = 371; +inp[969] = 262; +inp[970] = 371; +inp[971] = 262; +inp[972] = 370; +inp[973] = 262; +inp[974] = 370; +inp[975] = 261; +inp[976] = 370; +inp[977] = 261; +inp[978] = 369; +inp[979] = 261; +inp[980] = 369; +inp[981] = 261; +inp[982] = 368; +inp[983] = 260; +inp[984] = 368; +inp[985] = 260; +inp[986] = 368; +inp[987] = 260; +inp[988] = 367; +inp[989] = 260; +inp[990] = 367; +inp[991] = 259; +inp[992] = 367; +inp[993] = 259; +inp[994] = 366; +inp[995] = 259; +inp[996] = 366; +inp[997] = 259; +inp[998] = 365; +inp[999] = 258; +inp[1000] = 365; +inp[1001] = 258; +inp[1002] = 365; +inp[1003] = 258; +inp[1004] = 364; +inp[1005] = 258; +inp[1006] = 364; +inp[1007] = 257; +inp[1008] = 364; +inp[1009] = 257; +inp[1010] = 363; +inp[1011] = 257; +inp[1012] = 363; +inp[1013] = 257; +inp[1014] = 363; +inp[1015] = 256; +inp[1016] = 362; +inp[1017] = 256; +inp[1018] = 362; +inp[1019] = 256; +} + +def void fillLUTDIV(int32_pl[1020] inp) +{ +inp[0] = 10; +inp[1] = 15; +inp[2] = 5; +inp[3] = 10; +inp[4] = 25; +inp[5] = 63; +inp[6] = 17; +inp[7] = 51; +inp[8] = 12; +inp[9] = 42; +inp[10] = 9; +inp[11] = 36; +inp[12] = 56; +inp[13] = 255; +inp[14] = 45; +inp[15] = 227; +inp[16] = 37; +inp[17] = 204; +inp[18] = 31; +inp[19] = 186; +inp[20] = 26; +inp[21] = 170; +inp[22] = 22; +inp[23] = 157; +inp[24] = 19; +inp[25] = 146; +inp[26] = 17; +inp[27] = 136; +inp[28] = 120; +inp[29] = 1023; +inp[30] = 107; +inp[31] = 963; +inp[32] = 95; +inp[33] = 909; +inp[34] = 86; +inp[35] = 862; +inp[36] = 78; +inp[37] = 818; +inp[38] = 70; +inp[39] = 779; +inp[40] = 64; +inp[41] = 744; +inp[42] = 59; +inp[43] = 712; +inp[44] = 54; +inp[45] = 682; +inp[46] = 50; +inp[47] = 655; +inp[48] = 46; +inp[49] = 630; +inp[50] = 43; +inp[51] = 606; +inp[52] = 40; +inp[53] = 585; +inp[54] = 37; +inp[55] = 564; +inp[56] = 35; +inp[57] = 546; +inp[58] = 33; +inp[59] = 528; +inp[60] = 248; +inp[61] = 4095; +inp[62] = 233; +inp[63] = 3971; +inp[64] = 220; +inp[65] = 3854; +inp[66] = 208; +inp[67] = 3744; +inp[68] = 196; +inp[69] = 3640; +inp[70] = 186; +inp[71] = 3542; +inp[72] = 176; +inp[73] = 3448; +inp[74] = 168; +inp[75] = 3360; +inp[76] = 159; +inp[77] = 3276; +inp[78] = 152; +inp[79] = 3196; +inp[80] = 145; +inp[81] = 3120; +inp[82] = 138; +inp[83] = 3047; +inp[84] = 132; +inp[85] = 2978; +inp[86] = 126; +inp[87] = 2912; +inp[88] = 121; +inp[89] = 2849; +inp[90] = 116; +inp[91] = 2788; +inp[92] = 111; +inp[93] = 2730; +inp[94] = 106; +inp[95] = 2674; +inp[96] = 102; +inp[97] = 2621; +inp[98] = 98; +inp[99] = 2569; +inp[100] = 95; +inp[101] = 2520; +inp[102] = 91; +inp[103] = 2472; +inp[104] = 88; +inp[105] = 2427; +inp[106] = 85; +inp[107] = 2383; +inp[108] = 82; +inp[109] = 2340; +inp[110] = 79; +inp[111] = 2299; +inp[112] = 76; +inp[113] = 2259; +inp[114] = 74; +inp[115] = 2221; +inp[116] = 71; +inp[117] = 2184; +inp[118] = 69; +inp[119] = 2148; +inp[120] = 67; +inp[121] = 2113; +inp[122] = 65; +inp[123] = 2080; +inp[124] = 504; +inp[125] = 16383; +inp[126] = 488; +inp[127] = 16131; +inp[128] = 474; +inp[129] = 15887; +inp[130] = 460; +inp[131] = 15649; +inp[132] = 446; +inp[133] = 15419; +inp[134] = 434; +inp[135] = 15196; +inp[136] = 421; +inp[137] = 14979; +inp[138] = 410; +inp[139] = 14768; +inp[140] = 399; +inp[141] = 14563; +inp[142] = 388; +inp[143] = 14363; +inp[144] = 377; +inp[145] = 14169; +inp[146] = 367; +inp[147] = 13980; +inp[148] = 358; +inp[149] = 13796; +inp[150] = 349; +inp[151] = 13617; +inp[152] = 340; +inp[153] = 13443; +inp[154] = 331; +inp[155] = 13272; +inp[156] = 323; +inp[157] = 13106; +inp[158] = 315; +inp[159] = 12945; +inp[160] = 308; +inp[161] = 12787; +inp[162] = 300; +inp[163] = 12633; +inp[164] = 293; +inp[165] = 12482; +inp[166] = 286; +inp[167] = 12335; +inp[168] = 280; +inp[169] = 12192; +inp[170] = 273; +inp[171] = 12052; +inp[172] = 267; +inp[173] = 11915; +inp[174] = 261; +inp[175] = 11781; +inp[176] = 256; +inp[177] = 11650; +inp[178] = 250; +inp[179] = 11522; +inp[180] = 245; +inp[181] = 11397; +inp[182] = 239; +inp[183] = 11274; +inp[184] = 234; +inp[185] = 11154; +inp[186] = 229; +inp[187] = 11037; +inp[188] = 225; +inp[189] = 10922; +inp[190] = 220; +inp[191] = 10809; +inp[192] = 216; +inp[193] = 10699; +inp[194] = 211; +inp[195] = 10591; +inp[196] = 207; +inp[197] = 10485; +inp[198] = 203; +inp[199] = 10381; +inp[200] = 199; +inp[201] = 10280; +inp[202] = 195; +inp[203] = 10180; +inp[204] = 192; +inp[205] = 10082; +inp[206] = 188; +inp[207] = 9986; +inp[208] = 184; +inp[209] = 9892; +inp[210] = 181; +inp[211] = 9799; +inp[212] = 178; +inp[213] = 9708; +inp[214] = 174; +inp[215] = 9619; +inp[216] = 171; +inp[217] = 9532; +inp[218] = 168; +inp[219] = 9446; +inp[220] = 165; +inp[221] = 9362; +inp[222] = 162; +inp[223] = 9279; +inp[224] = 159; +inp[225] = 9197; +inp[226] = 157; +inp[227] = 9117; +inp[228] = 154; +inp[229] = 9039; +inp[230] = 151; +inp[231] = 8962; +inp[232] = 149; +inp[233] = 8886; +inp[234] = 146; +inp[235] = 8811; +inp[236] = 144; +inp[237] = 8738; +inp[238] = 142; +inp[239] = 8665; +inp[240] = 139; +inp[241] = 8594; +inp[242] = 137; +inp[243] = 8524; +inp[244] = 135; +inp[245] = 8456; +inp[246] = 133; +inp[247] = 8388; +inp[248] = 131; +inp[249] = 8321; +inp[250] = 129; +inp[251] = 8256; +inp[252] = 1016; +inp[253] = 65535; +inp[254] = 1000; +inp[255] = 65027; +inp[256] = 985; +inp[257] = 64527; +inp[258] = 970; +inp[259] = 64034; +inp[260] = 955; +inp[261] = 63549; +inp[262] = 941; +inp[263] = 63071; +inp[264] = 927; +inp[265] = 62601; +inp[266] = 913; +inp[267] = 62137; +inp[268] = 900; +inp[269] = 61680; +inp[270] = 887; +inp[271] = 61230; +inp[272] = 874; +inp[273] = 60786; +inp[274] = 862; +inp[275] = 60349; +inp[276] = 849; +inp[277] = 59918; +inp[278] = 837; +inp[279] = 59493; +inp[280] = 826; +inp[281] = 59074; +inp[282] = 814; +inp[283] = 58661; +inp[284] = 803; +inp[285] = 58253; +inp[286] = 792; +inp[287] = 57852; +inp[288] = 781; +inp[289] = 57455; +inp[290] = 771; +inp[291] = 57065; +inp[292] = 760; +inp[293] = 56679; +inp[294] = 750; +inp[295] = 56299; +inp[296] = 740; +inp[297] = 55923; +inp[298] = 730; +inp[299] = 55553; +inp[300] = 721; +inp[301] = 55187; +inp[302] = 712; +inp[303] = 54827; +inp[304] = 702; +inp[305] = 54471; +inp[306] = 693; +inp[307] = 54119; +inp[308] = 685; +inp[309] = 53772; +inp[310] = 676; +inp[311] = 53430; +inp[312] = 667; +inp[313] = 53092; +inp[314] = 659; +inp[315] = 52758; +inp[316] = 651; +inp[317] = 52428; +inp[318] = 643; +inp[319] = 52102; +inp[320] = 635; +inp[321] = 51781; +inp[322] = 627; +inp[323] = 51463; +inp[324] = 620; +inp[325] = 51149; +inp[326] = 612; +inp[327] = 50839; +inp[328] = 605; +inp[329] = 50533; +inp[330] = 597; +inp[331] = 50230; +inp[332] = 590; +inp[333] = 49931; +inp[334] = 583; +inp[335] = 49636; +inp[336] = 577; +inp[337] = 49344; +inp[338] = 570; +inp[339] = 49055; +inp[340] = 563; +inp[341] = 48770; +inp[342] = 557; +inp[343] = 48488; +inp[344] = 550; +inp[345] = 48210; +inp[346] = 544; +inp[347] = 47934; +inp[348] = 538; +inp[349] = 47662; +inp[350] = 532; +inp[351] = 47393; +inp[352] = 526; +inp[353] = 47126; +inp[354] = 520; +inp[355] = 46863; +inp[356] = 514; +inp[357] = 46603; +inp[358] = 509; +inp[359] = 46345; +inp[360] = 503; +inp[361] = 46091; +inp[362] = 498; +inp[363] = 45839; +inp[364] = 492; +inp[365] = 45590; +inp[366] = 487; +inp[367] = 45343; +inp[368] = 482; +inp[369] = 45099; +inp[370] = 477; +inp[371] = 44858; +inp[372] = 472; +inp[373] = 44620; +inp[374] = 467; +inp[375] = 44384; +inp[376] = 462; +inp[377] = 44150; +inp[378] = 457; +inp[379] = 43919; +inp[380] = 452; +inp[381] = 43690; +inp[382] = 448; +inp[383] = 43464; +inp[384] = 443; +inp[385] = 43240; +inp[386] = 438; +inp[387] = 43018; +inp[388] = 434; +inp[389] = 42798; +inp[390] = 430; +inp[391] = 42581; +inp[392] = 425; +inp[393] = 42366; +inp[394] = 421; +inp[395] = 42153; +inp[396] = 417; +inp[397] = 41942; +inp[398] = 413; +inp[399] = 41734; +inp[400] = 409; +inp[401] = 41527; +inp[402] = 405; +inp[403] = 41323; +inp[404] = 401; +inp[405] = 41120; +inp[406] = 397; +inp[407] = 40919; +inp[408] = 393; +inp[409] = 40721; +inp[410] = 389; +inp[411] = 40524; +inp[412] = 385; +inp[413] = 40329; +inp[414] = 382; +inp[415] = 40136; +inp[416] = 378; +inp[417] = 39945; +inp[418] = 375; +inp[419] = 39756; +inp[420] = 371; +inp[421] = 39568; +inp[422] = 368; +inp[423] = 39383; +inp[424] = 364; +inp[425] = 39198; +inp[426] = 361; +inp[427] = 39016; +inp[428] = 357; +inp[429] = 38836; +inp[430] = 354; +inp[431] = 38657; +inp[432] = 351; +inp[433] = 38479; +inp[434] = 348; +inp[435] = 38304; +inp[436] = 345; +inp[437] = 38129; +inp[438] = 341; +inp[439] = 37957; +inp[440] = 338; +inp[441] = 37786; +inp[442] = 335; +inp[443] = 37616; +inp[444] = 332; +inp[445] = 37449; +inp[446] = 329; +inp[447] = 37282; +inp[448] = 327; +inp[449] = 37117; +inp[450] = 324; +inp[451] = 36954; +inp[452] = 321; +inp[453] = 36792; +inp[454] = 318; +inp[455] = 36631; +inp[456] = 315; +inp[457] = 36472; +inp[458] = 313; +inp[459] = 36314; +inp[460] = 310; +inp[461] = 36157; +inp[462] = 307; +inp[463] = 36002; +inp[464] = 305; +inp[465] = 35848; +inp[466] = 302; +inp[467] = 35696; +inp[468] = 299; +inp[469] = 35544; +inp[470] = 297; +inp[471] = 35394; +inp[472] = 294; +inp[473] = 35246; +inp[474] = 292; +inp[475] = 35098; +inp[476] = 290; +inp[477] = 34952; +inp[478] = 287; +inp[479] = 34807; +inp[480] = 285; +inp[481] = 34663; +inp[482] = 282; +inp[483] = 34520; +inp[484] = 280; +inp[485] = 34379; +inp[486] = 278; +inp[487] = 34239; +inp[488] = 276; +inp[489] = 34099; +inp[490] = 273; +inp[491] = 33961; +inp[492] = 271; +inp[493] = 33824; +inp[494] = 269; +inp[495] = 33689; +inp[496] = 267; +inp[497] = 33554; +inp[498] = 265; +inp[499] = 33420; +inp[500] = 263; +inp[501] = 33288; +inp[502] = 261; +inp[503] = 33156; +inp[504] = 259; +inp[505] = 33025; +inp[506] = 257; +inp[507] = 32896; +inp[508] = 2040; +inp[509] = 262143; +inp[510] = 2024; +inp[511] = 261123; +inp[512] = 2008; +inp[513] = 260111; +inp[514] = 1993; +inp[515] = 259107; +inp[516] = 1977; +inp[517] = 258110; +inp[518] = 1962; +inp[519] = 257121; +inp[520] = 1947; +inp[521] = 256140; +inp[522] = 1933; +inp[523] = 255166; +inp[524] = 1918; +inp[525] = 254199; +inp[526] = 1904; +inp[527] = 253240; +inp[528] = 1889; +inp[529] = 252288; +inp[530] = 1875; +inp[531] = 251343; +inp[532] = 1861; +inp[533] = 250405; +inp[534] = 1847; +inp[535] = 249474; +inp[536] = 1834; +inp[537] = 248550; +inp[538] = 1820; +inp[539] = 247633; +inp[540] = 1807; +inp[541] = 246723; +inp[542] = 1794; +inp[543] = 245819; +inp[544] = 1781; +inp[545] = 244922; +inp[546] = 1768; +inp[547] = 244031; +inp[548] = 1755; +inp[549] = 243147; +inp[550] = 1742; +inp[551] = 242269; +inp[552] = 1730; +inp[553] = 241398; +inp[554] = 1718; +inp[555] = 240533; +inp[556] = 1705; +inp[557] = 239674; +inp[558] = 1693; +inp[559] = 238821; +inp[560] = 1681; +inp[561] = 237974; +inp[562] = 1669; +inp[563] = 237133; +inp[564] = 1658; +inp[565] = 236298; +inp[566] = 1646; +inp[567] = 235469; +inp[568] = 1635; +inp[569] = 234646; +inp[570] = 1623; +inp[571] = 233828; +inp[572] = 1612; +inp[573] = 233016; +inp[574] = 1601; +inp[575] = 232210; +inp[576] = 1590; +inp[577] = 231409; +inp[578] = 1579; +inp[579] = 230614; +inp[580] = 1568; +inp[581] = 229824; +inp[582] = 1558; +inp[583] = 229040; +inp[584] = 1547; +inp[585] = 228261; +inp[586] = 1537; +inp[587] = 227487; +inp[588] = 1526; +inp[589] = 226718; +inp[590] = 1516; +inp[591] = 225955; +inp[592] = 1506; +inp[593] = 225197; +inp[594] = 1496; +inp[595] = 224444; +inp[596] = 1486; +inp[597] = 223695; +inp[598] = 1476; +inp[599] = 222952; +inp[600] = 1466; +inp[601] = 222214; +inp[602] = 1457; +inp[603] = 221481; +inp[604] = 1447; +inp[605] = 220752; +inp[606] = 1438; +inp[607] = 220028; +inp[608] = 1428; +inp[609] = 219309; +inp[610] = 1419; +inp[611] = 218595; +inp[612] = 1410; +inp[613] = 217885; +inp[614] = 1401; +inp[615] = 217180; +inp[616] = 1392; +inp[617] = 216479; +inp[618] = 1383; +inp[619] = 215783; +inp[620] = 1374; +inp[621] = 215092; +inp[622] = 1365; +inp[623] = 214405; +inp[624] = 1356; +inp[625] = 213722; +inp[626] = 1348; +inp[627] = 213043; +inp[628] = 1339; +inp[629] = 212369; +inp[630] = 1331; +inp[631] = 211699; +inp[632] = 1323; +inp[633] = 211033; +inp[634] = 1314; +inp[635] = 210372; +inp[636] = 1306; +inp[637] = 209714; +inp[638] = 1298; +inp[639] = 209061; +inp[640] = 1290; +inp[641] = 208412; +inp[642] = 1282; +inp[643] = 207767; +inp[644] = 1274; +inp[645] = 207125; +inp[646] = 1266; +inp[647] = 206488; +inp[648] = 1259; +inp[649] = 205855; +inp[650] = 1251; +inp[651] = 205225; +inp[652] = 1243; +inp[653] = 204599; +inp[654] = 1236; +inp[655] = 203978; +inp[656] = 1228; +inp[657] = 203359; +inp[658] = 1221; +inp[659] = 202745; +inp[660] = 1214; +inp[661] = 202134; +inp[662] = 1206; +inp[663] = 201527; +inp[664] = 1199; +inp[665] = 200924; +inp[666] = 1192; +inp[667] = 200324; +inp[668] = 1185; +inp[669] = 199728; +inp[670] = 1178; +inp[671] = 199135; +inp[672] = 1171; +inp[673] = 198546; +inp[674] = 1164; +inp[675] = 197961; +inp[676] = 1157; +inp[677] = 197378; +inp[678] = 1150; +inp[679] = 196799; +inp[680] = 1144; +inp[681] = 196224; +inp[682] = 1137; +inp[683] = 195652; +inp[684] = 1130; +inp[685] = 195083; +inp[686] = 1124; +inp[687] = 194518; +inp[688] = 1117; +inp[689] = 193956; +inp[690] = 1111; +inp[691] = 193397; +inp[692] = 1105; +inp[693] = 192841; +inp[694] = 1098; +inp[695] = 192288; +inp[696] = 1092; +inp[697] = 191739; +inp[698] = 1086; +inp[699] = 191193; +inp[700] = 1080; +inp[701] = 190649; +inp[702] = 1074; +inp[703] = 190109; +inp[704] = 1068; +inp[705] = 189572; +inp[706] = 1062; +inp[707] = 189038; +inp[708] = 1056; +inp[709] = 188507; +inp[710] = 1050; +inp[711] = 187979; +inp[712] = 1044; +inp[713] = 187454; +inp[714] = 1038; +inp[715] = 186932; +inp[716] = 1032; +inp[717] = 186413; +inp[718] = 1027; +inp[719] = 185896; +inp[720] = 1021; +inp[721] = 185383; +inp[722] = 1015; +inp[723] = 184872; +inp[724] = 1010; +inp[725] = 184364; +inp[726] = 1004; +inp[727] = 183859; +inp[728] = 999; +inp[729] = 183357; +inp[730] = 993; +inp[731] = 182857; +inp[732] = 988; +inp[733] = 182360; +inp[734] = 983; +inp[735] = 181866; +inp[736] = 977; +inp[737] = 181375; +inp[738] = 972; +inp[739] = 180886; +inp[740] = 967; +inp[741] = 180400; +inp[742] = 962; +inp[743] = 179916; +inp[744] = 956; +inp[745] = 179435; +inp[746] = 951; +inp[747] = 178956; +inp[748] = 946; +inp[749] = 178480; +inp[750] = 941; +inp[751] = 178007; +inp[752] = 936; +inp[753] = 177536; +inp[754] = 931; +inp[755] = 177068; +inp[756] = 927; +inp[757] = 176602; +inp[758] = 922; +inp[759] = 176138; +inp[760] = 917; +inp[761] = 175677; +inp[762] = 912; +inp[763] = 175218; +inp[764] = 907; +inp[765] = 174762; +inp[766] = 903; +inp[767] = 174308; +inp[768] = 898; +inp[769] = 173857; +inp[770] = 893; +inp[771] = 173407; +inp[772] = 889; +inp[773] = 172960; +inp[774] = 884; +inp[775] = 172516; +inp[776] = 880; +inp[777] = 172073; +inp[778] = 875; +inp[779] = 171633; +inp[780] = 871; +inp[781] = 171195; +inp[782] = 866; +inp[783] = 170760; +inp[784] = 862; +inp[785] = 170326; +inp[786] = 858; +inp[787] = 169895; +inp[788] = 853; +inp[789] = 169466; +inp[790] = 849; +inp[791] = 169039; +inp[792] = 845; +inp[793] = 168615; +inp[794] = 840; +inp[795] = 168192; +inp[796] = 836; +inp[797] = 167772; +inp[798] = 832; +inp[799] = 167353; +inp[800] = 828; +inp[801] = 166937; +inp[802] = 824; +inp[803] = 166523; +inp[804] = 820; +inp[805] = 166110; +inp[806] = 816; +inp[807] = 165700; +inp[808] = 812; +inp[809] = 165292; +inp[810] = 808; +inp[811] = 164886; +inp[812] = 804; +inp[813] = 164482; +inp[814] = 800; +inp[815] = 164080; +inp[816] = 796; +inp[817] = 163680; +inp[818] = 792; +inp[819] = 163281; +inp[820] = 788; +inp[821] = 162885; +inp[822] = 784; +inp[823] = 162491; +inp[824] = 781; +inp[825] = 162098; +inp[826] = 777; +inp[827] = 161707; +inp[828] = 773; +inp[829] = 161319; +inp[830] = 770; +inp[831] = 160932; +inp[832] = 766; +inp[833] = 160547; +inp[834] = 762; +inp[835] = 160164; +inp[836] = 759; +inp[837] = 159782; +inp[838] = 755; +inp[839] = 159403; +inp[840] = 751; +inp[841] = 159025; +inp[842] = 748; +inp[843] = 158649; +inp[844] = 744; +inp[845] = 158275; +inp[846] = 741; +inp[847] = 157903; +inp[848] = 737; +inp[849] = 157532; +inp[850] = 734; +inp[851] = 157163; +inp[852] = 730; +inp[853] = 156796; +inp[854] = 727; +inp[855] = 156430; +inp[856] = 724; +inp[857] = 156067; +inp[858] = 720; +inp[859] = 155704; +inp[860] = 717; +inp[861] = 155344; +inp[862] = 714; +inp[863] = 154985; +inp[864] = 710; +inp[865] = 154628; +inp[866] = 707; +inp[867] = 154273; +inp[868] = 704; +inp[869] = 153919; +inp[870] = 701; +inp[871] = 153567; +inp[872] = 698; +inp[873] = 153216; +inp[874] = 694; +inp[875] = 152867; +inp[876] = 691; +inp[877] = 152520; +inp[878] = 688; +inp[879] = 152174; +inp[880] = 685; +inp[881] = 151829; +inp[882] = 682; +inp[883] = 151487; +inp[884] = 679; +inp[885] = 151145; +inp[886] = 676; +inp[887] = 150806; +inp[888] = 673; +inp[889] = 150468; +inp[890] = 670; +inp[891] = 150131; +inp[892] = 667; +inp[893] = 149796; +inp[894] = 664; +inp[895] = 149462; +inp[896] = 661; +inp[897] = 149130; +inp[898] = 658; +inp[899] = 148800; +inp[900] = 655; +inp[901] = 148470; +inp[902] = 652; +inp[903] = 148143; +inp[904] = 649; +inp[905] = 147816; +inp[906] = 646; +inp[907] = 147491; +inp[908] = 644; +inp[909] = 147168; +inp[910] = 641; +inp[911] = 146846; +inp[912] = 638; +inp[913] = 146525; +inp[914] = 635; +inp[915] = 146206; +inp[916] = 632; +inp[917] = 145888; +inp[918] = 630; +inp[919] = 145572; +inp[920] = 627; +inp[921] = 145257; +inp[922] = 624; +inp[923] = 144943; +inp[924] = 622; +inp[925] = 144631; +inp[926] = 619; +inp[927] = 144320; +inp[928] = 616; +inp[929] = 144010; +inp[930] = 614; +inp[931] = 143701; +inp[932] = 611; +inp[933] = 143394; +inp[934] = 608; +inp[935] = 143089; +inp[936] = 606; +inp[937] = 142784; +inp[938] = 603; +inp[939] = 142481; +inp[940] = 601; +inp[941] = 142179; +inp[942] = 598; +inp[943] = 141879; +inp[944] = 596; +inp[945] = 141579; +inp[946] = 593; +inp[947] = 141281; +inp[948] = 591; +inp[949] = 140984; +inp[950] = 588; +inp[951] = 140689; +inp[952] = 586; +inp[953] = 140395; +inp[954] = 583; +inp[955] = 140101; +inp[956] = 581; +inp[957] = 139810; +inp[958] = 578; +inp[959] = 139519; +inp[960] = 576; +inp[961] = 139229; +inp[962] = 574; +inp[963] = 138941; +inp[964] = 571; +inp[965] = 138654; +inp[966] = 569; +inp[967] = 138368; +inp[968] = 567; +inp[969] = 138084; +inp[970] = 564; +inp[971] = 137800; +inp[972] = 562; +inp[973] = 137518; +inp[974] = 560; +inp[975] = 137236; +inp[976] = 557; +inp[977] = 136956; +inp[978] = 555; +inp[979] = 136677; +inp[980] = 553; +inp[981] = 136400; +inp[982] = 551; +inp[983] = 136123; +inp[984] = 548; +inp[985] = 135847; +inp[986] = 546; +inp[987] = 135573; +inp[988] = 544; +inp[989] = 135300; +inp[990] = 542; +inp[991] = 135027; +inp[992] = 540; +inp[993] = 134756; +inp[994] = 537; +inp[995] = 134486; +inp[996] = 535; +inp[997] = 134217; +inp[998] = 533; +inp[999] = 133949; +inp[1000] = 531; +inp[1001] = 133682; +inp[1002] = 529; +inp[1003] = 133417; +inp[1004] = 527; +inp[1005] = 133152; +inp[1006] = 525; +inp[1007] = 132888; +inp[1008] = 523; +inp[1009] = 132626; +inp[1010] = 521; +inp[1011] = 132364; +inp[1012] = 519; +inp[1013] = 132103; +inp[1014] = 517; +inp[1015] = 131844; +inp[1016] = 515; +inp[1017] = 131585; +inp[1018] = 513; +inp[1019] = 131328; +} + +def void fillLUTNEGEXP(int32_pl[33660] inp) +{ +inp[0] = 1073741824; +inp[1] = 1073741824; +inp[2] = 395007542; +inp[3] = 395007542; +inp[4] = 1073741824; +inp[5] = 1073741824; +inp[6] = 651257336; +inp[7] = 145315153; +inp[8] = 1073741824; +inp[9] = 1073741824; +inp[10] = 836230973; +inp[11] = 19666267; +inp[12] = 1073741824; +inp[13] = 1073741824; +inp[14] = 947573833; +inp[15] = 360200; +inp[16] = 1073741824; +inp[17] = 1073741824; +inp[18] = 1008687095; +inp[19] = 120; +inp[20] = 1073741824; +inp[21] = 1073741824; +inp[22] = 1040706261; +inp[23] = 0; +inp[24] = 1073741824; +inp[25] = 1073741824; +inp[26] = 1057094999; +inp[27] = 0; +inp[28] = 1073741824; +inp[29] = 1073741824; +inp[30] = 1065385898; +inp[31] = 0; +inp[32] = 1073741824; +inp[33] = 1073741824; +inp[34] = 1069555701; +inp[35] = 0; +inp[36] = 1073741824; +inp[37] = 1073741824; +inp[38] = 1071646718; +inp[39] = 0; +inp[40] = 1073741824; +inp[41] = 1073741824; +inp[42] = 1072693759; +inp[43] = 0; +inp[44] = 1073741824; +inp[45] = 1073741824; +inp[46] = 1073217663; +inp[47] = 0; +inp[48] = 1073741824; +inp[49] = 1073741824; +inp[50] = 1073479711; +inp[51] = 0; +inp[52] = 1073741824; +inp[53] = 1073741824; +inp[54] = 1073610759; +inp[55] = 0; +inp[56] = 1073741824; +inp[57] = 1073741824; +inp[58] = 1073676289; +inp[59] = 0; +inp[60] = 1073741824; +inp[61] = 1073741824; +inp[62] = 1073709056; +inp[63] = 0; +inp[64] = 1073741824; +inp[65] = 1073741824; +inp[66] = 1073725440; +inp[67] = 0; +inp[68] = 1073741824; +inp[69] = 1073741824; +inp[70] = 1073733632; +inp[71] = 0; +inp[72] = 1073741824; +inp[73] = 1073741824; +inp[74] = 1073737728; +inp[75] = 0; +inp[76] = 1073741824; +inp[77] = 1073741824; +inp[78] = 1073739776; +inp[79] = 0; +inp[80] = 1073741824; +inp[81] = 1073741824; +inp[82] = 1073740800; +inp[83] = 0; +inp[84] = 1073741824; +inp[85] = 1073741824; +inp[86] = 1073741312; +inp[87] = 0; +inp[88] = 1073741824; +inp[89] = 1073741824; +inp[90] = 1073741568; +inp[91] = 0; +inp[92] = 1073741824; +inp[93] = 1073741824; +inp[94] = 1073741696; +inp[95] = 0; +inp[96] = 1073741824; +inp[97] = 1073741824; +inp[98] = 1073741760; +inp[99] = 0; +inp[100] = 1073741824; +inp[101] = 1073741824; +inp[102] = 1073741792; +inp[103] = 0; +inp[104] = 1073741824; +inp[105] = 1073741824; +inp[106] = 1073741808; +inp[107] = 0; +inp[108] = 1073741824; +inp[109] = 1073741824; +inp[110] = 1073741816; +inp[111] = 0; +inp[112] = 1073741824; +inp[113] = 1073741824; +inp[114] = 1073741820; +inp[115] = 0; +inp[116] = 1073741824; +inp[117] = 1073741824; +inp[118] = 1073741822; +inp[119] = 0; +inp[120] = 1073741824; +inp[121] = 1073741824; +inp[122] = 1073741823; +inp[123] = 0; +inp[124] = 1073741824; +inp[125] = 1073741824; +inp[126] = 1073741823; +inp[127] = 0; +inp[128] = 1073741824; +inp[129] = 1073741824; +inp[130] = 1073741823; +inp[131] = 0; +inp[132] = 1073741824; +inp[133] = 1073741824; +inp[134] = 395007542; +inp[135] = 395007542; +inp[136] = 145315153; +inp[137] = 145315153; +inp[138] = 53458457; +inp[139] = 53458457; +inp[140] = 1073741824; +inp[141] = 1073741824; +inp[142] = 651257336; +inp[143] = 145315153; +inp[144] = 395007542; +inp[145] = 19666267; +inp[146] = 239584185; +inp[147] = 2661539; +inp[148] = 1073741824; +inp[149] = 1073741824; +inp[150] = 836230973; +inp[151] = 19666267; +inp[152] = 651257336; +inp[153] = 360200; +inp[154] = 507199723; +inp[155] = 6597; +inp[156] = 1073741824; +inp[157] = 1073741824; +inp[158] = 947573833; +inp[159] = 360200; +inp[160] = 836230973; +inp[161] = 120; +inp[162] = 737971243; +inp[163] = 0; +inp[164] = 1073741824; +inp[165] = 1073741824; +inp[166] = 1008687095; +inp[167] = 120; +inp[168] = 947573833; +inp[169] = 0; +inp[170] = 890163237; +inp[171] = 0; +inp[172] = 1073741824; +inp[173] = 1073741824; +inp[174] = 1040706261; +inp[175] = 0; +inp[176] = 1008687095; +inp[177] = 0; +inp[178] = 977653056; +inp[179] = 0; +inp[180] = 1073741824; +inp[181] = 1073741824; +inp[182] = 1057094999; +inp[183] = 0; +inp[184] = 1040706261; +inp[185] = 0; +inp[186] = 1024571605; +inp[187] = 0; +inp[188] = 1073741824; +inp[189] = 1073741824; +inp[190] = 1065385898; +inp[191] = 0; +inp[192] = 1057094999; +inp[193] = 0; +inp[194] = 1048868621; +inp[195] = 0; +inp[196] = 1073741824; +inp[197] = 1073741824; +inp[198] = 1069555701; +inp[199] = 0; +inp[200] = 1065385898; +inp[201] = 0; +inp[202] = 1061232352; +inp[203] = 0; +inp[204] = 1073741824; +inp[205] = 1073741824; +inp[206] = 1071646718; +inp[207] = 0; +inp[208] = 1069555701; +inp[209] = 0; +inp[210] = 1067468764; +inp[211] = 0; +inp[212] = 1073741824; +inp[213] = 1073741824; +inp[214] = 1072693759; +inp[215] = 0; +inp[216] = 1071646718; +inp[217] = 0; +inp[218] = 1070600699; +inp[219] = 0; +inp[220] = 1073741824; +inp[221] = 1073741824; +inp[222] = 1073217663; +inp[223] = 0; +inp[224] = 1072693759; +inp[225] = 0; +inp[226] = 1072170111; +inp[227] = 0; +inp[228] = 1073741824; +inp[229] = 1073741824; +inp[230] = 1073479711; +inp[231] = 0; +inp[232] = 1073217663; +inp[233] = 0; +inp[234] = 1072955679; +inp[235] = 0; +inp[236] = 1073741824; +inp[237] = 1073741824; +inp[238] = 1073610759; +inp[239] = 0; +inp[240] = 1073479711; +inp[241] = 0; +inp[242] = 1073348679; +inp[243] = 0; +inp[244] = 1073741824; +inp[245] = 1073741824; +inp[246] = 1073676289; +inp[247] = 0; +inp[248] = 1073610759; +inp[249] = 0; +inp[250] = 1073545233; +inp[251] = 0; +inp[252] = 1073741824; +inp[253] = 1073741824; +inp[254] = 1073709056; +inp[255] = 0; +inp[256] = 1073676289; +inp[257] = 0; +inp[258] = 1073643524; +inp[259] = 0; +inp[260] = 1073741824; +inp[261] = 1073741824; +inp[262] = 1073725440; +inp[263] = 0; +inp[264] = 1073709056; +inp[265] = 0; +inp[266] = 1073692673; +inp[267] = 0; +inp[268] = 1073741824; +inp[269] = 1073741824; +inp[270] = 1073733632; +inp[271] = 0; +inp[272] = 1073725440; +inp[273] = 0; +inp[274] = 1073717248; +inp[275] = 0; +inp[276] = 1073741824; +inp[277] = 1073741824; +inp[278] = 1073737728; +inp[279] = 0; +inp[280] = 1073733632; +inp[281] = 0; +inp[282] = 1073729536; +inp[283] = 0; +inp[284] = 1073741824; +inp[285] = 1073741824; +inp[286] = 1073739776; +inp[287] = 0; +inp[288] = 1073737728; +inp[289] = 0; +inp[290] = 1073735680; +inp[291] = 0; +inp[292] = 1073741824; +inp[293] = 1073741824; +inp[294] = 1073740800; +inp[295] = 0; +inp[296] = 1073739776; +inp[297] = 0; +inp[298] = 1073738752; +inp[299] = 0; +inp[300] = 1073741824; +inp[301] = 1073741824; +inp[302] = 1073741312; +inp[303] = 0; +inp[304] = 1073740800; +inp[305] = 0; +inp[306] = 1073740288; +inp[307] = 0; +inp[308] = 1073741824; +inp[309] = 1073741824; +inp[310] = 1073741568; +inp[311] = 0; +inp[312] = 1073741312; +inp[313] = 0; +inp[314] = 1073741056; +inp[315] = 0; +inp[316] = 1073741824; +inp[317] = 1073741824; +inp[318] = 1073741696; +inp[319] = 0; +inp[320] = 1073741568; +inp[321] = 0; +inp[322] = 1073741440; +inp[323] = 0; +inp[324] = 1073741824; +inp[325] = 1073741824; +inp[326] = 1073741760; +inp[327] = 0; +inp[328] = 1073741696; +inp[329] = 0; +inp[330] = 1073741632; +inp[331] = 0; +inp[332] = 1073741824; +inp[333] = 1073741824; +inp[334] = 1073741792; +inp[335] = 0; +inp[336] = 1073741760; +inp[337] = 0; +inp[338] = 1073741728; +inp[339] = 0; +inp[340] = 1073741824; +inp[341] = 1073741824; +inp[342] = 1073741808; +inp[343] = 0; +inp[344] = 1073741792; +inp[345] = 0; +inp[346] = 1073741776; +inp[347] = 0; +inp[348] = 1073741824; +inp[349] = 1073741824; +inp[350] = 1073741816; +inp[351] = 0; +inp[352] = 1073741808; +inp[353] = 0; +inp[354] = 1073741800; +inp[355] = 0; +inp[356] = 1073741824; +inp[357] = 1073741824; +inp[358] = 1073741820; +inp[359] = 0; +inp[360] = 1073741816; +inp[361] = 0; +inp[362] = 1073741812; +inp[363] = 0; +inp[364] = 1073741824; +inp[365] = 1073741824; +inp[366] = 1073741822; +inp[367] = 0; +inp[368] = 1073741820; +inp[369] = 0; +inp[370] = 1073741818; +inp[371] = 0; +inp[372] = 1073741824; +inp[373] = 1073741824; +inp[374] = 1073741823; +inp[375] = 0; +inp[376] = 1073741822; +inp[377] = 0; +inp[378] = 1073741821; +inp[379] = 0; +inp[380] = 1073741824; +inp[381] = 1073741824; +inp[382] = 1073741823; +inp[383] = 0; +inp[384] = 1073741823; +inp[385] = 0; +inp[386] = 1073741822; +inp[387] = 0; +inp[388] = 1073741824; +inp[389] = 1073741824; +inp[390] = 1073741823; +inp[391] = 0; +inp[392] = 1073741823; +inp[393] = 0; +inp[394] = 1073741823; +inp[395] = 0; +inp[396] = 1073741824; +inp[397] = 1073741824; +inp[398] = 395007542; +inp[399] = 395007542; +inp[400] = 145315153; +inp[401] = 145315153; +inp[402] = 53458457; +inp[403] = 53458457; +inp[404] = 19666267; +inp[405] = 19666267; +inp[406] = 7234815; +inp[407] = 7234815; +inp[408] = 2661539; +inp[409] = 2661539; +inp[410] = 979125; +inp[411] = 979125; +inp[412] = 1073741824; +inp[413] = 1073741824; +inp[414] = 651257336; +inp[415] = 145315153; +inp[416] = 395007542; +inp[417] = 19666267; +inp[418] = 239584185; +inp[419] = 2661539; +inp[420] = 145315153; +inp[421] = 360200; +inp[422] = 88138096; +inp[423] = 48747; +inp[424] = 53458457; +inp[425] = 6597; +inp[426] = 32424193; +inp[427] = 892; +inp[428] = 1073741824; +inp[429] = 1073741824; +inp[430] = 836230973; +inp[431] = 19666267; +inp[432] = 651257336; +inp[433] = 360200; +inp[434] = 507199723; +inp[435] = 6597; +inp[436] = 395007542; +inp[437] = 120; +inp[438] = 307632183; +inp[439] = 2; +inp[440] = 239584185; +inp[441] = 0; +inp[442] = 186588351; +inp[443] = 0; +inp[444] = 1073741824; +inp[445] = 1073741824; +inp[446] = 947573833; +inp[447] = 360200; +inp[448] = 836230973; +inp[449] = 120; +inp[450] = 737971243; +inp[451] = 0; +inp[452] = 651257336; +inp[453] = 0; +inp[454] = 574732582; +inp[455] = 0; +inp[456] = 507199723; +inp[457] = 0; +inp[458] = 447602185; +inp[459] = 0; +inp[460] = 1073741824; +inp[461] = 1073741824; +inp[462] = 1008687095; +inp[463] = 120; +inp[464] = 947573833; +inp[465] = 0; +inp[466] = 890163237; +inp[467] = 0; +inp[468] = 836230973; +inp[469] = 0; +inp[470] = 785566299; +inp[471] = 0; +inp[472] = 737971243; +inp[473] = 0; +inp[474] = 693259826; +inp[475] = 0; +inp[476] = 1073741824; +inp[477] = 1073741824; +inp[478] = 1040706261; +inp[479] = 0; +inp[480] = 1008687095; +inp[481] = 0; +inp[482] = 977653056; +inp[483] = 0; +inp[484] = 947573833; +inp[485] = 0; +inp[486] = 918420051; +inp[487] = 0; +inp[488] = 890163237; +inp[489] = 0; +inp[490] = 862775793; +inp[491] = 0; +inp[492] = 1073741824; +inp[493] = 1073741824; +inp[494] = 1057094999; +inp[495] = 0; +inp[496] = 1040706261; +inp[497] = 0; +inp[498] = 1024571605; +inp[499] = 0; +inp[500] = 1008687095; +inp[501] = 0; +inp[502] = 993048851; +inp[503] = 0; +inp[504] = 977653056; +inp[505] = 0; +inp[506] = 962495950; +inp[507] = 0; +inp[508] = 1073741824; +inp[509] = 1073741824; +inp[510] = 1065385898; +inp[511] = 0; +inp[512] = 1057094999; +inp[513] = 0; +inp[514] = 1048868621; +inp[515] = 0; +inp[516] = 1040706261; +inp[517] = 0; +inp[518] = 1032607420; +inp[519] = 0; +inp[520] = 1024571605; +inp[521] = 0; +inp[522] = 1016598326; +inp[523] = 0; +inp[524] = 1073741824; +inp[525] = 1073741824; +inp[526] = 1069555701; +inp[527] = 0; +inp[528] = 1065385898; +inp[529] = 0; +inp[530] = 1061232352; +inp[531] = 0; +inp[532] = 1057094999; +inp[533] = 0; +inp[534] = 1052973777; +inp[535] = 0; +inp[536] = 1048868621; +inp[537] = 0; +inp[538] = 1044779470; +inp[539] = 0; +inp[540] = 1073741824; +inp[541] = 1073741824; +inp[542] = 1071646718; +inp[543] = 0; +inp[544] = 1069555701; +inp[545] = 0; +inp[546] = 1067468764; +inp[547] = 0; +inp[548] = 1065385898; +inp[549] = 0; +inp[550] = 1063307097; +inp[551] = 0; +inp[552] = 1061232352; +inp[553] = 0; +inp[554] = 1059161656; +inp[555] = 0; +inp[556] = 1073741824; +inp[557] = 1073741824; +inp[558] = 1072693759; +inp[559] = 0; +inp[560] = 1071646718; +inp[561] = 0; +inp[562] = 1070600699; +inp[563] = 0; +inp[564] = 1069555701; +inp[565] = 0; +inp[566] = 1068511723; +inp[567] = 0; +inp[568] = 1067468764; +inp[569] = 0; +inp[570] = 1066426822; +inp[571] = 0; +inp[572] = 1073741824; +inp[573] = 1073741824; +inp[574] = 1073217663; +inp[575] = 0; +inp[576] = 1072693759; +inp[577] = 0; +inp[578] = 1072170111; +inp[579] = 0; +inp[580] = 1071646718; +inp[581] = 0; +inp[582] = 1071123581; +inp[583] = 0; +inp[584] = 1070600699; +inp[585] = 0; +inp[586] = 1070078072; +inp[587] = 0; +inp[588] = 1073741824; +inp[589] = 1073741824; +inp[590] = 1073479711; +inp[591] = 0; +inp[592] = 1073217663; +inp[593] = 0; +inp[594] = 1072955679; +inp[595] = 0; +inp[596] = 1072693759; +inp[597] = 0; +inp[598] = 1072431903; +inp[599] = 0; +inp[600] = 1072170111; +inp[601] = 0; +inp[602] = 1071908383; +inp[603] = 0; +inp[604] = 1073741824; +inp[605] = 1073741824; +inp[606] = 1073610759; +inp[607] = 0; +inp[608] = 1073479711; +inp[609] = 0; +inp[610] = 1073348679; +inp[611] = 0; +inp[612] = 1073217663; +inp[613] = 0; +inp[614] = 1073086663; +inp[615] = 0; +inp[616] = 1072955679; +inp[617] = 0; +inp[618] = 1072824711; +inp[619] = 0; +inp[620] = 1073741824; +inp[621] = 1073741824; +inp[622] = 1073676289; +inp[623] = 0; +inp[624] = 1073610759; +inp[625] = 0; +inp[626] = 1073545233; +inp[627] = 0; +inp[628] = 1073479711; +inp[629] = 0; +inp[630] = 1073414193; +inp[631] = 0; +inp[632] = 1073348679; +inp[633] = 0; +inp[634] = 1073283169; +inp[635] = 0; +inp[636] = 1073741824; +inp[637] = 1073741824; +inp[638] = 1073709056; +inp[639] = 0; +inp[640] = 1073676289; +inp[641] = 0; +inp[642] = 1073643524; +inp[643] = 0; +inp[644] = 1073610759; +inp[645] = 0; +inp[646] = 1073577996; +inp[647] = 0; +inp[648] = 1073545233; +inp[649] = 0; +inp[650] = 1073512472; +inp[651] = 0; +inp[652] = 1073741824; +inp[653] = 1073741824; +inp[654] = 1073725440; +inp[655] = 0; +inp[656] = 1073709056; +inp[657] = 0; +inp[658] = 1073692673; +inp[659] = 0; +inp[660] = 1073676289; +inp[661] = 0; +inp[662] = 1073659907; +inp[663] = 0; +inp[664] = 1073643524; +inp[665] = 0; +inp[666] = 1073627142; +inp[667] = 0; +inp[668] = 1073741824; +inp[669] = 1073741824; +inp[670] = 1073733632; +inp[671] = 0; +inp[672] = 1073725440; +inp[673] = 0; +inp[674] = 1073717248; +inp[675] = 0; +inp[676] = 1073709056; +inp[677] = 0; +inp[678] = 1073700864; +inp[679] = 0; +inp[680] = 1073692673; +inp[681] = 0; +inp[682] = 1073684481; +inp[683] = 0; +inp[684] = 1073741824; +inp[685] = 1073741824; +inp[686] = 1073737728; +inp[687] = 0; +inp[688] = 1073733632; +inp[689] = 0; +inp[690] = 1073729536; +inp[691] = 0; +inp[692] = 1073725440; +inp[693] = 0; +inp[694] = 1073721344; +inp[695] = 0; +inp[696] = 1073717248; +inp[697] = 0; +inp[698] = 1073713152; +inp[699] = 0; +inp[700] = 1073741824; +inp[701] = 1073741824; +inp[702] = 1073739776; +inp[703] = 0; +inp[704] = 1073737728; +inp[705] = 0; +inp[706] = 1073735680; +inp[707] = 0; +inp[708] = 1073733632; +inp[709] = 0; +inp[710] = 1073731584; +inp[711] = 0; +inp[712] = 1073729536; +inp[713] = 0; +inp[714] = 1073727488; +inp[715] = 0; +inp[716] = 1073741824; +inp[717] = 1073741824; +inp[718] = 1073740800; +inp[719] = 0; +inp[720] = 1073739776; +inp[721] = 0; +inp[722] = 1073738752; +inp[723] = 0; +inp[724] = 1073737728; +inp[725] = 0; +inp[726] = 1073736704; +inp[727] = 0; +inp[728] = 1073735680; +inp[729] = 0; +inp[730] = 1073734656; +inp[731] = 0; +inp[732] = 1073741824; +inp[733] = 1073741824; +inp[734] = 1073741312; +inp[735] = 0; +inp[736] = 1073740800; +inp[737] = 0; +inp[738] = 1073740288; +inp[739] = 0; +inp[740] = 1073739776; +inp[741] = 0; +inp[742] = 1073739264; +inp[743] = 0; +inp[744] = 1073738752; +inp[745] = 0; +inp[746] = 1073738240; +inp[747] = 0; +inp[748] = 1073741824; +inp[749] = 1073741824; +inp[750] = 1073741568; +inp[751] = 0; +inp[752] = 1073741312; +inp[753] = 0; +inp[754] = 1073741056; +inp[755] = 0; +inp[756] = 1073740800; +inp[757] = 0; +inp[758] = 1073740544; +inp[759] = 0; +inp[760] = 1073740288; +inp[761] = 0; +inp[762] = 1073740032; +inp[763] = 0; +inp[764] = 1073741824; +inp[765] = 1073741824; +inp[766] = 1073741696; +inp[767] = 0; +inp[768] = 1073741568; +inp[769] = 0; +inp[770] = 1073741440; +inp[771] = 0; +inp[772] = 1073741312; +inp[773] = 0; +inp[774] = 1073741184; +inp[775] = 0; +inp[776] = 1073741056; +inp[777] = 0; +inp[778] = 1073740928; +inp[779] = 0; +inp[780] = 1073741824; +inp[781] = 1073741824; +inp[782] = 1073741760; +inp[783] = 0; +inp[784] = 1073741696; +inp[785] = 0; +inp[786] = 1073741632; +inp[787] = 0; +inp[788] = 1073741568; +inp[789] = 0; +inp[790] = 1073741504; +inp[791] = 0; +inp[792] = 1073741440; +inp[793] = 0; +inp[794] = 1073741376; +inp[795] = 0; +inp[796] = 1073741824; +inp[797] = 1073741824; +inp[798] = 1073741792; +inp[799] = 0; +inp[800] = 1073741760; +inp[801] = 0; +inp[802] = 1073741728; +inp[803] = 0; +inp[804] = 1073741696; +inp[805] = 0; +inp[806] = 1073741664; +inp[807] = 0; +inp[808] = 1073741632; +inp[809] = 0; +inp[810] = 1073741600; +inp[811] = 0; +inp[812] = 1073741824; +inp[813] = 1073741824; +inp[814] = 1073741808; +inp[815] = 0; +inp[816] = 1073741792; +inp[817] = 0; +inp[818] = 1073741776; +inp[819] = 0; +inp[820] = 1073741760; +inp[821] = 0; +inp[822] = 1073741744; +inp[823] = 0; +inp[824] = 1073741728; +inp[825] = 0; +inp[826] = 1073741712; +inp[827] = 0; +inp[828] = 1073741824; +inp[829] = 1073741824; +inp[830] = 1073741816; +inp[831] = 0; +inp[832] = 1073741808; +inp[833] = 0; +inp[834] = 1073741800; +inp[835] = 0; +inp[836] = 1073741792; +inp[837] = 0; +inp[838] = 1073741784; +inp[839] = 0; +inp[840] = 1073741776; +inp[841] = 0; +inp[842] = 1073741768; +inp[843] = 0; +inp[844] = 1073741824; +inp[845] = 1073741824; +inp[846] = 1073741820; +inp[847] = 0; +inp[848] = 1073741816; +inp[849] = 0; +inp[850] = 1073741812; +inp[851] = 0; +inp[852] = 1073741808; +inp[853] = 0; +inp[854] = 1073741804; +inp[855] = 0; +inp[856] = 1073741800; +inp[857] = 0; +inp[858] = 1073741796; +inp[859] = 0; +inp[860] = 1073741824; +inp[861] = 1073741824; +inp[862] = 1073741822; +inp[863] = 0; +inp[864] = 1073741820; +inp[865] = 0; +inp[866] = 1073741818; +inp[867] = 0; +inp[868] = 1073741816; +inp[869] = 0; +inp[870] = 1073741814; +inp[871] = 0; +inp[872] = 1073741812; +inp[873] = 0; +inp[874] = 1073741810; +inp[875] = 0; +inp[876] = 1073741824; +inp[877] = 1073741824; +inp[878] = 1073741823; +inp[879] = 0; +inp[880] = 1073741822; +inp[881] = 0; +inp[882] = 1073741821; +inp[883] = 0; +inp[884] = 1073741820; +inp[885] = 0; +inp[886] = 1073741819; +inp[887] = 0; +inp[888] = 1073741818; +inp[889] = 0; +inp[890] = 1073741817; +inp[891] = 0; +inp[892] = 1073741824; +inp[893] = 1073741824; +inp[894] = 1073741823; +inp[895] = 0; +inp[896] = 1073741823; +inp[897] = 0; +inp[898] = 1073741822; +inp[899] = 0; +inp[900] = 1073741822; +inp[901] = 0; +inp[902] = 1073741821; +inp[903] = 0; +inp[904] = 1073741821; +inp[905] = 0; +inp[906] = 1073741820; +inp[907] = 0; +inp[908] = 1073741824; +inp[909] = 1073741824; +inp[910] = 1073741823; +inp[911] = 0; +inp[912] = 1073741823; +inp[913] = 0; +inp[914] = 1073741823; +inp[915] = 0; +inp[916] = 1073741823; +inp[917] = 0; +inp[918] = 1073741822; +inp[919] = 0; +inp[920] = 1073741822; +inp[921] = 0; +inp[922] = 1073741822; +inp[923] = 0; +inp[924] = 1073741824; +inp[925] = 1073741824; +inp[926] = 395007542; +inp[927] = 395007542; +inp[928] = 145315153; +inp[929] = 145315153; +inp[930] = 53458457; +inp[931] = 53458457; +inp[932] = 19666267; +inp[933] = 19666267; +inp[934] = 7234815; +inp[935] = 7234815; +inp[936] = 2661539; +inp[937] = 2661539; +inp[938] = 979125; +inp[939] = 979125; +inp[940] = 360200; +inp[941] = 360200; +inp[942] = 132510; +inp[943] = 132510; +inp[944] = 48747; +inp[945] = 48747; +inp[946] = 17933; +inp[947] = 17933; +inp[948] = 6597; +inp[949] = 6597; +inp[950] = 2427; +inp[951] = 2427; +inp[952] = 892; +inp[953] = 892; +inp[954] = 328; +inp[955] = 328; +inp[956] = 1073741824; +inp[957] = 1073741824; +inp[958] = 651257336; +inp[959] = 145315153; +inp[960] = 395007542; +inp[961] = 19666267; +inp[962] = 239584185; +inp[963] = 2661539; +inp[964] = 145315153; +inp[965] = 360200; +inp[966] = 88138096; +inp[967] = 48747; +inp[968] = 53458457; +inp[969] = 6597; +inp[970] = 32424193; +inp[971] = 892; +inp[972] = 19666267; +inp[973] = 120; +inp[974] = 11928194; +inp[975] = 16; +inp[976] = 7234815; +inp[977] = 2; +inp[978] = 4388137; +inp[979] = 0; +inp[980] = 2661539; +inp[981] = 0; +inp[982] = 1614305; +inp[983] = 0; +inp[984] = 979125; +inp[985] = 0; +inp[986] = 593869; +inp[987] = 0; +inp[988] = 1073741824; +inp[989] = 1073741824; +inp[990] = 836230973; +inp[991] = 19666267; +inp[992] = 651257336; +inp[993] = 360200; +inp[994] = 507199723; +inp[995] = 6597; +inp[996] = 395007542; +inp[997] = 120; +inp[998] = 307632183; +inp[999] = 2; +inp[1000] = 239584185; +inp[1001] = 0; +inp[1002] = 186588351; +inp[1003] = 0; +inp[1004] = 145315153; +inp[1005] = 0; +inp[1006] = 113171555; +inp[1007] = 0; +inp[1008] = 88138096; +inp[1009] = 0; +inp[1010] = 68642018; +inp[1011] = 0; +inp[1012] = 53458457; +inp[1013] = 0; +inp[1014] = 41633488; +inp[1015] = 0; +inp[1016] = 32424193; +inp[1017] = 0; +inp[1018] = 25251987; +inp[1019] = 0; +inp[1020] = 1073741824; +inp[1021] = 1073741824; +inp[1022] = 947573833; +inp[1023] = 360200; +inp[1024] = 836230973; +inp[1025] = 120; +inp[1026] = 737971243; +inp[1027] = 0; +inp[1028] = 651257336; +inp[1029] = 0; +inp[1030] = 574732582; +inp[1031] = 0; +inp[1032] = 507199723; +inp[1033] = 0; +inp[1034] = 447602185; +inp[1035] = 0; +inp[1036] = 395007542; +inp[1037] = 0; +inp[1038] = 348592932; +inp[1039] = 0; +inp[1040] = 307632183; +inp[1041] = 0; +inp[1042] = 271484448; +inp[1043] = 0; +inp[1044] = 239584185; +inp[1045] = 0; +inp[1046] = 211432301; +inp[1047] = 0; +inp[1048] = 186588351; +inp[1049] = 0; +inp[1050] = 164663641; +inp[1051] = 0; +inp[1052] = 1073741824; +inp[1053] = 1073741824; +inp[1054] = 1008687095; +inp[1055] = 120; +inp[1056] = 947573833; +inp[1057] = 0; +inp[1058] = 890163237; +inp[1059] = 0; +inp[1060] = 836230973; +inp[1061] = 0; +inp[1062] = 785566299; +inp[1063] = 0; +inp[1064] = 737971243; +inp[1065] = 0; +inp[1066] = 693259826; +inp[1067] = 0; +inp[1068] = 651257336; +inp[1069] = 0; +inp[1070] = 611799649; +inp[1071] = 0; +inp[1072] = 574732582; +inp[1073] = 0; +inp[1074] = 539911295; +inp[1075] = 0; +inp[1076] = 507199723; +inp[1077] = 0; +inp[1078] = 476470046; +inp[1079] = 0; +inp[1080] = 447602185; +inp[1081] = 0; +inp[1082] = 420483339; +inp[1083] = 0; +inp[1084] = 1073741824; +inp[1085] = 1073741824; +inp[1086] = 1040706261; +inp[1087] = 0; +inp[1088] = 1008687095; +inp[1089] = 0; +inp[1090] = 977653056; +inp[1091] = 0; +inp[1092] = 947573833; +inp[1093] = 0; +inp[1094] = 918420051; +inp[1095] = 0; +inp[1096] = 890163237; +inp[1097] = 0; +inp[1098] = 862775793; +inp[1099] = 0; +inp[1100] = 836230973; +inp[1101] = 0; +inp[1102] = 810502851; +inp[1103] = 0; +inp[1104] = 785566299; +inp[1105] = 0; +inp[1106] = 761396965; +inp[1107] = 0; +inp[1108] = 737971243; +inp[1109] = 0; +inp[1110] = 715266255; +inp[1111] = 0; +inp[1112] = 693259826; +inp[1113] = 0; +inp[1114] = 671930463; +inp[1115] = 0; +inp[1116] = 1073741824; +inp[1117] = 1073741824; +inp[1118] = 1057094999; +inp[1119] = 0; +inp[1120] = 1040706261; +inp[1121] = 0; +inp[1122] = 1024571605; +inp[1123] = 0; +inp[1124] = 1008687095; +inp[1125] = 0; +inp[1126] = 993048851; +inp[1127] = 0; +inp[1128] = 977653056; +inp[1129] = 0; +inp[1130] = 962495950; +inp[1131] = 0; +inp[1132] = 947573833; +inp[1133] = 0; +inp[1134] = 932883063; +inp[1135] = 0; +inp[1136] = 918420051; +inp[1137] = 0; +inp[1138] = 904181268; +inp[1139] = 0; +inp[1140] = 890163237; +inp[1141] = 0; +inp[1142] = 876362535; +inp[1143] = 0; +inp[1144] = 862775793; +inp[1145] = 0; +inp[1146] = 849399695; +inp[1147] = 0; +inp[1148] = 1073741824; +inp[1149] = 1073741824; +inp[1150] = 1065385898; +inp[1151] = 0; +inp[1152] = 1057094999; +inp[1153] = 0; +inp[1154] = 1048868621; +inp[1155] = 0; +inp[1156] = 1040706261; +inp[1157] = 0; +inp[1158] = 1032607420; +inp[1159] = 0; +inp[1160] = 1024571605; +inp[1161] = 0; +inp[1162] = 1016598326; +inp[1163] = 0; +inp[1164] = 1008687095; +inp[1165] = 0; +inp[1166] = 1000837430; +inp[1167] = 0; +inp[1168] = 993048851; +inp[1169] = 0; +inp[1170] = 985320884; +inp[1171] = 0; +inp[1172] = 977653056; +inp[1173] = 0; +inp[1174] = 970044899; +inp[1175] = 0; +inp[1176] = 962495950; +inp[1177] = 0; +inp[1178] = 955005747; +inp[1179] = 0; +inp[1180] = 1073741824; +inp[1181] = 1073741824; +inp[1182] = 1069555701; +inp[1183] = 0; +inp[1184] = 1065385898; +inp[1185] = 0; +inp[1186] = 1061232352; +inp[1187] = 0; +inp[1188] = 1057094999; +inp[1189] = 0; +inp[1190] = 1052973777; +inp[1191] = 0; +inp[1192] = 1048868621; +inp[1193] = 0; +inp[1194] = 1044779470; +inp[1195] = 0; +inp[1196] = 1040706261; +inp[1197] = 0; +inp[1198] = 1036648931; +inp[1199] = 0; +inp[1200] = 1032607420; +inp[1201] = 0; +inp[1202] = 1028581665; +inp[1203] = 0; +inp[1204] = 1024571605; +inp[1205] = 0; +inp[1206] = 1020577179; +inp[1207] = 0; +inp[1208] = 1016598326; +inp[1209] = 0; +inp[1210] = 1012634985; +inp[1211] = 0; +inp[1212] = 1073741824; +inp[1213] = 1073741824; +inp[1214] = 1071646718; +inp[1215] = 0; +inp[1216] = 1069555701; +inp[1217] = 0; +inp[1218] = 1067468764; +inp[1219] = 0; +inp[1220] = 1065385898; +inp[1221] = 0; +inp[1222] = 1063307097; +inp[1223] = 0; +inp[1224] = 1061232352; +inp[1225] = 0; +inp[1226] = 1059161656; +inp[1227] = 0; +inp[1228] = 1057094999; +inp[1229] = 0; +inp[1230] = 1055032376; +inp[1231] = 0; +inp[1232] = 1052973777; +inp[1233] = 0; +inp[1234] = 1050919194; +inp[1235] = 0; +inp[1236] = 1048868621; +inp[1237] = 0; +inp[1238] = 1046822049; +inp[1239] = 0; +inp[1240] = 1044779470; +inp[1241] = 0; +inp[1242] = 1042740876; +inp[1243] = 0; +inp[1244] = 1073741824; +inp[1245] = 1073741824; +inp[1246] = 1072693759; +inp[1247] = 0; +inp[1248] = 1071646718; +inp[1249] = 0; +inp[1250] = 1070600699; +inp[1251] = 0; +inp[1252] = 1069555701; +inp[1253] = 0; +inp[1254] = 1068511723; +inp[1255] = 0; +inp[1256] = 1067468764; +inp[1257] = 0; +inp[1258] = 1066426822; +inp[1259] = 0; +inp[1260] = 1065385898; +inp[1261] = 0; +inp[1262] = 1064345990; +inp[1263] = 0; +inp[1264] = 1063307097; +inp[1265] = 0; +inp[1266] = 1062269218; +inp[1267] = 0; +inp[1268] = 1061232352; +inp[1269] = 0; +inp[1270] = 1060196498; +inp[1271] = 0; +inp[1272] = 1059161656; +inp[1273] = 0; +inp[1274] = 1058127823; +inp[1275] = 0; +inp[1276] = 1073741824; +inp[1277] = 1073741824; +inp[1278] = 1073217663; +inp[1279] = 0; +inp[1280] = 1072693759; +inp[1281] = 0; +inp[1282] = 1072170111; +inp[1283] = 0; +inp[1284] = 1071646718; +inp[1285] = 0; +inp[1286] = 1071123581; +inp[1287] = 0; +inp[1288] = 1070600699; +inp[1289] = 0; +inp[1290] = 1070078072; +inp[1291] = 0; +inp[1292] = 1069555701; +inp[1293] = 0; +inp[1294] = 1069033584; +inp[1295] = 0; +inp[1296] = 1068511723; +inp[1297] = 0; +inp[1298] = 1067990116; +inp[1299] = 0; +inp[1300] = 1067468764; +inp[1301] = 0; +inp[1302] = 1066947666; +inp[1303] = 0; +inp[1304] = 1066426822; +inp[1305] = 0; +inp[1306] = 1065906233; +inp[1307] = 0; +inp[1308] = 1073741824; +inp[1309] = 1073741824; +inp[1310] = 1073479711; +inp[1311] = 0; +inp[1312] = 1073217663; +inp[1313] = 0; +inp[1314] = 1072955679; +inp[1315] = 0; +inp[1316] = 1072693759; +inp[1317] = 0; +inp[1318] = 1072431903; +inp[1319] = 0; +inp[1320] = 1072170111; +inp[1321] = 0; +inp[1322] = 1071908383; +inp[1323] = 0; +inp[1324] = 1071646718; +inp[1325] = 0; +inp[1326] = 1071385118; +inp[1327] = 0; +inp[1328] = 1071123581; +inp[1329] = 0; +inp[1330] = 1070862108; +inp[1331] = 0; +inp[1332] = 1070600699; +inp[1333] = 0; +inp[1334] = 1070339354; +inp[1335] = 0; +inp[1336] = 1070078072; +inp[1337] = 0; +inp[1338] = 1069816855; +inp[1339] = 0; +inp[1340] = 1073741824; +inp[1341] = 1073741824; +inp[1342] = 1073610759; +inp[1343] = 0; +inp[1344] = 1073479711; +inp[1345] = 0; +inp[1346] = 1073348679; +inp[1347] = 0; +inp[1348] = 1073217663; +inp[1349] = 0; +inp[1350] = 1073086663; +inp[1351] = 0; +inp[1352] = 1072955679; +inp[1353] = 0; +inp[1354] = 1072824711; +inp[1355] = 0; +inp[1356] = 1072693759; +inp[1357] = 0; +inp[1358] = 1072562823; +inp[1359] = 0; +inp[1360] = 1072431903; +inp[1361] = 0; +inp[1362] = 1072300999; +inp[1363] = 0; +inp[1364] = 1072170111; +inp[1365] = 0; +inp[1366] = 1072039239; +inp[1367] = 0; +inp[1368] = 1071908383; +inp[1369] = 0; +inp[1370] = 1071777542; +inp[1371] = 0; +inp[1372] = 1073741824; +inp[1373] = 1073741824; +inp[1374] = 1073676289; +inp[1375] = 0; +inp[1376] = 1073610759; +inp[1377] = 0; +inp[1378] = 1073545233; +inp[1379] = 0; +inp[1380] = 1073479711; +inp[1381] = 0; +inp[1382] = 1073414193; +inp[1383] = 0; +inp[1384] = 1073348679; +inp[1385] = 0; +inp[1386] = 1073283169; +inp[1387] = 0; +inp[1388] = 1073217663; +inp[1389] = 0; +inp[1390] = 1073152161; +inp[1391] = 0; +inp[1392] = 1073086663; +inp[1393] = 0; +inp[1394] = 1073021169; +inp[1395] = 0; +inp[1396] = 1072955679; +inp[1397] = 0; +inp[1398] = 1072890193; +inp[1399] = 0; +inp[1400] = 1072824711; +inp[1401] = 0; +inp[1402] = 1072759233; +inp[1403] = 0; +inp[1404] = 1073741824; +inp[1405] = 1073741824; +inp[1406] = 1073709056; +inp[1407] = 0; +inp[1408] = 1073676289; +inp[1409] = 0; +inp[1410] = 1073643524; +inp[1411] = 0; +inp[1412] = 1073610759; +inp[1413] = 0; +inp[1414] = 1073577996; +inp[1415] = 0; +inp[1416] = 1073545233; +inp[1417] = 0; +inp[1418] = 1073512472; +inp[1419] = 0; +inp[1420] = 1073479711; +inp[1421] = 0; +inp[1422] = 1073446952; +inp[1423] = 0; +inp[1424] = 1073414193; +inp[1425] = 0; +inp[1426] = 1073381436; +inp[1427] = 0; +inp[1428] = 1073348679; +inp[1429] = 0; +inp[1430] = 1073315924; +inp[1431] = 0; +inp[1432] = 1073283169; +inp[1433] = 0; +inp[1434] = 1073250416; +inp[1435] = 0; +inp[1436] = 1073741824; +inp[1437] = 1073741824; +inp[1438] = 1073725440; +inp[1439] = 0; +inp[1440] = 1073709056; +inp[1441] = 0; +inp[1442] = 1073692673; +inp[1443] = 0; +inp[1444] = 1073676289; +inp[1445] = 0; +inp[1446] = 1073659907; +inp[1447] = 0; +inp[1448] = 1073643524; +inp[1449] = 0; +inp[1450] = 1073627142; +inp[1451] = 0; +inp[1452] = 1073610759; +inp[1453] = 0; +inp[1454] = 1073594378; +inp[1455] = 0; +inp[1456] = 1073577996; +inp[1457] = 0; +inp[1458] = 1073561615; +inp[1459] = 0; +inp[1460] = 1073545233; +inp[1461] = 0; +inp[1462] = 1073528853; +inp[1463] = 0; +inp[1464] = 1073512472; +inp[1465] = 0; +inp[1466] = 1073496092; +inp[1467] = 0; +inp[1468] = 1073741824; +inp[1469] = 1073741824; +inp[1470] = 1073733632; +inp[1471] = 0; +inp[1472] = 1073725440; +inp[1473] = 0; +inp[1474] = 1073717248; +inp[1475] = 0; +inp[1476] = 1073709056; +inp[1477] = 0; +inp[1478] = 1073700864; +inp[1479] = 0; +inp[1480] = 1073692673; +inp[1481] = 0; +inp[1482] = 1073684481; +inp[1483] = 0; +inp[1484] = 1073676289; +inp[1485] = 0; +inp[1486] = 1073668098; +inp[1487] = 0; +inp[1488] = 1073659907; +inp[1489] = 0; +inp[1490] = 1073651715; +inp[1491] = 0; +inp[1492] = 1073643524; +inp[1493] = 0; +inp[1494] = 1073635333; +inp[1495] = 0; +inp[1496] = 1073627142; +inp[1497] = 0; +inp[1498] = 1073618951; +inp[1499] = 0; +inp[1500] = 1073741824; +inp[1501] = 1073741824; +inp[1502] = 1073737728; +inp[1503] = 0; +inp[1504] = 1073733632; +inp[1505] = 0; +inp[1506] = 1073729536; +inp[1507] = 0; +inp[1508] = 1073725440; +inp[1509] = 0; +inp[1510] = 1073721344; +inp[1511] = 0; +inp[1512] = 1073717248; +inp[1513] = 0; +inp[1514] = 1073713152; +inp[1515] = 0; +inp[1516] = 1073709056; +inp[1517] = 0; +inp[1518] = 1073704960; +inp[1519] = 0; +inp[1520] = 1073700864; +inp[1521] = 0; +inp[1522] = 1073696768; +inp[1523] = 0; +inp[1524] = 1073692673; +inp[1525] = 0; +inp[1526] = 1073688577; +inp[1527] = 0; +inp[1528] = 1073684481; +inp[1529] = 0; +inp[1530] = 1073680385; +inp[1531] = 0; +inp[1532] = 1073741824; +inp[1533] = 1073741824; +inp[1534] = 1073739776; +inp[1535] = 0; +inp[1536] = 1073737728; +inp[1537] = 0; +inp[1538] = 1073735680; +inp[1539] = 0; +inp[1540] = 1073733632; +inp[1541] = 0; +inp[1542] = 1073731584; +inp[1543] = 0; +inp[1544] = 1073729536; +inp[1545] = 0; +inp[1546] = 1073727488; +inp[1547] = 0; +inp[1548] = 1073725440; +inp[1549] = 0; +inp[1550] = 1073723392; +inp[1551] = 0; +inp[1552] = 1073721344; +inp[1553] = 0; +inp[1554] = 1073719296; +inp[1555] = 0; +inp[1556] = 1073717248; +inp[1557] = 0; +inp[1558] = 1073715200; +inp[1559] = 0; +inp[1560] = 1073713152; +inp[1561] = 0; +inp[1562] = 1073711104; +inp[1563] = 0; +inp[1564] = 1073741824; +inp[1565] = 1073741824; +inp[1566] = 1073740800; +inp[1567] = 0; +inp[1568] = 1073739776; +inp[1569] = 0; +inp[1570] = 1073738752; +inp[1571] = 0; +inp[1572] = 1073737728; +inp[1573] = 0; +inp[1574] = 1073736704; +inp[1575] = 0; +inp[1576] = 1073735680; +inp[1577] = 0; +inp[1578] = 1073734656; +inp[1579] = 0; +inp[1580] = 1073733632; +inp[1581] = 0; +inp[1582] = 1073732608; +inp[1583] = 0; +inp[1584] = 1073731584; +inp[1585] = 0; +inp[1586] = 1073730560; +inp[1587] = 0; +inp[1588] = 1073729536; +inp[1589] = 0; +inp[1590] = 1073728512; +inp[1591] = 0; +inp[1592] = 1073727488; +inp[1593] = 0; +inp[1594] = 1073726464; +inp[1595] = 0; +inp[1596] = 1073741824; +inp[1597] = 1073741824; +inp[1598] = 1073741312; +inp[1599] = 0; +inp[1600] = 1073740800; +inp[1601] = 0; +inp[1602] = 1073740288; +inp[1603] = 0; +inp[1604] = 1073739776; +inp[1605] = 0; +inp[1606] = 1073739264; +inp[1607] = 0; +inp[1608] = 1073738752; +inp[1609] = 0; +inp[1610] = 1073738240; +inp[1611] = 0; +inp[1612] = 1073737728; +inp[1613] = 0; +inp[1614] = 1073737216; +inp[1615] = 0; +inp[1616] = 1073736704; +inp[1617] = 0; +inp[1618] = 1073736192; +inp[1619] = 0; +inp[1620] = 1073735680; +inp[1621] = 0; +inp[1622] = 1073735168; +inp[1623] = 0; +inp[1624] = 1073734656; +inp[1625] = 0; +inp[1626] = 1073734144; +inp[1627] = 0; +inp[1628] = 1073741824; +inp[1629] = 1073741824; +inp[1630] = 1073741568; +inp[1631] = 0; +inp[1632] = 1073741312; +inp[1633] = 0; +inp[1634] = 1073741056; +inp[1635] = 0; +inp[1636] = 1073740800; +inp[1637] = 0; +inp[1638] = 1073740544; +inp[1639] = 0; +inp[1640] = 1073740288; +inp[1641] = 0; +inp[1642] = 1073740032; +inp[1643] = 0; +inp[1644] = 1073739776; +inp[1645] = 0; +inp[1646] = 1073739520; +inp[1647] = 0; +inp[1648] = 1073739264; +inp[1649] = 0; +inp[1650] = 1073739008; +inp[1651] = 0; +inp[1652] = 1073738752; +inp[1653] = 0; +inp[1654] = 1073738496; +inp[1655] = 0; +inp[1656] = 1073738240; +inp[1657] = 0; +inp[1658] = 1073737984; +inp[1659] = 0; +inp[1660] = 1073741824; +inp[1661] = 1073741824; +inp[1662] = 1073741696; +inp[1663] = 0; +inp[1664] = 1073741568; +inp[1665] = 0; +inp[1666] = 1073741440; +inp[1667] = 0; +inp[1668] = 1073741312; +inp[1669] = 0; +inp[1670] = 1073741184; +inp[1671] = 0; +inp[1672] = 1073741056; +inp[1673] = 0; +inp[1674] = 1073740928; +inp[1675] = 0; +inp[1676] = 1073740800; +inp[1677] = 0; +inp[1678] = 1073740672; +inp[1679] = 0; +inp[1680] = 1073740544; +inp[1681] = 0; +inp[1682] = 1073740416; +inp[1683] = 0; +inp[1684] = 1073740288; +inp[1685] = 0; +inp[1686] = 1073740160; +inp[1687] = 0; +inp[1688] = 1073740032; +inp[1689] = 0; +inp[1690] = 1073739904; +inp[1691] = 0; +inp[1692] = 1073741824; +inp[1693] = 1073741824; +inp[1694] = 1073741760; +inp[1695] = 0; +inp[1696] = 1073741696; +inp[1697] = 0; +inp[1698] = 1073741632; +inp[1699] = 0; +inp[1700] = 1073741568; +inp[1701] = 0; +inp[1702] = 1073741504; +inp[1703] = 0; +inp[1704] = 1073741440; +inp[1705] = 0; +inp[1706] = 1073741376; +inp[1707] = 0; +inp[1708] = 1073741312; +inp[1709] = 0; +inp[1710] = 1073741248; +inp[1711] = 0; +inp[1712] = 1073741184; +inp[1713] = 0; +inp[1714] = 1073741120; +inp[1715] = 0; +inp[1716] = 1073741056; +inp[1717] = 0; +inp[1718] = 1073740992; +inp[1719] = 0; +inp[1720] = 1073740928; +inp[1721] = 0; +inp[1722] = 1073740864; +inp[1723] = 0; +inp[1724] = 1073741824; +inp[1725] = 1073741824; +inp[1726] = 1073741792; +inp[1727] = 0; +inp[1728] = 1073741760; +inp[1729] = 0; +inp[1730] = 1073741728; +inp[1731] = 0; +inp[1732] = 1073741696; +inp[1733] = 0; +inp[1734] = 1073741664; +inp[1735] = 0; +inp[1736] = 1073741632; +inp[1737] = 0; +inp[1738] = 1073741600; +inp[1739] = 0; +inp[1740] = 1073741568; +inp[1741] = 0; +inp[1742] = 1073741536; +inp[1743] = 0; +inp[1744] = 1073741504; +inp[1745] = 0; +inp[1746] = 1073741472; +inp[1747] = 0; +inp[1748] = 1073741440; +inp[1749] = 0; +inp[1750] = 1073741408; +inp[1751] = 0; +inp[1752] = 1073741376; +inp[1753] = 0; +inp[1754] = 1073741344; +inp[1755] = 0; +inp[1756] = 1073741824; +inp[1757] = 1073741824; +inp[1758] = 1073741808; +inp[1759] = 0; +inp[1760] = 1073741792; +inp[1761] = 0; +inp[1762] = 1073741776; +inp[1763] = 0; +inp[1764] = 1073741760; +inp[1765] = 0; +inp[1766] = 1073741744; +inp[1767] = 0; +inp[1768] = 1073741728; +inp[1769] = 0; +inp[1770] = 1073741712; +inp[1771] = 0; +inp[1772] = 1073741696; +inp[1773] = 0; +inp[1774] = 1073741680; +inp[1775] = 0; +inp[1776] = 1073741664; +inp[1777] = 0; +inp[1778] = 1073741648; +inp[1779] = 0; +inp[1780] = 1073741632; +inp[1781] = 0; +inp[1782] = 1073741616; +inp[1783] = 0; +inp[1784] = 1073741600; +inp[1785] = 0; +inp[1786] = 1073741584; +inp[1787] = 0; +inp[1788] = 1073741824; +inp[1789] = 1073741824; +inp[1790] = 1073741816; +inp[1791] = 0; +inp[1792] = 1073741808; +inp[1793] = 0; +inp[1794] = 1073741800; +inp[1795] = 0; +inp[1796] = 1073741792; +inp[1797] = 0; +inp[1798] = 1073741784; +inp[1799] = 0; +inp[1800] = 1073741776; +inp[1801] = 0; +inp[1802] = 1073741768; +inp[1803] = 0; +inp[1804] = 1073741760; +inp[1805] = 0; +inp[1806] = 1073741752; +inp[1807] = 0; +inp[1808] = 1073741744; +inp[1809] = 0; +inp[1810] = 1073741736; +inp[1811] = 0; +inp[1812] = 1073741728; +inp[1813] = 0; +inp[1814] = 1073741720; +inp[1815] = 0; +inp[1816] = 1073741712; +inp[1817] = 0; +inp[1818] = 1073741704; +inp[1819] = 0; +inp[1820] = 1073741824; +inp[1821] = 1073741824; +inp[1822] = 1073741820; +inp[1823] = 0; +inp[1824] = 1073741816; +inp[1825] = 0; +inp[1826] = 1073741812; +inp[1827] = 0; +inp[1828] = 1073741808; +inp[1829] = 0; +inp[1830] = 1073741804; +inp[1831] = 0; +inp[1832] = 1073741800; +inp[1833] = 0; +inp[1834] = 1073741796; +inp[1835] = 0; +inp[1836] = 1073741792; +inp[1837] = 0; +inp[1838] = 1073741788; +inp[1839] = 0; +inp[1840] = 1073741784; +inp[1841] = 0; +inp[1842] = 1073741780; +inp[1843] = 0; +inp[1844] = 1073741776; +inp[1845] = 0; +inp[1846] = 1073741772; +inp[1847] = 0; +inp[1848] = 1073741768; +inp[1849] = 0; +inp[1850] = 1073741764; +inp[1851] = 0; +inp[1852] = 1073741824; +inp[1853] = 1073741824; +inp[1854] = 1073741822; +inp[1855] = 0; +inp[1856] = 1073741820; +inp[1857] = 0; +inp[1858] = 1073741818; +inp[1859] = 0; +inp[1860] = 1073741816; +inp[1861] = 0; +inp[1862] = 1073741814; +inp[1863] = 0; +inp[1864] = 1073741812; +inp[1865] = 0; +inp[1866] = 1073741810; +inp[1867] = 0; +inp[1868] = 1073741808; +inp[1869] = 0; +inp[1870] = 1073741806; +inp[1871] = 0; +inp[1872] = 1073741804; +inp[1873] = 0; +inp[1874] = 1073741802; +inp[1875] = 0; +inp[1876] = 1073741800; +inp[1877] = 0; +inp[1878] = 1073741798; +inp[1879] = 0; +inp[1880] = 1073741796; +inp[1881] = 0; +inp[1882] = 1073741794; +inp[1883] = 0; +inp[1884] = 1073741824; +inp[1885] = 1073741824; +inp[1886] = 1073741823; +inp[1887] = 0; +inp[1888] = 1073741822; +inp[1889] = 0; +inp[1890] = 1073741821; +inp[1891] = 0; +inp[1892] = 1073741820; +inp[1893] = 0; +inp[1894] = 1073741819; +inp[1895] = 0; +inp[1896] = 1073741818; +inp[1897] = 0; +inp[1898] = 1073741817; +inp[1899] = 0; +inp[1900] = 1073741816; +inp[1901] = 0; +inp[1902] = 1073741815; +inp[1903] = 0; +inp[1904] = 1073741814; +inp[1905] = 0; +inp[1906] = 1073741813; +inp[1907] = 0; +inp[1908] = 1073741812; +inp[1909] = 0; +inp[1910] = 1073741811; +inp[1911] = 0; +inp[1912] = 1073741810; +inp[1913] = 0; +inp[1914] = 1073741809; +inp[1915] = 0; +inp[1916] = 1073741824; +inp[1917] = 1073741824; +inp[1918] = 1073741823; +inp[1919] = 0; +inp[1920] = 1073741823; +inp[1921] = 0; +inp[1922] = 1073741822; +inp[1923] = 0; +inp[1924] = 1073741822; +inp[1925] = 0; +inp[1926] = 1073741821; +inp[1927] = 0; +inp[1928] = 1073741821; +inp[1929] = 0; +inp[1930] = 1073741820; +inp[1931] = 0; +inp[1932] = 1073741820; +inp[1933] = 0; +inp[1934] = 1073741819; +inp[1935] = 0; +inp[1936] = 1073741819; +inp[1937] = 0; +inp[1938] = 1073741818; +inp[1939] = 0; +inp[1940] = 1073741818; +inp[1941] = 0; +inp[1942] = 1073741817; +inp[1943] = 0; +inp[1944] = 1073741817; +inp[1945] = 0; +inp[1946] = 1073741816; +inp[1947] = 0; +inp[1948] = 1073741824; +inp[1949] = 1073741824; +inp[1950] = 1073741823; +inp[1951] = 0; +inp[1952] = 1073741823; +inp[1953] = 0; +inp[1954] = 1073741823; +inp[1955] = 0; +inp[1956] = 1073741823; +inp[1957] = 0; +inp[1958] = 1073741822; +inp[1959] = 0; +inp[1960] = 1073741822; +inp[1961] = 0; +inp[1962] = 1073741822; +inp[1963] = 0; +inp[1964] = 1073741822; +inp[1965] = 0; +inp[1966] = 1073741821; +inp[1967] = 0; +inp[1968] = 1073741821; +inp[1969] = 0; +inp[1970] = 1073741821; +inp[1971] = 0; +inp[1972] = 1073741821; +inp[1973] = 0; +inp[1974] = 1073741820; +inp[1975] = 0; +inp[1976] = 1073741820; +inp[1977] = 0; +inp[1978] = 1073741820; +inp[1979] = 0; +inp[1980] = 1073741824; +inp[1981] = 1073741824; +inp[1982] = 395007542; +inp[1983] = 395007542; +inp[1984] = 145315153; +inp[1985] = 145315153; +inp[1986] = 53458457; +inp[1987] = 53458457; +inp[1988] = 19666267; +inp[1989] = 19666267; +inp[1990] = 7234815; +inp[1991] = 7234815; +inp[1992] = 2661539; +inp[1993] = 2661539; +inp[1994] = 979125; +inp[1995] = 979125; +inp[1996] = 360200; +inp[1997] = 360200; +inp[1998] = 132510; +inp[1999] = 132510; +inp[2000] = 48747; +inp[2001] = 48747; +inp[2002] = 17933; +inp[2003] = 17933; +inp[2004] = 6597; +inp[2005] = 6597; +inp[2006] = 2427; +inp[2007] = 2427; +inp[2008] = 892; +inp[2009] = 892; +inp[2010] = 328; +inp[2011] = 328; +inp[2012] = 120; +inp[2013] = 120; +inp[2014] = 44; +inp[2015] = 44; +inp[2016] = 16; +inp[2017] = 16; +inp[2018] = 6; +inp[2019] = 6; +inp[2020] = 2; +inp[2021] = 2; +inp[2022] = 0; +inp[2023] = 0; +inp[2024] = 0; +inp[2025] = 0; +inp[2026] = 0; +inp[2027] = 0; +inp[2028] = 0; +inp[2029] = 0; +inp[2030] = 0; +inp[2031] = 0; +inp[2032] = 0; +inp[2033] = 0; +inp[2034] = 0; +inp[2035] = 0; +inp[2036] = 0; +inp[2037] = 0; +inp[2038] = 0; +inp[2039] = 0; +inp[2040] = 0; +inp[2041] = 0; +inp[2042] = 0; +inp[2043] = 0; +inp[2044] = 1073741824; +inp[2045] = 1073741824; +inp[2046] = 651257336; +inp[2047] = 145315153; +inp[2048] = 395007542; +inp[2049] = 19666267; +inp[2050] = 239584185; +inp[2051] = 2661539; +inp[2052] = 145315153; +inp[2053] = 360200; +inp[2054] = 88138096; +inp[2055] = 48747; +inp[2056] = 53458457; +inp[2057] = 6597; +inp[2058] = 32424193; +inp[2059] = 892; +inp[2060] = 19666267; +inp[2061] = 120; +inp[2062] = 11928194; +inp[2063] = 16; +inp[2064] = 7234815; +inp[2065] = 2; +inp[2066] = 4388137; +inp[2067] = 0; +inp[2068] = 2661539; +inp[2069] = 0; +inp[2070] = 1614305; +inp[2071] = 0; +inp[2072] = 979125; +inp[2073] = 0; +inp[2074] = 593869; +inp[2075] = 0; +inp[2076] = 360200; +inp[2077] = 0; +inp[2078] = 218472; +inp[2079] = 0; +inp[2080] = 132510; +inp[2081] = 0; +inp[2082] = 80371; +inp[2083] = 0; +inp[2084] = 48747; +inp[2085] = 0; +inp[2086] = 29567; +inp[2087] = 0; +inp[2088] = 17933; +inp[2089] = 0; +inp[2090] = 10877; +inp[2091] = 0; +inp[2092] = 6597; +inp[2093] = 0; +inp[2094] = 4001; +inp[2095] = 0; +inp[2096] = 2427; +inp[2097] = 0; +inp[2098] = 1472; +inp[2099] = 0; +inp[2100] = 892; +inp[2101] = 0; +inp[2102] = 541; +inp[2103] = 0; +inp[2104] = 328; +inp[2105] = 0; +inp[2106] = 199; +inp[2107] = 0; +inp[2108] = 1073741824; +inp[2109] = 1073741824; +inp[2110] = 836230973; +inp[2111] = 19666267; +inp[2112] = 651257336; +inp[2113] = 360200; +inp[2114] = 507199723; +inp[2115] = 6597; +inp[2116] = 395007542; +inp[2117] = 120; +inp[2118] = 307632183; +inp[2119] = 2; +inp[2120] = 239584185; +inp[2121] = 0; +inp[2122] = 186588351; +inp[2123] = 0; +inp[2124] = 145315153; +inp[2125] = 0; +inp[2126] = 113171555; +inp[2127] = 0; +inp[2128] = 88138096; +inp[2129] = 0; +inp[2130] = 68642018; +inp[2131] = 0; +inp[2132] = 53458457; +inp[2133] = 0; +inp[2134] = 41633488; +inp[2135] = 0; +inp[2136] = 32424193; +inp[2137] = 0; +inp[2138] = 25251987; +inp[2139] = 0; +inp[2140] = 19666267; +inp[2141] = 0; +inp[2142] = 15316104; +inp[2143] = 0; +inp[2144] = 11928194; +inp[2145] = 0; +inp[2146] = 9289686; +inp[2147] = 0; +inp[2148] = 7234815; +inp[2149] = 0; +inp[2150] = 5634479; +inp[2151] = 0; +inp[2152] = 4388137; +inp[2153] = 0; +inp[2154] = 3417484; +inp[2155] = 0; +inp[2156] = 2661539; +inp[2157] = 0; +inp[2158] = 2072809; +inp[2159] = 0; +inp[2160] = 1614305; +inp[2161] = 0; +inp[2162] = 1257222; +inp[2163] = 0; +inp[2164] = 979125; +inp[2165] = 0; +inp[2166] = 762543; +inp[2167] = 0; +inp[2168] = 593869; +inp[2169] = 0; +inp[2170] = 462506; +inp[2171] = 0; +inp[2172] = 1073741824; +inp[2173] = 1073741824; +inp[2174] = 947573833; +inp[2175] = 360200; +inp[2176] = 836230973; +inp[2177] = 120; +inp[2178] = 737971243; +inp[2179] = 0; +inp[2180] = 651257336; +inp[2181] = 0; +inp[2182] = 574732582; +inp[2183] = 0; +inp[2184] = 507199723; +inp[2185] = 0; +inp[2186] = 447602185; +inp[2187] = 0; +inp[2188] = 395007542; +inp[2189] = 0; +inp[2190] = 348592932; +inp[2191] = 0; +inp[2192] = 307632183; +inp[2193] = 0; +inp[2194] = 271484448; +inp[2195] = 0; +inp[2196] = 239584185; +inp[2197] = 0; +inp[2198] = 211432301; +inp[2199] = 0; +inp[2200] = 186588351; +inp[2201] = 0; +inp[2202] = 164663641; +inp[2203] = 0; +inp[2204] = 145315153; +inp[2205] = 0; +inp[2206] = 128240173; +inp[2207] = 0; +inp[2208] = 113171555; +inp[2209] = 0; +inp[2210] = 99873547; +inp[2211] = 0; +inp[2212] = 88138096; +inp[2213] = 0; +inp[2214] = 77781596; +inp[2215] = 0; +inp[2216] = 68642018; +inp[2217] = 0; +inp[2218] = 60576368; +inp[2219] = 0; +inp[2220] = 53458457; +inp[2221] = 0; +inp[2222] = 47176923; +inp[2223] = 0; +inp[2224] = 41633488; +inp[2225] = 0; +inp[2226] = 36741424; +inp[2227] = 0; +inp[2228] = 32424193; +inp[2229] = 0; +inp[2230] = 28614250; +inp[2231] = 0; +inp[2232] = 25251987; +inp[2233] = 0; +inp[2234] = 22284800; +inp[2235] = 0; +inp[2236] = 1073741824; +inp[2237] = 1073741824; +inp[2238] = 1008687095; +inp[2239] = 120; +inp[2240] = 947573833; +inp[2241] = 0; +inp[2242] = 890163237; +inp[2243] = 0; +inp[2244] = 836230973; +inp[2245] = 0; +inp[2246] = 785566299; +inp[2247] = 0; +inp[2248] = 737971243; +inp[2249] = 0; +inp[2250] = 693259826; +inp[2251] = 0; +inp[2252] = 651257336; +inp[2253] = 0; +inp[2254] = 611799649; +inp[2255] = 0; +inp[2256] = 574732582; +inp[2257] = 0; +inp[2258] = 539911295; +inp[2259] = 0; +inp[2260] = 507199723; +inp[2261] = 0; +inp[2262] = 476470046; +inp[2263] = 0; +inp[2264] = 447602185; +inp[2265] = 0; +inp[2266] = 420483339; +inp[2267] = 0; +inp[2268] = 395007542; +inp[2269] = 0; +inp[2270] = 371075245; +inp[2271] = 0; +inp[2272] = 348592932; +inp[2273] = 0; +inp[2274] = 327472754; +inp[2275] = 0; +inp[2276] = 307632183; +inp[2277] = 0; +inp[2278] = 288993691; +inp[2279] = 0; +inp[2280] = 271484448; +inp[2281] = 0; +inp[2282] = 255036037; +inp[2283] = 0; +inp[2284] = 239584185; +inp[2285] = 0; +inp[2286] = 225068513; +inp[2287] = 0; +inp[2288] = 211432301; +inp[2289] = 0; +inp[2290] = 198622265; +inp[2291] = 0; +inp[2292] = 186588351; +inp[2293] = 0; +inp[2294] = 175283534; +inp[2295] = 0; +inp[2296] = 164663641; +inp[2297] = 0; +inp[2298] = 154687176; +inp[2299] = 0; +inp[2300] = 1073741824; +inp[2301] = 1073741824; +inp[2302] = 1040706261; +inp[2303] = 0; +inp[2304] = 1008687095; +inp[2305] = 0; +inp[2306] = 977653056; +inp[2307] = 0; +inp[2308] = 947573833; +inp[2309] = 0; +inp[2310] = 918420051; +inp[2311] = 0; +inp[2312] = 890163237; +inp[2313] = 0; +inp[2314] = 862775793; +inp[2315] = 0; +inp[2316] = 836230973; +inp[2317] = 0; +inp[2318] = 810502851; +inp[2319] = 0; +inp[2320] = 785566299; +inp[2321] = 0; +inp[2322] = 761396965; +inp[2323] = 0; +inp[2324] = 737971243; +inp[2325] = 0; +inp[2326] = 715266255; +inp[2327] = 0; +inp[2328] = 693259826; +inp[2329] = 0; +inp[2330] = 671930463; +inp[2331] = 0; +inp[2332] = 651257336; +inp[2333] = 0; +inp[2334] = 631220255; +inp[2335] = 0; +inp[2336] = 611799649; +inp[2337] = 0; +inp[2338] = 592976553; +inp[2339] = 0; +inp[2340] = 574732582; +inp[2341] = 0; +inp[2342] = 557049919; +inp[2343] = 0; +inp[2344] = 539911295; +inp[2345] = 0; +inp[2346] = 523299971; +inp[2347] = 0; +inp[2348] = 507199723; +inp[2349] = 0; +inp[2350] = 491594828; +inp[2351] = 0; +inp[2352] = 476470046; +inp[2353] = 0; +inp[2354] = 461810603; +inp[2355] = 0; +inp[2356] = 447602185; +inp[2357] = 0; +inp[2358] = 433830913; +inp[2359] = 0; +inp[2360] = 420483339; +inp[2361] = 0; +inp[2362] = 407546427; +inp[2363] = 0; +inp[2364] = 1073741824; +inp[2365] = 1073741824; +inp[2366] = 1057094999; +inp[2367] = 0; +inp[2368] = 1040706261; +inp[2369] = 0; +inp[2370] = 1024571605; +inp[2371] = 0; +inp[2372] = 1008687095; +inp[2373] = 0; +inp[2374] = 993048851; +inp[2375] = 0; +inp[2376] = 977653056; +inp[2377] = 0; +inp[2378] = 962495950; +inp[2379] = 0; +inp[2380] = 947573833; +inp[2381] = 0; +inp[2382] = 932883063; +inp[2383] = 0; +inp[2384] = 918420051; +inp[2385] = 0; +inp[2386] = 904181268; +inp[2387] = 0; +inp[2388] = 890163237; +inp[2389] = 0; +inp[2390] = 876362535; +inp[2391] = 0; +inp[2392] = 862775793; +inp[2393] = 0; +inp[2394] = 849399695; +inp[2395] = 0; +inp[2396] = 836230973; +inp[2397] = 0; +inp[2398] = 823266413; +inp[2399] = 0; +inp[2400] = 810502851; +inp[2401] = 0; +inp[2402] = 797937169; +inp[2403] = 0; +inp[2404] = 785566299; +inp[2405] = 0; +inp[2406] = 773387223; +inp[2407] = 0; +inp[2408] = 761396965; +inp[2409] = 0; +inp[2410] = 749592599; +inp[2411] = 0; +inp[2412] = 737971243; +inp[2413] = 0; +inp[2414] = 726530060; +inp[2415] = 0; +inp[2416] = 715266255; +inp[2417] = 0; +inp[2418] = 704177080; +inp[2419] = 0; +inp[2420] = 693259826; +inp[2421] = 0; +inp[2422] = 682511829; +inp[2423] = 0; +inp[2424] = 671930463; +inp[2425] = 0; +inp[2426] = 661513147; +inp[2427] = 0; +inp[2428] = 1073741824; +inp[2429] = 1073741824; +inp[2430] = 1065385898; +inp[2431] = 0; +inp[2432] = 1057094999; +inp[2433] = 0; +inp[2434] = 1048868621; +inp[2435] = 0; +inp[2436] = 1040706261; +inp[2437] = 0; +inp[2438] = 1032607420; +inp[2439] = 0; +inp[2440] = 1024571605; +inp[2441] = 0; +inp[2442] = 1016598326; +inp[2443] = 0; +inp[2444] = 1008687095; +inp[2445] = 0; +inp[2446] = 1000837430; +inp[2447] = 0; +inp[2448] = 993048851; +inp[2449] = 0; +inp[2450] = 985320884; +inp[2451] = 0; +inp[2452] = 977653056; +inp[2453] = 0; +inp[2454] = 970044899; +inp[2455] = 0; +inp[2456] = 962495950; +inp[2457] = 0; +inp[2458] = 955005747; +inp[2459] = 0; +inp[2460] = 947573833; +inp[2461] = 0; +inp[2462] = 940199755; +inp[2463] = 0; +inp[2464] = 932883063; +inp[2465] = 0; +inp[2466] = 925623309; +inp[2467] = 0; +inp[2468] = 918420051; +inp[2469] = 0; +inp[2470] = 911272850; +inp[2471] = 0; +inp[2472] = 904181268; +inp[2473] = 0; +inp[2474] = 897144874; +inp[2475] = 0; +inp[2476] = 890163237; +inp[2477] = 0; +inp[2478] = 883235932; +inp[2479] = 0; +inp[2480] = 876362535; +inp[2481] = 0; +inp[2482] = 869542628; +inp[2483] = 0; +inp[2484] = 862775793; +inp[2485] = 0; +inp[2486] = 856061619; +inp[2487] = 0; +inp[2488] = 849399695; +inp[2489] = 0; +inp[2490] = 842789614; +inp[2491] = 0; +inp[2492] = 1073741824; +inp[2493] = 1073741824; +inp[2494] = 1069555701; +inp[2495] = 0; +inp[2496] = 1065385898; +inp[2497] = 0; +inp[2498] = 1061232352; +inp[2499] = 0; +inp[2500] = 1057094999; +inp[2501] = 0; +inp[2502] = 1052973777; +inp[2503] = 0; +inp[2504] = 1048868621; +inp[2505] = 0; +inp[2506] = 1044779470; +inp[2507] = 0; +inp[2508] = 1040706261; +inp[2509] = 0; +inp[2510] = 1036648931; +inp[2511] = 0; +inp[2512] = 1032607420; +inp[2513] = 0; +inp[2514] = 1028581665; +inp[2515] = 0; +inp[2516] = 1024571605; +inp[2517] = 0; +inp[2518] = 1020577179; +inp[2519] = 0; +inp[2520] = 1016598326; +inp[2521] = 0; +inp[2522] = 1012634985; +inp[2523] = 0; +inp[2524] = 1008687095; +inp[2525] = 0; +inp[2526] = 1004754597; +inp[2527] = 0; +inp[2528] = 1000837430; +inp[2529] = 0; +inp[2530] = 996935534; +inp[2531] = 0; +inp[2532] = 993048851; +inp[2533] = 0; +inp[2534] = 989177321; +inp[2535] = 0; +inp[2536] = 985320884; +inp[2537] = 0; +inp[2538] = 981479482; +inp[2539] = 0; +inp[2540] = 977653056; +inp[2541] = 0; +inp[2542] = 973841548; +inp[2543] = 0; +inp[2544] = 970044899; +inp[2545] = 0; +inp[2546] = 966263053; +inp[2547] = 0; +inp[2548] = 962495950; +inp[2549] = 0; +inp[2550] = 958743534; +inp[2551] = 0; +inp[2552] = 955005747; +inp[2553] = 0; +inp[2554] = 951282532; +inp[2555] = 0; +inp[2556] = 1073741824; +inp[2557] = 1073741824; +inp[2558] = 1071646718; +inp[2559] = 0; +inp[2560] = 1069555701; +inp[2561] = 0; +inp[2562] = 1067468764; +inp[2563] = 0; +inp[2564] = 1065385898; +inp[2565] = 0; +inp[2566] = 1063307097; +inp[2567] = 0; +inp[2568] = 1061232352; +inp[2569] = 0; +inp[2570] = 1059161656; +inp[2571] = 0; +inp[2572] = 1057094999; +inp[2573] = 0; +inp[2574] = 1055032376; +inp[2575] = 0; +inp[2576] = 1052973777; +inp[2577] = 0; +inp[2578] = 1050919194; +inp[2579] = 0; +inp[2580] = 1048868621; +inp[2581] = 0; +inp[2582] = 1046822049; +inp[2583] = 0; +inp[2584] = 1044779470; +inp[2585] = 0; +inp[2586] = 1042740876; +inp[2587] = 0; +inp[2588] = 1040706261; +inp[2589] = 0; +inp[2590] = 1038675615; +inp[2591] = 0; +inp[2592] = 1036648931; +inp[2593] = 0; +inp[2594] = 1034626202; +inp[2595] = 0; +inp[2596] = 1032607420; +inp[2597] = 0; +inp[2598] = 1030592577; +inp[2599] = 0; +inp[2600] = 1028581665; +inp[2601] = 0; +inp[2602] = 1026574677; +inp[2603] = 0; +inp[2604] = 1024571605; +inp[2605] = 0; +inp[2606] = 1022572442; +inp[2607] = 0; +inp[2608] = 1020577179; +inp[2609] = 0; +inp[2610] = 1018585810; +inp[2611] = 0; +inp[2612] = 1016598326; +inp[2613] = 0; +inp[2614] = 1014614720; +inp[2615] = 0; +inp[2616] = 1012634985; +inp[2617] = 0; +inp[2618] = 1010659112; +inp[2619] = 0; +inp[2620] = 1073741824; +inp[2621] = 1073741824; +inp[2622] = 1072693759; +inp[2623] = 0; +inp[2624] = 1071646718; +inp[2625] = 0; +inp[2626] = 1070600699; +inp[2627] = 0; +inp[2628] = 1069555701; +inp[2629] = 0; +inp[2630] = 1068511723; +inp[2631] = 0; +inp[2632] = 1067468764; +inp[2633] = 0; +inp[2634] = 1066426822; +inp[2635] = 0; +inp[2636] = 1065385898; +inp[2637] = 0; +inp[2638] = 1064345990; +inp[2639] = 0; +inp[2640] = 1063307097; +inp[2641] = 0; +inp[2642] = 1062269218; +inp[2643] = 0; +inp[2644] = 1061232352; +inp[2645] = 0; +inp[2646] = 1060196498; +inp[2647] = 0; +inp[2648] = 1059161656; +inp[2649] = 0; +inp[2650] = 1058127823; +inp[2651] = 0; +inp[2652] = 1057094999; +inp[2653] = 0; +inp[2654] = 1056063184; +inp[2655] = 0; +inp[2656] = 1055032376; +inp[2657] = 0; +inp[2658] = 1054002574; +inp[2659] = 0; +inp[2660] = 1052973777; +inp[2661] = 0; +inp[2662] = 1051945984; +inp[2663] = 0; +inp[2664] = 1050919194; +inp[2665] = 0; +inp[2666] = 1049893407; +inp[2667] = 0; +inp[2668] = 1048868621; +inp[2669] = 0; +inp[2670] = 1047844835; +inp[2671] = 0; +inp[2672] = 1046822049; +inp[2673] = 0; +inp[2674] = 1045800261; +inp[2675] = 0; +inp[2676] = 1044779470; +inp[2677] = 0; +inp[2678] = 1043759675; +inp[2679] = 0; +inp[2680] = 1042740876; +inp[2681] = 0; +inp[2682] = 1041723072; +inp[2683] = 0; +inp[2684] = 1073741824; +inp[2685] = 1073741824; +inp[2686] = 1073217663; +inp[2687] = 0; +inp[2688] = 1072693759; +inp[2689] = 0; +inp[2690] = 1072170111; +inp[2691] = 0; +inp[2692] = 1071646718; +inp[2693] = 0; +inp[2694] = 1071123581; +inp[2695] = 0; +inp[2696] = 1070600699; +inp[2697] = 0; +inp[2698] = 1070078072; +inp[2699] = 0; +inp[2700] = 1069555701; +inp[2701] = 0; +inp[2702] = 1069033584; +inp[2703] = 0; +inp[2704] = 1068511723; +inp[2705] = 0; +inp[2706] = 1067990116; +inp[2707] = 0; +inp[2708] = 1067468764; +inp[2709] = 0; +inp[2710] = 1066947666; +inp[2711] = 0; +inp[2712] = 1066426822; +inp[2713] = 0; +inp[2714] = 1065906233; +inp[2715] = 0; +inp[2716] = 1065385898; +inp[2717] = 0; +inp[2718] = 1064865817; +inp[2719] = 0; +inp[2720] = 1064345990; +inp[2721] = 0; +inp[2722] = 1063826417; +inp[2723] = 0; +inp[2724] = 1063307097; +inp[2725] = 0; +inp[2726] = 1062788031; +inp[2727] = 0; +inp[2728] = 1062269218; +inp[2729] = 0; +inp[2730] = 1061750659; +inp[2731] = 0; +inp[2732] = 1061232352; +inp[2733] = 0; +inp[2734] = 1060714299; +inp[2735] = 0; +inp[2736] = 1060196498; +inp[2737] = 0; +inp[2738] = 1059678951; +inp[2739] = 0; +inp[2740] = 1059161656; +inp[2741] = 0; +inp[2742] = 1058644613; +inp[2743] = 0; +inp[2744] = 1058127823; +inp[2745] = 0; +inp[2746] = 1057611285; +inp[2747] = 0; +inp[2748] = 1073741824; +inp[2749] = 1073741824; +inp[2750] = 1073479711; +inp[2751] = 0; +inp[2752] = 1073217663; +inp[2753] = 0; +inp[2754] = 1072955679; +inp[2755] = 0; +inp[2756] = 1072693759; +inp[2757] = 0; +inp[2758] = 1072431903; +inp[2759] = 0; +inp[2760] = 1072170111; +inp[2761] = 0; +inp[2762] = 1071908383; +inp[2763] = 0; +inp[2764] = 1071646718; +inp[2765] = 0; +inp[2766] = 1071385118; +inp[2767] = 0; +inp[2768] = 1071123581; +inp[2769] = 0; +inp[2770] = 1070862108; +inp[2771] = 0; +inp[2772] = 1070600699; +inp[2773] = 0; +inp[2774] = 1070339354; +inp[2775] = 0; +inp[2776] = 1070078072; +inp[2777] = 0; +inp[2778] = 1069816855; +inp[2779] = 0; +inp[2780] = 1069555701; +inp[2781] = 0; +inp[2782] = 1069294611; +inp[2783] = 0; +inp[2784] = 1069033584; +inp[2785] = 0; +inp[2786] = 1068772622; +inp[2787] = 0; +inp[2788] = 1068511723; +inp[2789] = 0; +inp[2790] = 1068250887; +inp[2791] = 0; +inp[2792] = 1067990116; +inp[2793] = 0; +inp[2794] = 1067729408; +inp[2795] = 0; +inp[2796] = 1067468764; +inp[2797] = 0; +inp[2798] = 1067208183; +inp[2799] = 0; +inp[2800] = 1066947666; +inp[2801] = 0; +inp[2802] = 1066687212; +inp[2803] = 0; +inp[2804] = 1066426822; +inp[2805] = 0; +inp[2806] = 1066166496; +inp[2807] = 0; +inp[2808] = 1065906233; +inp[2809] = 0; +inp[2810] = 1065646034; +inp[2811] = 0; +inp[2812] = 1073741824; +inp[2813] = 1073741824; +inp[2814] = 1073610759; +inp[2815] = 0; +inp[2816] = 1073479711; +inp[2817] = 0; +inp[2818] = 1073348679; +inp[2819] = 0; +inp[2820] = 1073217663; +inp[2821] = 0; +inp[2822] = 1073086663; +inp[2823] = 0; +inp[2824] = 1072955679; +inp[2825] = 0; +inp[2826] = 1072824711; +inp[2827] = 0; +inp[2828] = 1072693759; +inp[2829] = 0; +inp[2830] = 1072562823; +inp[2831] = 0; +inp[2832] = 1072431903; +inp[2833] = 0; +inp[2834] = 1072300999; +inp[2835] = 0; +inp[2836] = 1072170111; +inp[2837] = 0; +inp[2838] = 1072039239; +inp[2839] = 0; +inp[2840] = 1071908383; +inp[2841] = 0; +inp[2842] = 1071777542; +inp[2843] = 0; +inp[2844] = 1071646718; +inp[2845] = 0; +inp[2846] = 1071515910; +inp[2847] = 0; +inp[2848] = 1071385118; +inp[2849] = 0; +inp[2850] = 1071254341; +inp[2851] = 0; +inp[2852] = 1071123581; +inp[2853] = 0; +inp[2854] = 1070992836; +inp[2855] = 0; +inp[2856] = 1070862108; +inp[2857] = 0; +inp[2858] = 1070731396; +inp[2859] = 0; +inp[2860] = 1070600699; +inp[2861] = 0; +inp[2862] = 1070470018; +inp[2863] = 0; +inp[2864] = 1070339354; +inp[2865] = 0; +inp[2866] = 1070208705; +inp[2867] = 0; +inp[2868] = 1070078072; +inp[2869] = 0; +inp[2870] = 1069947456; +inp[2871] = 0; +inp[2872] = 1069816855; +inp[2873] = 0; +inp[2874] = 1069686270; +inp[2875] = 0; +inp[2876] = 1073741824; +inp[2877] = 1073741824; +inp[2878] = 1073676289; +inp[2879] = 0; +inp[2880] = 1073610759; +inp[2881] = 0; +inp[2882] = 1073545233; +inp[2883] = 0; +inp[2884] = 1073479711; +inp[2885] = 0; +inp[2886] = 1073414193; +inp[2887] = 0; +inp[2888] = 1073348679; +inp[2889] = 0; +inp[2890] = 1073283169; +inp[2891] = 0; +inp[2892] = 1073217663; +inp[2893] = 0; +inp[2894] = 1073152161; +inp[2895] = 0; +inp[2896] = 1073086663; +inp[2897] = 0; +inp[2898] = 1073021169; +inp[2899] = 0; +inp[2900] = 1072955679; +inp[2901] = 0; +inp[2902] = 1072890193; +inp[2903] = 0; +inp[2904] = 1072824711; +inp[2905] = 0; +inp[2906] = 1072759233; +inp[2907] = 0; +inp[2908] = 1072693759; +inp[2909] = 0; +inp[2910] = 1072628289; +inp[2911] = 0; +inp[2912] = 1072562823; +inp[2913] = 0; +inp[2914] = 1072497361; +inp[2915] = 0; +inp[2916] = 1072431903; +inp[2917] = 0; +inp[2918] = 1072366449; +inp[2919] = 0; +inp[2920] = 1072300999; +inp[2921] = 0; +inp[2922] = 1072235553; +inp[2923] = 0; +inp[2924] = 1072170111; +inp[2925] = 0; +inp[2926] = 1072104673; +inp[2927] = 0; +inp[2928] = 1072039239; +inp[2929] = 0; +inp[2930] = 1071973809; +inp[2931] = 0; +inp[2932] = 1071908383; +inp[2933] = 0; +inp[2934] = 1071842961; +inp[2935] = 0; +inp[2936] = 1071777542; +inp[2937] = 0; +inp[2938] = 1071712128; +inp[2939] = 0; +inp[2940] = 1073741824; +inp[2941] = 1073741824; +inp[2942] = 1073709056; +inp[2943] = 0; +inp[2944] = 1073676289; +inp[2945] = 0; +inp[2946] = 1073643524; +inp[2947] = 0; +inp[2948] = 1073610759; +inp[2949] = 0; +inp[2950] = 1073577996; +inp[2951] = 0; +inp[2952] = 1073545233; +inp[2953] = 0; +inp[2954] = 1073512472; +inp[2955] = 0; +inp[2956] = 1073479711; +inp[2957] = 0; +inp[2958] = 1073446952; +inp[2959] = 0; +inp[2960] = 1073414193; +inp[2961] = 0; +inp[2962] = 1073381436; +inp[2963] = 0; +inp[2964] = 1073348679; +inp[2965] = 0; +inp[2966] = 1073315924; +inp[2967] = 0; +inp[2968] = 1073283169; +inp[2969] = 0; +inp[2970] = 1073250416; +inp[2971] = 0; +inp[2972] = 1073217663; +inp[2973] = 0; +inp[2974] = 1073184912; +inp[2975] = 0; +inp[2976] = 1073152161; +inp[2977] = 0; +inp[2978] = 1073119412; +inp[2979] = 0; +inp[2980] = 1073086663; +inp[2981] = 0; +inp[2982] = 1073053916; +inp[2983] = 0; +inp[2984] = 1073021169; +inp[2985] = 0; +inp[2986] = 1072988424; +inp[2987] = 0; +inp[2988] = 1072955679; +inp[2989] = 0; +inp[2990] = 1072922936; +inp[2991] = 0; +inp[2992] = 1072890193; +inp[2993] = 0; +inp[2994] = 1072857452; +inp[2995] = 0; +inp[2996] = 1072824711; +inp[2997] = 0; +inp[2998] = 1072791972; +inp[2999] = 0; +inp[3000] = 1072759233; +inp[3001] = 0; +inp[3002] = 1072726496; +inp[3003] = 0; +inp[3004] = 1073741824; +inp[3005] = 1073741824; +inp[3006] = 1073725440; +inp[3007] = 0; +inp[3008] = 1073709056; +inp[3009] = 0; +inp[3010] = 1073692673; +inp[3011] = 0; +inp[3012] = 1073676289; +inp[3013] = 0; +inp[3014] = 1073659907; +inp[3015] = 0; +inp[3016] = 1073643524; +inp[3017] = 0; +inp[3018] = 1073627142; +inp[3019] = 0; +inp[3020] = 1073610759; +inp[3021] = 0; +inp[3022] = 1073594378; +inp[3023] = 0; +inp[3024] = 1073577996; +inp[3025] = 0; +inp[3026] = 1073561615; +inp[3027] = 0; +inp[3028] = 1073545233; +inp[3029] = 0; +inp[3030] = 1073528853; +inp[3031] = 0; +inp[3032] = 1073512472; +inp[3033] = 0; +inp[3034] = 1073496092; +inp[3035] = 0; +inp[3036] = 1073479711; +inp[3037] = 0; +inp[3038] = 1073463332; +inp[3039] = 0; +inp[3040] = 1073446952; +inp[3041] = 0; +inp[3042] = 1073430573; +inp[3043] = 0; +inp[3044] = 1073414193; +inp[3045] = 0; +inp[3046] = 1073397815; +inp[3047] = 0; +inp[3048] = 1073381436; +inp[3049] = 0; +inp[3050] = 1073365058; +inp[3051] = 0; +inp[3052] = 1073348679; +inp[3053] = 0; +inp[3054] = 1073332302; +inp[3055] = 0; +inp[3056] = 1073315924; +inp[3057] = 0; +inp[3058] = 1073299547; +inp[3059] = 0; +inp[3060] = 1073283169; +inp[3061] = 0; +inp[3062] = 1073266793; +inp[3063] = 0; +inp[3064] = 1073250416; +inp[3065] = 0; +inp[3066] = 1073234040; +inp[3067] = 0; +inp[3068] = 1073741824; +inp[3069] = 1073741824; +inp[3070] = 1073733632; +inp[3071] = 0; +inp[3072] = 1073725440; +inp[3073] = 0; +inp[3074] = 1073717248; +inp[3075] = 0; +inp[3076] = 1073709056; +inp[3077] = 0; +inp[3078] = 1073700864; +inp[3079] = 0; +inp[3080] = 1073692673; +inp[3081] = 0; +inp[3082] = 1073684481; +inp[3083] = 0; +inp[3084] = 1073676289; +inp[3085] = 0; +inp[3086] = 1073668098; +inp[3087] = 0; +inp[3088] = 1073659907; +inp[3089] = 0; +inp[3090] = 1073651715; +inp[3091] = 0; +inp[3092] = 1073643524; +inp[3093] = 0; +inp[3094] = 1073635333; +inp[3095] = 0; +inp[3096] = 1073627142; +inp[3097] = 0; +inp[3098] = 1073618951; +inp[3099] = 0; +inp[3100] = 1073610759; +inp[3101] = 0; +inp[3102] = 1073602569; +inp[3103] = 0; +inp[3104] = 1073594378; +inp[3105] = 0; +inp[3106] = 1073586187; +inp[3107] = 0; +inp[3108] = 1073577996; +inp[3109] = 0; +inp[3110] = 1073569805; +inp[3111] = 0; +inp[3112] = 1073561615; +inp[3113] = 0; +inp[3114] = 1073553424; +inp[3115] = 0; +inp[3116] = 1073545233; +inp[3117] = 0; +inp[3118] = 1073537043; +inp[3119] = 0; +inp[3120] = 1073528853; +inp[3121] = 0; +inp[3122] = 1073520662; +inp[3123] = 0; +inp[3124] = 1073512472; +inp[3125] = 0; +inp[3126] = 1073504282; +inp[3127] = 0; +inp[3128] = 1073496092; +inp[3129] = 0; +inp[3130] = 1073487902; +inp[3131] = 0; +inp[3132] = 1073741824; +inp[3133] = 1073741824; +inp[3134] = 1073737728; +inp[3135] = 0; +inp[3136] = 1073733632; +inp[3137] = 0; +inp[3138] = 1073729536; +inp[3139] = 0; +inp[3140] = 1073725440; +inp[3141] = 0; +inp[3142] = 1073721344; +inp[3143] = 0; +inp[3144] = 1073717248; +inp[3145] = 0; +inp[3146] = 1073713152; +inp[3147] = 0; +inp[3148] = 1073709056; +inp[3149] = 0; +inp[3150] = 1073704960; +inp[3151] = 0; +inp[3152] = 1073700864; +inp[3153] = 0; +inp[3154] = 1073696768; +inp[3155] = 0; +inp[3156] = 1073692673; +inp[3157] = 0; +inp[3158] = 1073688577; +inp[3159] = 0; +inp[3160] = 1073684481; +inp[3161] = 0; +inp[3162] = 1073680385; +inp[3163] = 0; +inp[3164] = 1073676289; +inp[3165] = 0; +inp[3166] = 1073672194; +inp[3167] = 0; +inp[3168] = 1073668098; +inp[3169] = 0; +inp[3170] = 1073664002; +inp[3171] = 0; +inp[3172] = 1073659907; +inp[3173] = 0; +inp[3174] = 1073655811; +inp[3175] = 0; +inp[3176] = 1073651715; +inp[3177] = 0; +inp[3178] = 1073647620; +inp[3179] = 0; +inp[3180] = 1073643524; +inp[3181] = 0; +inp[3182] = 1073639428; +inp[3183] = 0; +inp[3184] = 1073635333; +inp[3185] = 0; +inp[3186] = 1073631237; +inp[3187] = 0; +inp[3188] = 1073627142; +inp[3189] = 0; +inp[3190] = 1073623046; +inp[3191] = 0; +inp[3192] = 1073618951; +inp[3193] = 0; +inp[3194] = 1073614855; +inp[3195] = 0; +inp[3196] = 1073741824; +inp[3197] = 1073741824; +inp[3198] = 1073739776; +inp[3199] = 0; +inp[3200] = 1073737728; +inp[3201] = 0; +inp[3202] = 1073735680; +inp[3203] = 0; +inp[3204] = 1073733632; +inp[3205] = 0; +inp[3206] = 1073731584; +inp[3207] = 0; +inp[3208] = 1073729536; +inp[3209] = 0; +inp[3210] = 1073727488; +inp[3211] = 0; +inp[3212] = 1073725440; +inp[3213] = 0; +inp[3214] = 1073723392; +inp[3215] = 0; +inp[3216] = 1073721344; +inp[3217] = 0; +inp[3218] = 1073719296; +inp[3219] = 0; +inp[3220] = 1073717248; +inp[3221] = 0; +inp[3222] = 1073715200; +inp[3223] = 0; +inp[3224] = 1073713152; +inp[3225] = 0; +inp[3226] = 1073711104; +inp[3227] = 0; +inp[3228] = 1073709056; +inp[3229] = 0; +inp[3230] = 1073707008; +inp[3231] = 0; +inp[3232] = 1073704960; +inp[3233] = 0; +inp[3234] = 1073702912; +inp[3235] = 0; +inp[3236] = 1073700864; +inp[3237] = 0; +inp[3238] = 1073698816; +inp[3239] = 0; +inp[3240] = 1073696768; +inp[3241] = 0; +inp[3242] = 1073694721; +inp[3243] = 0; +inp[3244] = 1073692673; +inp[3245] = 0; +inp[3246] = 1073690625; +inp[3247] = 0; +inp[3248] = 1073688577; +inp[3249] = 0; +inp[3250] = 1073686529; +inp[3251] = 0; +inp[3252] = 1073684481; +inp[3253] = 0; +inp[3254] = 1073682433; +inp[3255] = 0; +inp[3256] = 1073680385; +inp[3257] = 0; +inp[3258] = 1073678337; +inp[3259] = 0; +inp[3260] = 1073741824; +inp[3261] = 1073741824; +inp[3262] = 1073740800; +inp[3263] = 0; +inp[3264] = 1073739776; +inp[3265] = 0; +inp[3266] = 1073738752; +inp[3267] = 0; +inp[3268] = 1073737728; +inp[3269] = 0; +inp[3270] = 1073736704; +inp[3271] = 0; +inp[3272] = 1073735680; +inp[3273] = 0; +inp[3274] = 1073734656; +inp[3275] = 0; +inp[3276] = 1073733632; +inp[3277] = 0; +inp[3278] = 1073732608; +inp[3279] = 0; +inp[3280] = 1073731584; +inp[3281] = 0; +inp[3282] = 1073730560; +inp[3283] = 0; +inp[3284] = 1073729536; +inp[3285] = 0; +inp[3286] = 1073728512; +inp[3287] = 0; +inp[3288] = 1073727488; +inp[3289] = 0; +inp[3290] = 1073726464; +inp[3291] = 0; +inp[3292] = 1073725440; +inp[3293] = 0; +inp[3294] = 1073724416; +inp[3295] = 0; +inp[3296] = 1073723392; +inp[3297] = 0; +inp[3298] = 1073722368; +inp[3299] = 0; +inp[3300] = 1073721344; +inp[3301] = 0; +inp[3302] = 1073720320; +inp[3303] = 0; +inp[3304] = 1073719296; +inp[3305] = 0; +inp[3306] = 1073718272; +inp[3307] = 0; +inp[3308] = 1073717248; +inp[3309] = 0; +inp[3310] = 1073716224; +inp[3311] = 0; +inp[3312] = 1073715200; +inp[3313] = 0; +inp[3314] = 1073714176; +inp[3315] = 0; +inp[3316] = 1073713152; +inp[3317] = 0; +inp[3318] = 1073712128; +inp[3319] = 0; +inp[3320] = 1073711104; +inp[3321] = 0; +inp[3322] = 1073710080; +inp[3323] = 0; +inp[3324] = 1073741824; +inp[3325] = 1073741824; +inp[3326] = 1073741312; +inp[3327] = 0; +inp[3328] = 1073740800; +inp[3329] = 0; +inp[3330] = 1073740288; +inp[3331] = 0; +inp[3332] = 1073739776; +inp[3333] = 0; +inp[3334] = 1073739264; +inp[3335] = 0; +inp[3336] = 1073738752; +inp[3337] = 0; +inp[3338] = 1073738240; +inp[3339] = 0; +inp[3340] = 1073737728; +inp[3341] = 0; +inp[3342] = 1073737216; +inp[3343] = 0; +inp[3344] = 1073736704; +inp[3345] = 0; +inp[3346] = 1073736192; +inp[3347] = 0; +inp[3348] = 1073735680; +inp[3349] = 0; +inp[3350] = 1073735168; +inp[3351] = 0; +inp[3352] = 1073734656; +inp[3353] = 0; +inp[3354] = 1073734144; +inp[3355] = 0; +inp[3356] = 1073733632; +inp[3357] = 0; +inp[3358] = 1073733120; +inp[3359] = 0; +inp[3360] = 1073732608; +inp[3361] = 0; +inp[3362] = 1073732096; +inp[3363] = 0; +inp[3364] = 1073731584; +inp[3365] = 0; +inp[3366] = 1073731072; +inp[3367] = 0; +inp[3368] = 1073730560; +inp[3369] = 0; +inp[3370] = 1073730048; +inp[3371] = 0; +inp[3372] = 1073729536; +inp[3373] = 0; +inp[3374] = 1073729024; +inp[3375] = 0; +inp[3376] = 1073728512; +inp[3377] = 0; +inp[3378] = 1073728000; +inp[3379] = 0; +inp[3380] = 1073727488; +inp[3381] = 0; +inp[3382] = 1073726976; +inp[3383] = 0; +inp[3384] = 1073726464; +inp[3385] = 0; +inp[3386] = 1073725952; +inp[3387] = 0; +inp[3388] = 1073741824; +inp[3389] = 1073741824; +inp[3390] = 1073741568; +inp[3391] = 0; +inp[3392] = 1073741312; +inp[3393] = 0; +inp[3394] = 1073741056; +inp[3395] = 0; +inp[3396] = 1073740800; +inp[3397] = 0; +inp[3398] = 1073740544; +inp[3399] = 0; +inp[3400] = 1073740288; +inp[3401] = 0; +inp[3402] = 1073740032; +inp[3403] = 0; +inp[3404] = 1073739776; +inp[3405] = 0; +inp[3406] = 1073739520; +inp[3407] = 0; +inp[3408] = 1073739264; +inp[3409] = 0; +inp[3410] = 1073739008; +inp[3411] = 0; +inp[3412] = 1073738752; +inp[3413] = 0; +inp[3414] = 1073738496; +inp[3415] = 0; +inp[3416] = 1073738240; +inp[3417] = 0; +inp[3418] = 1073737984; +inp[3419] = 0; +inp[3420] = 1073737728; +inp[3421] = 0; +inp[3422] = 1073737472; +inp[3423] = 0; +inp[3424] = 1073737216; +inp[3425] = 0; +inp[3426] = 1073736960; +inp[3427] = 0; +inp[3428] = 1073736704; +inp[3429] = 0; +inp[3430] = 1073736448; +inp[3431] = 0; +inp[3432] = 1073736192; +inp[3433] = 0; +inp[3434] = 1073735936; +inp[3435] = 0; +inp[3436] = 1073735680; +inp[3437] = 0; +inp[3438] = 1073735424; +inp[3439] = 0; +inp[3440] = 1073735168; +inp[3441] = 0; +inp[3442] = 1073734912; +inp[3443] = 0; +inp[3444] = 1073734656; +inp[3445] = 0; +inp[3446] = 1073734400; +inp[3447] = 0; +inp[3448] = 1073734144; +inp[3449] = 0; +inp[3450] = 1073733888; +inp[3451] = 0; +inp[3452] = 1073741824; +inp[3453] = 1073741824; +inp[3454] = 1073741696; +inp[3455] = 0; +inp[3456] = 1073741568; +inp[3457] = 0; +inp[3458] = 1073741440; +inp[3459] = 0; +inp[3460] = 1073741312; +inp[3461] = 0; +inp[3462] = 1073741184; +inp[3463] = 0; +inp[3464] = 1073741056; +inp[3465] = 0; +inp[3466] = 1073740928; +inp[3467] = 0; +inp[3468] = 1073740800; +inp[3469] = 0; +inp[3470] = 1073740672; +inp[3471] = 0; +inp[3472] = 1073740544; +inp[3473] = 0; +inp[3474] = 1073740416; +inp[3475] = 0; +inp[3476] = 1073740288; +inp[3477] = 0; +inp[3478] = 1073740160; +inp[3479] = 0; +inp[3480] = 1073740032; +inp[3481] = 0; +inp[3482] = 1073739904; +inp[3483] = 0; +inp[3484] = 1073739776; +inp[3485] = 0; +inp[3486] = 1073739648; +inp[3487] = 0; +inp[3488] = 1073739520; +inp[3489] = 0; +inp[3490] = 1073739392; +inp[3491] = 0; +inp[3492] = 1073739264; +inp[3493] = 0; +inp[3494] = 1073739136; +inp[3495] = 0; +inp[3496] = 1073739008; +inp[3497] = 0; +inp[3498] = 1073738880; +inp[3499] = 0; +inp[3500] = 1073738752; +inp[3501] = 0; +inp[3502] = 1073738624; +inp[3503] = 0; +inp[3504] = 1073738496; +inp[3505] = 0; +inp[3506] = 1073738368; +inp[3507] = 0; +inp[3508] = 1073738240; +inp[3509] = 0; +inp[3510] = 1073738112; +inp[3511] = 0; +inp[3512] = 1073737984; +inp[3513] = 0; +inp[3514] = 1073737856; +inp[3515] = 0; +inp[3516] = 1073741824; +inp[3517] = 1073741824; +inp[3518] = 1073741760; +inp[3519] = 0; +inp[3520] = 1073741696; +inp[3521] = 0; +inp[3522] = 1073741632; +inp[3523] = 0; +inp[3524] = 1073741568; +inp[3525] = 0; +inp[3526] = 1073741504; +inp[3527] = 0; +inp[3528] = 1073741440; +inp[3529] = 0; +inp[3530] = 1073741376; +inp[3531] = 0; +inp[3532] = 1073741312; +inp[3533] = 0; +inp[3534] = 1073741248; +inp[3535] = 0; +inp[3536] = 1073741184; +inp[3537] = 0; +inp[3538] = 1073741120; +inp[3539] = 0; +inp[3540] = 1073741056; +inp[3541] = 0; +inp[3542] = 1073740992; +inp[3543] = 0; +inp[3544] = 1073740928; +inp[3545] = 0; +inp[3546] = 1073740864; +inp[3547] = 0; +inp[3548] = 1073740800; +inp[3549] = 0; +inp[3550] = 1073740736; +inp[3551] = 0; +inp[3552] = 1073740672; +inp[3553] = 0; +inp[3554] = 1073740608; +inp[3555] = 0; +inp[3556] = 1073740544; +inp[3557] = 0; +inp[3558] = 1073740480; +inp[3559] = 0; +inp[3560] = 1073740416; +inp[3561] = 0; +inp[3562] = 1073740352; +inp[3563] = 0; +inp[3564] = 1073740288; +inp[3565] = 0; +inp[3566] = 1073740224; +inp[3567] = 0; +inp[3568] = 1073740160; +inp[3569] = 0; +inp[3570] = 1073740096; +inp[3571] = 0; +inp[3572] = 1073740032; +inp[3573] = 0; +inp[3574] = 1073739968; +inp[3575] = 0; +inp[3576] = 1073739904; +inp[3577] = 0; +inp[3578] = 1073739840; +inp[3579] = 0; +inp[3580] = 1073741824; +inp[3581] = 1073741824; +inp[3582] = 1073741792; +inp[3583] = 0; +inp[3584] = 1073741760; +inp[3585] = 0; +inp[3586] = 1073741728; +inp[3587] = 0; +inp[3588] = 1073741696; +inp[3589] = 0; +inp[3590] = 1073741664; +inp[3591] = 0; +inp[3592] = 1073741632; +inp[3593] = 0; +inp[3594] = 1073741600; +inp[3595] = 0; +inp[3596] = 1073741568; +inp[3597] = 0; +inp[3598] = 1073741536; +inp[3599] = 0; +inp[3600] = 1073741504; +inp[3601] = 0; +inp[3602] = 1073741472; +inp[3603] = 0; +inp[3604] = 1073741440; +inp[3605] = 0; +inp[3606] = 1073741408; +inp[3607] = 0; +inp[3608] = 1073741376; +inp[3609] = 0; +inp[3610] = 1073741344; +inp[3611] = 0; +inp[3612] = 1073741312; +inp[3613] = 0; +inp[3614] = 1073741280; +inp[3615] = 0; +inp[3616] = 1073741248; +inp[3617] = 0; +inp[3618] = 1073741216; +inp[3619] = 0; +inp[3620] = 1073741184; +inp[3621] = 0; +inp[3622] = 1073741152; +inp[3623] = 0; +inp[3624] = 1073741120; +inp[3625] = 0; +inp[3626] = 1073741088; +inp[3627] = 0; +inp[3628] = 1073741056; +inp[3629] = 0; +inp[3630] = 1073741024; +inp[3631] = 0; +inp[3632] = 1073740992; +inp[3633] = 0; +inp[3634] = 1073740960; +inp[3635] = 0; +inp[3636] = 1073740928; +inp[3637] = 0; +inp[3638] = 1073740896; +inp[3639] = 0; +inp[3640] = 1073740864; +inp[3641] = 0; +inp[3642] = 1073740832; +inp[3643] = 0; +inp[3644] = 1073741824; +inp[3645] = 1073741824; +inp[3646] = 1073741808; +inp[3647] = 0; +inp[3648] = 1073741792; +inp[3649] = 0; +inp[3650] = 1073741776; +inp[3651] = 0; +inp[3652] = 1073741760; +inp[3653] = 0; +inp[3654] = 1073741744; +inp[3655] = 0; +inp[3656] = 1073741728; +inp[3657] = 0; +inp[3658] = 1073741712; +inp[3659] = 0; +inp[3660] = 1073741696; +inp[3661] = 0; +inp[3662] = 1073741680; +inp[3663] = 0; +inp[3664] = 1073741664; +inp[3665] = 0; +inp[3666] = 1073741648; +inp[3667] = 0; +inp[3668] = 1073741632; +inp[3669] = 0; +inp[3670] = 1073741616; +inp[3671] = 0; +inp[3672] = 1073741600; +inp[3673] = 0; +inp[3674] = 1073741584; +inp[3675] = 0; +inp[3676] = 1073741568; +inp[3677] = 0; +inp[3678] = 1073741552; +inp[3679] = 0; +inp[3680] = 1073741536; +inp[3681] = 0; +inp[3682] = 1073741520; +inp[3683] = 0; +inp[3684] = 1073741504; +inp[3685] = 0; +inp[3686] = 1073741488; +inp[3687] = 0; +inp[3688] = 1073741472; +inp[3689] = 0; +inp[3690] = 1073741456; +inp[3691] = 0; +inp[3692] = 1073741440; +inp[3693] = 0; +inp[3694] = 1073741424; +inp[3695] = 0; +inp[3696] = 1073741408; +inp[3697] = 0; +inp[3698] = 1073741392; +inp[3699] = 0; +inp[3700] = 1073741376; +inp[3701] = 0; +inp[3702] = 1073741360; +inp[3703] = 0; +inp[3704] = 1073741344; +inp[3705] = 0; +inp[3706] = 1073741328; +inp[3707] = 0; +inp[3708] = 1073741824; +inp[3709] = 1073741824; +inp[3710] = 1073741816; +inp[3711] = 0; +inp[3712] = 1073741808; +inp[3713] = 0; +inp[3714] = 1073741800; +inp[3715] = 0; +inp[3716] = 1073741792; +inp[3717] = 0; +inp[3718] = 1073741784; +inp[3719] = 0; +inp[3720] = 1073741776; +inp[3721] = 0; +inp[3722] = 1073741768; +inp[3723] = 0; +inp[3724] = 1073741760; +inp[3725] = 0; +inp[3726] = 1073741752; +inp[3727] = 0; +inp[3728] = 1073741744; +inp[3729] = 0; +inp[3730] = 1073741736; +inp[3731] = 0; +inp[3732] = 1073741728; +inp[3733] = 0; +inp[3734] = 1073741720; +inp[3735] = 0; +inp[3736] = 1073741712; +inp[3737] = 0; +inp[3738] = 1073741704; +inp[3739] = 0; +inp[3740] = 1073741696; +inp[3741] = 0; +inp[3742] = 1073741688; +inp[3743] = 0; +inp[3744] = 1073741680; +inp[3745] = 0; +inp[3746] = 1073741672; +inp[3747] = 0; +inp[3748] = 1073741664; +inp[3749] = 0; +inp[3750] = 1073741656; +inp[3751] = 0; +inp[3752] = 1073741648; +inp[3753] = 0; +inp[3754] = 1073741640; +inp[3755] = 0; +inp[3756] = 1073741632; +inp[3757] = 0; +inp[3758] = 1073741624; +inp[3759] = 0; +inp[3760] = 1073741616; +inp[3761] = 0; +inp[3762] = 1073741608; +inp[3763] = 0; +inp[3764] = 1073741600; +inp[3765] = 0; +inp[3766] = 1073741592; +inp[3767] = 0; +inp[3768] = 1073741584; +inp[3769] = 0; +inp[3770] = 1073741576; +inp[3771] = 0; +inp[3772] = 1073741824; +inp[3773] = 1073741824; +inp[3774] = 1073741820; +inp[3775] = 0; +inp[3776] = 1073741816; +inp[3777] = 0; +inp[3778] = 1073741812; +inp[3779] = 0; +inp[3780] = 1073741808; +inp[3781] = 0; +inp[3782] = 1073741804; +inp[3783] = 0; +inp[3784] = 1073741800; +inp[3785] = 0; +inp[3786] = 1073741796; +inp[3787] = 0; +inp[3788] = 1073741792; +inp[3789] = 0; +inp[3790] = 1073741788; +inp[3791] = 0; +inp[3792] = 1073741784; +inp[3793] = 0; +inp[3794] = 1073741780; +inp[3795] = 0; +inp[3796] = 1073741776; +inp[3797] = 0; +inp[3798] = 1073741772; +inp[3799] = 0; +inp[3800] = 1073741768; +inp[3801] = 0; +inp[3802] = 1073741764; +inp[3803] = 0; +inp[3804] = 1073741760; +inp[3805] = 0; +inp[3806] = 1073741756; +inp[3807] = 0; +inp[3808] = 1073741752; +inp[3809] = 0; +inp[3810] = 1073741748; +inp[3811] = 0; +inp[3812] = 1073741744; +inp[3813] = 0; +inp[3814] = 1073741740; +inp[3815] = 0; +inp[3816] = 1073741736; +inp[3817] = 0; +inp[3818] = 1073741732; +inp[3819] = 0; +inp[3820] = 1073741728; +inp[3821] = 0; +inp[3822] = 1073741724; +inp[3823] = 0; +inp[3824] = 1073741720; +inp[3825] = 0; +inp[3826] = 1073741716; +inp[3827] = 0; +inp[3828] = 1073741712; +inp[3829] = 0; +inp[3830] = 1073741708; +inp[3831] = 0; +inp[3832] = 1073741704; +inp[3833] = 0; +inp[3834] = 1073741700; +inp[3835] = 0; +inp[3836] = 1073741824; +inp[3837] = 1073741824; +inp[3838] = 1073741822; +inp[3839] = 0; +inp[3840] = 1073741820; +inp[3841] = 0; +inp[3842] = 1073741818; +inp[3843] = 0; +inp[3844] = 1073741816; +inp[3845] = 0; +inp[3846] = 1073741814; +inp[3847] = 0; +inp[3848] = 1073741812; +inp[3849] = 0; +inp[3850] = 1073741810; +inp[3851] = 0; +inp[3852] = 1073741808; +inp[3853] = 0; +inp[3854] = 1073741806; +inp[3855] = 0; +inp[3856] = 1073741804; +inp[3857] = 0; +inp[3858] = 1073741802; +inp[3859] = 0; +inp[3860] = 1073741800; +inp[3861] = 0; +inp[3862] = 1073741798; +inp[3863] = 0; +inp[3864] = 1073741796; +inp[3865] = 0; +inp[3866] = 1073741794; +inp[3867] = 0; +inp[3868] = 1073741792; +inp[3869] = 0; +inp[3870] = 1073741790; +inp[3871] = 0; +inp[3872] = 1073741788; +inp[3873] = 0; +inp[3874] = 1073741786; +inp[3875] = 0; +inp[3876] = 1073741784; +inp[3877] = 0; +inp[3878] = 1073741782; +inp[3879] = 0; +inp[3880] = 1073741780; +inp[3881] = 0; +inp[3882] = 1073741778; +inp[3883] = 0; +inp[3884] = 1073741776; +inp[3885] = 0; +inp[3886] = 1073741774; +inp[3887] = 0; +inp[3888] = 1073741772; +inp[3889] = 0; +inp[3890] = 1073741770; +inp[3891] = 0; +inp[3892] = 1073741768; +inp[3893] = 0; +inp[3894] = 1073741766; +inp[3895] = 0; +inp[3896] = 1073741764; +inp[3897] = 0; +inp[3898] = 1073741762; +inp[3899] = 0; +inp[3900] = 1073741824; +inp[3901] = 1073741824; +inp[3902] = 1073741823; +inp[3903] = 0; +inp[3904] = 1073741822; +inp[3905] = 0; +inp[3906] = 1073741821; +inp[3907] = 0; +inp[3908] = 1073741820; +inp[3909] = 0; +inp[3910] = 1073741819; +inp[3911] = 0; +inp[3912] = 1073741818; +inp[3913] = 0; +inp[3914] = 1073741817; +inp[3915] = 0; +inp[3916] = 1073741816; +inp[3917] = 0; +inp[3918] = 1073741815; +inp[3919] = 0; +inp[3920] = 1073741814; +inp[3921] = 0; +inp[3922] = 1073741813; +inp[3923] = 0; +inp[3924] = 1073741812; +inp[3925] = 0; +inp[3926] = 1073741811; +inp[3927] = 0; +inp[3928] = 1073741810; +inp[3929] = 0; +inp[3930] = 1073741809; +inp[3931] = 0; +inp[3932] = 1073741808; +inp[3933] = 0; +inp[3934] = 1073741807; +inp[3935] = 0; +inp[3936] = 1073741806; +inp[3937] = 0; +inp[3938] = 1073741805; +inp[3939] = 0; +inp[3940] = 1073741804; +inp[3941] = 0; +inp[3942] = 1073741803; +inp[3943] = 0; +inp[3944] = 1073741802; +inp[3945] = 0; +inp[3946] = 1073741801; +inp[3947] = 0; +inp[3948] = 1073741800; +inp[3949] = 0; +inp[3950] = 1073741799; +inp[3951] = 0; +inp[3952] = 1073741798; +inp[3953] = 0; +inp[3954] = 1073741797; +inp[3955] = 0; +inp[3956] = 1073741796; +inp[3957] = 0; +inp[3958] = 1073741795; +inp[3959] = 0; +inp[3960] = 1073741794; +inp[3961] = 0; +inp[3962] = 1073741793; +inp[3963] = 0; +inp[3964] = 1073741824; +inp[3965] = 1073741824; +inp[3966] = 1073741823; +inp[3967] = 0; +inp[3968] = 1073741823; +inp[3969] = 0; +inp[3970] = 1073741822; +inp[3971] = 0; +inp[3972] = 1073741822; +inp[3973] = 0; +inp[3974] = 1073741821; +inp[3975] = 0; +inp[3976] = 1073741821; +inp[3977] = 0; +inp[3978] = 1073741820; +inp[3979] = 0; +inp[3980] = 1073741820; +inp[3981] = 0; +inp[3982] = 1073741819; +inp[3983] = 0; +inp[3984] = 1073741819; +inp[3985] = 0; +inp[3986] = 1073741818; +inp[3987] = 0; +inp[3988] = 1073741818; +inp[3989] = 0; +inp[3990] = 1073741817; +inp[3991] = 0; +inp[3992] = 1073741817; +inp[3993] = 0; +inp[3994] = 1073741816; +inp[3995] = 0; +inp[3996] = 1073741816; +inp[3997] = 0; +inp[3998] = 1073741815; +inp[3999] = 0; +inp[4000] = 1073741815; +inp[4001] = 0; +inp[4002] = 1073741814; +inp[4003] = 0; +inp[4004] = 1073741814; +inp[4005] = 0; +inp[4006] = 1073741813; +inp[4007] = 0; +inp[4008] = 1073741813; +inp[4009] = 0; +inp[4010] = 1073741812; +inp[4011] = 0; +inp[4012] = 1073741812; +inp[4013] = 0; +inp[4014] = 1073741811; +inp[4015] = 0; +inp[4016] = 1073741811; +inp[4017] = 0; +inp[4018] = 1073741810; +inp[4019] = 0; +inp[4020] = 1073741810; +inp[4021] = 0; +inp[4022] = 1073741809; +inp[4023] = 0; +inp[4024] = 1073741809; +inp[4025] = 0; +inp[4026] = 1073741808; +inp[4027] = 0; +inp[4028] = 1073741824; +inp[4029] = 1073741824; +inp[4030] = 1073741823; +inp[4031] = 0; +inp[4032] = 1073741823; +inp[4033] = 0; +inp[4034] = 1073741823; +inp[4035] = 0; +inp[4036] = 1073741823; +inp[4037] = 0; +inp[4038] = 1073741822; +inp[4039] = 0; +inp[4040] = 1073741822; +inp[4041] = 0; +inp[4042] = 1073741822; +inp[4043] = 0; +inp[4044] = 1073741822; +inp[4045] = 0; +inp[4046] = 1073741821; +inp[4047] = 0; +inp[4048] = 1073741821; +inp[4049] = 0; +inp[4050] = 1073741821; +inp[4051] = 0; +inp[4052] = 1073741821; +inp[4053] = 0; +inp[4054] = 1073741820; +inp[4055] = 0; +inp[4056] = 1073741820; +inp[4057] = 0; +inp[4058] = 1073741820; +inp[4059] = 0; +inp[4060] = 1073741820; +inp[4061] = 0; +inp[4062] = 1073741819; +inp[4063] = 0; +inp[4064] = 1073741819; +inp[4065] = 0; +inp[4066] = 1073741819; +inp[4067] = 0; +inp[4068] = 1073741819; +inp[4069] = 0; +inp[4070] = 1073741818; +inp[4071] = 0; +inp[4072] = 1073741818; +inp[4073] = 0; +inp[4074] = 1073741818; +inp[4075] = 0; +inp[4076] = 1073741818; +inp[4077] = 0; +inp[4078] = 1073741817; +inp[4079] = 0; +inp[4080] = 1073741817; +inp[4081] = 0; +inp[4082] = 1073741817; +inp[4083] = 0; +inp[4084] = 1073741817; +inp[4085] = 0; +inp[4086] = 1073741816; +inp[4087] = 0; +inp[4088] = 1073741816; +inp[4089] = 0; +inp[4090] = 1073741816; +inp[4091] = 0; +inp[4092] = 1073741824; +inp[4093] = 1073741824; +inp[4094] = 395007542; +inp[4095] = 395007542; +inp[4096] = 145315153; +inp[4097] = 145315153; +inp[4098] = 53458457; +inp[4099] = 53458457; +inp[4100] = 19666267; +inp[4101] = 19666267; +inp[4102] = 7234815; +inp[4103] = 7234815; +inp[4104] = 2661539; +inp[4105] = 2661539; +inp[4106] = 979125; +inp[4107] = 979125; +inp[4108] = 360200; +inp[4109] = 360200; +inp[4110] = 132510; +inp[4111] = 132510; +inp[4112] = 48747; +inp[4113] = 48747; +inp[4114] = 17933; +inp[4115] = 17933; +inp[4116] = 6597; +inp[4117] = 6597; +inp[4118] = 2427; +inp[4119] = 2427; +inp[4120] = 892; +inp[4121] = 892; +inp[4122] = 328; +inp[4123] = 328; +inp[4124] = 120; +inp[4125] = 120; +inp[4126] = 44; +inp[4127] = 44; +inp[4128] = 16; +inp[4129] = 16; +inp[4130] = 6; +inp[4131] = 6; +inp[4132] = 2; +inp[4133] = 2; +inp[4134] = 0; +inp[4135] = 0; +inp[4136] = 0; +inp[4137] = 0; +inp[4138] = 0; +inp[4139] = 0; +inp[4140] = 0; +inp[4141] = 0; +inp[4142] = 0; +inp[4143] = 0; +inp[4144] = 0; +inp[4145] = 0; +inp[4146] = 0; +inp[4147] = 0; +inp[4148] = 0; +inp[4149] = 0; +inp[4150] = 0; +inp[4151] = 0; +inp[4152] = 0; +inp[4153] = 0; +inp[4154] = 0; +inp[4155] = 0; +inp[4156] = 0; +inp[4157] = 0; +inp[4158] = 0; +inp[4159] = 0; +inp[4160] = 0; +inp[4161] = 0; +inp[4162] = 0; +inp[4163] = 0; +inp[4164] = 0; +inp[4165] = 0; +inp[4166] = 0; +inp[4167] = 0; +inp[4168] = 0; +inp[4169] = 0; +inp[4170] = 0; +inp[4171] = 0; +inp[4172] = 0; +inp[4173] = 0; +inp[4174] = 0; +inp[4175] = 0; +inp[4176] = 0; +inp[4177] = 0; +inp[4178] = 0; +inp[4179] = 0; +inp[4180] = 0; +inp[4181] = 0; +inp[4182] = 0; +inp[4183] = 0; +inp[4184] = 0; +inp[4185] = 0; +inp[4186] = 0; +inp[4187] = 0; +inp[4188] = 0; +inp[4189] = 0; +inp[4190] = 0; +inp[4191] = 0; +inp[4192] = 0; +inp[4193] = 0; +inp[4194] = 0; +inp[4195] = 0; +inp[4196] = 0; +inp[4197] = 0; +inp[4198] = 0; +inp[4199] = 0; +inp[4200] = 0; +inp[4201] = 0; +inp[4202] = 0; +inp[4203] = 0; +inp[4204] = 0; +inp[4205] = 0; +inp[4206] = 0; +inp[4207] = 0; +inp[4208] = 0; +inp[4209] = 0; +inp[4210] = 0; +inp[4211] = 0; +inp[4212] = 0; +inp[4213] = 0; +inp[4214] = 0; +inp[4215] = 0; +inp[4216] = 0; +inp[4217] = 0; +inp[4218] = 0; +inp[4219] = 0; +inp[4220] = 1073741824; +inp[4221] = 1073741824; +inp[4222] = 651257336; +inp[4223] = 145315153; +inp[4224] = 395007542; +inp[4225] = 19666267; +inp[4226] = 239584185; +inp[4227] = 2661539; +inp[4228] = 145315153; +inp[4229] = 360200; +inp[4230] = 88138096; +inp[4231] = 48747; +inp[4232] = 53458457; +inp[4233] = 6597; +inp[4234] = 32424193; +inp[4235] = 892; +inp[4236] = 19666267; +inp[4237] = 120; +inp[4238] = 11928194; +inp[4239] = 16; +inp[4240] = 7234815; +inp[4241] = 2; +inp[4242] = 4388137; +inp[4243] = 0; +inp[4244] = 2661539; +inp[4245] = 0; +inp[4246] = 1614305; +inp[4247] = 0; +inp[4248] = 979125; +inp[4249] = 0; +inp[4250] = 593869; +inp[4251] = 0; +inp[4252] = 360200; +inp[4253] = 0; +inp[4254] = 218472; +inp[4255] = 0; +inp[4256] = 132510; +inp[4257] = 0; +inp[4258] = 80371; +inp[4259] = 0; +inp[4260] = 48747; +inp[4261] = 0; +inp[4262] = 29567; +inp[4263] = 0; +inp[4264] = 17933; +inp[4265] = 0; +inp[4266] = 10877; +inp[4267] = 0; +inp[4268] = 6597; +inp[4269] = 0; +inp[4270] = 4001; +inp[4271] = 0; +inp[4272] = 2427; +inp[4273] = 0; +inp[4274] = 1472; +inp[4275] = 0; +inp[4276] = 892; +inp[4277] = 0; +inp[4278] = 541; +inp[4279] = 0; +inp[4280] = 328; +inp[4281] = 0; +inp[4282] = 199; +inp[4283] = 0; +inp[4284] = 120; +inp[4285] = 0; +inp[4286] = 73; +inp[4287] = 0; +inp[4288] = 44; +inp[4289] = 0; +inp[4290] = 26; +inp[4291] = 0; +inp[4292] = 16; +inp[4293] = 0; +inp[4294] = 9; +inp[4295] = 0; +inp[4296] = 6; +inp[4297] = 0; +inp[4298] = 3; +inp[4299] = 0; +inp[4300] = 2; +inp[4301] = 0; +inp[4302] = 1; +inp[4303] = 0; +inp[4304] = 0; +inp[4305] = 0; +inp[4306] = 0; +inp[4307] = 0; +inp[4308] = 0; +inp[4309] = 0; +inp[4310] = 0; +inp[4311] = 0; +inp[4312] = 0; +inp[4313] = 0; +inp[4314] = 0; +inp[4315] = 0; +inp[4316] = 0; +inp[4317] = 0; +inp[4318] = 0; +inp[4319] = 0; +inp[4320] = 0; +inp[4321] = 0; +inp[4322] = 0; +inp[4323] = 0; +inp[4324] = 0; +inp[4325] = 0; +inp[4326] = 0; +inp[4327] = 0; +inp[4328] = 0; +inp[4329] = 0; +inp[4330] = 0; +inp[4331] = 0; +inp[4332] = 0; +inp[4333] = 0; +inp[4334] = 0; +inp[4335] = 0; +inp[4336] = 0; +inp[4337] = 0; +inp[4338] = 0; +inp[4339] = 0; +inp[4340] = 0; +inp[4341] = 0; +inp[4342] = 0; +inp[4343] = 0; +inp[4344] = 0; +inp[4345] = 0; +inp[4346] = 0; +inp[4347] = 0; +inp[4348] = 1073741824; +inp[4349] = 1073741824; +inp[4350] = 836230973; +inp[4351] = 19666267; +inp[4352] = 651257336; +inp[4353] = 360200; +inp[4354] = 507199723; +inp[4355] = 6597; +inp[4356] = 395007542; +inp[4357] = 120; +inp[4358] = 307632183; +inp[4359] = 2; +inp[4360] = 239584185; +inp[4361] = 0; +inp[4362] = 186588351; +inp[4363] = 0; +inp[4364] = 145315153; +inp[4365] = 0; +inp[4366] = 113171555; +inp[4367] = 0; +inp[4368] = 88138096; +inp[4369] = 0; +inp[4370] = 68642018; +inp[4371] = 0; +inp[4372] = 53458457; +inp[4373] = 0; +inp[4374] = 41633488; +inp[4375] = 0; +inp[4376] = 32424193; +inp[4377] = 0; +inp[4378] = 25251987; +inp[4379] = 0; +inp[4380] = 19666267; +inp[4381] = 0; +inp[4382] = 15316104; +inp[4383] = 0; +inp[4384] = 11928194; +inp[4385] = 0; +inp[4386] = 9289686; +inp[4387] = 0; +inp[4388] = 7234815; +inp[4389] = 0; +inp[4390] = 5634479; +inp[4391] = 0; +inp[4392] = 4388137; +inp[4393] = 0; +inp[4394] = 3417484; +inp[4395] = 0; +inp[4396] = 2661539; +inp[4397] = 0; +inp[4398] = 2072809; +inp[4399] = 0; +inp[4400] = 1614305; +inp[4401] = 0; +inp[4402] = 1257222; +inp[4403] = 0; +inp[4404] = 979125; +inp[4405] = 0; +inp[4406] = 762543; +inp[4407] = 0; +inp[4408] = 593869; +inp[4409] = 0; +inp[4410] = 462506; +inp[4411] = 0; +inp[4412] = 360200; +inp[4413] = 0; +inp[4414] = 280524; +inp[4415] = 0; +inp[4416] = 218472; +inp[4417] = 0; +inp[4418] = 170146; +inp[4419] = 0; +inp[4420] = 132510; +inp[4421] = 0; +inp[4422] = 103199; +inp[4423] = 0; +inp[4424] = 80371; +inp[4425] = 0; +inp[4426] = 62593; +inp[4427] = 0; +inp[4428] = 48747; +inp[4429] = 0; +inp[4430] = 37964; +inp[4431] = 0; +inp[4432] = 29567; +inp[4433] = 0; +inp[4434] = 23026; +inp[4435] = 0; +inp[4436] = 17933; +inp[4437] = 0; +inp[4438] = 13966; +inp[4439] = 0; +inp[4440] = 10877; +inp[4441] = 0; +inp[4442] = 8471; +inp[4443] = 0; +inp[4444] = 6597; +inp[4445] = 0; +inp[4446] = 5137; +inp[4447] = 0; +inp[4448] = 4001; +inp[4449] = 0; +inp[4450] = 3116; +inp[4451] = 0; +inp[4452] = 2427; +inp[4453] = 0; +inp[4454] = 1890; +inp[4455] = 0; +inp[4456] = 1472; +inp[4457] = 0; +inp[4458] = 1146; +inp[4459] = 0; +inp[4460] = 892; +inp[4461] = 0; +inp[4462] = 695; +inp[4463] = 0; +inp[4464] = 541; +inp[4465] = 0; +inp[4466] = 421; +inp[4467] = 0; +inp[4468] = 328; +inp[4469] = 0; +inp[4470] = 255; +inp[4471] = 0; +inp[4472] = 199; +inp[4473] = 0; +inp[4474] = 155; +inp[4475] = 0; +inp[4476] = 1073741824; +inp[4477] = 1073741824; +inp[4478] = 947573833; +inp[4479] = 360200; +inp[4480] = 836230973; +inp[4481] = 120; +inp[4482] = 737971243; +inp[4483] = 0; +inp[4484] = 651257336; +inp[4485] = 0; +inp[4486] = 574732582; +inp[4487] = 0; +inp[4488] = 507199723; +inp[4489] = 0; +inp[4490] = 447602185; +inp[4491] = 0; +inp[4492] = 395007542; +inp[4493] = 0; +inp[4494] = 348592932; +inp[4495] = 0; +inp[4496] = 307632183; +inp[4497] = 0; +inp[4498] = 271484448; +inp[4499] = 0; +inp[4500] = 239584185; +inp[4501] = 0; +inp[4502] = 211432301; +inp[4503] = 0; +inp[4504] = 186588351; +inp[4505] = 0; +inp[4506] = 164663641; +inp[4507] = 0; +inp[4508] = 145315153; +inp[4509] = 0; +inp[4510] = 128240173; +inp[4511] = 0; +inp[4512] = 113171555; +inp[4513] = 0; +inp[4514] = 99873547; +inp[4515] = 0; +inp[4516] = 88138096; +inp[4517] = 0; +inp[4518] = 77781596; +inp[4519] = 0; +inp[4520] = 68642018; +inp[4521] = 0; +inp[4522] = 60576368; +inp[4523] = 0; +inp[4524] = 53458457; +inp[4525] = 0; +inp[4526] = 47176923; +inp[4527] = 0; +inp[4528] = 41633488; +inp[4529] = 0; +inp[4530] = 36741424; +inp[4531] = 0; +inp[4532] = 32424193; +inp[4533] = 0; +inp[4534] = 28614250; +inp[4535] = 0; +inp[4536] = 25251987; +inp[4537] = 0; +inp[4538] = 22284800; +inp[4539] = 0; +inp[4540] = 19666267; +inp[4541] = 0; +inp[4542] = 17355420; +inp[4543] = 0; +inp[4544] = 15316104; +inp[4545] = 0; +inp[4546] = 13516414; +inp[4547] = 0; +inp[4548] = 11928194; +inp[4549] = 0; +inp[4550] = 10526594; +inp[4551] = 0; +inp[4552] = 9289686; +inp[4553] = 0; +inp[4554] = 8198119; +inp[4555] = 0; +inp[4556] = 7234815; +inp[4557] = 0; +inp[4558] = 6384702; +inp[4559] = 0; +inp[4560] = 5634479; +inp[4561] = 0; +inp[4562] = 4972411; +inp[4563] = 0; +inp[4564] = 4388137; +inp[4565] = 0; +inp[4566] = 3872517; +inp[4567] = 0; +inp[4568] = 3417484; +inp[4569] = 0; +inp[4570] = 3015919; +inp[4571] = 0; +inp[4572] = 2661539; +inp[4573] = 0; +inp[4574] = 2348800; +inp[4575] = 0; +inp[4576] = 2072809; +inp[4577] = 0; +inp[4578] = 1829247; +inp[4579] = 0; +inp[4580] = 1614305; +inp[4581] = 0; +inp[4582] = 1424619; +inp[4583] = 0; +inp[4584] = 1257222; +inp[4585] = 0; +inp[4586] = 1109494; +inp[4587] = 0; +inp[4588] = 979125; +inp[4589] = 0; +inp[4590] = 864075; +inp[4591] = 0; +inp[4592] = 762543; +inp[4593] = 0; +inp[4594] = 672942; +inp[4595] = 0; +inp[4596] = 593869; +inp[4597] = 0; +inp[4598] = 524088; +inp[4599] = 0; +inp[4600] = 462506; +inp[4601] = 0; +inp[4602] = 408160; +inp[4603] = 0; +inp[4604] = 1073741824; +inp[4605] = 1073741824; +inp[4606] = 1008687095; +inp[4607] = 120; +inp[4608] = 947573833; +inp[4609] = 0; +inp[4610] = 890163237; +inp[4611] = 0; +inp[4612] = 836230973; +inp[4613] = 0; +inp[4614] = 785566299; +inp[4615] = 0; +inp[4616] = 737971243; +inp[4617] = 0; +inp[4618] = 693259826; +inp[4619] = 0; +inp[4620] = 651257336; +inp[4621] = 0; +inp[4622] = 611799649; +inp[4623] = 0; +inp[4624] = 574732582; +inp[4625] = 0; +inp[4626] = 539911295; +inp[4627] = 0; +inp[4628] = 507199723; +inp[4629] = 0; +inp[4630] = 476470046; +inp[4631] = 0; +inp[4632] = 447602185; +inp[4633] = 0; +inp[4634] = 420483339; +inp[4635] = 0; +inp[4636] = 395007542; +inp[4637] = 0; +inp[4638] = 371075245; +inp[4639] = 0; +inp[4640] = 348592932; +inp[4641] = 0; +inp[4642] = 327472754; +inp[4643] = 0; +inp[4644] = 307632183; +inp[4645] = 0; +inp[4646] = 288993691; +inp[4647] = 0; +inp[4648] = 271484448; +inp[4649] = 0; +inp[4650] = 255036037; +inp[4651] = 0; +inp[4652] = 239584185; +inp[4653] = 0; +inp[4654] = 225068513; +inp[4655] = 0; +inp[4656] = 211432301; +inp[4657] = 0; +inp[4658] = 198622265; +inp[4659] = 0; +inp[4660] = 186588351; +inp[4661] = 0; +inp[4662] = 175283534; +inp[4663] = 0; +inp[4664] = 164663641; +inp[4665] = 0; +inp[4666] = 154687176; +inp[4667] = 0; +inp[4668] = 145315153; +inp[4669] = 0; +inp[4670] = 136510953; +inp[4671] = 0; +inp[4672] = 128240173; +inp[4673] = 0; +inp[4674] = 120470493; +inp[4675] = 0; +inp[4676] = 113171555; +inp[4677] = 0; +inp[4678] = 106314837; +inp[4679] = 0; +inp[4680] = 99873547; +inp[4681] = 0; +inp[4682] = 93822514; +inp[4683] = 0; +inp[4684] = 88138096; +inp[4685] = 0; +inp[4686] = 82798078; +inp[4687] = 0; +inp[4688] = 77781596; +inp[4689] = 0; +inp[4690] = 73069048; +inp[4691] = 0; +inp[4692] = 68642018; +inp[4693] = 0; +inp[4694] = 64483208; +inp[4695] = 0; +inp[4696] = 60576368; +inp[4697] = 0; +inp[4698] = 56906231; +inp[4699] = 0; +inp[4700] = 53458457; +inp[4701] = 0; +inp[4702] = 50219573; +inp[4703] = 0; +inp[4704] = 47176923; +inp[4705] = 0; +inp[4706] = 44318617; +inp[4707] = 0; +inp[4708] = 41633488; +inp[4709] = 0; +inp[4710] = 39111043; +inp[4711] = 0; +inp[4712] = 36741424; +inp[4713] = 0; +inp[4714] = 34515374; +inp[4715] = 0; +inp[4716] = 32424193; +inp[4717] = 0; +inp[4718] = 30459710; +inp[4719] = 0; +inp[4720] = 28614250; +inp[4721] = 0; +inp[4722] = 26880600; +inp[4723] = 0; +inp[4724] = 25251987; +inp[4725] = 0; +inp[4726] = 23722046; +inp[4727] = 0; +inp[4728] = 22284800; +inp[4729] = 0; +inp[4730] = 20934632; +inp[4731] = 0; +inp[4732] = 1073741824; +inp[4733] = 1073741824; +inp[4734] = 1040706261; +inp[4735] = 0; +inp[4736] = 1008687095; +inp[4737] = 0; +inp[4738] = 977653056; +inp[4739] = 0; +inp[4740] = 947573833; +inp[4741] = 0; +inp[4742] = 918420051; +inp[4743] = 0; +inp[4744] = 890163237; +inp[4745] = 0; +inp[4746] = 862775793; +inp[4747] = 0; +inp[4748] = 836230973; +inp[4749] = 0; +inp[4750] = 810502851; +inp[4751] = 0; +inp[4752] = 785566299; +inp[4753] = 0; +inp[4754] = 761396965; +inp[4755] = 0; +inp[4756] = 737971243; +inp[4757] = 0; +inp[4758] = 715266255; +inp[4759] = 0; +inp[4760] = 693259826; +inp[4761] = 0; +inp[4762] = 671930463; +inp[4763] = 0; +inp[4764] = 651257336; +inp[4765] = 0; +inp[4766] = 631220255; +inp[4767] = 0; +inp[4768] = 611799649; +inp[4769] = 0; +inp[4770] = 592976553; +inp[4771] = 0; +inp[4772] = 574732582; +inp[4773] = 0; +inp[4774] = 557049919; +inp[4775] = 0; +inp[4776] = 539911295; +inp[4777] = 0; +inp[4778] = 523299971; +inp[4779] = 0; +inp[4780] = 507199723; +inp[4781] = 0; +inp[4782] = 491594828; +inp[4783] = 0; +inp[4784] = 476470046; +inp[4785] = 0; +inp[4786] = 461810603; +inp[4787] = 0; +inp[4788] = 447602185; +inp[4789] = 0; +inp[4790] = 433830913; +inp[4791] = 0; +inp[4792] = 420483339; +inp[4793] = 0; +inp[4794] = 407546427; +inp[4795] = 0; +inp[4796] = 395007542; +inp[4797] = 0; +inp[4798] = 382854437; +inp[4799] = 0; +inp[4800] = 371075245; +inp[4801] = 0; +inp[4802] = 359658459; +inp[4803] = 0; +inp[4804] = 348592932; +inp[4805] = 0; +inp[4806] = 337867855; +inp[4807] = 0; +inp[4808] = 327472754; +inp[4809] = 0; +inp[4810] = 317397476; +inp[4811] = 0; +inp[4812] = 307632183; +inp[4813] = 0; +inp[4814] = 298167335; +inp[4815] = 0; +inp[4816] = 288993691; +inp[4817] = 0; +inp[4818] = 280102290; +inp[4819] = 0; +inp[4820] = 271484448; +inp[4821] = 0; +inp[4822] = 263131750; +inp[4823] = 0; +inp[4824] = 255036037; +inp[4825] = 0; +inp[4826] = 247189403; +inp[4827] = 0; +inp[4828] = 239584185; +inp[4829] = 0; +inp[4830] = 232212954; +inp[4831] = 0; +inp[4832] = 225068513; +inp[4833] = 0; +inp[4834] = 218143882; +inp[4835] = 0; +inp[4836] = 211432301; +inp[4837] = 0; +inp[4838] = 204927213; +inp[4839] = 0; +inp[4840] = 198622265; +inp[4841] = 0; +inp[4842] = 192511301; +inp[4843] = 0; +inp[4844] = 186588351; +inp[4845] = 0; +inp[4846] = 180847630; +inp[4847] = 0; +inp[4848] = 175283534; +inp[4849] = 0; +inp[4850] = 169890626; +inp[4851] = 0; +inp[4852] = 164663641; +inp[4853] = 0; +inp[4854] = 159597474; +inp[4855] = 0; +inp[4856] = 154687176; +inp[4857] = 0; +inp[4858] = 149927952; +inp[4859] = 0; +inp[4860] = 1073741824; +inp[4861] = 1073741824; +inp[4862] = 1057094999; +inp[4863] = 0; +inp[4864] = 1040706261; +inp[4865] = 0; +inp[4866] = 1024571605; +inp[4867] = 0; +inp[4868] = 1008687095; +inp[4869] = 0; +inp[4870] = 993048851; +inp[4871] = 0; +inp[4872] = 977653056; +inp[4873] = 0; +inp[4874] = 962495950; +inp[4875] = 0; +inp[4876] = 947573833; +inp[4877] = 0; +inp[4878] = 932883063; +inp[4879] = 0; +inp[4880] = 918420051; +inp[4881] = 0; +inp[4882] = 904181268; +inp[4883] = 0; +inp[4884] = 890163237; +inp[4885] = 0; +inp[4886] = 876362535; +inp[4887] = 0; +inp[4888] = 862775793; +inp[4889] = 0; +inp[4890] = 849399695; +inp[4891] = 0; +inp[4892] = 836230973; +inp[4893] = 0; +inp[4894] = 823266413; +inp[4895] = 0; +inp[4896] = 810502851; +inp[4897] = 0; +inp[4898] = 797937169; +inp[4899] = 0; +inp[4900] = 785566299; +inp[4901] = 0; +inp[4902] = 773387223; +inp[4903] = 0; +inp[4904] = 761396965; +inp[4905] = 0; +inp[4906] = 749592599; +inp[4907] = 0; +inp[4908] = 737971243; +inp[4909] = 0; +inp[4910] = 726530060; +inp[4911] = 0; +inp[4912] = 715266255; +inp[4913] = 0; +inp[4914] = 704177080; +inp[4915] = 0; +inp[4916] = 693259826; +inp[4917] = 0; +inp[4918] = 682511829; +inp[4919] = 0; +inp[4920] = 671930463; +inp[4921] = 0; +inp[4922] = 661513147; +inp[4923] = 0; +inp[4924] = 651257336; +inp[4925] = 0; +inp[4926] = 641160527; +inp[4927] = 0; +inp[4928] = 631220255; +inp[4929] = 0; +inp[4930] = 621434092; +inp[4931] = 0; +inp[4932] = 611799649; +inp[4933] = 0; +inp[4934] = 602314575; +inp[4935] = 0; +inp[4936] = 592976553; +inp[4937] = 0; +inp[4938] = 583783303; +inp[4939] = 0; +inp[4940] = 574732582; +inp[4941] = 0; +inp[4942] = 565822179; +inp[4943] = 0; +inp[4944] = 557049919; +inp[4945] = 0; +inp[4946] = 548413661; +inp[4947] = 0; +inp[4948] = 539911295; +inp[4949] = 0; +inp[4950] = 531540746; +inp[4951] = 0; +inp[4952] = 523299971; +inp[4953] = 0; +inp[4954] = 515186957; +inp[4955] = 0; +inp[4956] = 507199723; +inp[4957] = 0; +inp[4958] = 499336321; +inp[4959] = 0; +inp[4960] = 491594828; +inp[4961] = 0; +inp[4962] = 483973357; +inp[4963] = 0; +inp[4964] = 476470046; +inp[4965] = 0; +inp[4966] = 469083062; +inp[4967] = 0; +inp[4968] = 461810603; +inp[4969] = 0; +inp[4970] = 454650894; +inp[4971] = 0; +inp[4972] = 447602185; +inp[4973] = 0; +inp[4974] = 440662756; +inp[4975] = 0; +inp[4976] = 433830913; +inp[4977] = 0; +inp[4978] = 427104988; +inp[4979] = 0; +inp[4980] = 420483339; +inp[4981] = 0; +inp[4982] = 413964349; +inp[4983] = 0; +inp[4984] = 407546427; +inp[4985] = 0; +inp[4986] = 401228005; +inp[4987] = 0; +inp[4988] = 1073741824; +inp[4989] = 1073741824; +inp[4990] = 1065385898; +inp[4991] = 0; +inp[4992] = 1057094999; +inp[4993] = 0; +inp[4994] = 1048868621; +inp[4995] = 0; +inp[4996] = 1040706261; +inp[4997] = 0; +inp[4998] = 1032607420; +inp[4999] = 0; +inp[5000] = 1024571605; +inp[5001] = 0; +inp[5002] = 1016598326; +inp[5003] = 0; +inp[5004] = 1008687095; +inp[5005] = 0; +inp[5006] = 1000837430; +inp[5007] = 0; +inp[5008] = 993048851; +inp[5009] = 0; +inp[5010] = 985320884; +inp[5011] = 0; +inp[5012] = 977653056; +inp[5013] = 0; +inp[5014] = 970044899; +inp[5015] = 0; +inp[5016] = 962495950; +inp[5017] = 0; +inp[5018] = 955005747; +inp[5019] = 0; +inp[5020] = 947573833; +inp[5021] = 0; +inp[5022] = 940199755; +inp[5023] = 0; +inp[5024] = 932883063; +inp[5025] = 0; +inp[5026] = 925623309; +inp[5027] = 0; +inp[5028] = 918420051; +inp[5029] = 0; +inp[5030] = 911272850; +inp[5031] = 0; +inp[5032] = 904181268; +inp[5033] = 0; +inp[5034] = 897144874; +inp[5035] = 0; +inp[5036] = 890163237; +inp[5037] = 0; +inp[5038] = 883235932; +inp[5039] = 0; +inp[5040] = 876362535; +inp[5041] = 0; +inp[5042] = 869542628; +inp[5043] = 0; +inp[5044] = 862775793; +inp[5045] = 0; +inp[5046] = 856061619; +inp[5047] = 0; +inp[5048] = 849399695; +inp[5049] = 0; +inp[5050] = 842789614; +inp[5051] = 0; +inp[5052] = 836230973; +inp[5053] = 0; +inp[5054] = 829723372; +inp[5055] = 0; +inp[5056] = 823266413; +inp[5057] = 0; +inp[5058] = 816859703; +inp[5059] = 0; +inp[5060] = 810502851; +inp[5061] = 0; +inp[5062] = 804195467; +inp[5063] = 0; +inp[5064] = 797937169; +inp[5065] = 0; +inp[5066] = 791727572; +inp[5067] = 0; +inp[5068] = 785566299; +inp[5069] = 0; +inp[5070] = 779452974; +inp[5071] = 0; +inp[5072] = 773387223; +inp[5073] = 0; +inp[5074] = 767368676; +inp[5075] = 0; +inp[5076] = 761396965; +inp[5077] = 0; +inp[5078] = 755471727; +inp[5079] = 0; +inp[5080] = 749592599; +inp[5081] = 0; +inp[5082] = 743759224; +inp[5083] = 0; +inp[5084] = 737971243; +inp[5085] = 0; +inp[5086] = 732228306; +inp[5087] = 0; +inp[5088] = 726530060; +inp[5089] = 0; +inp[5090] = 720876158; +inp[5091] = 0; +inp[5092] = 715266255; +inp[5093] = 0; +inp[5094] = 709700009; +inp[5095] = 0; +inp[5096] = 704177080; +inp[5097] = 0; +inp[5098] = 698697130; +inp[5099] = 0; +inp[5100] = 693259826; +inp[5101] = 0; +inp[5102] = 687864835; +inp[5103] = 0; +inp[5104] = 682511829; +inp[5105] = 0; +inp[5106] = 677200479; +inp[5107] = 0; +inp[5108] = 671930463; +inp[5109] = 0; +inp[5110] = 666701459; +inp[5111] = 0; +inp[5112] = 661513147; +inp[5113] = 0; +inp[5114] = 656365211; +inp[5115] = 0; +inp[5116] = 1073741824; +inp[5117] = 1073741824; +inp[5118] = 1069555701; +inp[5119] = 0; +inp[5120] = 1065385898; +inp[5121] = 0; +inp[5122] = 1061232352; +inp[5123] = 0; +inp[5124] = 1057094999; +inp[5125] = 0; +inp[5126] = 1052973777; +inp[5127] = 0; +inp[5128] = 1048868621; +inp[5129] = 0; +inp[5130] = 1044779470; +inp[5131] = 0; +inp[5132] = 1040706261; +inp[5133] = 0; +inp[5134] = 1036648931; +inp[5135] = 0; +inp[5136] = 1032607420; +inp[5137] = 0; +inp[5138] = 1028581665; +inp[5139] = 0; +inp[5140] = 1024571605; +inp[5141] = 0; +inp[5142] = 1020577179; +inp[5143] = 0; +inp[5144] = 1016598326; +inp[5145] = 0; +inp[5146] = 1012634985; +inp[5147] = 0; +inp[5148] = 1008687095; +inp[5149] = 0; +inp[5150] = 1004754597; +inp[5151] = 0; +inp[5152] = 1000837430; +inp[5153] = 0; +inp[5154] = 996935534; +inp[5155] = 0; +inp[5156] = 993048851; +inp[5157] = 0; +inp[5158] = 989177321; +inp[5159] = 0; +inp[5160] = 985320884; +inp[5161] = 0; +inp[5162] = 981479482; +inp[5163] = 0; +inp[5164] = 977653056; +inp[5165] = 0; +inp[5166] = 973841548; +inp[5167] = 0; +inp[5168] = 970044899; +inp[5169] = 0; +inp[5170] = 966263053; +inp[5171] = 0; +inp[5172] = 962495950; +inp[5173] = 0; +inp[5174] = 958743534; +inp[5175] = 0; +inp[5176] = 955005747; +inp[5177] = 0; +inp[5178] = 951282532; +inp[5179] = 0; +inp[5180] = 947573833; +inp[5181] = 0; +inp[5182] = 943879593; +inp[5183] = 0; +inp[5184] = 940199755; +inp[5185] = 0; +inp[5186] = 936534264; +inp[5187] = 0; +inp[5188] = 932883063; +inp[5189] = 0; +inp[5190] = 929246096; +inp[5191] = 0; +inp[5192] = 925623309; +inp[5193] = 0; +inp[5194] = 922014646; +inp[5195] = 0; +inp[5196] = 918420051; +inp[5197] = 0; +inp[5198] = 914839471; +inp[5199] = 0; +inp[5200] = 911272850; +inp[5201] = 0; +inp[5202] = 907720134; +inp[5203] = 0; +inp[5204] = 904181268; +inp[5205] = 0; +inp[5206] = 900656200; +inp[5207] = 0; +inp[5208] = 897144874; +inp[5209] = 0; +inp[5210] = 893647237; +inp[5211] = 0; +inp[5212] = 890163237; +inp[5213] = 0; +inp[5214] = 886692819; +inp[5215] = 0; +inp[5216] = 883235932; +inp[5217] = 0; +inp[5218] = 879792521; +inp[5219] = 0; +inp[5220] = 876362535; +inp[5221] = 0; +inp[5222] = 872945921; +inp[5223] = 0; +inp[5224] = 869542628; +inp[5225] = 0; +inp[5226] = 866152602; +inp[5227] = 0; +inp[5228] = 862775793; +inp[5229] = 0; +inp[5230] = 859412149; +inp[5231] = 0; +inp[5232] = 856061619; +inp[5233] = 0; +inp[5234] = 852724151; +inp[5235] = 0; +inp[5236] = 849399695; +inp[5237] = 0; +inp[5238] = 846088199; +inp[5239] = 0; +inp[5240] = 842789614; +inp[5241] = 0; +inp[5242] = 839503888; +inp[5243] = 0; +inp[5244] = 1073741824; +inp[5245] = 1073741824; +inp[5246] = 1071646718; +inp[5247] = 0; +inp[5248] = 1069555701; +inp[5249] = 0; +inp[5250] = 1067468764; +inp[5251] = 0; +inp[5252] = 1065385898; +inp[5253] = 0; +inp[5254] = 1063307097; +inp[5255] = 0; +inp[5256] = 1061232352; +inp[5257] = 0; +inp[5258] = 1059161656; +inp[5259] = 0; +inp[5260] = 1057094999; +inp[5261] = 0; +inp[5262] = 1055032376; +inp[5263] = 0; +inp[5264] = 1052973777; +inp[5265] = 0; +inp[5266] = 1050919194; +inp[5267] = 0; +inp[5268] = 1048868621; +inp[5269] = 0; +inp[5270] = 1046822049; +inp[5271] = 0; +inp[5272] = 1044779470; +inp[5273] = 0; +inp[5274] = 1042740876; +inp[5275] = 0; +inp[5276] = 1040706261; +inp[5277] = 0; +inp[5278] = 1038675615; +inp[5279] = 0; +inp[5280] = 1036648931; +inp[5281] = 0; +inp[5282] = 1034626202; +inp[5283] = 0; +inp[5284] = 1032607420; +inp[5285] = 0; +inp[5286] = 1030592577; +inp[5287] = 0; +inp[5288] = 1028581665; +inp[5289] = 0; +inp[5290] = 1026574677; +inp[5291] = 0; +inp[5292] = 1024571605; +inp[5293] = 0; +inp[5294] = 1022572442; +inp[5295] = 0; +inp[5296] = 1020577179; +inp[5297] = 0; +inp[5298] = 1018585810; +inp[5299] = 0; +inp[5300] = 1016598326; +inp[5301] = 0; +inp[5302] = 1014614720; +inp[5303] = 0; +inp[5304] = 1012634985; +inp[5305] = 0; +inp[5306] = 1010659112; +inp[5307] = 0; +inp[5308] = 1008687095; +inp[5309] = 0; +inp[5310] = 1006718926; +inp[5311] = 0; +inp[5312] = 1004754597; +inp[5313] = 0; +inp[5314] = 1002794101; +inp[5315] = 0; +inp[5316] = 1000837430; +inp[5317] = 0; +inp[5318] = 998884577; +inp[5319] = 0; +inp[5320] = 996935534; +inp[5321] = 0; +inp[5322] = 994990295; +inp[5323] = 0; +inp[5324] = 993048851; +inp[5325] = 0; +inp[5326] = 991111195; +inp[5327] = 0; +inp[5328] = 989177321; +inp[5329] = 0; +inp[5330] = 987247219; +inp[5331] = 0; +inp[5332] = 985320884; +inp[5333] = 0; +inp[5334] = 983398307; +inp[5335] = 0; +inp[5336] = 981479482; +inp[5337] = 0; +inp[5338] = 979564400; +inp[5339] = 0; +inp[5340] = 977653056; +inp[5341] = 0; +inp[5342] = 975745441; +inp[5343] = 0; +inp[5344] = 973841548; +inp[5345] = 0; +inp[5346] = 971941370; +inp[5347] = 0; +inp[5348] = 970044899; +inp[5349] = 0; +inp[5350] = 968152129; +inp[5351] = 0; +inp[5352] = 966263053; +inp[5353] = 0; +inp[5354] = 964377662; +inp[5355] = 0; +inp[5356] = 962495950; +inp[5357] = 0; +inp[5358] = 960617910; +inp[5359] = 0; +inp[5360] = 958743534; +inp[5361] = 0; +inp[5362] = 956872815; +inp[5363] = 0; +inp[5364] = 955005747; +inp[5365] = 0; +inp[5366] = 953142322; +inp[5367] = 0; +inp[5368] = 951282532; +inp[5369] = 0; +inp[5370] = 949426372; +inp[5371] = 0; +inp[5372] = 1073741824; +inp[5373] = 1073741824; +inp[5374] = 1072693759; +inp[5375] = 0; +inp[5376] = 1071646718; +inp[5377] = 0; +inp[5378] = 1070600699; +inp[5379] = 0; +inp[5380] = 1069555701; +inp[5381] = 0; +inp[5382] = 1068511723; +inp[5383] = 0; +inp[5384] = 1067468764; +inp[5385] = 0; +inp[5386] = 1066426822; +inp[5387] = 0; +inp[5388] = 1065385898; +inp[5389] = 0; +inp[5390] = 1064345990; +inp[5391] = 0; +inp[5392] = 1063307097; +inp[5393] = 0; +inp[5394] = 1062269218; +inp[5395] = 0; +inp[5396] = 1061232352; +inp[5397] = 0; +inp[5398] = 1060196498; +inp[5399] = 0; +inp[5400] = 1059161656; +inp[5401] = 0; +inp[5402] = 1058127823; +inp[5403] = 0; +inp[5404] = 1057094999; +inp[5405] = 0; +inp[5406] = 1056063184; +inp[5407] = 0; +inp[5408] = 1055032376; +inp[5409] = 0; +inp[5410] = 1054002574; +inp[5411] = 0; +inp[5412] = 1052973777; +inp[5413] = 0; +inp[5414] = 1051945984; +inp[5415] = 0; +inp[5416] = 1050919194; +inp[5417] = 0; +inp[5418] = 1049893407; +inp[5419] = 0; +inp[5420] = 1048868621; +inp[5421] = 0; +inp[5422] = 1047844835; +inp[5423] = 0; +inp[5424] = 1046822049; +inp[5425] = 0; +inp[5426] = 1045800261; +inp[5427] = 0; +inp[5428] = 1044779470; +inp[5429] = 0; +inp[5430] = 1043759675; +inp[5431] = 0; +inp[5432] = 1042740876; +inp[5433] = 0; +inp[5434] = 1041723072; +inp[5435] = 0; +inp[5436] = 1040706261; +inp[5437] = 0; +inp[5438] = 1039690442; +inp[5439] = 0; +inp[5440] = 1038675615; +inp[5441] = 0; +inp[5442] = 1037661778; +inp[5443] = 0; +inp[5444] = 1036648931; +inp[5445] = 0; +inp[5446] = 1035637073; +inp[5447] = 0; +inp[5448] = 1034626202; +inp[5449] = 0; +inp[5450] = 1033616318; +inp[5451] = 0; +inp[5452] = 1032607420; +inp[5453] = 0; +inp[5454] = 1031599507; +inp[5455] = 0; +inp[5456] = 1030592577; +inp[5457] = 0; +inp[5458] = 1029586630; +inp[5459] = 0; +inp[5460] = 1028581665; +inp[5461] = 0; +inp[5462] = 1027577681; +inp[5463] = 0; +inp[5464] = 1026574677; +inp[5465] = 0; +inp[5466] = 1025572652; +inp[5467] = 0; +inp[5468] = 1024571605; +inp[5469] = 0; +inp[5470] = 1023571536; +inp[5471] = 0; +inp[5472] = 1022572442; +inp[5473] = 0; +inp[5474] = 1021574324; +inp[5475] = 0; +inp[5476] = 1020577179; +inp[5477] = 0; +inp[5478] = 1019581008; +inp[5479] = 0; +inp[5480] = 1018585810; +inp[5481] = 0; +inp[5482] = 1017591583; +inp[5483] = 0; +inp[5484] = 1016598326; +inp[5485] = 0; +inp[5486] = 1015606039; +inp[5487] = 0; +inp[5488] = 1014614720; +inp[5489] = 0; +inp[5490] = 1013624369; +inp[5491] = 0; +inp[5492] = 1012634985; +inp[5493] = 0; +inp[5494] = 1011646566; +inp[5495] = 0; +inp[5496] = 1010659112; +inp[5497] = 0; +inp[5498] = 1009672622; +inp[5499] = 0; +inp[5500] = 1073741824; +inp[5501] = 1073741824; +inp[5502] = 1073217663; +inp[5503] = 0; +inp[5504] = 1072693759; +inp[5505] = 0; +inp[5506] = 1072170111; +inp[5507] = 0; +inp[5508] = 1071646718; +inp[5509] = 0; +inp[5510] = 1071123581; +inp[5511] = 0; +inp[5512] = 1070600699; +inp[5513] = 0; +inp[5514] = 1070078072; +inp[5515] = 0; +inp[5516] = 1069555701; +inp[5517] = 0; +inp[5518] = 1069033584; +inp[5519] = 0; +inp[5520] = 1068511723; +inp[5521] = 0; +inp[5522] = 1067990116; +inp[5523] = 0; +inp[5524] = 1067468764; +inp[5525] = 0; +inp[5526] = 1066947666; +inp[5527] = 0; +inp[5528] = 1066426822; +inp[5529] = 0; +inp[5530] = 1065906233; +inp[5531] = 0; +inp[5532] = 1065385898; +inp[5533] = 0; +inp[5534] = 1064865817; +inp[5535] = 0; +inp[5536] = 1064345990; +inp[5537] = 0; +inp[5538] = 1063826417; +inp[5539] = 0; +inp[5540] = 1063307097; +inp[5541] = 0; +inp[5542] = 1062788031; +inp[5543] = 0; +inp[5544] = 1062269218; +inp[5545] = 0; +inp[5546] = 1061750659; +inp[5547] = 0; +inp[5548] = 1061232352; +inp[5549] = 0; +inp[5550] = 1060714299; +inp[5551] = 0; +inp[5552] = 1060196498; +inp[5553] = 0; +inp[5554] = 1059678951; +inp[5555] = 0; +inp[5556] = 1059161656; +inp[5557] = 0; +inp[5558] = 1058644613; +inp[5559] = 0; +inp[5560] = 1058127823; +inp[5561] = 0; +inp[5562] = 1057611285; +inp[5563] = 0; +inp[5564] = 1057094999; +inp[5565] = 0; +inp[5566] = 1056578966; +inp[5567] = 0; +inp[5568] = 1056063184; +inp[5569] = 0; +inp[5570] = 1055547654; +inp[5571] = 0; +inp[5572] = 1055032376; +inp[5573] = 0; +inp[5574] = 1054517349; +inp[5575] = 0; +inp[5576] = 1054002574; +inp[5577] = 0; +inp[5578] = 1053488050; +inp[5579] = 0; +inp[5580] = 1052973777; +inp[5581] = 0; +inp[5582] = 1052459755; +inp[5583] = 0; +inp[5584] = 1051945984; +inp[5585] = 0; +inp[5586] = 1051432464; +inp[5587] = 0; +inp[5588] = 1050919194; +inp[5589] = 0; +inp[5590] = 1050406175; +inp[5591] = 0; +inp[5592] = 1049893407; +inp[5593] = 0; +inp[5594] = 1049380889; +inp[5595] = 0; +inp[5596] = 1048868621; +inp[5597] = 0; +inp[5598] = 1048356603; +inp[5599] = 0; +inp[5600] = 1047844835; +inp[5601] = 0; +inp[5602] = 1047333317; +inp[5603] = 0; +inp[5604] = 1046822049; +inp[5605] = 0; +inp[5606] = 1046311030; +inp[5607] = 0; +inp[5608] = 1045800261; +inp[5609] = 0; +inp[5610] = 1045289741; +inp[5611] = 0; +inp[5612] = 1044779470; +inp[5613] = 0; +inp[5614] = 1044269448; +inp[5615] = 0; +inp[5616] = 1043759675; +inp[5617] = 0; +inp[5618] = 1043250151; +inp[5619] = 0; +inp[5620] = 1042740876; +inp[5621] = 0; +inp[5622] = 1042231850; +inp[5623] = 0; +inp[5624] = 1041723072; +inp[5625] = 0; +inp[5626] = 1041214542; +inp[5627] = 0; +inp[5628] = 1073741824; +inp[5629] = 1073741824; +inp[5630] = 1073479711; +inp[5631] = 0; +inp[5632] = 1073217663; +inp[5633] = 0; +inp[5634] = 1072955679; +inp[5635] = 0; +inp[5636] = 1072693759; +inp[5637] = 0; +inp[5638] = 1072431903; +inp[5639] = 0; +inp[5640] = 1072170111; +inp[5641] = 0; +inp[5642] = 1071908383; +inp[5643] = 0; +inp[5644] = 1071646718; +inp[5645] = 0; +inp[5646] = 1071385118; +inp[5647] = 0; +inp[5648] = 1071123581; +inp[5649] = 0; +inp[5650] = 1070862108; +inp[5651] = 0; +inp[5652] = 1070600699; +inp[5653] = 0; +inp[5654] = 1070339354; +inp[5655] = 0; +inp[5656] = 1070078072; +inp[5657] = 0; +inp[5658] = 1069816855; +inp[5659] = 0; +inp[5660] = 1069555701; +inp[5661] = 0; +inp[5662] = 1069294611; +inp[5663] = 0; +inp[5664] = 1069033584; +inp[5665] = 0; +inp[5666] = 1068772622; +inp[5667] = 0; +inp[5668] = 1068511723; +inp[5669] = 0; +inp[5670] = 1068250887; +inp[5671] = 0; +inp[5672] = 1067990116; +inp[5673] = 0; +inp[5674] = 1067729408; +inp[5675] = 0; +inp[5676] = 1067468764; +inp[5677] = 0; +inp[5678] = 1067208183; +inp[5679] = 0; +inp[5680] = 1066947666; +inp[5681] = 0; +inp[5682] = 1066687212; +inp[5683] = 0; +inp[5684] = 1066426822; +inp[5685] = 0; +inp[5686] = 1066166496; +inp[5687] = 0; +inp[5688] = 1065906233; +inp[5689] = 0; +inp[5690] = 1065646034; +inp[5691] = 0; +inp[5692] = 1065385898; +inp[5693] = 0; +inp[5694] = 1065125826; +inp[5695] = 0; +inp[5696] = 1064865817; +inp[5697] = 0; +inp[5698] = 1064605872; +inp[5699] = 0; +inp[5700] = 1064345990; +inp[5701] = 0; +inp[5702] = 1064086172; +inp[5703] = 0; +inp[5704] = 1063826417; +inp[5705] = 0; +inp[5706] = 1063566725; +inp[5707] = 0; +inp[5708] = 1063307097; +inp[5709] = 0; +inp[5710] = 1063047532; +inp[5711] = 0; +inp[5712] = 1062788031; +inp[5713] = 0; +inp[5714] = 1062528593; +inp[5715] = 0; +inp[5716] = 1062269218; +inp[5717] = 0; +inp[5718] = 1062009907; +inp[5719] = 0; +inp[5720] = 1061750659; +inp[5721] = 0; +inp[5722] = 1061491474; +inp[5723] = 0; +inp[5724] = 1061232352; +inp[5725] = 0; +inp[5726] = 1060973294; +inp[5727] = 0; +inp[5728] = 1060714299; +inp[5729] = 0; +inp[5730] = 1060455367; +inp[5731] = 0; +inp[5732] = 1060196498; +inp[5733] = 0; +inp[5734] = 1059937693; +inp[5735] = 0; +inp[5736] = 1059678951; +inp[5737] = 0; +inp[5738] = 1059420272; +inp[5739] = 0; +inp[5740] = 1059161656; +inp[5741] = 0; +inp[5742] = 1058903103; +inp[5743] = 0; +inp[5744] = 1058644613; +inp[5745] = 0; +inp[5746] = 1058386187; +inp[5747] = 0; +inp[5748] = 1058127823; +inp[5749] = 0; +inp[5750] = 1057869523; +inp[5751] = 0; +inp[5752] = 1057611285; +inp[5753] = 0; +inp[5754] = 1057353111; +inp[5755] = 0; +inp[5756] = 1073741824; +inp[5757] = 1073741824; +inp[5758] = 1073610759; +inp[5759] = 0; +inp[5760] = 1073479711; +inp[5761] = 0; +inp[5762] = 1073348679; +inp[5763] = 0; +inp[5764] = 1073217663; +inp[5765] = 0; +inp[5766] = 1073086663; +inp[5767] = 0; +inp[5768] = 1072955679; +inp[5769] = 0; +inp[5770] = 1072824711; +inp[5771] = 0; +inp[5772] = 1072693759; +inp[5773] = 0; +inp[5774] = 1072562823; +inp[5775] = 0; +inp[5776] = 1072431903; +inp[5777] = 0; +inp[5778] = 1072300999; +inp[5779] = 0; +inp[5780] = 1072170111; +inp[5781] = 0; +inp[5782] = 1072039239; +inp[5783] = 0; +inp[5784] = 1071908383; +inp[5785] = 0; +inp[5786] = 1071777542; +inp[5787] = 0; +inp[5788] = 1071646718; +inp[5789] = 0; +inp[5790] = 1071515910; +inp[5791] = 0; +inp[5792] = 1071385118; +inp[5793] = 0; +inp[5794] = 1071254341; +inp[5795] = 0; +inp[5796] = 1071123581; +inp[5797] = 0; +inp[5798] = 1070992836; +inp[5799] = 0; +inp[5800] = 1070862108; +inp[5801] = 0; +inp[5802] = 1070731396; +inp[5803] = 0; +inp[5804] = 1070600699; +inp[5805] = 0; +inp[5806] = 1070470018; +inp[5807] = 0; +inp[5808] = 1070339354; +inp[5809] = 0; +inp[5810] = 1070208705; +inp[5811] = 0; +inp[5812] = 1070078072; +inp[5813] = 0; +inp[5814] = 1069947456; +inp[5815] = 0; +inp[5816] = 1069816855; +inp[5817] = 0; +inp[5818] = 1069686270; +inp[5819] = 0; +inp[5820] = 1069555701; +inp[5821] = 0; +inp[5822] = 1069425148; +inp[5823] = 0; +inp[5824] = 1069294611; +inp[5825] = 0; +inp[5826] = 1069164090; +inp[5827] = 0; +inp[5828] = 1069033584; +inp[5829] = 0; +inp[5830] = 1068903095; +inp[5831] = 0; +inp[5832] = 1068772622; +inp[5833] = 0; +inp[5834] = 1068642164; +inp[5835] = 0; +inp[5836] = 1068511723; +inp[5837] = 0; +inp[5838] = 1068381297; +inp[5839] = 0; +inp[5840] = 1068250887; +inp[5841] = 0; +inp[5842] = 1068120494; +inp[5843] = 0; +inp[5844] = 1067990116; +inp[5845] = 0; +inp[5846] = 1067859754; +inp[5847] = 0; +inp[5848] = 1067729408; +inp[5849] = 0; +inp[5850] = 1067599078; +inp[5851] = 0; +inp[5852] = 1067468764; +inp[5853] = 0; +inp[5854] = 1067338465; +inp[5855] = 0; +inp[5856] = 1067208183; +inp[5857] = 0; +inp[5858] = 1067077916; +inp[5859] = 0; +inp[5860] = 1066947666; +inp[5861] = 0; +inp[5862] = 1066817431; +inp[5863] = 0; +inp[5864] = 1066687212; +inp[5865] = 0; +inp[5866] = 1066557009; +inp[5867] = 0; +inp[5868] = 1066426822; +inp[5869] = 0; +inp[5870] = 1066296651; +inp[5871] = 0; +inp[5872] = 1066166496; +inp[5873] = 0; +inp[5874] = 1066036357; +inp[5875] = 0; +inp[5876] = 1065906233; +inp[5877] = 0; +inp[5878] = 1065776126; +inp[5879] = 0; +inp[5880] = 1065646034; +inp[5881] = 0; +inp[5882] = 1065515958; +inp[5883] = 0; +inp[5884] = 1073741824; +inp[5885] = 1073741824; +inp[5886] = 1073676289; +inp[5887] = 0; +inp[5888] = 1073610759; +inp[5889] = 0; +inp[5890] = 1073545233; +inp[5891] = 0; +inp[5892] = 1073479711; +inp[5893] = 0; +inp[5894] = 1073414193; +inp[5895] = 0; +inp[5896] = 1073348679; +inp[5897] = 0; +inp[5898] = 1073283169; +inp[5899] = 0; +inp[5900] = 1073217663; +inp[5901] = 0; +inp[5902] = 1073152161; +inp[5903] = 0; +inp[5904] = 1073086663; +inp[5905] = 0; +inp[5906] = 1073021169; +inp[5907] = 0; +inp[5908] = 1072955679; +inp[5909] = 0; +inp[5910] = 1072890193; +inp[5911] = 0; +inp[5912] = 1072824711; +inp[5913] = 0; +inp[5914] = 1072759233; +inp[5915] = 0; +inp[5916] = 1072693759; +inp[5917] = 0; +inp[5918] = 1072628289; +inp[5919] = 0; +inp[5920] = 1072562823; +inp[5921] = 0; +inp[5922] = 1072497361; +inp[5923] = 0; +inp[5924] = 1072431903; +inp[5925] = 0; +inp[5926] = 1072366449; +inp[5927] = 0; +inp[5928] = 1072300999; +inp[5929] = 0; +inp[5930] = 1072235553; +inp[5931] = 0; +inp[5932] = 1072170111; +inp[5933] = 0; +inp[5934] = 1072104673; +inp[5935] = 0; +inp[5936] = 1072039239; +inp[5937] = 0; +inp[5938] = 1071973809; +inp[5939] = 0; +inp[5940] = 1071908383; +inp[5941] = 0; +inp[5942] = 1071842961; +inp[5943] = 0; +inp[5944] = 1071777542; +inp[5945] = 0; +inp[5946] = 1071712128; +inp[5947] = 0; +inp[5948] = 1071646718; +inp[5949] = 0; +inp[5950] = 1071581312; +inp[5951] = 0; +inp[5952] = 1071515910; +inp[5953] = 0; +inp[5954] = 1071450512; +inp[5955] = 0; +inp[5956] = 1071385118; +inp[5957] = 0; +inp[5958] = 1071319727; +inp[5959] = 0; +inp[5960] = 1071254341; +inp[5961] = 0; +inp[5962] = 1071188959; +inp[5963] = 0; +inp[5964] = 1071123581; +inp[5965] = 0; +inp[5966] = 1071058207; +inp[5967] = 0; +inp[5968] = 1070992836; +inp[5969] = 0; +inp[5970] = 1070927470; +inp[5971] = 0; +inp[5972] = 1070862108; +inp[5973] = 0; +inp[5974] = 1070796750; +inp[5975] = 0; +inp[5976] = 1070731396; +inp[5977] = 0; +inp[5978] = 1070666045; +inp[5979] = 0; +inp[5980] = 1070600699; +inp[5981] = 0; +inp[5982] = 1070535357; +inp[5983] = 0; +inp[5984] = 1070470018; +inp[5985] = 0; +inp[5986] = 1070404684; +inp[5987] = 0; +inp[5988] = 1070339354; +inp[5989] = 0; +inp[5990] = 1070274027; +inp[5991] = 0; +inp[5992] = 1070208705; +inp[5993] = 0; +inp[5994] = 1070143387; +inp[5995] = 0; +inp[5996] = 1070078072; +inp[5997] = 0; +inp[5998] = 1070012762; +inp[5999] = 0; +inp[6000] = 1069947456; +inp[6001] = 0; +inp[6002] = 1069882153; +inp[6003] = 0; +inp[6004] = 1069816855; +inp[6005] = 0; +inp[6006] = 1069751560; +inp[6007] = 0; +inp[6008] = 1069686270; +inp[6009] = 0; +inp[6010] = 1069620983; +inp[6011] = 0; +inp[6012] = 1073741824; +inp[6013] = 1073741824; +inp[6014] = 1073709056; +inp[6015] = 0; +inp[6016] = 1073676289; +inp[6017] = 0; +inp[6018] = 1073643524; +inp[6019] = 0; +inp[6020] = 1073610759; +inp[6021] = 0; +inp[6022] = 1073577996; +inp[6023] = 0; +inp[6024] = 1073545233; +inp[6025] = 0; +inp[6026] = 1073512472; +inp[6027] = 0; +inp[6028] = 1073479711; +inp[6029] = 0; +inp[6030] = 1073446952; +inp[6031] = 0; +inp[6032] = 1073414193; +inp[6033] = 0; +inp[6034] = 1073381436; +inp[6035] = 0; +inp[6036] = 1073348679; +inp[6037] = 0; +inp[6038] = 1073315924; +inp[6039] = 0; +inp[6040] = 1073283169; +inp[6041] = 0; +inp[6042] = 1073250416; +inp[6043] = 0; +inp[6044] = 1073217663; +inp[6045] = 0; +inp[6046] = 1073184912; +inp[6047] = 0; +inp[6048] = 1073152161; +inp[6049] = 0; +inp[6050] = 1073119412; +inp[6051] = 0; +inp[6052] = 1073086663; +inp[6053] = 0; +inp[6054] = 1073053916; +inp[6055] = 0; +inp[6056] = 1073021169; +inp[6057] = 0; +inp[6058] = 1072988424; +inp[6059] = 0; +inp[6060] = 1072955679; +inp[6061] = 0; +inp[6062] = 1072922936; +inp[6063] = 0; +inp[6064] = 1072890193; +inp[6065] = 0; +inp[6066] = 1072857452; +inp[6067] = 0; +inp[6068] = 1072824711; +inp[6069] = 0; +inp[6070] = 1072791972; +inp[6071] = 0; +inp[6072] = 1072759233; +inp[6073] = 0; +inp[6074] = 1072726496; +inp[6075] = 0; +inp[6076] = 1072693759; +inp[6077] = 0; +inp[6078] = 1072661024; +inp[6079] = 0; +inp[6080] = 1072628289; +inp[6081] = 0; +inp[6082] = 1072595556; +inp[6083] = 0; +inp[6084] = 1072562823; +inp[6085] = 0; +inp[6086] = 1072530092; +inp[6087] = 0; +inp[6088] = 1072497361; +inp[6089] = 0; +inp[6090] = 1072464632; +inp[6091] = 0; +inp[6092] = 1072431903; +inp[6093] = 0; +inp[6094] = 1072399176; +inp[6095] = 0; +inp[6096] = 1072366449; +inp[6097] = 0; +inp[6098] = 1072333724; +inp[6099] = 0; +inp[6100] = 1072300999; +inp[6101] = 0; +inp[6102] = 1072268276; +inp[6103] = 0; +inp[6104] = 1072235553; +inp[6105] = 0; +inp[6106] = 1072202831; +inp[6107] = 0; +inp[6108] = 1072170111; +inp[6109] = 0; +inp[6110] = 1072137391; +inp[6111] = 0; +inp[6112] = 1072104673; +inp[6113] = 0; +inp[6114] = 1072071955; +inp[6115] = 0; +inp[6116] = 1072039239; +inp[6117] = 0; +inp[6118] = 1072006523; +inp[6119] = 0; +inp[6120] = 1071973809; +inp[6121] = 0; +inp[6122] = 1071941095; +inp[6123] = 0; +inp[6124] = 1071908383; +inp[6125] = 0; +inp[6126] = 1071875671; +inp[6127] = 0; +inp[6128] = 1071842961; +inp[6129] = 0; +inp[6130] = 1071810251; +inp[6131] = 0; +inp[6132] = 1071777542; +inp[6133] = 0; +inp[6134] = 1071744835; +inp[6135] = 0; +inp[6136] = 1071712128; +inp[6137] = 0; +inp[6138] = 1071679423; +inp[6139] = 0; +inp[6140] = 1073741824; +inp[6141] = 1073741824; +inp[6142] = 1073725440; +inp[6143] = 0; +inp[6144] = 1073709056; +inp[6145] = 0; +inp[6146] = 1073692673; +inp[6147] = 0; +inp[6148] = 1073676289; +inp[6149] = 0; +inp[6150] = 1073659907; +inp[6151] = 0; +inp[6152] = 1073643524; +inp[6153] = 0; +inp[6154] = 1073627142; +inp[6155] = 0; +inp[6156] = 1073610759; +inp[6157] = 0; +inp[6158] = 1073594378; +inp[6159] = 0; +inp[6160] = 1073577996; +inp[6161] = 0; +inp[6162] = 1073561615; +inp[6163] = 0; +inp[6164] = 1073545233; +inp[6165] = 0; +inp[6166] = 1073528853; +inp[6167] = 0; +inp[6168] = 1073512472; +inp[6169] = 0; +inp[6170] = 1073496092; +inp[6171] = 0; +inp[6172] = 1073479711; +inp[6173] = 0; +inp[6174] = 1073463332; +inp[6175] = 0; +inp[6176] = 1073446952; +inp[6177] = 0; +inp[6178] = 1073430573; +inp[6179] = 0; +inp[6180] = 1073414193; +inp[6181] = 0; +inp[6182] = 1073397815; +inp[6183] = 0; +inp[6184] = 1073381436; +inp[6185] = 0; +inp[6186] = 1073365058; +inp[6187] = 0; +inp[6188] = 1073348679; +inp[6189] = 0; +inp[6190] = 1073332302; +inp[6191] = 0; +inp[6192] = 1073315924; +inp[6193] = 0; +inp[6194] = 1073299547; +inp[6195] = 0; +inp[6196] = 1073283169; +inp[6197] = 0; +inp[6198] = 1073266793; +inp[6199] = 0; +inp[6200] = 1073250416; +inp[6201] = 0; +inp[6202] = 1073234040; +inp[6203] = 0; +inp[6204] = 1073217663; +inp[6205] = 0; +inp[6206] = 1073201288; +inp[6207] = 0; +inp[6208] = 1073184912; +inp[6209] = 0; +inp[6210] = 1073168537; +inp[6211] = 0; +inp[6212] = 1073152161; +inp[6213] = 0; +inp[6214] = 1073135787; +inp[6215] = 0; +inp[6216] = 1073119412; +inp[6217] = 0; +inp[6218] = 1073103038; +inp[6219] = 0; +inp[6220] = 1073086663; +inp[6221] = 0; +inp[6222] = 1073070290; +inp[6223] = 0; +inp[6224] = 1073053916; +inp[6225] = 0; +inp[6226] = 1073037543; +inp[6227] = 0; +inp[6228] = 1073021169; +inp[6229] = 0; +inp[6230] = 1073004797; +inp[6231] = 0; +inp[6232] = 1072988424; +inp[6233] = 0; +inp[6234] = 1072972052; +inp[6235] = 0; +inp[6236] = 1072955679; +inp[6237] = 0; +inp[6238] = 1072939308; +inp[6239] = 0; +inp[6240] = 1072922936; +inp[6241] = 0; +inp[6242] = 1072906565; +inp[6243] = 0; +inp[6244] = 1072890193; +inp[6245] = 0; +inp[6246] = 1072873823; +inp[6247] = 0; +inp[6248] = 1072857452; +inp[6249] = 0; +inp[6250] = 1072841082; +inp[6251] = 0; +inp[6252] = 1072824711; +inp[6253] = 0; +inp[6254] = 1072808342; +inp[6255] = 0; +inp[6256] = 1072791972; +inp[6257] = 0; +inp[6258] = 1072775602; +inp[6259] = 0; +inp[6260] = 1072759233; +inp[6261] = 0; +inp[6262] = 1072742864; +inp[6263] = 0; +inp[6264] = 1072726496; +inp[6265] = 0; +inp[6266] = 1072710127; +inp[6267] = 0; +inp[6268] = 1073741824; +inp[6269] = 1073741824; +inp[6270] = 1073733632; +inp[6271] = 0; +inp[6272] = 1073725440; +inp[6273] = 0; +inp[6274] = 1073717248; +inp[6275] = 0; +inp[6276] = 1073709056; +inp[6277] = 0; +inp[6278] = 1073700864; +inp[6279] = 0; +inp[6280] = 1073692673; +inp[6281] = 0; +inp[6282] = 1073684481; +inp[6283] = 0; +inp[6284] = 1073676289; +inp[6285] = 0; +inp[6286] = 1073668098; +inp[6287] = 0; +inp[6288] = 1073659907; +inp[6289] = 0; +inp[6290] = 1073651715; +inp[6291] = 0; +inp[6292] = 1073643524; +inp[6293] = 0; +inp[6294] = 1073635333; +inp[6295] = 0; +inp[6296] = 1073627142; +inp[6297] = 0; +inp[6298] = 1073618951; +inp[6299] = 0; +inp[6300] = 1073610759; +inp[6301] = 0; +inp[6302] = 1073602569; +inp[6303] = 0; +inp[6304] = 1073594378; +inp[6305] = 0; +inp[6306] = 1073586187; +inp[6307] = 0; +inp[6308] = 1073577996; +inp[6309] = 0; +inp[6310] = 1073569805; +inp[6311] = 0; +inp[6312] = 1073561615; +inp[6313] = 0; +inp[6314] = 1073553424; +inp[6315] = 0; +inp[6316] = 1073545233; +inp[6317] = 0; +inp[6318] = 1073537043; +inp[6319] = 0; +inp[6320] = 1073528853; +inp[6321] = 0; +inp[6322] = 1073520662; +inp[6323] = 0; +inp[6324] = 1073512472; +inp[6325] = 0; +inp[6326] = 1073504282; +inp[6327] = 0; +inp[6328] = 1073496092; +inp[6329] = 0; +inp[6330] = 1073487902; +inp[6331] = 0; +inp[6332] = 1073479711; +inp[6333] = 0; +inp[6334] = 1073471522; +inp[6335] = 0; +inp[6336] = 1073463332; +inp[6337] = 0; +inp[6338] = 1073455142; +inp[6339] = 0; +inp[6340] = 1073446952; +inp[6341] = 0; +inp[6342] = 1073438762; +inp[6343] = 0; +inp[6344] = 1073430573; +inp[6345] = 0; +inp[6346] = 1073422383; +inp[6347] = 0; +inp[6348] = 1073414193; +inp[6349] = 0; +inp[6350] = 1073406004; +inp[6351] = 0; +inp[6352] = 1073397815; +inp[6353] = 0; +inp[6354] = 1073389625; +inp[6355] = 0; +inp[6356] = 1073381436; +inp[6357] = 0; +inp[6358] = 1073373247; +inp[6359] = 0; +inp[6360] = 1073365058; +inp[6361] = 0; +inp[6362] = 1073356869; +inp[6363] = 0; +inp[6364] = 1073348679; +inp[6365] = 0; +inp[6366] = 1073340491; +inp[6367] = 0; +inp[6368] = 1073332302; +inp[6369] = 0; +inp[6370] = 1073324113; +inp[6371] = 0; +inp[6372] = 1073315924; +inp[6373] = 0; +inp[6374] = 1073307735; +inp[6375] = 0; +inp[6376] = 1073299547; +inp[6377] = 0; +inp[6378] = 1073291358; +inp[6379] = 0; +inp[6380] = 1073283169; +inp[6381] = 0; +inp[6382] = 1073274981; +inp[6383] = 0; +inp[6384] = 1073266793; +inp[6385] = 0; +inp[6386] = 1073258604; +inp[6387] = 0; +inp[6388] = 1073250416; +inp[6389] = 0; +inp[6390] = 1073242228; +inp[6391] = 0; +inp[6392] = 1073234040; +inp[6393] = 0; +inp[6394] = 1073225852; +inp[6395] = 0; +inp[6396] = 1073741824; +inp[6397] = 1073741824; +inp[6398] = 1073737728; +inp[6399] = 0; +inp[6400] = 1073733632; +inp[6401] = 0; +inp[6402] = 1073729536; +inp[6403] = 0; +inp[6404] = 1073725440; +inp[6405] = 0; +inp[6406] = 1073721344; +inp[6407] = 0; +inp[6408] = 1073717248; +inp[6409] = 0; +inp[6410] = 1073713152; +inp[6411] = 0; +inp[6412] = 1073709056; +inp[6413] = 0; +inp[6414] = 1073704960; +inp[6415] = 0; +inp[6416] = 1073700864; +inp[6417] = 0; +inp[6418] = 1073696768; +inp[6419] = 0; +inp[6420] = 1073692673; +inp[6421] = 0; +inp[6422] = 1073688577; +inp[6423] = 0; +inp[6424] = 1073684481; +inp[6425] = 0; +inp[6426] = 1073680385; +inp[6427] = 0; +inp[6428] = 1073676289; +inp[6429] = 0; +inp[6430] = 1073672194; +inp[6431] = 0; +inp[6432] = 1073668098; +inp[6433] = 0; +inp[6434] = 1073664002; +inp[6435] = 0; +inp[6436] = 1073659907; +inp[6437] = 0; +inp[6438] = 1073655811; +inp[6439] = 0; +inp[6440] = 1073651715; +inp[6441] = 0; +inp[6442] = 1073647620; +inp[6443] = 0; +inp[6444] = 1073643524; +inp[6445] = 0; +inp[6446] = 1073639428; +inp[6447] = 0; +inp[6448] = 1073635333; +inp[6449] = 0; +inp[6450] = 1073631237; +inp[6451] = 0; +inp[6452] = 1073627142; +inp[6453] = 0; +inp[6454] = 1073623046; +inp[6455] = 0; +inp[6456] = 1073618951; +inp[6457] = 0; +inp[6458] = 1073614855; +inp[6459] = 0; +inp[6460] = 1073610759; +inp[6461] = 0; +inp[6462] = 1073606664; +inp[6463] = 0; +inp[6464] = 1073602569; +inp[6465] = 0; +inp[6466] = 1073598473; +inp[6467] = 0; +inp[6468] = 1073594378; +inp[6469] = 0; +inp[6470] = 1073590282; +inp[6471] = 0; +inp[6472] = 1073586187; +inp[6473] = 0; +inp[6474] = 1073582091; +inp[6475] = 0; +inp[6476] = 1073577996; +inp[6477] = 0; +inp[6478] = 1073573901; +inp[6479] = 0; +inp[6480] = 1073569805; +inp[6481] = 0; +inp[6482] = 1073565710; +inp[6483] = 0; +inp[6484] = 1073561615; +inp[6485] = 0; +inp[6486] = 1073557519; +inp[6487] = 0; +inp[6488] = 1073553424; +inp[6489] = 0; +inp[6490] = 1073549329; +inp[6491] = 0; +inp[6492] = 1073545233; +inp[6493] = 0; +inp[6494] = 1073541138; +inp[6495] = 0; +inp[6496] = 1073537043; +inp[6497] = 0; +inp[6498] = 1073532948; +inp[6499] = 0; +inp[6500] = 1073528853; +inp[6501] = 0; +inp[6502] = 1073524757; +inp[6503] = 0; +inp[6504] = 1073520662; +inp[6505] = 0; +inp[6506] = 1073516567; +inp[6507] = 0; +inp[6508] = 1073512472; +inp[6509] = 0; +inp[6510] = 1073508377; +inp[6511] = 0; +inp[6512] = 1073504282; +inp[6513] = 0; +inp[6514] = 1073500187; +inp[6515] = 0; +inp[6516] = 1073496092; +inp[6517] = 0; +inp[6518] = 1073491997; +inp[6519] = 0; +inp[6520] = 1073487902; +inp[6521] = 0; +inp[6522] = 1073483807; +inp[6523] = 0; +inp[6524] = 1073741824; +inp[6525] = 1073741824; +inp[6526] = 1073739776; +inp[6527] = 0; +inp[6528] = 1073737728; +inp[6529] = 0; +inp[6530] = 1073735680; +inp[6531] = 0; +inp[6532] = 1073733632; +inp[6533] = 0; +inp[6534] = 1073731584; +inp[6535] = 0; +inp[6536] = 1073729536; +inp[6537] = 0; +inp[6538] = 1073727488; +inp[6539] = 0; +inp[6540] = 1073725440; +inp[6541] = 0; +inp[6542] = 1073723392; +inp[6543] = 0; +inp[6544] = 1073721344; +inp[6545] = 0; +inp[6546] = 1073719296; +inp[6547] = 0; +inp[6548] = 1073717248; +inp[6549] = 0; +inp[6550] = 1073715200; +inp[6551] = 0; +inp[6552] = 1073713152; +inp[6553] = 0; +inp[6554] = 1073711104; +inp[6555] = 0; +inp[6556] = 1073709056; +inp[6557] = 0; +inp[6558] = 1073707008; +inp[6559] = 0; +inp[6560] = 1073704960; +inp[6561] = 0; +inp[6562] = 1073702912; +inp[6563] = 0; +inp[6564] = 1073700864; +inp[6565] = 0; +inp[6566] = 1073698816; +inp[6567] = 0; +inp[6568] = 1073696768; +inp[6569] = 0; +inp[6570] = 1073694721; +inp[6571] = 0; +inp[6572] = 1073692673; +inp[6573] = 0; +inp[6574] = 1073690625; +inp[6575] = 0; +inp[6576] = 1073688577; +inp[6577] = 0; +inp[6578] = 1073686529; +inp[6579] = 0; +inp[6580] = 1073684481; +inp[6581] = 0; +inp[6582] = 1073682433; +inp[6583] = 0; +inp[6584] = 1073680385; +inp[6585] = 0; +inp[6586] = 1073678337; +inp[6587] = 0; +inp[6588] = 1073676289; +inp[6589] = 0; +inp[6590] = 1073674242; +inp[6591] = 0; +inp[6592] = 1073672194; +inp[6593] = 0; +inp[6594] = 1073670146; +inp[6595] = 0; +inp[6596] = 1073668098; +inp[6597] = 0; +inp[6598] = 1073666050; +inp[6599] = 0; +inp[6600] = 1073664002; +inp[6601] = 0; +inp[6602] = 1073661954; +inp[6603] = 0; +inp[6604] = 1073659907; +inp[6605] = 0; +inp[6606] = 1073657859; +inp[6607] = 0; +inp[6608] = 1073655811; +inp[6609] = 0; +inp[6610] = 1073653763; +inp[6611] = 0; +inp[6612] = 1073651715; +inp[6613] = 0; +inp[6614] = 1073649667; +inp[6615] = 0; +inp[6616] = 1073647620; +inp[6617] = 0; +inp[6618] = 1073645572; +inp[6619] = 0; +inp[6620] = 1073643524; +inp[6621] = 0; +inp[6622] = 1073641476; +inp[6623] = 0; +inp[6624] = 1073639428; +inp[6625] = 0; +inp[6626] = 1073637381; +inp[6627] = 0; +inp[6628] = 1073635333; +inp[6629] = 0; +inp[6630] = 1073633285; +inp[6631] = 0; +inp[6632] = 1073631237; +inp[6633] = 0; +inp[6634] = 1073629189; +inp[6635] = 0; +inp[6636] = 1073627142; +inp[6637] = 0; +inp[6638] = 1073625094; +inp[6639] = 0; +inp[6640] = 1073623046; +inp[6641] = 0; +inp[6642] = 1073620998; +inp[6643] = 0; +inp[6644] = 1073618951; +inp[6645] = 0; +inp[6646] = 1073616903; +inp[6647] = 0; +inp[6648] = 1073614855; +inp[6649] = 0; +inp[6650] = 1073612807; +inp[6651] = 0; +inp[6652] = 1073741824; +inp[6653] = 1073741824; +inp[6654] = 1073740800; +inp[6655] = 0; +inp[6656] = 1073739776; +inp[6657] = 0; +inp[6658] = 1073738752; +inp[6659] = 0; +inp[6660] = 1073737728; +inp[6661] = 0; +inp[6662] = 1073736704; +inp[6663] = 0; +inp[6664] = 1073735680; +inp[6665] = 0; +inp[6666] = 1073734656; +inp[6667] = 0; +inp[6668] = 1073733632; +inp[6669] = 0; +inp[6670] = 1073732608; +inp[6671] = 0; +inp[6672] = 1073731584; +inp[6673] = 0; +inp[6674] = 1073730560; +inp[6675] = 0; +inp[6676] = 1073729536; +inp[6677] = 0; +inp[6678] = 1073728512; +inp[6679] = 0; +inp[6680] = 1073727488; +inp[6681] = 0; +inp[6682] = 1073726464; +inp[6683] = 0; +inp[6684] = 1073725440; +inp[6685] = 0; +inp[6686] = 1073724416; +inp[6687] = 0; +inp[6688] = 1073723392; +inp[6689] = 0; +inp[6690] = 1073722368; +inp[6691] = 0; +inp[6692] = 1073721344; +inp[6693] = 0; +inp[6694] = 1073720320; +inp[6695] = 0; +inp[6696] = 1073719296; +inp[6697] = 0; +inp[6698] = 1073718272; +inp[6699] = 0; +inp[6700] = 1073717248; +inp[6701] = 0; +inp[6702] = 1073716224; +inp[6703] = 0; +inp[6704] = 1073715200; +inp[6705] = 0; +inp[6706] = 1073714176; +inp[6707] = 0; +inp[6708] = 1073713152; +inp[6709] = 0; +inp[6710] = 1073712128; +inp[6711] = 0; +inp[6712] = 1073711104; +inp[6713] = 0; +inp[6714] = 1073710080; +inp[6715] = 0; +inp[6716] = 1073709056; +inp[6717] = 0; +inp[6718] = 1073708032; +inp[6719] = 0; +inp[6720] = 1073707008; +inp[6721] = 0; +inp[6722] = 1073705984; +inp[6723] = 0; +inp[6724] = 1073704960; +inp[6725] = 0; +inp[6726] = 1073703936; +inp[6727] = 0; +inp[6728] = 1073702912; +inp[6729] = 0; +inp[6730] = 1073701888; +inp[6731] = 0; +inp[6732] = 1073700864; +inp[6733] = 0; +inp[6734] = 1073699840; +inp[6735] = 0; +inp[6736] = 1073698816; +inp[6737] = 0; +inp[6738] = 1073697792; +inp[6739] = 0; +inp[6740] = 1073696768; +inp[6741] = 0; +inp[6742] = 1073695744; +inp[6743] = 0; +inp[6744] = 1073694721; +inp[6745] = 0; +inp[6746] = 1073693697; +inp[6747] = 0; +inp[6748] = 1073692673; +inp[6749] = 0; +inp[6750] = 1073691649; +inp[6751] = 0; +inp[6752] = 1073690625; +inp[6753] = 0; +inp[6754] = 1073689601; +inp[6755] = 0; +inp[6756] = 1073688577; +inp[6757] = 0; +inp[6758] = 1073687553; +inp[6759] = 0; +inp[6760] = 1073686529; +inp[6761] = 0; +inp[6762] = 1073685505; +inp[6763] = 0; +inp[6764] = 1073684481; +inp[6765] = 0; +inp[6766] = 1073683457; +inp[6767] = 0; +inp[6768] = 1073682433; +inp[6769] = 0; +inp[6770] = 1073681409; +inp[6771] = 0; +inp[6772] = 1073680385; +inp[6773] = 0; +inp[6774] = 1073679361; +inp[6775] = 0; +inp[6776] = 1073678337; +inp[6777] = 0; +inp[6778] = 1073677313; +inp[6779] = 0; +inp[6780] = 1073741824; +inp[6781] = 1073741824; +inp[6782] = 1073741312; +inp[6783] = 0; +inp[6784] = 1073740800; +inp[6785] = 0; +inp[6786] = 1073740288; +inp[6787] = 0; +inp[6788] = 1073739776; +inp[6789] = 0; +inp[6790] = 1073739264; +inp[6791] = 0; +inp[6792] = 1073738752; +inp[6793] = 0; +inp[6794] = 1073738240; +inp[6795] = 0; +inp[6796] = 1073737728; +inp[6797] = 0; +inp[6798] = 1073737216; +inp[6799] = 0; +inp[6800] = 1073736704; +inp[6801] = 0; +inp[6802] = 1073736192; +inp[6803] = 0; +inp[6804] = 1073735680; +inp[6805] = 0; +inp[6806] = 1073735168; +inp[6807] = 0; +inp[6808] = 1073734656; +inp[6809] = 0; +inp[6810] = 1073734144; +inp[6811] = 0; +inp[6812] = 1073733632; +inp[6813] = 0; +inp[6814] = 1073733120; +inp[6815] = 0; +inp[6816] = 1073732608; +inp[6817] = 0; +inp[6818] = 1073732096; +inp[6819] = 0; +inp[6820] = 1073731584; +inp[6821] = 0; +inp[6822] = 1073731072; +inp[6823] = 0; +inp[6824] = 1073730560; +inp[6825] = 0; +inp[6826] = 1073730048; +inp[6827] = 0; +inp[6828] = 1073729536; +inp[6829] = 0; +inp[6830] = 1073729024; +inp[6831] = 0; +inp[6832] = 1073728512; +inp[6833] = 0; +inp[6834] = 1073728000; +inp[6835] = 0; +inp[6836] = 1073727488; +inp[6837] = 0; +inp[6838] = 1073726976; +inp[6839] = 0; +inp[6840] = 1073726464; +inp[6841] = 0; +inp[6842] = 1073725952; +inp[6843] = 0; +inp[6844] = 1073725440; +inp[6845] = 0; +inp[6846] = 1073724928; +inp[6847] = 0; +inp[6848] = 1073724416; +inp[6849] = 0; +inp[6850] = 1073723904; +inp[6851] = 0; +inp[6852] = 1073723392; +inp[6853] = 0; +inp[6854] = 1073722880; +inp[6855] = 0; +inp[6856] = 1073722368; +inp[6857] = 0; +inp[6858] = 1073721856; +inp[6859] = 0; +inp[6860] = 1073721344; +inp[6861] = 0; +inp[6862] = 1073720832; +inp[6863] = 0; +inp[6864] = 1073720320; +inp[6865] = 0; +inp[6866] = 1073719808; +inp[6867] = 0; +inp[6868] = 1073719296; +inp[6869] = 0; +inp[6870] = 1073718784; +inp[6871] = 0; +inp[6872] = 1073718272; +inp[6873] = 0; +inp[6874] = 1073717760; +inp[6875] = 0; +inp[6876] = 1073717248; +inp[6877] = 0; +inp[6878] = 1073716736; +inp[6879] = 0; +inp[6880] = 1073716224; +inp[6881] = 0; +inp[6882] = 1073715712; +inp[6883] = 0; +inp[6884] = 1073715200; +inp[6885] = 0; +inp[6886] = 1073714688; +inp[6887] = 0; +inp[6888] = 1073714176; +inp[6889] = 0; +inp[6890] = 1073713664; +inp[6891] = 0; +inp[6892] = 1073713152; +inp[6893] = 0; +inp[6894] = 1073712640; +inp[6895] = 0; +inp[6896] = 1073712128; +inp[6897] = 0; +inp[6898] = 1073711616; +inp[6899] = 0; +inp[6900] = 1073711104; +inp[6901] = 0; +inp[6902] = 1073710592; +inp[6903] = 0; +inp[6904] = 1073710080; +inp[6905] = 0; +inp[6906] = 1073709568; +inp[6907] = 0; +inp[6908] = 1073741824; +inp[6909] = 1073741824; +inp[6910] = 1073741568; +inp[6911] = 0; +inp[6912] = 1073741312; +inp[6913] = 0; +inp[6914] = 1073741056; +inp[6915] = 0; +inp[6916] = 1073740800; +inp[6917] = 0; +inp[6918] = 1073740544; +inp[6919] = 0; +inp[6920] = 1073740288; +inp[6921] = 0; +inp[6922] = 1073740032; +inp[6923] = 0; +inp[6924] = 1073739776; +inp[6925] = 0; +inp[6926] = 1073739520; +inp[6927] = 0; +inp[6928] = 1073739264; +inp[6929] = 0; +inp[6930] = 1073739008; +inp[6931] = 0; +inp[6932] = 1073738752; +inp[6933] = 0; +inp[6934] = 1073738496; +inp[6935] = 0; +inp[6936] = 1073738240; +inp[6937] = 0; +inp[6938] = 1073737984; +inp[6939] = 0; +inp[6940] = 1073737728; +inp[6941] = 0; +inp[6942] = 1073737472; +inp[6943] = 0; +inp[6944] = 1073737216; +inp[6945] = 0; +inp[6946] = 1073736960; +inp[6947] = 0; +inp[6948] = 1073736704; +inp[6949] = 0; +inp[6950] = 1073736448; +inp[6951] = 0; +inp[6952] = 1073736192; +inp[6953] = 0; +inp[6954] = 1073735936; +inp[6955] = 0; +inp[6956] = 1073735680; +inp[6957] = 0; +inp[6958] = 1073735424; +inp[6959] = 0; +inp[6960] = 1073735168; +inp[6961] = 0; +inp[6962] = 1073734912; +inp[6963] = 0; +inp[6964] = 1073734656; +inp[6965] = 0; +inp[6966] = 1073734400; +inp[6967] = 0; +inp[6968] = 1073734144; +inp[6969] = 0; +inp[6970] = 1073733888; +inp[6971] = 0; +inp[6972] = 1073733632; +inp[6973] = 0; +inp[6974] = 1073733376; +inp[6975] = 0; +inp[6976] = 1073733120; +inp[6977] = 0; +inp[6978] = 1073732864; +inp[6979] = 0; +inp[6980] = 1073732608; +inp[6981] = 0; +inp[6982] = 1073732352; +inp[6983] = 0; +inp[6984] = 1073732096; +inp[6985] = 0; +inp[6986] = 1073731840; +inp[6987] = 0; +inp[6988] = 1073731584; +inp[6989] = 0; +inp[6990] = 1073731328; +inp[6991] = 0; +inp[6992] = 1073731072; +inp[6993] = 0; +inp[6994] = 1073730816; +inp[6995] = 0; +inp[6996] = 1073730560; +inp[6997] = 0; +inp[6998] = 1073730304; +inp[6999] = 0; +inp[7000] = 1073730048; +inp[7001] = 0; +inp[7002] = 1073729792; +inp[7003] = 0; +inp[7004] = 1073729536; +inp[7005] = 0; +inp[7006] = 1073729280; +inp[7007] = 0; +inp[7008] = 1073729024; +inp[7009] = 0; +inp[7010] = 1073728768; +inp[7011] = 0; +inp[7012] = 1073728512; +inp[7013] = 0; +inp[7014] = 1073728256; +inp[7015] = 0; +inp[7016] = 1073728000; +inp[7017] = 0; +inp[7018] = 1073727744; +inp[7019] = 0; +inp[7020] = 1073727488; +inp[7021] = 0; +inp[7022] = 1073727232; +inp[7023] = 0; +inp[7024] = 1073726976; +inp[7025] = 0; +inp[7026] = 1073726720; +inp[7027] = 0; +inp[7028] = 1073726464; +inp[7029] = 0; +inp[7030] = 1073726208; +inp[7031] = 0; +inp[7032] = 1073725952; +inp[7033] = 0; +inp[7034] = 1073725696; +inp[7035] = 0; +inp[7036] = 1073741824; +inp[7037] = 1073741824; +inp[7038] = 1073741696; +inp[7039] = 0; +inp[7040] = 1073741568; +inp[7041] = 0; +inp[7042] = 1073741440; +inp[7043] = 0; +inp[7044] = 1073741312; +inp[7045] = 0; +inp[7046] = 1073741184; +inp[7047] = 0; +inp[7048] = 1073741056; +inp[7049] = 0; +inp[7050] = 1073740928; +inp[7051] = 0; +inp[7052] = 1073740800; +inp[7053] = 0; +inp[7054] = 1073740672; +inp[7055] = 0; +inp[7056] = 1073740544; +inp[7057] = 0; +inp[7058] = 1073740416; +inp[7059] = 0; +inp[7060] = 1073740288; +inp[7061] = 0; +inp[7062] = 1073740160; +inp[7063] = 0; +inp[7064] = 1073740032; +inp[7065] = 0; +inp[7066] = 1073739904; +inp[7067] = 0; +inp[7068] = 1073739776; +inp[7069] = 0; +inp[7070] = 1073739648; +inp[7071] = 0; +inp[7072] = 1073739520; +inp[7073] = 0; +inp[7074] = 1073739392; +inp[7075] = 0; +inp[7076] = 1073739264; +inp[7077] = 0; +inp[7078] = 1073739136; +inp[7079] = 0; +inp[7080] = 1073739008; +inp[7081] = 0; +inp[7082] = 1073738880; +inp[7083] = 0; +inp[7084] = 1073738752; +inp[7085] = 0; +inp[7086] = 1073738624; +inp[7087] = 0; +inp[7088] = 1073738496; +inp[7089] = 0; +inp[7090] = 1073738368; +inp[7091] = 0; +inp[7092] = 1073738240; +inp[7093] = 0; +inp[7094] = 1073738112; +inp[7095] = 0; +inp[7096] = 1073737984; +inp[7097] = 0; +inp[7098] = 1073737856; +inp[7099] = 0; +inp[7100] = 1073737728; +inp[7101] = 0; +inp[7102] = 1073737600; +inp[7103] = 0; +inp[7104] = 1073737472; +inp[7105] = 0; +inp[7106] = 1073737344; +inp[7107] = 0; +inp[7108] = 1073737216; +inp[7109] = 0; +inp[7110] = 1073737088; +inp[7111] = 0; +inp[7112] = 1073736960; +inp[7113] = 0; +inp[7114] = 1073736832; +inp[7115] = 0; +inp[7116] = 1073736704; +inp[7117] = 0; +inp[7118] = 1073736576; +inp[7119] = 0; +inp[7120] = 1073736448; +inp[7121] = 0; +inp[7122] = 1073736320; +inp[7123] = 0; +inp[7124] = 1073736192; +inp[7125] = 0; +inp[7126] = 1073736064; +inp[7127] = 0; +inp[7128] = 1073735936; +inp[7129] = 0; +inp[7130] = 1073735808; +inp[7131] = 0; +inp[7132] = 1073735680; +inp[7133] = 0; +inp[7134] = 1073735552; +inp[7135] = 0; +inp[7136] = 1073735424; +inp[7137] = 0; +inp[7138] = 1073735296; +inp[7139] = 0; +inp[7140] = 1073735168; +inp[7141] = 0; +inp[7142] = 1073735040; +inp[7143] = 0; +inp[7144] = 1073734912; +inp[7145] = 0; +inp[7146] = 1073734784; +inp[7147] = 0; +inp[7148] = 1073734656; +inp[7149] = 0; +inp[7150] = 1073734528; +inp[7151] = 0; +inp[7152] = 1073734400; +inp[7153] = 0; +inp[7154] = 1073734272; +inp[7155] = 0; +inp[7156] = 1073734144; +inp[7157] = 0; +inp[7158] = 1073734016; +inp[7159] = 0; +inp[7160] = 1073733888; +inp[7161] = 0; +inp[7162] = 1073733760; +inp[7163] = 0; +inp[7164] = 1073741824; +inp[7165] = 1073741824; +inp[7166] = 1073741760; +inp[7167] = 0; +inp[7168] = 1073741696; +inp[7169] = 0; +inp[7170] = 1073741632; +inp[7171] = 0; +inp[7172] = 1073741568; +inp[7173] = 0; +inp[7174] = 1073741504; +inp[7175] = 0; +inp[7176] = 1073741440; +inp[7177] = 0; +inp[7178] = 1073741376; +inp[7179] = 0; +inp[7180] = 1073741312; +inp[7181] = 0; +inp[7182] = 1073741248; +inp[7183] = 0; +inp[7184] = 1073741184; +inp[7185] = 0; +inp[7186] = 1073741120; +inp[7187] = 0; +inp[7188] = 1073741056; +inp[7189] = 0; +inp[7190] = 1073740992; +inp[7191] = 0; +inp[7192] = 1073740928; +inp[7193] = 0; +inp[7194] = 1073740864; +inp[7195] = 0; +inp[7196] = 1073740800; +inp[7197] = 0; +inp[7198] = 1073740736; +inp[7199] = 0; +inp[7200] = 1073740672; +inp[7201] = 0; +inp[7202] = 1073740608; +inp[7203] = 0; +inp[7204] = 1073740544; +inp[7205] = 0; +inp[7206] = 1073740480; +inp[7207] = 0; +inp[7208] = 1073740416; +inp[7209] = 0; +inp[7210] = 1073740352; +inp[7211] = 0; +inp[7212] = 1073740288; +inp[7213] = 0; +inp[7214] = 1073740224; +inp[7215] = 0; +inp[7216] = 1073740160; +inp[7217] = 0; +inp[7218] = 1073740096; +inp[7219] = 0; +inp[7220] = 1073740032; +inp[7221] = 0; +inp[7222] = 1073739968; +inp[7223] = 0; +inp[7224] = 1073739904; +inp[7225] = 0; +inp[7226] = 1073739840; +inp[7227] = 0; +inp[7228] = 1073739776; +inp[7229] = 0; +inp[7230] = 1073739712; +inp[7231] = 0; +inp[7232] = 1073739648; +inp[7233] = 0; +inp[7234] = 1073739584; +inp[7235] = 0; +inp[7236] = 1073739520; +inp[7237] = 0; +inp[7238] = 1073739456; +inp[7239] = 0; +inp[7240] = 1073739392; +inp[7241] = 0; +inp[7242] = 1073739328; +inp[7243] = 0; +inp[7244] = 1073739264; +inp[7245] = 0; +inp[7246] = 1073739200; +inp[7247] = 0; +inp[7248] = 1073739136; +inp[7249] = 0; +inp[7250] = 1073739072; +inp[7251] = 0; +inp[7252] = 1073739008; +inp[7253] = 0; +inp[7254] = 1073738944; +inp[7255] = 0; +inp[7256] = 1073738880; +inp[7257] = 0; +inp[7258] = 1073738816; +inp[7259] = 0; +inp[7260] = 1073738752; +inp[7261] = 0; +inp[7262] = 1073738688; +inp[7263] = 0; +inp[7264] = 1073738624; +inp[7265] = 0; +inp[7266] = 1073738560; +inp[7267] = 0; +inp[7268] = 1073738496; +inp[7269] = 0; +inp[7270] = 1073738432; +inp[7271] = 0; +inp[7272] = 1073738368; +inp[7273] = 0; +inp[7274] = 1073738304; +inp[7275] = 0; +inp[7276] = 1073738240; +inp[7277] = 0; +inp[7278] = 1073738176; +inp[7279] = 0; +inp[7280] = 1073738112; +inp[7281] = 0; +inp[7282] = 1073738048; +inp[7283] = 0; +inp[7284] = 1073737984; +inp[7285] = 0; +inp[7286] = 1073737920; +inp[7287] = 0; +inp[7288] = 1073737856; +inp[7289] = 0; +inp[7290] = 1073737792; +inp[7291] = 0; +inp[7292] = 1073741824; +inp[7293] = 1073741824; +inp[7294] = 1073741792; +inp[7295] = 0; +inp[7296] = 1073741760; +inp[7297] = 0; +inp[7298] = 1073741728; +inp[7299] = 0; +inp[7300] = 1073741696; +inp[7301] = 0; +inp[7302] = 1073741664; +inp[7303] = 0; +inp[7304] = 1073741632; +inp[7305] = 0; +inp[7306] = 1073741600; +inp[7307] = 0; +inp[7308] = 1073741568; +inp[7309] = 0; +inp[7310] = 1073741536; +inp[7311] = 0; +inp[7312] = 1073741504; +inp[7313] = 0; +inp[7314] = 1073741472; +inp[7315] = 0; +inp[7316] = 1073741440; +inp[7317] = 0; +inp[7318] = 1073741408; +inp[7319] = 0; +inp[7320] = 1073741376; +inp[7321] = 0; +inp[7322] = 1073741344; +inp[7323] = 0; +inp[7324] = 1073741312; +inp[7325] = 0; +inp[7326] = 1073741280; +inp[7327] = 0; +inp[7328] = 1073741248; +inp[7329] = 0; +inp[7330] = 1073741216; +inp[7331] = 0; +inp[7332] = 1073741184; +inp[7333] = 0; +inp[7334] = 1073741152; +inp[7335] = 0; +inp[7336] = 1073741120; +inp[7337] = 0; +inp[7338] = 1073741088; +inp[7339] = 0; +inp[7340] = 1073741056; +inp[7341] = 0; +inp[7342] = 1073741024; +inp[7343] = 0; +inp[7344] = 1073740992; +inp[7345] = 0; +inp[7346] = 1073740960; +inp[7347] = 0; +inp[7348] = 1073740928; +inp[7349] = 0; +inp[7350] = 1073740896; +inp[7351] = 0; +inp[7352] = 1073740864; +inp[7353] = 0; +inp[7354] = 1073740832; +inp[7355] = 0; +inp[7356] = 1073740800; +inp[7357] = 0; +inp[7358] = 1073740768; +inp[7359] = 0; +inp[7360] = 1073740736; +inp[7361] = 0; +inp[7362] = 1073740704; +inp[7363] = 0; +inp[7364] = 1073740672; +inp[7365] = 0; +inp[7366] = 1073740640; +inp[7367] = 0; +inp[7368] = 1073740608; +inp[7369] = 0; +inp[7370] = 1073740576; +inp[7371] = 0; +inp[7372] = 1073740544; +inp[7373] = 0; +inp[7374] = 1073740512; +inp[7375] = 0; +inp[7376] = 1073740480; +inp[7377] = 0; +inp[7378] = 1073740448; +inp[7379] = 0; +inp[7380] = 1073740416; +inp[7381] = 0; +inp[7382] = 1073740384; +inp[7383] = 0; +inp[7384] = 1073740352; +inp[7385] = 0; +inp[7386] = 1073740320; +inp[7387] = 0; +inp[7388] = 1073740288; +inp[7389] = 0; +inp[7390] = 1073740256; +inp[7391] = 0; +inp[7392] = 1073740224; +inp[7393] = 0; +inp[7394] = 1073740192; +inp[7395] = 0; +inp[7396] = 1073740160; +inp[7397] = 0; +inp[7398] = 1073740128; +inp[7399] = 0; +inp[7400] = 1073740096; +inp[7401] = 0; +inp[7402] = 1073740064; +inp[7403] = 0; +inp[7404] = 1073740032; +inp[7405] = 0; +inp[7406] = 1073740000; +inp[7407] = 0; +inp[7408] = 1073739968; +inp[7409] = 0; +inp[7410] = 1073739936; +inp[7411] = 0; +inp[7412] = 1073739904; +inp[7413] = 0; +inp[7414] = 1073739872; +inp[7415] = 0; +inp[7416] = 1073739840; +inp[7417] = 0; +inp[7418] = 1073739808; +inp[7419] = 0; +inp[7420] = 1073741824; +inp[7421] = 1073741824; +inp[7422] = 1073741808; +inp[7423] = 0; +inp[7424] = 1073741792; +inp[7425] = 0; +inp[7426] = 1073741776; +inp[7427] = 0; +inp[7428] = 1073741760; +inp[7429] = 0; +inp[7430] = 1073741744; +inp[7431] = 0; +inp[7432] = 1073741728; +inp[7433] = 0; +inp[7434] = 1073741712; +inp[7435] = 0; +inp[7436] = 1073741696; +inp[7437] = 0; +inp[7438] = 1073741680; +inp[7439] = 0; +inp[7440] = 1073741664; +inp[7441] = 0; +inp[7442] = 1073741648; +inp[7443] = 0; +inp[7444] = 1073741632; +inp[7445] = 0; +inp[7446] = 1073741616; +inp[7447] = 0; +inp[7448] = 1073741600; +inp[7449] = 0; +inp[7450] = 1073741584; +inp[7451] = 0; +inp[7452] = 1073741568; +inp[7453] = 0; +inp[7454] = 1073741552; +inp[7455] = 0; +inp[7456] = 1073741536; +inp[7457] = 0; +inp[7458] = 1073741520; +inp[7459] = 0; +inp[7460] = 1073741504; +inp[7461] = 0; +inp[7462] = 1073741488; +inp[7463] = 0; +inp[7464] = 1073741472; +inp[7465] = 0; +inp[7466] = 1073741456; +inp[7467] = 0; +inp[7468] = 1073741440; +inp[7469] = 0; +inp[7470] = 1073741424; +inp[7471] = 0; +inp[7472] = 1073741408; +inp[7473] = 0; +inp[7474] = 1073741392; +inp[7475] = 0; +inp[7476] = 1073741376; +inp[7477] = 0; +inp[7478] = 1073741360; +inp[7479] = 0; +inp[7480] = 1073741344; +inp[7481] = 0; +inp[7482] = 1073741328; +inp[7483] = 0; +inp[7484] = 1073741312; +inp[7485] = 0; +inp[7486] = 1073741296; +inp[7487] = 0; +inp[7488] = 1073741280; +inp[7489] = 0; +inp[7490] = 1073741264; +inp[7491] = 0; +inp[7492] = 1073741248; +inp[7493] = 0; +inp[7494] = 1073741232; +inp[7495] = 0; +inp[7496] = 1073741216; +inp[7497] = 0; +inp[7498] = 1073741200; +inp[7499] = 0; +inp[7500] = 1073741184; +inp[7501] = 0; +inp[7502] = 1073741168; +inp[7503] = 0; +inp[7504] = 1073741152; +inp[7505] = 0; +inp[7506] = 1073741136; +inp[7507] = 0; +inp[7508] = 1073741120; +inp[7509] = 0; +inp[7510] = 1073741104; +inp[7511] = 0; +inp[7512] = 1073741088; +inp[7513] = 0; +inp[7514] = 1073741072; +inp[7515] = 0; +inp[7516] = 1073741056; +inp[7517] = 0; +inp[7518] = 1073741040; +inp[7519] = 0; +inp[7520] = 1073741024; +inp[7521] = 0; +inp[7522] = 1073741008; +inp[7523] = 0; +inp[7524] = 1073740992; +inp[7525] = 0; +inp[7526] = 1073740976; +inp[7527] = 0; +inp[7528] = 1073740960; +inp[7529] = 0; +inp[7530] = 1073740944; +inp[7531] = 0; +inp[7532] = 1073740928; +inp[7533] = 0; +inp[7534] = 1073740912; +inp[7535] = 0; +inp[7536] = 1073740896; +inp[7537] = 0; +inp[7538] = 1073740880; +inp[7539] = 0; +inp[7540] = 1073740864; +inp[7541] = 0; +inp[7542] = 1073740848; +inp[7543] = 0; +inp[7544] = 1073740832; +inp[7545] = 0; +inp[7546] = 1073740816; +inp[7547] = 0; +inp[7548] = 1073741824; +inp[7549] = 1073741824; +inp[7550] = 1073741816; +inp[7551] = 0; +inp[7552] = 1073741808; +inp[7553] = 0; +inp[7554] = 1073741800; +inp[7555] = 0; +inp[7556] = 1073741792; +inp[7557] = 0; +inp[7558] = 1073741784; +inp[7559] = 0; +inp[7560] = 1073741776; +inp[7561] = 0; +inp[7562] = 1073741768; +inp[7563] = 0; +inp[7564] = 1073741760; +inp[7565] = 0; +inp[7566] = 1073741752; +inp[7567] = 0; +inp[7568] = 1073741744; +inp[7569] = 0; +inp[7570] = 1073741736; +inp[7571] = 0; +inp[7572] = 1073741728; +inp[7573] = 0; +inp[7574] = 1073741720; +inp[7575] = 0; +inp[7576] = 1073741712; +inp[7577] = 0; +inp[7578] = 1073741704; +inp[7579] = 0; +inp[7580] = 1073741696; +inp[7581] = 0; +inp[7582] = 1073741688; +inp[7583] = 0; +inp[7584] = 1073741680; +inp[7585] = 0; +inp[7586] = 1073741672; +inp[7587] = 0; +inp[7588] = 1073741664; +inp[7589] = 0; +inp[7590] = 1073741656; +inp[7591] = 0; +inp[7592] = 1073741648; +inp[7593] = 0; +inp[7594] = 1073741640; +inp[7595] = 0; +inp[7596] = 1073741632; +inp[7597] = 0; +inp[7598] = 1073741624; +inp[7599] = 0; +inp[7600] = 1073741616; +inp[7601] = 0; +inp[7602] = 1073741608; +inp[7603] = 0; +inp[7604] = 1073741600; +inp[7605] = 0; +inp[7606] = 1073741592; +inp[7607] = 0; +inp[7608] = 1073741584; +inp[7609] = 0; +inp[7610] = 1073741576; +inp[7611] = 0; +inp[7612] = 1073741568; +inp[7613] = 0; +inp[7614] = 1073741560; +inp[7615] = 0; +inp[7616] = 1073741552; +inp[7617] = 0; +inp[7618] = 1073741544; +inp[7619] = 0; +inp[7620] = 1073741536; +inp[7621] = 0; +inp[7622] = 1073741528; +inp[7623] = 0; +inp[7624] = 1073741520; +inp[7625] = 0; +inp[7626] = 1073741512; +inp[7627] = 0; +inp[7628] = 1073741504; +inp[7629] = 0; +inp[7630] = 1073741496; +inp[7631] = 0; +inp[7632] = 1073741488; +inp[7633] = 0; +inp[7634] = 1073741480; +inp[7635] = 0; +inp[7636] = 1073741472; +inp[7637] = 0; +inp[7638] = 1073741464; +inp[7639] = 0; +inp[7640] = 1073741456; +inp[7641] = 0; +inp[7642] = 1073741448; +inp[7643] = 0; +inp[7644] = 1073741440; +inp[7645] = 0; +inp[7646] = 1073741432; +inp[7647] = 0; +inp[7648] = 1073741424; +inp[7649] = 0; +inp[7650] = 1073741416; +inp[7651] = 0; +inp[7652] = 1073741408; +inp[7653] = 0; +inp[7654] = 1073741400; +inp[7655] = 0; +inp[7656] = 1073741392; +inp[7657] = 0; +inp[7658] = 1073741384; +inp[7659] = 0; +inp[7660] = 1073741376; +inp[7661] = 0; +inp[7662] = 1073741368; +inp[7663] = 0; +inp[7664] = 1073741360; +inp[7665] = 0; +inp[7666] = 1073741352; +inp[7667] = 0; +inp[7668] = 1073741344; +inp[7669] = 0; +inp[7670] = 1073741336; +inp[7671] = 0; +inp[7672] = 1073741328; +inp[7673] = 0; +inp[7674] = 1073741320; +inp[7675] = 0; +inp[7676] = 1073741824; +inp[7677] = 1073741824; +inp[7678] = 1073741820; +inp[7679] = 0; +inp[7680] = 1073741816; +inp[7681] = 0; +inp[7682] = 1073741812; +inp[7683] = 0; +inp[7684] = 1073741808; +inp[7685] = 0; +inp[7686] = 1073741804; +inp[7687] = 0; +inp[7688] = 1073741800; +inp[7689] = 0; +inp[7690] = 1073741796; +inp[7691] = 0; +inp[7692] = 1073741792; +inp[7693] = 0; +inp[7694] = 1073741788; +inp[7695] = 0; +inp[7696] = 1073741784; +inp[7697] = 0; +inp[7698] = 1073741780; +inp[7699] = 0; +inp[7700] = 1073741776; +inp[7701] = 0; +inp[7702] = 1073741772; +inp[7703] = 0; +inp[7704] = 1073741768; +inp[7705] = 0; +inp[7706] = 1073741764; +inp[7707] = 0; +inp[7708] = 1073741760; +inp[7709] = 0; +inp[7710] = 1073741756; +inp[7711] = 0; +inp[7712] = 1073741752; +inp[7713] = 0; +inp[7714] = 1073741748; +inp[7715] = 0; +inp[7716] = 1073741744; +inp[7717] = 0; +inp[7718] = 1073741740; +inp[7719] = 0; +inp[7720] = 1073741736; +inp[7721] = 0; +inp[7722] = 1073741732; +inp[7723] = 0; +inp[7724] = 1073741728; +inp[7725] = 0; +inp[7726] = 1073741724; +inp[7727] = 0; +inp[7728] = 1073741720; +inp[7729] = 0; +inp[7730] = 1073741716; +inp[7731] = 0; +inp[7732] = 1073741712; +inp[7733] = 0; +inp[7734] = 1073741708; +inp[7735] = 0; +inp[7736] = 1073741704; +inp[7737] = 0; +inp[7738] = 1073741700; +inp[7739] = 0; +inp[7740] = 1073741696; +inp[7741] = 0; +inp[7742] = 1073741692; +inp[7743] = 0; +inp[7744] = 1073741688; +inp[7745] = 0; +inp[7746] = 1073741684; +inp[7747] = 0; +inp[7748] = 1073741680; +inp[7749] = 0; +inp[7750] = 1073741676; +inp[7751] = 0; +inp[7752] = 1073741672; +inp[7753] = 0; +inp[7754] = 1073741668; +inp[7755] = 0; +inp[7756] = 1073741664; +inp[7757] = 0; +inp[7758] = 1073741660; +inp[7759] = 0; +inp[7760] = 1073741656; +inp[7761] = 0; +inp[7762] = 1073741652; +inp[7763] = 0; +inp[7764] = 1073741648; +inp[7765] = 0; +inp[7766] = 1073741644; +inp[7767] = 0; +inp[7768] = 1073741640; +inp[7769] = 0; +inp[7770] = 1073741636; +inp[7771] = 0; +inp[7772] = 1073741632; +inp[7773] = 0; +inp[7774] = 1073741628; +inp[7775] = 0; +inp[7776] = 1073741624; +inp[7777] = 0; +inp[7778] = 1073741620; +inp[7779] = 0; +inp[7780] = 1073741616; +inp[7781] = 0; +inp[7782] = 1073741612; +inp[7783] = 0; +inp[7784] = 1073741608; +inp[7785] = 0; +inp[7786] = 1073741604; +inp[7787] = 0; +inp[7788] = 1073741600; +inp[7789] = 0; +inp[7790] = 1073741596; +inp[7791] = 0; +inp[7792] = 1073741592; +inp[7793] = 0; +inp[7794] = 1073741588; +inp[7795] = 0; +inp[7796] = 1073741584; +inp[7797] = 0; +inp[7798] = 1073741580; +inp[7799] = 0; +inp[7800] = 1073741576; +inp[7801] = 0; +inp[7802] = 1073741572; +inp[7803] = 0; +inp[7804] = 1073741824; +inp[7805] = 1073741824; +inp[7806] = 1073741822; +inp[7807] = 0; +inp[7808] = 1073741820; +inp[7809] = 0; +inp[7810] = 1073741818; +inp[7811] = 0; +inp[7812] = 1073741816; +inp[7813] = 0; +inp[7814] = 1073741814; +inp[7815] = 0; +inp[7816] = 1073741812; +inp[7817] = 0; +inp[7818] = 1073741810; +inp[7819] = 0; +inp[7820] = 1073741808; +inp[7821] = 0; +inp[7822] = 1073741806; +inp[7823] = 0; +inp[7824] = 1073741804; +inp[7825] = 0; +inp[7826] = 1073741802; +inp[7827] = 0; +inp[7828] = 1073741800; +inp[7829] = 0; +inp[7830] = 1073741798; +inp[7831] = 0; +inp[7832] = 1073741796; +inp[7833] = 0; +inp[7834] = 1073741794; +inp[7835] = 0; +inp[7836] = 1073741792; +inp[7837] = 0; +inp[7838] = 1073741790; +inp[7839] = 0; +inp[7840] = 1073741788; +inp[7841] = 0; +inp[7842] = 1073741786; +inp[7843] = 0; +inp[7844] = 1073741784; +inp[7845] = 0; +inp[7846] = 1073741782; +inp[7847] = 0; +inp[7848] = 1073741780; +inp[7849] = 0; +inp[7850] = 1073741778; +inp[7851] = 0; +inp[7852] = 1073741776; +inp[7853] = 0; +inp[7854] = 1073741774; +inp[7855] = 0; +inp[7856] = 1073741772; +inp[7857] = 0; +inp[7858] = 1073741770; +inp[7859] = 0; +inp[7860] = 1073741768; +inp[7861] = 0; +inp[7862] = 1073741766; +inp[7863] = 0; +inp[7864] = 1073741764; +inp[7865] = 0; +inp[7866] = 1073741762; +inp[7867] = 0; +inp[7868] = 1073741760; +inp[7869] = 0; +inp[7870] = 1073741758; +inp[7871] = 0; +inp[7872] = 1073741756; +inp[7873] = 0; +inp[7874] = 1073741754; +inp[7875] = 0; +inp[7876] = 1073741752; +inp[7877] = 0; +inp[7878] = 1073741750; +inp[7879] = 0; +inp[7880] = 1073741748; +inp[7881] = 0; +inp[7882] = 1073741746; +inp[7883] = 0; +inp[7884] = 1073741744; +inp[7885] = 0; +inp[7886] = 1073741742; +inp[7887] = 0; +inp[7888] = 1073741740; +inp[7889] = 0; +inp[7890] = 1073741738; +inp[7891] = 0; +inp[7892] = 1073741736; +inp[7893] = 0; +inp[7894] = 1073741734; +inp[7895] = 0; +inp[7896] = 1073741732; +inp[7897] = 0; +inp[7898] = 1073741730; +inp[7899] = 0; +inp[7900] = 1073741728; +inp[7901] = 0; +inp[7902] = 1073741726; +inp[7903] = 0; +inp[7904] = 1073741724; +inp[7905] = 0; +inp[7906] = 1073741722; +inp[7907] = 0; +inp[7908] = 1073741720; +inp[7909] = 0; +inp[7910] = 1073741718; +inp[7911] = 0; +inp[7912] = 1073741716; +inp[7913] = 0; +inp[7914] = 1073741714; +inp[7915] = 0; +inp[7916] = 1073741712; +inp[7917] = 0; +inp[7918] = 1073741710; +inp[7919] = 0; +inp[7920] = 1073741708; +inp[7921] = 0; +inp[7922] = 1073741706; +inp[7923] = 0; +inp[7924] = 1073741704; +inp[7925] = 0; +inp[7926] = 1073741702; +inp[7927] = 0; +inp[7928] = 1073741700; +inp[7929] = 0; +inp[7930] = 1073741698; +inp[7931] = 0; +inp[7932] = 1073741824; +inp[7933] = 1073741824; +inp[7934] = 1073741823; +inp[7935] = 0; +inp[7936] = 1073741822; +inp[7937] = 0; +inp[7938] = 1073741821; +inp[7939] = 0; +inp[7940] = 1073741820; +inp[7941] = 0; +inp[7942] = 1073741819; +inp[7943] = 0; +inp[7944] = 1073741818; +inp[7945] = 0; +inp[7946] = 1073741817; +inp[7947] = 0; +inp[7948] = 1073741816; +inp[7949] = 0; +inp[7950] = 1073741815; +inp[7951] = 0; +inp[7952] = 1073741814; +inp[7953] = 0; +inp[7954] = 1073741813; +inp[7955] = 0; +inp[7956] = 1073741812; +inp[7957] = 0; +inp[7958] = 1073741811; +inp[7959] = 0; +inp[7960] = 1073741810; +inp[7961] = 0; +inp[7962] = 1073741809; +inp[7963] = 0; +inp[7964] = 1073741808; +inp[7965] = 0; +inp[7966] = 1073741807; +inp[7967] = 0; +inp[7968] = 1073741806; +inp[7969] = 0; +inp[7970] = 1073741805; +inp[7971] = 0; +inp[7972] = 1073741804; +inp[7973] = 0; +inp[7974] = 1073741803; +inp[7975] = 0; +inp[7976] = 1073741802; +inp[7977] = 0; +inp[7978] = 1073741801; +inp[7979] = 0; +inp[7980] = 1073741800; +inp[7981] = 0; +inp[7982] = 1073741799; +inp[7983] = 0; +inp[7984] = 1073741798; +inp[7985] = 0; +inp[7986] = 1073741797; +inp[7987] = 0; +inp[7988] = 1073741796; +inp[7989] = 0; +inp[7990] = 1073741795; +inp[7991] = 0; +inp[7992] = 1073741794; +inp[7993] = 0; +inp[7994] = 1073741793; +inp[7995] = 0; +inp[7996] = 1073741792; +inp[7997] = 0; +inp[7998] = 1073741791; +inp[7999] = 0; +inp[8000] = 1073741790; +inp[8001] = 0; +inp[8002] = 1073741789; +inp[8003] = 0; +inp[8004] = 1073741788; +inp[8005] = 0; +inp[8006] = 1073741787; +inp[8007] = 0; +inp[8008] = 1073741786; +inp[8009] = 0; +inp[8010] = 1073741785; +inp[8011] = 0; +inp[8012] = 1073741784; +inp[8013] = 0; +inp[8014] = 1073741783; +inp[8015] = 0; +inp[8016] = 1073741782; +inp[8017] = 0; +inp[8018] = 1073741781; +inp[8019] = 0; +inp[8020] = 1073741780; +inp[8021] = 0; +inp[8022] = 1073741779; +inp[8023] = 0; +inp[8024] = 1073741778; +inp[8025] = 0; +inp[8026] = 1073741777; +inp[8027] = 0; +inp[8028] = 1073741776; +inp[8029] = 0; +inp[8030] = 1073741775; +inp[8031] = 0; +inp[8032] = 1073741774; +inp[8033] = 0; +inp[8034] = 1073741773; +inp[8035] = 0; +inp[8036] = 1073741772; +inp[8037] = 0; +inp[8038] = 1073741771; +inp[8039] = 0; +inp[8040] = 1073741770; +inp[8041] = 0; +inp[8042] = 1073741769; +inp[8043] = 0; +inp[8044] = 1073741768; +inp[8045] = 0; +inp[8046] = 1073741767; +inp[8047] = 0; +inp[8048] = 1073741766; +inp[8049] = 0; +inp[8050] = 1073741765; +inp[8051] = 0; +inp[8052] = 1073741764; +inp[8053] = 0; +inp[8054] = 1073741763; +inp[8055] = 0; +inp[8056] = 1073741762; +inp[8057] = 0; +inp[8058] = 1073741761; +inp[8059] = 0; +inp[8060] = 1073741824; +inp[8061] = 1073741824; +inp[8062] = 1073741823; +inp[8063] = 0; +inp[8064] = 1073741823; +inp[8065] = 0; +inp[8066] = 1073741822; +inp[8067] = 0; +inp[8068] = 1073741822; +inp[8069] = 0; +inp[8070] = 1073741821; +inp[8071] = 0; +inp[8072] = 1073741821; +inp[8073] = 0; +inp[8074] = 1073741820; +inp[8075] = 0; +inp[8076] = 1073741820; +inp[8077] = 0; +inp[8078] = 1073741819; +inp[8079] = 0; +inp[8080] = 1073741819; +inp[8081] = 0; +inp[8082] = 1073741818; +inp[8083] = 0; +inp[8084] = 1073741818; +inp[8085] = 0; +inp[8086] = 1073741817; +inp[8087] = 0; +inp[8088] = 1073741817; +inp[8089] = 0; +inp[8090] = 1073741816; +inp[8091] = 0; +inp[8092] = 1073741816; +inp[8093] = 0; +inp[8094] = 1073741815; +inp[8095] = 0; +inp[8096] = 1073741815; +inp[8097] = 0; +inp[8098] = 1073741814; +inp[8099] = 0; +inp[8100] = 1073741814; +inp[8101] = 0; +inp[8102] = 1073741813; +inp[8103] = 0; +inp[8104] = 1073741813; +inp[8105] = 0; +inp[8106] = 1073741812; +inp[8107] = 0; +inp[8108] = 1073741812; +inp[8109] = 0; +inp[8110] = 1073741811; +inp[8111] = 0; +inp[8112] = 1073741811; +inp[8113] = 0; +inp[8114] = 1073741810; +inp[8115] = 0; +inp[8116] = 1073741810; +inp[8117] = 0; +inp[8118] = 1073741809; +inp[8119] = 0; +inp[8120] = 1073741809; +inp[8121] = 0; +inp[8122] = 1073741808; +inp[8123] = 0; +inp[8124] = 1073741808; +inp[8125] = 0; +inp[8126] = 1073741807; +inp[8127] = 0; +inp[8128] = 1073741807; +inp[8129] = 0; +inp[8130] = 1073741806; +inp[8131] = 0; +inp[8132] = 1073741806; +inp[8133] = 0; +inp[8134] = 1073741805; +inp[8135] = 0; +inp[8136] = 1073741805; +inp[8137] = 0; +inp[8138] = 1073741804; +inp[8139] = 0; +inp[8140] = 1073741804; +inp[8141] = 0; +inp[8142] = 1073741803; +inp[8143] = 0; +inp[8144] = 1073741803; +inp[8145] = 0; +inp[8146] = 1073741802; +inp[8147] = 0; +inp[8148] = 1073741802; +inp[8149] = 0; +inp[8150] = 1073741801; +inp[8151] = 0; +inp[8152] = 1073741801; +inp[8153] = 0; +inp[8154] = 1073741800; +inp[8155] = 0; +inp[8156] = 1073741800; +inp[8157] = 0; +inp[8158] = 1073741799; +inp[8159] = 0; +inp[8160] = 1073741799; +inp[8161] = 0; +inp[8162] = 1073741798; +inp[8163] = 0; +inp[8164] = 1073741798; +inp[8165] = 0; +inp[8166] = 1073741797; +inp[8167] = 0; +inp[8168] = 1073741797; +inp[8169] = 0; +inp[8170] = 1073741796; +inp[8171] = 0; +inp[8172] = 1073741796; +inp[8173] = 0; +inp[8174] = 1073741795; +inp[8175] = 0; +inp[8176] = 1073741795; +inp[8177] = 0; +inp[8178] = 1073741794; +inp[8179] = 0; +inp[8180] = 1073741794; +inp[8181] = 0; +inp[8182] = 1073741793; +inp[8183] = 0; +inp[8184] = 1073741793; +inp[8185] = 0; +inp[8186] = 1073741792; +inp[8187] = 0; +inp[8188] = 1073741824; +inp[8189] = 1073741824; +inp[8190] = 1073741823; +inp[8191] = 0; +inp[8192] = 1073741823; +inp[8193] = 0; +inp[8194] = 1073741823; +inp[8195] = 0; +inp[8196] = 1073741823; +inp[8197] = 0; +inp[8198] = 1073741822; +inp[8199] = 0; +inp[8200] = 1073741822; +inp[8201] = 0; +inp[8202] = 1073741822; +inp[8203] = 0; +inp[8204] = 1073741822; +inp[8205] = 0; +inp[8206] = 1073741821; +inp[8207] = 0; +inp[8208] = 1073741821; +inp[8209] = 0; +inp[8210] = 1073741821; +inp[8211] = 0; +inp[8212] = 1073741821; +inp[8213] = 0; +inp[8214] = 1073741820; +inp[8215] = 0; +inp[8216] = 1073741820; +inp[8217] = 0; +inp[8218] = 1073741820; +inp[8219] = 0; +inp[8220] = 1073741820; +inp[8221] = 0; +inp[8222] = 1073741819; +inp[8223] = 0; +inp[8224] = 1073741819; +inp[8225] = 0; +inp[8226] = 1073741819; +inp[8227] = 0; +inp[8228] = 1073741819; +inp[8229] = 0; +inp[8230] = 1073741818; +inp[8231] = 0; +inp[8232] = 1073741818; +inp[8233] = 0; +inp[8234] = 1073741818; +inp[8235] = 0; +inp[8236] = 1073741818; +inp[8237] = 0; +inp[8238] = 1073741817; +inp[8239] = 0; +inp[8240] = 1073741817; +inp[8241] = 0; +inp[8242] = 1073741817; +inp[8243] = 0; +inp[8244] = 1073741817; +inp[8245] = 0; +inp[8246] = 1073741816; +inp[8247] = 0; +inp[8248] = 1073741816; +inp[8249] = 0; +inp[8250] = 1073741816; +inp[8251] = 0; +inp[8252] = 1073741816; +inp[8253] = 0; +inp[8254] = 1073741815; +inp[8255] = 0; +inp[8256] = 1073741815; +inp[8257] = 0; +inp[8258] = 1073741815; +inp[8259] = 0; +inp[8260] = 1073741815; +inp[8261] = 0; +inp[8262] = 1073741814; +inp[8263] = 0; +inp[8264] = 1073741814; +inp[8265] = 0; +inp[8266] = 1073741814; +inp[8267] = 0; +inp[8268] = 1073741814; +inp[8269] = 0; +inp[8270] = 1073741813; +inp[8271] = 0; +inp[8272] = 1073741813; +inp[8273] = 0; +inp[8274] = 1073741813; +inp[8275] = 0; +inp[8276] = 1073741813; +inp[8277] = 0; +inp[8278] = 1073741812; +inp[8279] = 0; +inp[8280] = 1073741812; +inp[8281] = 0; +inp[8282] = 1073741812; +inp[8283] = 0; +inp[8284] = 1073741812; +inp[8285] = 0; +inp[8286] = 1073741811; +inp[8287] = 0; +inp[8288] = 1073741811; +inp[8289] = 0; +inp[8290] = 1073741811; +inp[8291] = 0; +inp[8292] = 1073741811; +inp[8293] = 0; +inp[8294] = 1073741810; +inp[8295] = 0; +inp[8296] = 1073741810; +inp[8297] = 0; +inp[8298] = 1073741810; +inp[8299] = 0; +inp[8300] = 1073741810; +inp[8301] = 0; +inp[8302] = 1073741809; +inp[8303] = 0; +inp[8304] = 1073741809; +inp[8305] = 0; +inp[8306] = 1073741809; +inp[8307] = 0; +inp[8308] = 1073741809; +inp[8309] = 0; +inp[8310] = 1073741808; +inp[8311] = 0; +inp[8312] = 1073741808; +inp[8313] = 0; +inp[8314] = 1073741808; +inp[8315] = 0; +inp[8316] = 1073741824; +inp[8317] = 1073741824; +inp[8318] = 395007542; +inp[8319] = 395007542; +inp[8320] = 145315153; +inp[8321] = 145315153; +inp[8322] = 53458457; +inp[8323] = 53458457; +inp[8324] = 19666267; +inp[8325] = 19666267; +inp[8326] = 7234815; +inp[8327] = 7234815; +inp[8328] = 2661539; +inp[8329] = 2661539; +inp[8330] = 979125; +inp[8331] = 979125; +inp[8332] = 360200; +inp[8333] = 360200; +inp[8334] = 132510; +inp[8335] = 132510; +inp[8336] = 48747; +inp[8337] = 48747; +inp[8338] = 17933; +inp[8339] = 17933; +inp[8340] = 6597; +inp[8341] = 6597; +inp[8342] = 2427; +inp[8343] = 2427; +inp[8344] = 892; +inp[8345] = 892; +inp[8346] = 328; +inp[8347] = 328; +inp[8348] = 120; +inp[8349] = 120; +inp[8350] = 44; +inp[8351] = 44; +inp[8352] = 16; +inp[8353] = 16; +inp[8354] = 6; +inp[8355] = 6; +inp[8356] = 2; +inp[8357] = 2; +inp[8358] = 0; +inp[8359] = 0; +inp[8360] = 0; +inp[8361] = 0; +inp[8362] = 0; +inp[8363] = 0; +inp[8364] = 0; +inp[8365] = 0; +inp[8366] = 0; +inp[8367] = 0; +inp[8368] = 0; +inp[8369] = 0; +inp[8370] = 0; +inp[8371] = 0; +inp[8372] = 0; +inp[8373] = 0; +inp[8374] = 0; +inp[8375] = 0; +inp[8376] = 0; +inp[8377] = 0; +inp[8378] = 0; +inp[8379] = 0; +inp[8380] = 0; +inp[8381] = 0; +inp[8382] = 0; +inp[8383] = 0; +inp[8384] = 0; +inp[8385] = 0; +inp[8386] = 0; +inp[8387] = 0; +inp[8388] = 0; +inp[8389] = 0; +inp[8390] = 0; +inp[8391] = 0; +inp[8392] = 0; +inp[8393] = 0; +inp[8394] = 0; +inp[8395] = 0; +inp[8396] = 0; +inp[8397] = 0; +inp[8398] = 0; +inp[8399] = 0; +inp[8400] = 0; +inp[8401] = 0; +inp[8402] = 0; +inp[8403] = 0; +inp[8404] = 0; +inp[8405] = 0; +inp[8406] = 0; +inp[8407] = 0; +inp[8408] = 0; +inp[8409] = 0; +inp[8410] = 0; +inp[8411] = 0; +inp[8412] = 0; +inp[8413] = 0; +inp[8414] = 0; +inp[8415] = 0; +inp[8416] = 0; +inp[8417] = 0; +inp[8418] = 0; +inp[8419] = 0; +inp[8420] = 0; +inp[8421] = 0; +inp[8422] = 0; +inp[8423] = 0; +inp[8424] = 0; +inp[8425] = 0; +inp[8426] = 0; +inp[8427] = 0; +inp[8428] = 0; +inp[8429] = 0; +inp[8430] = 0; +inp[8431] = 0; +inp[8432] = 0; +inp[8433] = 0; +inp[8434] = 0; +inp[8435] = 0; +inp[8436] = 0; +inp[8437] = 0; +inp[8438] = 0; +inp[8439] = 0; +inp[8440] = 0; +inp[8441] = 0; +inp[8442] = 0; +inp[8443] = 0; +inp[8444] = 0; +inp[8445] = 0; +inp[8446] = 0; +inp[8447] = 0; +inp[8448] = 0; +inp[8449] = 0; +inp[8450] = 0; +inp[8451] = 0; +inp[8452] = 0; +inp[8453] = 0; +inp[8454] = 0; +inp[8455] = 0; +inp[8456] = 0; +inp[8457] = 0; +inp[8458] = 0; +inp[8459] = 0; +inp[8460] = 0; +inp[8461] = 0; +inp[8462] = 0; +inp[8463] = 0; +inp[8464] = 0; +inp[8465] = 0; +inp[8466] = 0; +inp[8467] = 0; +inp[8468] = 0; +inp[8469] = 0; +inp[8470] = 0; +inp[8471] = 0; +inp[8472] = 0; +inp[8473] = 0; +inp[8474] = 0; +inp[8475] = 0; +inp[8476] = 0; +inp[8477] = 0; +inp[8478] = 0; +inp[8479] = 0; +inp[8480] = 0; +inp[8481] = 0; +inp[8482] = 0; +inp[8483] = 0; +inp[8484] = 0; +inp[8485] = 0; +inp[8486] = 0; +inp[8487] = 0; +inp[8488] = 0; +inp[8489] = 0; +inp[8490] = 0; +inp[8491] = 0; +inp[8492] = 0; +inp[8493] = 0; +inp[8494] = 0; +inp[8495] = 0; +inp[8496] = 0; +inp[8497] = 0; +inp[8498] = 0; +inp[8499] = 0; +inp[8500] = 0; +inp[8501] = 0; +inp[8502] = 0; +inp[8503] = 0; +inp[8504] = 0; +inp[8505] = 0; +inp[8506] = 0; +inp[8507] = 0; +inp[8508] = 0; +inp[8509] = 0; +inp[8510] = 0; +inp[8511] = 0; +inp[8512] = 0; +inp[8513] = 0; +inp[8514] = 0; +inp[8515] = 0; +inp[8516] = 0; +inp[8517] = 0; +inp[8518] = 0; +inp[8519] = 0; +inp[8520] = 0; +inp[8521] = 0; +inp[8522] = 0; +inp[8523] = 0; +inp[8524] = 0; +inp[8525] = 0; +inp[8526] = 0; +inp[8527] = 0; +inp[8528] = 0; +inp[8529] = 0; +inp[8530] = 0; +inp[8531] = 0; +inp[8532] = 0; +inp[8533] = 0; +inp[8534] = 0; +inp[8535] = 0; +inp[8536] = 0; +inp[8537] = 0; +inp[8538] = 0; +inp[8539] = 0; +inp[8540] = 0; +inp[8541] = 0; +inp[8542] = 0; +inp[8543] = 0; +inp[8544] = 0; +inp[8545] = 0; +inp[8546] = 0; +inp[8547] = 0; +inp[8548] = 0; +inp[8549] = 0; +inp[8550] = 0; +inp[8551] = 0; +inp[8552] = 0; +inp[8553] = 0; +inp[8554] = 0; +inp[8555] = 0; +inp[8556] = 0; +inp[8557] = 0; +inp[8558] = 0; +inp[8559] = 0; +inp[8560] = 0; +inp[8561] = 0; +inp[8562] = 0; +inp[8563] = 0; +inp[8564] = 0; +inp[8565] = 0; +inp[8566] = 0; +inp[8567] = 0; +inp[8568] = 0; +inp[8569] = 0; +inp[8570] = 0; +inp[8571] = 0; +inp[8572] = 1073741824; +inp[8573] = 1073741824; +inp[8574] = 651257336; +inp[8575] = 145315153; +inp[8576] = 395007542; +inp[8577] = 19666267; +inp[8578] = 239584185; +inp[8579] = 2661539; +inp[8580] = 145315153; +inp[8581] = 360200; +inp[8582] = 88138096; +inp[8583] = 48747; +inp[8584] = 53458457; +inp[8585] = 6597; +inp[8586] = 32424193; +inp[8587] = 892; +inp[8588] = 19666267; +inp[8589] = 120; +inp[8590] = 11928194; +inp[8591] = 16; +inp[8592] = 7234815; +inp[8593] = 2; +inp[8594] = 4388137; +inp[8595] = 0; +inp[8596] = 2661539; +inp[8597] = 0; +inp[8598] = 1614305; +inp[8599] = 0; +inp[8600] = 979125; +inp[8601] = 0; +inp[8602] = 593869; +inp[8603] = 0; +inp[8604] = 360200; +inp[8605] = 0; +inp[8606] = 218472; +inp[8607] = 0; +inp[8608] = 132510; +inp[8609] = 0; +inp[8610] = 80371; +inp[8611] = 0; +inp[8612] = 48747; +inp[8613] = 0; +inp[8614] = 29567; +inp[8615] = 0; +inp[8616] = 17933; +inp[8617] = 0; +inp[8618] = 10877; +inp[8619] = 0; +inp[8620] = 6597; +inp[8621] = 0; +inp[8622] = 4001; +inp[8623] = 0; +inp[8624] = 2427; +inp[8625] = 0; +inp[8626] = 1472; +inp[8627] = 0; +inp[8628] = 892; +inp[8629] = 0; +inp[8630] = 541; +inp[8631] = 0; +inp[8632] = 328; +inp[8633] = 0; +inp[8634] = 199; +inp[8635] = 0; +inp[8636] = 120; +inp[8637] = 0; +inp[8638] = 73; +inp[8639] = 0; +inp[8640] = 44; +inp[8641] = 0; +inp[8642] = 26; +inp[8643] = 0; +inp[8644] = 16; +inp[8645] = 0; +inp[8646] = 9; +inp[8647] = 0; +inp[8648] = 6; +inp[8649] = 0; +inp[8650] = 3; +inp[8651] = 0; +inp[8652] = 2; +inp[8653] = 0; +inp[8654] = 1; +inp[8655] = 0; +inp[8656] = 0; +inp[8657] = 0; +inp[8658] = 0; +inp[8659] = 0; +inp[8660] = 0; +inp[8661] = 0; +inp[8662] = 0; +inp[8663] = 0; +inp[8664] = 0; +inp[8665] = 0; +inp[8666] = 0; +inp[8667] = 0; +inp[8668] = 0; +inp[8669] = 0; +inp[8670] = 0; +inp[8671] = 0; +inp[8672] = 0; +inp[8673] = 0; +inp[8674] = 0; +inp[8675] = 0; +inp[8676] = 0; +inp[8677] = 0; +inp[8678] = 0; +inp[8679] = 0; +inp[8680] = 0; +inp[8681] = 0; +inp[8682] = 0; +inp[8683] = 0; +inp[8684] = 0; +inp[8685] = 0; +inp[8686] = 0; +inp[8687] = 0; +inp[8688] = 0; +inp[8689] = 0; +inp[8690] = 0; +inp[8691] = 0; +inp[8692] = 0; +inp[8693] = 0; +inp[8694] = 0; +inp[8695] = 0; +inp[8696] = 0; +inp[8697] = 0; +inp[8698] = 0; +inp[8699] = 0; +inp[8700] = 0; +inp[8701] = 0; +inp[8702] = 0; +inp[8703] = 0; +inp[8704] = 0; +inp[8705] = 0; +inp[8706] = 0; +inp[8707] = 0; +inp[8708] = 0; +inp[8709] = 0; +inp[8710] = 0; +inp[8711] = 0; +inp[8712] = 0; +inp[8713] = 0; +inp[8714] = 0; +inp[8715] = 0; +inp[8716] = 0; +inp[8717] = 0; +inp[8718] = 0; +inp[8719] = 0; +inp[8720] = 0; +inp[8721] = 0; +inp[8722] = 0; +inp[8723] = 0; +inp[8724] = 0; +inp[8725] = 0; +inp[8726] = 0; +inp[8727] = 0; +inp[8728] = 0; +inp[8729] = 0; +inp[8730] = 0; +inp[8731] = 0; +inp[8732] = 0; +inp[8733] = 0; +inp[8734] = 0; +inp[8735] = 0; +inp[8736] = 0; +inp[8737] = 0; +inp[8738] = 0; +inp[8739] = 0; +inp[8740] = 0; +inp[8741] = 0; +inp[8742] = 0; +inp[8743] = 0; +inp[8744] = 0; +inp[8745] = 0; +inp[8746] = 0; +inp[8747] = 0; +inp[8748] = 0; +inp[8749] = 0; +inp[8750] = 0; +inp[8751] = 0; +inp[8752] = 0; +inp[8753] = 0; +inp[8754] = 0; +inp[8755] = 0; +inp[8756] = 0; +inp[8757] = 0; +inp[8758] = 0; +inp[8759] = 0; +inp[8760] = 0; +inp[8761] = 0; +inp[8762] = 0; +inp[8763] = 0; +inp[8764] = 0; +inp[8765] = 0; +inp[8766] = 0; +inp[8767] = 0; +inp[8768] = 0; +inp[8769] = 0; +inp[8770] = 0; +inp[8771] = 0; +inp[8772] = 0; +inp[8773] = 0; +inp[8774] = 0; +inp[8775] = 0; +inp[8776] = 0; +inp[8777] = 0; +inp[8778] = 0; +inp[8779] = 0; +inp[8780] = 0; +inp[8781] = 0; +inp[8782] = 0; +inp[8783] = 0; +inp[8784] = 0; +inp[8785] = 0; +inp[8786] = 0; +inp[8787] = 0; +inp[8788] = 0; +inp[8789] = 0; +inp[8790] = 0; +inp[8791] = 0; +inp[8792] = 0; +inp[8793] = 0; +inp[8794] = 0; +inp[8795] = 0; +inp[8796] = 0; +inp[8797] = 0; +inp[8798] = 0; +inp[8799] = 0; +inp[8800] = 0; +inp[8801] = 0; +inp[8802] = 0; +inp[8803] = 0; +inp[8804] = 0; +inp[8805] = 0; +inp[8806] = 0; +inp[8807] = 0; +inp[8808] = 0; +inp[8809] = 0; +inp[8810] = 0; +inp[8811] = 0; +inp[8812] = 0; +inp[8813] = 0; +inp[8814] = 0; +inp[8815] = 0; +inp[8816] = 0; +inp[8817] = 0; +inp[8818] = 0; +inp[8819] = 0; +inp[8820] = 0; +inp[8821] = 0; +inp[8822] = 0; +inp[8823] = 0; +inp[8824] = 0; +inp[8825] = 0; +inp[8826] = 0; +inp[8827] = 0; +inp[8828] = 1073741824; +inp[8829] = 1073741824; +inp[8830] = 836230973; +inp[8831] = 19666267; +inp[8832] = 651257336; +inp[8833] = 360200; +inp[8834] = 507199723; +inp[8835] = 6597; +inp[8836] = 395007542; +inp[8837] = 120; +inp[8838] = 307632183; +inp[8839] = 2; +inp[8840] = 239584185; +inp[8841] = 0; +inp[8842] = 186588351; +inp[8843] = 0; +inp[8844] = 145315153; +inp[8845] = 0; +inp[8846] = 113171555; +inp[8847] = 0; +inp[8848] = 88138096; +inp[8849] = 0; +inp[8850] = 68642018; +inp[8851] = 0; +inp[8852] = 53458457; +inp[8853] = 0; +inp[8854] = 41633488; +inp[8855] = 0; +inp[8856] = 32424193; +inp[8857] = 0; +inp[8858] = 25251987; +inp[8859] = 0; +inp[8860] = 19666267; +inp[8861] = 0; +inp[8862] = 15316104; +inp[8863] = 0; +inp[8864] = 11928194; +inp[8865] = 0; +inp[8866] = 9289686; +inp[8867] = 0; +inp[8868] = 7234815; +inp[8869] = 0; +inp[8870] = 5634479; +inp[8871] = 0; +inp[8872] = 4388137; +inp[8873] = 0; +inp[8874] = 3417484; +inp[8875] = 0; +inp[8876] = 2661539; +inp[8877] = 0; +inp[8878] = 2072809; +inp[8879] = 0; +inp[8880] = 1614305; +inp[8881] = 0; +inp[8882] = 1257222; +inp[8883] = 0; +inp[8884] = 979125; +inp[8885] = 0; +inp[8886] = 762543; +inp[8887] = 0; +inp[8888] = 593869; +inp[8889] = 0; +inp[8890] = 462506; +inp[8891] = 0; +inp[8892] = 360200; +inp[8893] = 0; +inp[8894] = 280524; +inp[8895] = 0; +inp[8896] = 218472; +inp[8897] = 0; +inp[8898] = 170146; +inp[8899] = 0; +inp[8900] = 132510; +inp[8901] = 0; +inp[8902] = 103199; +inp[8903] = 0; +inp[8904] = 80371; +inp[8905] = 0; +inp[8906] = 62593; +inp[8907] = 0; +inp[8908] = 48747; +inp[8909] = 0; +inp[8910] = 37964; +inp[8911] = 0; +inp[8912] = 29567; +inp[8913] = 0; +inp[8914] = 23026; +inp[8915] = 0; +inp[8916] = 17933; +inp[8917] = 0; +inp[8918] = 13966; +inp[8919] = 0; +inp[8920] = 10877; +inp[8921] = 0; +inp[8922] = 8471; +inp[8923] = 0; +inp[8924] = 6597; +inp[8925] = 0; +inp[8926] = 5137; +inp[8927] = 0; +inp[8928] = 4001; +inp[8929] = 0; +inp[8930] = 3116; +inp[8931] = 0; +inp[8932] = 2427; +inp[8933] = 0; +inp[8934] = 1890; +inp[8935] = 0; +inp[8936] = 1472; +inp[8937] = 0; +inp[8938] = 1146; +inp[8939] = 0; +inp[8940] = 892; +inp[8941] = 0; +inp[8942] = 695; +inp[8943] = 0; +inp[8944] = 541; +inp[8945] = 0; +inp[8946] = 421; +inp[8947] = 0; +inp[8948] = 328; +inp[8949] = 0; +inp[8950] = 255; +inp[8951] = 0; +inp[8952] = 199; +inp[8953] = 0; +inp[8954] = 155; +inp[8955] = 0; +inp[8956] = 120; +inp[8957] = 0; +inp[8958] = 94; +inp[8959] = 0; +inp[8960] = 73; +inp[8961] = 0; +inp[8962] = 57; +inp[8963] = 0; +inp[8964] = 44; +inp[8965] = 0; +inp[8966] = 34; +inp[8967] = 0; +inp[8968] = 26; +inp[8969] = 0; +inp[8970] = 20; +inp[8971] = 0; +inp[8972] = 16; +inp[8973] = 0; +inp[8974] = 12; +inp[8975] = 0; +inp[8976] = 9; +inp[8977] = 0; +inp[8978] = 7; +inp[8979] = 0; +inp[8980] = 6; +inp[8981] = 0; +inp[8982] = 4; +inp[8983] = 0; +inp[8984] = 3; +inp[8985] = 0; +inp[8986] = 2; +inp[8987] = 0; +inp[8988] = 2; +inp[8989] = 0; +inp[8990] = 1; +inp[8991] = 0; +inp[8992] = 1; +inp[8993] = 0; +inp[8994] = 1; +inp[8995] = 0; +inp[8996] = 0; +inp[8997] = 0; +inp[8998] = 0; +inp[8999] = 0; +inp[9000] = 0; +inp[9001] = 0; +inp[9002] = 0; +inp[9003] = 0; +inp[9004] = 0; +inp[9005] = 0; +inp[9006] = 0; +inp[9007] = 0; +inp[9008] = 0; +inp[9009] = 0; +inp[9010] = 0; +inp[9011] = 0; +inp[9012] = 0; +inp[9013] = 0; +inp[9014] = 0; +inp[9015] = 0; +inp[9016] = 0; +inp[9017] = 0; +inp[9018] = 0; +inp[9019] = 0; +inp[9020] = 0; +inp[9021] = 0; +inp[9022] = 0; +inp[9023] = 0; +inp[9024] = 0; +inp[9025] = 0; +inp[9026] = 0; +inp[9027] = 0; +inp[9028] = 0; +inp[9029] = 0; +inp[9030] = 0; +inp[9031] = 0; +inp[9032] = 0; +inp[9033] = 0; +inp[9034] = 0; +inp[9035] = 0; +inp[9036] = 0; +inp[9037] = 0; +inp[9038] = 0; +inp[9039] = 0; +inp[9040] = 0; +inp[9041] = 0; +inp[9042] = 0; +inp[9043] = 0; +inp[9044] = 0; +inp[9045] = 0; +inp[9046] = 0; +inp[9047] = 0; +inp[9048] = 0; +inp[9049] = 0; +inp[9050] = 0; +inp[9051] = 0; +inp[9052] = 0; +inp[9053] = 0; +inp[9054] = 0; +inp[9055] = 0; +inp[9056] = 0; +inp[9057] = 0; +inp[9058] = 0; +inp[9059] = 0; +inp[9060] = 0; +inp[9061] = 0; +inp[9062] = 0; +inp[9063] = 0; +inp[9064] = 0; +inp[9065] = 0; +inp[9066] = 0; +inp[9067] = 0; +inp[9068] = 0; +inp[9069] = 0; +inp[9070] = 0; +inp[9071] = 0; +inp[9072] = 0; +inp[9073] = 0; +inp[9074] = 0; +inp[9075] = 0; +inp[9076] = 0; +inp[9077] = 0; +inp[9078] = 0; +inp[9079] = 0; +inp[9080] = 0; +inp[9081] = 0; +inp[9082] = 0; +inp[9083] = 0; +inp[9084] = 1073741824; +inp[9085] = 1073741824; +inp[9086] = 947573833; +inp[9087] = 360200; +inp[9088] = 836230973; +inp[9089] = 120; +inp[9090] = 737971243; +inp[9091] = 0; +inp[9092] = 651257336; +inp[9093] = 0; +inp[9094] = 574732582; +inp[9095] = 0; +inp[9096] = 507199723; +inp[9097] = 0; +inp[9098] = 447602185; +inp[9099] = 0; +inp[9100] = 395007542; +inp[9101] = 0; +inp[9102] = 348592932; +inp[9103] = 0; +inp[9104] = 307632183; +inp[9105] = 0; +inp[9106] = 271484448; +inp[9107] = 0; +inp[9108] = 239584185; +inp[9109] = 0; +inp[9110] = 211432301; +inp[9111] = 0; +inp[9112] = 186588351; +inp[9113] = 0; +inp[9114] = 164663641; +inp[9115] = 0; +inp[9116] = 145315153; +inp[9117] = 0; +inp[9118] = 128240173; +inp[9119] = 0; +inp[9120] = 113171555; +inp[9121] = 0; +inp[9122] = 99873547; +inp[9123] = 0; +inp[9124] = 88138096; +inp[9125] = 0; +inp[9126] = 77781596; +inp[9127] = 0; +inp[9128] = 68642018; +inp[9129] = 0; +inp[9130] = 60576368; +inp[9131] = 0; +inp[9132] = 53458457; +inp[9133] = 0; +inp[9134] = 47176923; +inp[9135] = 0; +inp[9136] = 41633488; +inp[9137] = 0; +inp[9138] = 36741424; +inp[9139] = 0; +inp[9140] = 32424193; +inp[9141] = 0; +inp[9142] = 28614250; +inp[9143] = 0; +inp[9144] = 25251987; +inp[9145] = 0; +inp[9146] = 22284800; +inp[9147] = 0; +inp[9148] = 19666267; +inp[9149] = 0; +inp[9150] = 17355420; +inp[9151] = 0; +inp[9152] = 15316104; +inp[9153] = 0; +inp[9154] = 13516414; +inp[9155] = 0; +inp[9156] = 11928194; +inp[9157] = 0; +inp[9158] = 10526594; +inp[9159] = 0; +inp[9160] = 9289686; +inp[9161] = 0; +inp[9162] = 8198119; +inp[9163] = 0; +inp[9164] = 7234815; +inp[9165] = 0; +inp[9166] = 6384702; +inp[9167] = 0; +inp[9168] = 5634479; +inp[9169] = 0; +inp[9170] = 4972411; +inp[9171] = 0; +inp[9172] = 4388137; +inp[9173] = 0; +inp[9174] = 3872517; +inp[9175] = 0; +inp[9176] = 3417484; +inp[9177] = 0; +inp[9178] = 3015919; +inp[9179] = 0; +inp[9180] = 2661539; +inp[9181] = 0; +inp[9182] = 2348800; +inp[9183] = 0; +inp[9184] = 2072809; +inp[9185] = 0; +inp[9186] = 1829247; +inp[9187] = 0; +inp[9188] = 1614305; +inp[9189] = 0; +inp[9190] = 1424619; +inp[9191] = 0; +inp[9192] = 1257222; +inp[9193] = 0; +inp[9194] = 1109494; +inp[9195] = 0; +inp[9196] = 979125; +inp[9197] = 0; +inp[9198] = 864075; +inp[9199] = 0; +inp[9200] = 762543; +inp[9201] = 0; +inp[9202] = 672942; +inp[9203] = 0; +inp[9204] = 593869; +inp[9205] = 0; +inp[9206] = 524088; +inp[9207] = 0; +inp[9208] = 462506; +inp[9209] = 0; +inp[9210] = 408160; +inp[9211] = 0; +inp[9212] = 360200; +inp[9213] = 0; +inp[9214] = 317875; +inp[9215] = 0; +inp[9216] = 280524; +inp[9217] = 0; +inp[9218] = 247561; +inp[9219] = 0; +inp[9220] = 218472; +inp[9221] = 0; +inp[9222] = 192801; +inp[9223] = 0; +inp[9224] = 170146; +inp[9225] = 0; +inp[9226] = 150153; +inp[9227] = 0; +inp[9228] = 132510; +inp[9229] = 0; +inp[9230] = 116939; +inp[9231] = 0; +inp[9232] = 103199; +inp[9233] = 0; +inp[9234] = 91072; +inp[9235] = 0; +inp[9236] = 80371; +inp[9237] = 0; +inp[9238] = 70927; +inp[9239] = 0; +inp[9240] = 62593; +inp[9241] = 0; +inp[9242] = 55238; +inp[9243] = 0; +inp[9244] = 48747; +inp[9245] = 0; +inp[9246] = 43019; +inp[9247] = 0; +inp[9248] = 37964; +inp[9249] = 0; +inp[9250] = 33503; +inp[9251] = 0; +inp[9252] = 29567; +inp[9253] = 0; +inp[9254] = 26092; +inp[9255] = 0; +inp[9256] = 23026; +inp[9257] = 0; +inp[9258] = 20321; +inp[9259] = 0; +inp[9260] = 17933; +inp[9261] = 0; +inp[9262] = 15826; +inp[9263] = 0; +inp[9264] = 13966; +inp[9265] = 0; +inp[9266] = 12325; +inp[9267] = 0; +inp[9268] = 10877; +inp[9269] = 0; +inp[9270] = 9599; +inp[9271] = 0; +inp[9272] = 8471; +inp[9273] = 0; +inp[9274] = 7475; +inp[9275] = 0; +inp[9276] = 6597; +inp[9277] = 0; +inp[9278] = 5822; +inp[9279] = 0; +inp[9280] = 5137; +inp[9281] = 0; +inp[9282] = 4534; +inp[9283] = 0; +inp[9284] = 4001; +inp[9285] = 0; +inp[9286] = 3531; +inp[9287] = 0; +inp[9288] = 3116; +inp[9289] = 0; +inp[9290] = 2750; +inp[9291] = 0; +inp[9292] = 2427; +inp[9293] = 0; +inp[9294] = 2141; +inp[9295] = 0; +inp[9296] = 1890; +inp[9297] = 0; +inp[9298] = 1668; +inp[9299] = 0; +inp[9300] = 1472; +inp[9301] = 0; +inp[9302] = 1299; +inp[9303] = 0; +inp[9304] = 1146; +inp[9305] = 0; +inp[9306] = 1011; +inp[9307] = 0; +inp[9308] = 892; +inp[9309] = 0; +inp[9310] = 787; +inp[9311] = 0; +inp[9312] = 695; +inp[9313] = 0; +inp[9314] = 613; +inp[9315] = 0; +inp[9316] = 541; +inp[9317] = 0; +inp[9318] = 477; +inp[9319] = 0; +inp[9320] = 421; +inp[9321] = 0; +inp[9322] = 372; +inp[9323] = 0; +inp[9324] = 328; +inp[9325] = 0; +inp[9326] = 289; +inp[9327] = 0; +inp[9328] = 255; +inp[9329] = 0; +inp[9330] = 225; +inp[9331] = 0; +inp[9332] = 199; +inp[9333] = 0; +inp[9334] = 175; +inp[9335] = 0; +inp[9336] = 155; +inp[9337] = 0; +inp[9338] = 136; +inp[9339] = 0; +inp[9340] = 1073741824; +inp[9341] = 1073741824; +inp[9342] = 1008687095; +inp[9343] = 120; +inp[9344] = 947573833; +inp[9345] = 0; +inp[9346] = 890163237; +inp[9347] = 0; +inp[9348] = 836230973; +inp[9349] = 0; +inp[9350] = 785566299; +inp[9351] = 0; +inp[9352] = 737971243; +inp[9353] = 0; +inp[9354] = 693259826; +inp[9355] = 0; +inp[9356] = 651257336; +inp[9357] = 0; +inp[9358] = 611799649; +inp[9359] = 0; +inp[9360] = 574732582; +inp[9361] = 0; +inp[9362] = 539911295; +inp[9363] = 0; +inp[9364] = 507199723; +inp[9365] = 0; +inp[9366] = 476470046; +inp[9367] = 0; +inp[9368] = 447602185; +inp[9369] = 0; +inp[9370] = 420483339; +inp[9371] = 0; +inp[9372] = 395007542; +inp[9373] = 0; +inp[9374] = 371075245; +inp[9375] = 0; +inp[9376] = 348592932; +inp[9377] = 0; +inp[9378] = 327472754; +inp[9379] = 0; +inp[9380] = 307632183; +inp[9381] = 0; +inp[9382] = 288993691; +inp[9383] = 0; +inp[9384] = 271484448; +inp[9385] = 0; +inp[9386] = 255036037; +inp[9387] = 0; +inp[9388] = 239584185; +inp[9389] = 0; +inp[9390] = 225068513; +inp[9391] = 0; +inp[9392] = 211432301; +inp[9393] = 0; +inp[9394] = 198622265; +inp[9395] = 0; +inp[9396] = 186588351; +inp[9397] = 0; +inp[9398] = 175283534; +inp[9399] = 0; +inp[9400] = 164663641; +inp[9401] = 0; +inp[9402] = 154687176; +inp[9403] = 0; +inp[9404] = 145315153; +inp[9405] = 0; +inp[9406] = 136510953; +inp[9407] = 0; +inp[9408] = 128240173; +inp[9409] = 0; +inp[9410] = 120470493; +inp[9411] = 0; +inp[9412] = 113171555; +inp[9413] = 0; +inp[9414] = 106314837; +inp[9415] = 0; +inp[9416] = 99873547; +inp[9417] = 0; +inp[9418] = 93822514; +inp[9419] = 0; +inp[9420] = 88138096; +inp[9421] = 0; +inp[9422] = 82798078; +inp[9423] = 0; +inp[9424] = 77781596; +inp[9425] = 0; +inp[9426] = 73069048; +inp[9427] = 0; +inp[9428] = 68642018; +inp[9429] = 0; +inp[9430] = 64483208; +inp[9431] = 0; +inp[9432] = 60576368; +inp[9433] = 0; +inp[9434] = 56906231; +inp[9435] = 0; +inp[9436] = 53458457; +inp[9437] = 0; +inp[9438] = 50219573; +inp[9439] = 0; +inp[9440] = 47176923; +inp[9441] = 0; +inp[9442] = 44318617; +inp[9443] = 0; +inp[9444] = 41633488; +inp[9445] = 0; +inp[9446] = 39111043; +inp[9447] = 0; +inp[9448] = 36741424; +inp[9449] = 0; +inp[9450] = 34515374; +inp[9451] = 0; +inp[9452] = 32424193; +inp[9453] = 0; +inp[9454] = 30459710; +inp[9455] = 0; +inp[9456] = 28614250; +inp[9457] = 0; +inp[9458] = 26880600; +inp[9459] = 0; +inp[9460] = 25251987; +inp[9461] = 0; +inp[9462] = 23722046; +inp[9463] = 0; +inp[9464] = 22284800; +inp[9465] = 0; +inp[9466] = 20934632; +inp[9467] = 0; +inp[9468] = 19666267; +inp[9469] = 0; +inp[9470] = 18474748; +inp[9471] = 0; +inp[9472] = 17355420; +inp[9473] = 0; +inp[9474] = 16303908; +inp[9475] = 0; +inp[9476] = 15316104; +inp[9477] = 0; +inp[9478] = 14388148; +inp[9479] = 0; +inp[9480] = 13516414; +inp[9481] = 0; +inp[9482] = 12697496; +inp[9483] = 0; +inp[9484] = 11928194; +inp[9485] = 0; +inp[9486] = 11205501; +inp[9487] = 0; +inp[9488] = 10526594; +inp[9489] = 0; +inp[9490] = 9888820; +inp[9491] = 0; +inp[9492] = 9289686; +inp[9493] = 0; +inp[9494] = 8726853; +inp[9495] = 0; +inp[9496] = 8198119; +inp[9497] = 0; +inp[9498] = 7701421; +inp[9499] = 0; +inp[9500] = 7234815; +inp[9501] = 0; +inp[9502] = 6796480; +inp[9503] = 0; +inp[9504] = 6384702; +inp[9505] = 0; +inp[9506] = 5997872; +inp[9507] = 0; +inp[9508] = 5634479; +inp[9509] = 0; +inp[9510] = 5293104; +inp[9511] = 0; +inp[9512] = 4972411; +inp[9513] = 0; +inp[9514] = 4671147; +inp[9515] = 0; +inp[9516] = 4388137; +inp[9517] = 0; +inp[9518] = 4122273; +inp[9519] = 0; +inp[9520] = 3872517; +inp[9521] = 0; +inp[9522] = 3637893; +inp[9523] = 0; +inp[9524] = 3417484; +inp[9525] = 0; +inp[9526] = 3210429; +inp[9527] = 0; +inp[9528] = 3015919; +inp[9529] = 0; +inp[9530] = 2833194; +inp[9531] = 0; +inp[9532] = 2661539; +inp[9533] = 0; +inp[9534] = 2500285; +inp[9535] = 0; +inp[9536] = 2348800; +inp[9537] = 0; +inp[9538] = 2206494; +inp[9539] = 0; +inp[9540] = 2072809; +inp[9541] = 0; +inp[9542] = 1947224; +inp[9543] = 0; +inp[9544] = 1829247; +inp[9545] = 0; +inp[9546] = 1718419; +inp[9547] = 0; +inp[9548] = 1614305; +inp[9549] = 0; +inp[9550] = 1516499; +inp[9551] = 0; +inp[9552] = 1424619; +inp[9553] = 0; +inp[9554] = 1338306; +inp[9555] = 0; +inp[9556] = 1257222; +inp[9557] = 0; +inp[9558] = 1181051; +inp[9559] = 0; +inp[9560] = 1109494; +inp[9561] = 0; +inp[9562] = 1042273; +inp[9563] = 0; +inp[9564] = 979125; +inp[9565] = 0; +inp[9566] = 919803; +inp[9567] = 0; +inp[9568] = 864075; +inp[9569] = 0; +inp[9570] = 811723; +inp[9571] = 0; +inp[9572] = 762543; +inp[9573] = 0; +inp[9574] = 716343; +inp[9575] = 0; +inp[9576] = 672942; +inp[9577] = 0; +inp[9578] = 632171; +inp[9579] = 0; +inp[9580] = 593869; +inp[9581] = 0; +inp[9582] = 557889; +inp[9583] = 0; +inp[9584] = 524088; +inp[9585] = 0; +inp[9586] = 492335; +inp[9587] = 0; +inp[9588] = 462506; +inp[9589] = 0; +inp[9590] = 434484; +inp[9591] = 0; +inp[9592] = 408160; +inp[9593] = 0; +inp[9594] = 383431; +inp[9595] = 0; +inp[9596] = 1073741824; +inp[9597] = 1073741824; +inp[9598] = 1040706261; +inp[9599] = 0; +inp[9600] = 1008687095; +inp[9601] = 0; +inp[9602] = 977653056; +inp[9603] = 0; +inp[9604] = 947573833; +inp[9605] = 0; +inp[9606] = 918420051; +inp[9607] = 0; +inp[9608] = 890163237; +inp[9609] = 0; +inp[9610] = 862775793; +inp[9611] = 0; +inp[9612] = 836230973; +inp[9613] = 0; +inp[9614] = 810502851; +inp[9615] = 0; +inp[9616] = 785566299; +inp[9617] = 0; +inp[9618] = 761396965; +inp[9619] = 0; +inp[9620] = 737971243; +inp[9621] = 0; +inp[9622] = 715266255; +inp[9623] = 0; +inp[9624] = 693259826; +inp[9625] = 0; +inp[9626] = 671930463; +inp[9627] = 0; +inp[9628] = 651257336; +inp[9629] = 0; +inp[9630] = 631220255; +inp[9631] = 0; +inp[9632] = 611799649; +inp[9633] = 0; +inp[9634] = 592976553; +inp[9635] = 0; +inp[9636] = 574732582; +inp[9637] = 0; +inp[9638] = 557049919; +inp[9639] = 0; +inp[9640] = 539911295; +inp[9641] = 0; +inp[9642] = 523299971; +inp[9643] = 0; +inp[9644] = 507199723; +inp[9645] = 0; +inp[9646] = 491594828; +inp[9647] = 0; +inp[9648] = 476470046; +inp[9649] = 0; +inp[9650] = 461810603; +inp[9651] = 0; +inp[9652] = 447602185; +inp[9653] = 0; +inp[9654] = 433830913; +inp[9655] = 0; +inp[9656] = 420483339; +inp[9657] = 0; +inp[9658] = 407546427; +inp[9659] = 0; +inp[9660] = 395007542; +inp[9661] = 0; +inp[9662] = 382854437; +inp[9663] = 0; +inp[9664] = 371075245; +inp[9665] = 0; +inp[9666] = 359658459; +inp[9667] = 0; +inp[9668] = 348592932; +inp[9669] = 0; +inp[9670] = 337867855; +inp[9671] = 0; +inp[9672] = 327472754; +inp[9673] = 0; +inp[9674] = 317397476; +inp[9675] = 0; +inp[9676] = 307632183; +inp[9677] = 0; +inp[9678] = 298167335; +inp[9679] = 0; +inp[9680] = 288993691; +inp[9681] = 0; +inp[9682] = 280102290; +inp[9683] = 0; +inp[9684] = 271484448; +inp[9685] = 0; +inp[9686] = 263131750; +inp[9687] = 0; +inp[9688] = 255036037; +inp[9689] = 0; +inp[9690] = 247189403; +inp[9691] = 0; +inp[9692] = 239584185; +inp[9693] = 0; +inp[9694] = 232212954; +inp[9695] = 0; +inp[9696] = 225068513; +inp[9697] = 0; +inp[9698] = 218143882; +inp[9699] = 0; +inp[9700] = 211432301; +inp[9701] = 0; +inp[9702] = 204927213; +inp[9703] = 0; +inp[9704] = 198622265; +inp[9705] = 0; +inp[9706] = 192511301; +inp[9707] = 0; +inp[9708] = 186588351; +inp[9709] = 0; +inp[9710] = 180847630; +inp[9711] = 0; +inp[9712] = 175283534; +inp[9713] = 0; +inp[9714] = 169890626; +inp[9715] = 0; +inp[9716] = 164663641; +inp[9717] = 0; +inp[9718] = 159597474; +inp[9719] = 0; +inp[9720] = 154687176; +inp[9721] = 0; +inp[9722] = 149927952; +inp[9723] = 0; +inp[9724] = 145315153; +inp[9725] = 0; +inp[9726] = 140844276; +inp[9727] = 0; +inp[9728] = 136510953; +inp[9729] = 0; +inp[9730] = 132310953; +inp[9731] = 0; +inp[9732] = 128240173; +inp[9733] = 0; +inp[9734] = 124294637; +inp[9735] = 0; +inp[9736] = 120470493; +inp[9737] = 0; +inp[9738] = 116764006; +inp[9739] = 0; +inp[9740] = 113171555; +inp[9741] = 0; +inp[9742] = 109689632; +inp[9743] = 0; +inp[9744] = 106314837; +inp[9745] = 0; +inp[9746] = 103043874; +inp[9747] = 0; +inp[9748] = 99873547; +inp[9749] = 0; +inp[9750] = 96800761; +inp[9751] = 0; +inp[9752] = 93822514; +inp[9753] = 0; +inp[9754] = 90935899; +inp[9755] = 0; +inp[9756] = 88138096; +inp[9757] = 0; +inp[9758] = 85426372; +inp[9759] = 0; +inp[9760] = 82798078; +inp[9761] = 0; +inp[9762] = 80250649; +inp[9763] = 0; +inp[9764] = 77781596; +inp[9765] = 0; +inp[9766] = 75388508; +inp[9767] = 0; +inp[9768] = 73069048; +inp[9769] = 0; +inp[9770] = 70820949; +inp[9771] = 0; +inp[9772] = 68642018; +inp[9773] = 0; +inp[9774] = 66530125; +inp[9775] = 0; +inp[9776] = 64483208; +inp[9777] = 0; +inp[9778] = 62499268; +inp[9779] = 0; +inp[9780] = 60576368; +inp[9781] = 0; +inp[9782] = 58712629; +inp[9783] = 0; +inp[9784] = 56906231; +inp[9785] = 0; +inp[9786] = 55155411; +inp[9787] = 0; +inp[9788] = 53458457; +inp[9789] = 0; +inp[9790] = 51813713; +inp[9791] = 0; +inp[9792] = 50219573; +inp[9793] = 0; +inp[9794] = 48674479; +inp[9795] = 0; +inp[9796] = 47176923; +inp[9797] = 0; +inp[9798] = 45725441; +inp[9799] = 0; +inp[9800] = 44318617; +inp[9801] = 0; +inp[9802] = 42955077; +inp[9803] = 0; +inp[9804] = 41633488; +inp[9805] = 0; +inp[9806] = 40352560; +inp[9807] = 0; +inp[9808] = 39111043; +inp[9809] = 0; +inp[9810] = 37907722; +inp[9811] = 0; +inp[9812] = 36741424; +inp[9813] = 0; +inp[9814] = 35611009; +inp[9815] = 0; +inp[9816] = 34515374; +inp[9817] = 0; +inp[9818] = 33453447; +inp[9819] = 0; +inp[9820] = 32424193; +inp[9821] = 0; +inp[9822] = 31426605; +inp[9823] = 0; +inp[9824] = 30459710; +inp[9825] = 0; +inp[9826] = 29522564; +inp[9827] = 0; +inp[9828] = 28614250; +inp[9829] = 0; +inp[9830] = 27733882; +inp[9831] = 0; +inp[9832] = 26880600; +inp[9833] = 0; +inp[9834] = 26053571; +inp[9835] = 0; +inp[9836] = 25251987; +inp[9837] = 0; +inp[9838] = 24475065; +inp[9839] = 0; +inp[9840] = 23722046; +inp[9841] = 0; +inp[9842] = 22992196; +inp[9843] = 0; +inp[9844] = 22284800; +inp[9845] = 0; +inp[9846] = 21599169; +inp[9847] = 0; +inp[9848] = 20934632; +inp[9849] = 0; +inp[9850] = 20290541; +inp[9851] = 0; +inp[9852] = 1073741824; +inp[9853] = 1073741824; +inp[9854] = 1057094999; +inp[9855] = 0; +inp[9856] = 1040706261; +inp[9857] = 0; +inp[9858] = 1024571605; +inp[9859] = 0; +inp[9860] = 1008687095; +inp[9861] = 0; +inp[9862] = 993048851; +inp[9863] = 0; +inp[9864] = 977653056; +inp[9865] = 0; +inp[9866] = 962495950; +inp[9867] = 0; +inp[9868] = 947573833; +inp[9869] = 0; +inp[9870] = 932883063; +inp[9871] = 0; +inp[9872] = 918420051; +inp[9873] = 0; +inp[9874] = 904181268; +inp[9875] = 0; +inp[9876] = 890163237; +inp[9877] = 0; +inp[9878] = 876362535; +inp[9879] = 0; +inp[9880] = 862775793; +inp[9881] = 0; +inp[9882] = 849399695; +inp[9883] = 0; +inp[9884] = 836230973; +inp[9885] = 0; +inp[9886] = 823266413; +inp[9887] = 0; +inp[9888] = 810502851; +inp[9889] = 0; +inp[9890] = 797937169; +inp[9891] = 0; +inp[9892] = 785566299; +inp[9893] = 0; +inp[9894] = 773387223; +inp[9895] = 0; +inp[9896] = 761396965; +inp[9897] = 0; +inp[9898] = 749592599; +inp[9899] = 0; +inp[9900] = 737971243; +inp[9901] = 0; +inp[9902] = 726530060; +inp[9903] = 0; +inp[9904] = 715266255; +inp[9905] = 0; +inp[9906] = 704177080; +inp[9907] = 0; +inp[9908] = 693259826; +inp[9909] = 0; +inp[9910] = 682511829; +inp[9911] = 0; +inp[9912] = 671930463; +inp[9913] = 0; +inp[9914] = 661513147; +inp[9915] = 0; +inp[9916] = 651257336; +inp[9917] = 0; +inp[9918] = 641160527; +inp[9919] = 0; +inp[9920] = 631220255; +inp[9921] = 0; +inp[9922] = 621434092; +inp[9923] = 0; +inp[9924] = 611799649; +inp[9925] = 0; +inp[9926] = 602314575; +inp[9927] = 0; +inp[9928] = 592976553; +inp[9929] = 0; +inp[9930] = 583783303; +inp[9931] = 0; +inp[9932] = 574732582; +inp[9933] = 0; +inp[9934] = 565822179; +inp[9935] = 0; +inp[9936] = 557049919; +inp[9937] = 0; +inp[9938] = 548413661; +inp[9939] = 0; +inp[9940] = 539911295; +inp[9941] = 0; +inp[9942] = 531540746; +inp[9943] = 0; +inp[9944] = 523299971; +inp[9945] = 0; +inp[9946] = 515186957; +inp[9947] = 0; +inp[9948] = 507199723; +inp[9949] = 0; +inp[9950] = 499336321; +inp[9951] = 0; +inp[9952] = 491594828; +inp[9953] = 0; +inp[9954] = 483973357; +inp[9955] = 0; +inp[9956] = 476470046; +inp[9957] = 0; +inp[9958] = 469083062; +inp[9959] = 0; +inp[9960] = 461810603; +inp[9961] = 0; +inp[9962] = 454650894; +inp[9963] = 0; +inp[9964] = 447602185; +inp[9965] = 0; +inp[9966] = 440662756; +inp[9967] = 0; +inp[9968] = 433830913; +inp[9969] = 0; +inp[9970] = 427104988; +inp[9971] = 0; +inp[9972] = 420483339; +inp[9973] = 0; +inp[9974] = 413964349; +inp[9975] = 0; +inp[9976] = 407546427; +inp[9977] = 0; +inp[9978] = 401228005; +inp[9979] = 0; +inp[9980] = 395007542; +inp[9981] = 0; +inp[9982] = 388883517; +inp[9983] = 0; +inp[9984] = 382854437; +inp[9985] = 0; +inp[9986] = 376918829; +inp[9987] = 0; +inp[9988] = 371075245; +inp[9989] = 0; +inp[9990] = 365322256; +inp[9991] = 0; +inp[9992] = 359658459; +inp[9993] = 0; +inp[9994] = 354082472; +inp[9995] = 0; +inp[9996] = 348592932; +inp[9997] = 0; +inp[9998] = 343188499; +inp[9999] = 0; +inp[10000] = 337867855; +inp[10001] = 0; +inp[10002] = 332629699; +inp[10003] = 0; +inp[10004] = 327472754; +inp[10005] = 0; +inp[10006] = 322395759; +inp[10007] = 0; +inp[10008] = 317397476; +inp[10009] = 0; +inp[10010] = 312476685; +inp[10011] = 0; +inp[10012] = 307632183; +inp[10013] = 0; +inp[10014] = 302862788; +inp[10015] = 0; +inp[10016] = 298167335; +inp[10017] = 0; +inp[10018] = 293544679; +inp[10019] = 0; +inp[10020] = 288993691; +inp[10021] = 0; +inp[10022] = 284513259; +inp[10023] = 0; +inp[10024] = 280102290; +inp[10025] = 0; +inp[10026] = 275759706; +inp[10027] = 0; +inp[10028] = 271484448; +inp[10029] = 0; +inp[10030] = 267275472; +inp[10031] = 0; +inp[10032] = 263131750; +inp[10033] = 0; +inp[10034] = 259052270; +inp[10035] = 0; +inp[10036] = 255036037; +inp[10037] = 0; +inp[10038] = 251082070; +inp[10039] = 0; +inp[10040] = 247189403; +inp[10041] = 0; +inp[10042] = 243357087; +inp[10043] = 0; +inp[10044] = 239584185; +inp[10045] = 0; +inp[10046] = 235869776; +inp[10047] = 0; +inp[10048] = 232212954; +inp[10049] = 0; +inp[10050] = 228612826; +inp[10051] = 0; +inp[10052] = 225068513; +inp[10053] = 0; +inp[10054] = 221579149; +inp[10055] = 0; +inp[10056] = 218143882; +inp[10057] = 0; +inp[10058] = 214761875; +inp[10059] = 0; +inp[10060] = 211432301; +inp[10061] = 0; +inp[10062] = 208154347; +inp[10063] = 0; +inp[10064] = 204927213; +inp[10065] = 0; +inp[10066] = 201750111; +inp[10067] = 0; +inp[10068] = 198622265; +inp[10069] = 0; +inp[10070] = 195542912; +inp[10071] = 0; +inp[10072] = 192511301; +inp[10073] = 0; +inp[10074] = 189526689; +inp[10075] = 0; +inp[10076] = 186588351; +inp[10077] = 0; +inp[10078] = 183695566; +inp[10079] = 0; +inp[10080] = 180847630; +inp[10081] = 0; +inp[10082] = 178043848; +inp[10083] = 0; +inp[10084] = 175283534; +inp[10085] = 0; +inp[10086] = 172566014; +inp[10087] = 0; +inp[10088] = 169890626; +inp[10089] = 0; +inp[10090] = 167256716; +inp[10091] = 0; +inp[10092] = 164663641; +inp[10093] = 0; +inp[10094] = 162110768; +inp[10095] = 0; +inp[10096] = 159597474; +inp[10097] = 0; +inp[10098] = 157123144; +inp[10099] = 0; +inp[10100] = 154687176; +inp[10101] = 0; +inp[10102] = 152288973; +inp[10103] = 0; +inp[10104] = 149927952; +inp[10105] = 0; +inp[10106] = 147603534; +inp[10107] = 0; +inp[10108] = 1073741824; +inp[10109] = 1073741824; +inp[10110] = 1065385898; +inp[10111] = 0; +inp[10112] = 1057094999; +inp[10113] = 0; +inp[10114] = 1048868621; +inp[10115] = 0; +inp[10116] = 1040706261; +inp[10117] = 0; +inp[10118] = 1032607420; +inp[10119] = 0; +inp[10120] = 1024571605; +inp[10121] = 0; +inp[10122] = 1016598326; +inp[10123] = 0; +inp[10124] = 1008687095; +inp[10125] = 0; +inp[10126] = 1000837430; +inp[10127] = 0; +inp[10128] = 993048851; +inp[10129] = 0; +inp[10130] = 985320884; +inp[10131] = 0; +inp[10132] = 977653056; +inp[10133] = 0; +inp[10134] = 970044899; +inp[10135] = 0; +inp[10136] = 962495950; +inp[10137] = 0; +inp[10138] = 955005747; +inp[10139] = 0; +inp[10140] = 947573833; +inp[10141] = 0; +inp[10142] = 940199755; +inp[10143] = 0; +inp[10144] = 932883063; +inp[10145] = 0; +inp[10146] = 925623309; +inp[10147] = 0; +inp[10148] = 918420051; +inp[10149] = 0; +inp[10150] = 911272850; +inp[10151] = 0; +inp[10152] = 904181268; +inp[10153] = 0; +inp[10154] = 897144874; +inp[10155] = 0; +inp[10156] = 890163237; +inp[10157] = 0; +inp[10158] = 883235932; +inp[10159] = 0; +inp[10160] = 876362535; +inp[10161] = 0; +inp[10162] = 869542628; +inp[10163] = 0; +inp[10164] = 862775793; +inp[10165] = 0; +inp[10166] = 856061619; +inp[10167] = 0; +inp[10168] = 849399695; +inp[10169] = 0; +inp[10170] = 842789614; +inp[10171] = 0; +inp[10172] = 836230973; +inp[10173] = 0; +inp[10174] = 829723372; +inp[10175] = 0; +inp[10176] = 823266413; +inp[10177] = 0; +inp[10178] = 816859703; +inp[10179] = 0; +inp[10180] = 810502851; +inp[10181] = 0; +inp[10182] = 804195467; +inp[10183] = 0; +inp[10184] = 797937169; +inp[10185] = 0; +inp[10186] = 791727572; +inp[10187] = 0; +inp[10188] = 785566299; +inp[10189] = 0; +inp[10190] = 779452974; +inp[10191] = 0; +inp[10192] = 773387223; +inp[10193] = 0; +inp[10194] = 767368676; +inp[10195] = 0; +inp[10196] = 761396965; +inp[10197] = 0; +inp[10198] = 755471727; +inp[10199] = 0; +inp[10200] = 749592599; +inp[10201] = 0; +inp[10202] = 743759224; +inp[10203] = 0; +inp[10204] = 737971243; +inp[10205] = 0; +inp[10206] = 732228306; +inp[10207] = 0; +inp[10208] = 726530060; +inp[10209] = 0; +inp[10210] = 720876158; +inp[10211] = 0; +inp[10212] = 715266255; +inp[10213] = 0; +inp[10214] = 709700009; +inp[10215] = 0; +inp[10216] = 704177080; +inp[10217] = 0; +inp[10218] = 698697130; +inp[10219] = 0; +inp[10220] = 693259826; +inp[10221] = 0; +inp[10222] = 687864835; +inp[10223] = 0; +inp[10224] = 682511829; +inp[10225] = 0; +inp[10226] = 677200479; +inp[10227] = 0; +inp[10228] = 671930463; +inp[10229] = 0; +inp[10230] = 666701459; +inp[10231] = 0; +inp[10232] = 661513147; +inp[10233] = 0; +inp[10234] = 656365211; +inp[10235] = 0; +inp[10236] = 651257336; +inp[10237] = 0; +inp[10238] = 646189212; +inp[10239] = 0; +inp[10240] = 641160527; +inp[10241] = 0; +inp[10242] = 636170976; +inp[10243] = 0; +inp[10244] = 631220255; +inp[10245] = 0; +inp[10246] = 626308060; +inp[10247] = 0; +inp[10248] = 621434092; +inp[10249] = 0; +inp[10250] = 616598053; +inp[10251] = 0; +inp[10252] = 611799649; +inp[10253] = 0; +inp[10254] = 607038586; +inp[10255] = 0; +inp[10256] = 602314575; +inp[10257] = 0; +inp[10258] = 597627325; +inp[10259] = 0; +inp[10260] = 592976553; +inp[10261] = 0; +inp[10262] = 588361972; +inp[10263] = 0; +inp[10264] = 583783303; +inp[10265] = 0; +inp[10266] = 579240266; +inp[10267] = 0; +inp[10268] = 574732582; +inp[10269] = 0; +inp[10270] = 570259978; +inp[10271] = 0; +inp[10272] = 565822179; +inp[10273] = 0; +inp[10274] = 561418916; +inp[10275] = 0; +inp[10276] = 557049919; +inp[10277] = 0; +inp[10278] = 552714923; +inp[10279] = 0; +inp[10280] = 548413661; +inp[10281] = 0; +inp[10282] = 544145872; +inp[10283] = 0; +inp[10284] = 539911295; +inp[10285] = 0; +inp[10286] = 535709672; +inp[10287] = 0; +inp[10288] = 531540746; +inp[10289] = 0; +inp[10290] = 527404264; +inp[10291] = 0; +inp[10292] = 523299971; +inp[10293] = 0; +inp[10294] = 519227618; +inp[10295] = 0; +inp[10296] = 515186957; +inp[10297] = 0; +inp[10298] = 511177740; +inp[10299] = 0; +inp[10300] = 507199723; +inp[10301] = 0; +inp[10302] = 503252664; +inp[10303] = 0; +inp[10304] = 499336321; +inp[10305] = 0; +inp[10306] = 495450454; +inp[10307] = 0; +inp[10308] = 491594828; +inp[10309] = 0; +inp[10310] = 487769207; +inp[10311] = 0; +inp[10312] = 483973357; +inp[10313] = 0; +inp[10314] = 480207047; +inp[10315] = 0; +inp[10316] = 476470046; +inp[10317] = 0; +inp[10318] = 472762126; +inp[10319] = 0; +inp[10320] = 469083062; +inp[10321] = 0; +inp[10322] = 465432629; +inp[10323] = 0; +inp[10324] = 461810603; +inp[10325] = 0; +inp[10326] = 458216765; +inp[10327] = 0; +inp[10328] = 454650894; +inp[10329] = 0; +inp[10330] = 451112772; +inp[10331] = 0; +inp[10332] = 447602185; +inp[10333] = 0; +inp[10334] = 444118917; +inp[10335] = 0; +inp[10336] = 440662756; +inp[10337] = 0; +inp[10338] = 437233491; +inp[10339] = 0; +inp[10340] = 433830913; +inp[10341] = 0; +inp[10342] = 430454814; +inp[10343] = 0; +inp[10344] = 427104988; +inp[10345] = 0; +inp[10346] = 423781231; +inp[10347] = 0; +inp[10348] = 420483339; +inp[10349] = 0; +inp[10350] = 417211112; +inp[10351] = 0; +inp[10352] = 413964349; +inp[10353] = 0; +inp[10354] = 410742853; +inp[10355] = 0; +inp[10356] = 407546427; +inp[10357] = 0; +inp[10358] = 404374876; +inp[10359] = 0; +inp[10360] = 401228005; +inp[10361] = 0; +inp[10362] = 398105624; +inp[10363] = 0; +inp[10364] = 1073741824; +inp[10365] = 1073741824; +inp[10366] = 1069555701; +inp[10367] = 0; +inp[10368] = 1065385898; +inp[10369] = 0; +inp[10370] = 1061232352; +inp[10371] = 0; +inp[10372] = 1057094999; +inp[10373] = 0; +inp[10374] = 1052973777; +inp[10375] = 0; +inp[10376] = 1048868621; +inp[10377] = 0; +inp[10378] = 1044779470; +inp[10379] = 0; +inp[10380] = 1040706261; +inp[10381] = 0; +inp[10382] = 1036648931; +inp[10383] = 0; +inp[10384] = 1032607420; +inp[10385] = 0; +inp[10386] = 1028581665; +inp[10387] = 0; +inp[10388] = 1024571605; +inp[10389] = 0; +inp[10390] = 1020577179; +inp[10391] = 0; +inp[10392] = 1016598326; +inp[10393] = 0; +inp[10394] = 1012634985; +inp[10395] = 0; +inp[10396] = 1008687095; +inp[10397] = 0; +inp[10398] = 1004754597; +inp[10399] = 0; +inp[10400] = 1000837430; +inp[10401] = 0; +inp[10402] = 996935534; +inp[10403] = 0; +inp[10404] = 993048851; +inp[10405] = 0; +inp[10406] = 989177321; +inp[10407] = 0; +inp[10408] = 985320884; +inp[10409] = 0; +inp[10410] = 981479482; +inp[10411] = 0; +inp[10412] = 977653056; +inp[10413] = 0; +inp[10414] = 973841548; +inp[10415] = 0; +inp[10416] = 970044899; +inp[10417] = 0; +inp[10418] = 966263053; +inp[10419] = 0; +inp[10420] = 962495950; +inp[10421] = 0; +inp[10422] = 958743534; +inp[10423] = 0; +inp[10424] = 955005747; +inp[10425] = 0; +inp[10426] = 951282532; +inp[10427] = 0; +inp[10428] = 947573833; +inp[10429] = 0; +inp[10430] = 943879593; +inp[10431] = 0; +inp[10432] = 940199755; +inp[10433] = 0; +inp[10434] = 936534264; +inp[10435] = 0; +inp[10436] = 932883063; +inp[10437] = 0; +inp[10438] = 929246096; +inp[10439] = 0; +inp[10440] = 925623309; +inp[10441] = 0; +inp[10442] = 922014646; +inp[10443] = 0; +inp[10444] = 918420051; +inp[10445] = 0; +inp[10446] = 914839471; +inp[10447] = 0; +inp[10448] = 911272850; +inp[10449] = 0; +inp[10450] = 907720134; +inp[10451] = 0; +inp[10452] = 904181268; +inp[10453] = 0; +inp[10454] = 900656200; +inp[10455] = 0; +inp[10456] = 897144874; +inp[10457] = 0; +inp[10458] = 893647237; +inp[10459] = 0; +inp[10460] = 890163237; +inp[10461] = 0; +inp[10462] = 886692819; +inp[10463] = 0; +inp[10464] = 883235932; +inp[10465] = 0; +inp[10466] = 879792521; +inp[10467] = 0; +inp[10468] = 876362535; +inp[10469] = 0; +inp[10470] = 872945921; +inp[10471] = 0; +inp[10472] = 869542628; +inp[10473] = 0; +inp[10474] = 866152602; +inp[10475] = 0; +inp[10476] = 862775793; +inp[10477] = 0; +inp[10478] = 859412149; +inp[10479] = 0; +inp[10480] = 856061619; +inp[10481] = 0; +inp[10482] = 852724151; +inp[10483] = 0; +inp[10484] = 849399695; +inp[10485] = 0; +inp[10486] = 846088199; +inp[10487] = 0; +inp[10488] = 842789614; +inp[10489] = 0; +inp[10490] = 839503888; +inp[10491] = 0; +inp[10492] = 836230973; +inp[10493] = 0; +inp[10494] = 832970817; +inp[10495] = 0; +inp[10496] = 829723372; +inp[10497] = 0; +inp[10498] = 826488587; +inp[10499] = 0; +inp[10500] = 823266413; +inp[10501] = 0; +inp[10502] = 820056802; +inp[10503] = 0; +inp[10504] = 816859703; +inp[10505] = 0; +inp[10506] = 813675069; +inp[10507] = 0; +inp[10508] = 810502851; +inp[10509] = 0; +inp[10510] = 807342999; +inp[10511] = 0; +inp[10512] = 804195467; +inp[10513] = 0; +inp[10514] = 801060206; +inp[10515] = 0; +inp[10516] = 797937169; +inp[10517] = 0; +inp[10518] = 794826306; +inp[10519] = 0; +inp[10520] = 791727572; +inp[10521] = 0; +inp[10522] = 788640919; +inp[10523] = 0; +inp[10524] = 785566299; +inp[10525] = 0; +inp[10526] = 782503667; +inp[10527] = 0; +inp[10528] = 779452974; +inp[10529] = 0; +inp[10530] = 776414175; +inp[10531] = 0; +inp[10532] = 773387223; +inp[10533] = 0; +inp[10534] = 770372072; +inp[10535] = 0; +inp[10536] = 767368676; +inp[10537] = 0; +inp[10538] = 764376989; +inp[10539] = 0; +inp[10540] = 761396965; +inp[10541] = 0; +inp[10542] = 758428560; +inp[10543] = 0; +inp[10544] = 755471727; +inp[10545] = 0; +inp[10546] = 752526422; +inp[10547] = 0; +inp[10548] = 749592599; +inp[10549] = 0; +inp[10550] = 746670215; +inp[10551] = 0; +inp[10552] = 743759224; +inp[10553] = 0; +inp[10554] = 740859581; +inp[10555] = 0; +inp[10556] = 737971243; +inp[10557] = 0; +inp[10558] = 735094166; +inp[10559] = 0; +inp[10560] = 732228306; +inp[10561] = 0; +inp[10562] = 729373618; +inp[10563] = 0; +inp[10564] = 726530060; +inp[10565] = 0; +inp[10566] = 723697587; +inp[10567] = 0; +inp[10568] = 720876158; +inp[10569] = 0; +inp[10570] = 718065728; +inp[10571] = 0; +inp[10572] = 715266255; +inp[10573] = 0; +inp[10574] = 712477696; +inp[10575] = 0; +inp[10576] = 709700009; +inp[10577] = 0; +inp[10578] = 706933151; +inp[10579] = 0; +inp[10580] = 704177080; +inp[10581] = 0; +inp[10582] = 701431753; +inp[10583] = 0; +inp[10584] = 698697130; +inp[10585] = 0; +inp[10586] = 695973168; +inp[10587] = 0; +inp[10588] = 693259826; +inp[10589] = 0; +inp[10590] = 690557062; +inp[10591] = 0; +inp[10592] = 687864835; +inp[10593] = 0; +inp[10594] = 685183104; +inp[10595] = 0; +inp[10596] = 682511829; +inp[10597] = 0; +inp[10598] = 679850967; +inp[10599] = 0; +inp[10600] = 677200479; +inp[10601] = 0; +inp[10602] = 674560325; +inp[10603] = 0; +inp[10604] = 671930463; +inp[10605] = 0; +inp[10606] = 669310855; +inp[10607] = 0; +inp[10608] = 666701459; +inp[10609] = 0; +inp[10610] = 664102236; +inp[10611] = 0; +inp[10612] = 661513147; +inp[10613] = 0; +inp[10614] = 658934152; +inp[10615] = 0; +inp[10616] = 656365211; +inp[10617] = 0; +inp[10618] = 653806286; +inp[10619] = 0; +inp[10620] = 1073741824; +inp[10621] = 1073741824; +inp[10622] = 1071646718; +inp[10623] = 0; +inp[10624] = 1069555701; +inp[10625] = 0; +inp[10626] = 1067468764; +inp[10627] = 0; +inp[10628] = 1065385898; +inp[10629] = 0; +inp[10630] = 1063307097; +inp[10631] = 0; +inp[10632] = 1061232352; +inp[10633] = 0; +inp[10634] = 1059161656; +inp[10635] = 0; +inp[10636] = 1057094999; +inp[10637] = 0; +inp[10638] = 1055032376; +inp[10639] = 0; +inp[10640] = 1052973777; +inp[10641] = 0; +inp[10642] = 1050919194; +inp[10643] = 0; +inp[10644] = 1048868621; +inp[10645] = 0; +inp[10646] = 1046822049; +inp[10647] = 0; +inp[10648] = 1044779470; +inp[10649] = 0; +inp[10650] = 1042740876; +inp[10651] = 0; +inp[10652] = 1040706261; +inp[10653] = 0; +inp[10654] = 1038675615; +inp[10655] = 0; +inp[10656] = 1036648931; +inp[10657] = 0; +inp[10658] = 1034626202; +inp[10659] = 0; +inp[10660] = 1032607420; +inp[10661] = 0; +inp[10662] = 1030592577; +inp[10663] = 0; +inp[10664] = 1028581665; +inp[10665] = 0; +inp[10666] = 1026574677; +inp[10667] = 0; +inp[10668] = 1024571605; +inp[10669] = 0; +inp[10670] = 1022572442; +inp[10671] = 0; +inp[10672] = 1020577179; +inp[10673] = 0; +inp[10674] = 1018585810; +inp[10675] = 0; +inp[10676] = 1016598326; +inp[10677] = 0; +inp[10678] = 1014614720; +inp[10679] = 0; +inp[10680] = 1012634985; +inp[10681] = 0; +inp[10682] = 1010659112; +inp[10683] = 0; +inp[10684] = 1008687095; +inp[10685] = 0; +inp[10686] = 1006718926; +inp[10687] = 0; +inp[10688] = 1004754597; +inp[10689] = 0; +inp[10690] = 1002794101; +inp[10691] = 0; +inp[10692] = 1000837430; +inp[10693] = 0; +inp[10694] = 998884577; +inp[10695] = 0; +inp[10696] = 996935534; +inp[10697] = 0; +inp[10698] = 994990295; +inp[10699] = 0; +inp[10700] = 993048851; +inp[10701] = 0; +inp[10702] = 991111195; +inp[10703] = 0; +inp[10704] = 989177321; +inp[10705] = 0; +inp[10706] = 987247219; +inp[10707] = 0; +inp[10708] = 985320884; +inp[10709] = 0; +inp[10710] = 983398307; +inp[10711] = 0; +inp[10712] = 981479482; +inp[10713] = 0; +inp[10714] = 979564400; +inp[10715] = 0; +inp[10716] = 977653056; +inp[10717] = 0; +inp[10718] = 975745441; +inp[10719] = 0; +inp[10720] = 973841548; +inp[10721] = 0; +inp[10722] = 971941370; +inp[10723] = 0; +inp[10724] = 970044899; +inp[10725] = 0; +inp[10726] = 968152129; +inp[10727] = 0; +inp[10728] = 966263053; +inp[10729] = 0; +inp[10730] = 964377662; +inp[10731] = 0; +inp[10732] = 962495950; +inp[10733] = 0; +inp[10734] = 960617910; +inp[10735] = 0; +inp[10736] = 958743534; +inp[10737] = 0; +inp[10738] = 956872815; +inp[10739] = 0; +inp[10740] = 955005747; +inp[10741] = 0; +inp[10742] = 953142322; +inp[10743] = 0; +inp[10744] = 951282532; +inp[10745] = 0; +inp[10746] = 949426372; +inp[10747] = 0; +inp[10748] = 947573833; +inp[10749] = 0; +inp[10750] = 945724909; +inp[10751] = 0; +inp[10752] = 943879593; +inp[10753] = 0; +inp[10754] = 942037877; +inp[10755] = 0; +inp[10756] = 940199755; +inp[10757] = 0; +inp[10758] = 938365220; +inp[10759] = 0; +inp[10760] = 936534264; +inp[10761] = 0; +inp[10762] = 934706880; +inp[10763] = 0; +inp[10764] = 932883063; +inp[10765] = 0; +inp[10766] = 931062804; +inp[10767] = 0; +inp[10768] = 929246096; +inp[10769] = 0; +inp[10770] = 927432934; +inp[10771] = 0; +inp[10772] = 925623309; +inp[10773] = 0; +inp[10774] = 923817215; +inp[10775] = 0; +inp[10776] = 922014646; +inp[10777] = 0; +inp[10778] = 920215593; +inp[10779] = 0; +inp[10780] = 918420051; +inp[10781] = 0; +inp[10782] = 916628013; +inp[10783] = 0; +inp[10784] = 914839471; +inp[10785] = 0; +inp[10786] = 913054419; +inp[10787] = 0; +inp[10788] = 911272850; +inp[10789] = 0; +inp[10790] = 909494757; +inp[10791] = 0; +inp[10792] = 907720134; +inp[10793] = 0; +inp[10794] = 905948973; +inp[10795] = 0; +inp[10796] = 904181268; +inp[10797] = 0; +inp[10798] = 902417013; +inp[10799] = 0; +inp[10800] = 900656200; +inp[10801] = 0; +inp[10802] = 898898822; +inp[10803] = 0; +inp[10804] = 897144874; +inp[10805] = 0; +inp[10806] = 895394348; +inp[10807] = 0; +inp[10808] = 893647237; +inp[10809] = 0; +inp[10810] = 891903536; +inp[10811] = 0; +inp[10812] = 890163237; +inp[10813] = 0; +inp[10814] = 888426334; +inp[10815] = 0; +inp[10816] = 886692819; +inp[10817] = 0; +inp[10818] = 884962688; +inp[10819] = 0; +inp[10820] = 883235932; +inp[10821] = 0; +inp[10822] = 881512545; +inp[10823] = 0; +inp[10824] = 879792521; +inp[10825] = 0; +inp[10826] = 878075853; +inp[10827] = 0; +inp[10828] = 876362535; +inp[10829] = 0; +inp[10830] = 874652560; +inp[10831] = 0; +inp[10832] = 872945921; +inp[10833] = 0; +inp[10834] = 871242613; +inp[10835] = 0; +inp[10836] = 869542628; +inp[10837] = 0; +inp[10838] = 867845960; +inp[10839] = 0; +inp[10840] = 866152602; +inp[10841] = 0; +inp[10842] = 864462549; +inp[10843] = 0; +inp[10844] = 862775793; +inp[10845] = 0; +inp[10846] = 861092329; +inp[10847] = 0; +inp[10848] = 859412149; +inp[10849] = 0; +inp[10850] = 857735248; +inp[10851] = 0; +inp[10852] = 856061619; +inp[10853] = 0; +inp[10854] = 854391255; +inp[10855] = 0; +inp[10856] = 852724151; +inp[10857] = 0; +inp[10858] = 851060299; +inp[10859] = 0; +inp[10860] = 849399695; +inp[10861] = 0; +inp[10862] = 847742330; +inp[10863] = 0; +inp[10864] = 846088199; +inp[10865] = 0; +inp[10866] = 844437296; +inp[10867] = 0; +inp[10868] = 842789614; +inp[10869] = 0; +inp[10870] = 841145147; +inp[10871] = 0; +inp[10872] = 839503888; +inp[10873] = 0; +inp[10874] = 837865832; +inp[10875] = 0; +inp[10876] = 1073741824; +inp[10877] = 1073741824; +inp[10878] = 1072693759; +inp[10879] = 0; +inp[10880] = 1071646718; +inp[10881] = 0; +inp[10882] = 1070600699; +inp[10883] = 0; +inp[10884] = 1069555701; +inp[10885] = 0; +inp[10886] = 1068511723; +inp[10887] = 0; +inp[10888] = 1067468764; +inp[10889] = 0; +inp[10890] = 1066426822; +inp[10891] = 0; +inp[10892] = 1065385898; +inp[10893] = 0; +inp[10894] = 1064345990; +inp[10895] = 0; +inp[10896] = 1063307097; +inp[10897] = 0; +inp[10898] = 1062269218; +inp[10899] = 0; +inp[10900] = 1061232352; +inp[10901] = 0; +inp[10902] = 1060196498; +inp[10903] = 0; +inp[10904] = 1059161656; +inp[10905] = 0; +inp[10906] = 1058127823; +inp[10907] = 0; +inp[10908] = 1057094999; +inp[10909] = 0; +inp[10910] = 1056063184; +inp[10911] = 0; +inp[10912] = 1055032376; +inp[10913] = 0; +inp[10914] = 1054002574; +inp[10915] = 0; +inp[10916] = 1052973777; +inp[10917] = 0; +inp[10918] = 1051945984; +inp[10919] = 0; +inp[10920] = 1050919194; +inp[10921] = 0; +inp[10922] = 1049893407; +inp[10923] = 0; +inp[10924] = 1048868621; +inp[10925] = 0; +inp[10926] = 1047844835; +inp[10927] = 0; +inp[10928] = 1046822049; +inp[10929] = 0; +inp[10930] = 1045800261; +inp[10931] = 0; +inp[10932] = 1044779470; +inp[10933] = 0; +inp[10934] = 1043759675; +inp[10935] = 0; +inp[10936] = 1042740876; +inp[10937] = 0; +inp[10938] = 1041723072; +inp[10939] = 0; +inp[10940] = 1040706261; +inp[10941] = 0; +inp[10942] = 1039690442; +inp[10943] = 0; +inp[10944] = 1038675615; +inp[10945] = 0; +inp[10946] = 1037661778; +inp[10947] = 0; +inp[10948] = 1036648931; +inp[10949] = 0; +inp[10950] = 1035637073; +inp[10951] = 0; +inp[10952] = 1034626202; +inp[10953] = 0; +inp[10954] = 1033616318; +inp[10955] = 0; +inp[10956] = 1032607420; +inp[10957] = 0; +inp[10958] = 1031599507; +inp[10959] = 0; +inp[10960] = 1030592577; +inp[10961] = 0; +inp[10962] = 1029586630; +inp[10963] = 0; +inp[10964] = 1028581665; +inp[10965] = 0; +inp[10966] = 1027577681; +inp[10967] = 0; +inp[10968] = 1026574677; +inp[10969] = 0; +inp[10970] = 1025572652; +inp[10971] = 0; +inp[10972] = 1024571605; +inp[10973] = 0; +inp[10974] = 1023571536; +inp[10975] = 0; +inp[10976] = 1022572442; +inp[10977] = 0; +inp[10978] = 1021574324; +inp[10979] = 0; +inp[10980] = 1020577179; +inp[10981] = 0; +inp[10982] = 1019581008; +inp[10983] = 0; +inp[10984] = 1018585810; +inp[10985] = 0; +inp[10986] = 1017591583; +inp[10987] = 0; +inp[10988] = 1016598326; +inp[10989] = 0; +inp[10990] = 1015606039; +inp[10991] = 0; +inp[10992] = 1014614720; +inp[10993] = 0; +inp[10994] = 1013624369; +inp[10995] = 0; +inp[10996] = 1012634985; +inp[10997] = 0; +inp[10998] = 1011646566; +inp[10999] = 0; +inp[11000] = 1010659112; +inp[11001] = 0; +inp[11002] = 1009672622; +inp[11003] = 0; +inp[11004] = 1008687095; +inp[11005] = 0; +inp[11006] = 1007702530; +inp[11007] = 0; +inp[11008] = 1006718926; +inp[11009] = 0; +inp[11010] = 1005736282; +inp[11011] = 0; +inp[11012] = 1004754597; +inp[11013] = 0; +inp[11014] = 1003773870; +inp[11015] = 0; +inp[11016] = 1002794101; +inp[11017] = 0; +inp[11018] = 1001815287; +inp[11019] = 0; +inp[11020] = 1000837430; +inp[11021] = 0; +inp[11022] = 999860527; +inp[11023] = 0; +inp[11024] = 998884577; +inp[11025] = 0; +inp[11026] = 997909580; +inp[11027] = 0; +inp[11028] = 996935534; +inp[11029] = 0; +inp[11030] = 995962440; +inp[11031] = 0; +inp[11032] = 994990295; +inp[11033] = 0; +inp[11034] = 994019099; +inp[11035] = 0; +inp[11036] = 993048851; +inp[11037] = 0; +inp[11038] = 992079550; +inp[11039] = 0; +inp[11040] = 991111195; +inp[11041] = 0; +inp[11042] = 990143786; +inp[11043] = 0; +inp[11044] = 989177321; +inp[11045] = 0; +inp[11046] = 988211799; +inp[11047] = 0; +inp[11048] = 987247219; +inp[11049] = 0; +inp[11050] = 986283581; +inp[11051] = 0; +inp[11052] = 985320884; +inp[11053] = 0; +inp[11054] = 984359126; +inp[11055] = 0; +inp[11056] = 983398307; +inp[11057] = 0; +inp[11058] = 982438426; +inp[11059] = 0; +inp[11060] = 981479482; +inp[11061] = 0; +inp[11062] = 980521473; +inp[11063] = 0; +inp[11064] = 979564400; +inp[11065] = 0; +inp[11066] = 978608261; +inp[11067] = 0; +inp[11068] = 977653056; +inp[11069] = 0; +inp[11070] = 976698782; +inp[11071] = 0; +inp[11072] = 975745441; +inp[11073] = 0; +inp[11074] = 974793029; +inp[11075] = 0; +inp[11076] = 973841548; +inp[11077] = 0; +inp[11078] = 972890995; +inp[11079] = 0; +inp[11080] = 971941370; +inp[11081] = 0; +inp[11082] = 970992671; +inp[11083] = 0; +inp[11084] = 970044899; +inp[11085] = 0; +inp[11086] = 969098052; +inp[11087] = 0; +inp[11088] = 968152129; +inp[11089] = 0; +inp[11090] = 967207130; +inp[11091] = 0; +inp[11092] = 966263053; +inp[11093] = 0; +inp[11094] = 965319897; +inp[11095] = 0; +inp[11096] = 964377662; +inp[11097] = 0; +inp[11098] = 963436347; +inp[11099] = 0; +inp[11100] = 962495950; +inp[11101] = 0; +inp[11102] = 961556471; +inp[11103] = 0; +inp[11104] = 960617910; +inp[11105] = 0; +inp[11106] = 959680264; +inp[11107] = 0; +inp[11108] = 958743534; +inp[11109] = 0; +inp[11110] = 957807718; +inp[11111] = 0; +inp[11112] = 956872815; +inp[11113] = 0; +inp[11114] = 955938825; +inp[11115] = 0; +inp[11116] = 955005747; +inp[11117] = 0; +inp[11118] = 954073579; +inp[11119] = 0; +inp[11120] = 953142322; +inp[11121] = 0; +inp[11122] = 952211973; +inp[11123] = 0; +inp[11124] = 951282532; +inp[11125] = 0; +inp[11126] = 950353999; +inp[11127] = 0; +inp[11128] = 949426372; +inp[11129] = 0; +inp[11130] = 948499650; +inp[11131] = 0; +inp[11132] = 1073741824; +inp[11133] = 1073741824; +inp[11134] = 1073217663; +inp[11135] = 0; +inp[11136] = 1072693759; +inp[11137] = 0; +inp[11138] = 1072170111; +inp[11139] = 0; +inp[11140] = 1071646718; +inp[11141] = 0; +inp[11142] = 1071123581; +inp[11143] = 0; +inp[11144] = 1070600699; +inp[11145] = 0; +inp[11146] = 1070078072; +inp[11147] = 0; +inp[11148] = 1069555701; +inp[11149] = 0; +inp[11150] = 1069033584; +inp[11151] = 0; +inp[11152] = 1068511723; +inp[11153] = 0; +inp[11154] = 1067990116; +inp[11155] = 0; +inp[11156] = 1067468764; +inp[11157] = 0; +inp[11158] = 1066947666; +inp[11159] = 0; +inp[11160] = 1066426822; +inp[11161] = 0; +inp[11162] = 1065906233; +inp[11163] = 0; +inp[11164] = 1065385898; +inp[11165] = 0; +inp[11166] = 1064865817; +inp[11167] = 0; +inp[11168] = 1064345990; +inp[11169] = 0; +inp[11170] = 1063826417; +inp[11171] = 0; +inp[11172] = 1063307097; +inp[11173] = 0; +inp[11174] = 1062788031; +inp[11175] = 0; +inp[11176] = 1062269218; +inp[11177] = 0; +inp[11178] = 1061750659; +inp[11179] = 0; +inp[11180] = 1061232352; +inp[11181] = 0; +inp[11182] = 1060714299; +inp[11183] = 0; +inp[11184] = 1060196498; +inp[11185] = 0; +inp[11186] = 1059678951; +inp[11187] = 0; +inp[11188] = 1059161656; +inp[11189] = 0; +inp[11190] = 1058644613; +inp[11191] = 0; +inp[11192] = 1058127823; +inp[11193] = 0; +inp[11194] = 1057611285; +inp[11195] = 0; +inp[11196] = 1057094999; +inp[11197] = 0; +inp[11198] = 1056578966; +inp[11199] = 0; +inp[11200] = 1056063184; +inp[11201] = 0; +inp[11202] = 1055547654; +inp[11203] = 0; +inp[11204] = 1055032376; +inp[11205] = 0; +inp[11206] = 1054517349; +inp[11207] = 0; +inp[11208] = 1054002574; +inp[11209] = 0; +inp[11210] = 1053488050; +inp[11211] = 0; +inp[11212] = 1052973777; +inp[11213] = 0; +inp[11214] = 1052459755; +inp[11215] = 0; +inp[11216] = 1051945984; +inp[11217] = 0; +inp[11218] = 1051432464; +inp[11219] = 0; +inp[11220] = 1050919194; +inp[11221] = 0; +inp[11222] = 1050406175; +inp[11223] = 0; +inp[11224] = 1049893407; +inp[11225] = 0; +inp[11226] = 1049380889; +inp[11227] = 0; +inp[11228] = 1048868621; +inp[11229] = 0; +inp[11230] = 1048356603; +inp[11231] = 0; +inp[11232] = 1047844835; +inp[11233] = 0; +inp[11234] = 1047333317; +inp[11235] = 0; +inp[11236] = 1046822049; +inp[11237] = 0; +inp[11238] = 1046311030; +inp[11239] = 0; +inp[11240] = 1045800261; +inp[11241] = 0; +inp[11242] = 1045289741; +inp[11243] = 0; +inp[11244] = 1044779470; +inp[11245] = 0; +inp[11246] = 1044269448; +inp[11247] = 0; +inp[11248] = 1043759675; +inp[11249] = 0; +inp[11250] = 1043250151; +inp[11251] = 0; +inp[11252] = 1042740876; +inp[11253] = 0; +inp[11254] = 1042231850; +inp[11255] = 0; +inp[11256] = 1041723072; +inp[11257] = 0; +inp[11258] = 1041214542; +inp[11259] = 0; +inp[11260] = 1040706261; +inp[11261] = 0; +inp[11262] = 1040198227; +inp[11263] = 0; +inp[11264] = 1039690442; +inp[11265] = 0; +inp[11266] = 1039182905; +inp[11267] = 0; +inp[11268] = 1038675615; +inp[11269] = 0; +inp[11270] = 1038168573; +inp[11271] = 0; +inp[11272] = 1037661778; +inp[11273] = 0; +inp[11274] = 1037155231; +inp[11275] = 0; +inp[11276] = 1036648931; +inp[11277] = 0; +inp[11278] = 1036142879; +inp[11279] = 0; +inp[11280] = 1035637073; +inp[11281] = 0; +inp[11282] = 1035131514; +inp[11283] = 0; +inp[11284] = 1034626202; +inp[11285] = 0; +inp[11286] = 1034121137; +inp[11287] = 0; +inp[11288] = 1033616318; +inp[11289] = 0; +inp[11290] = 1033111746; +inp[11291] = 0; +inp[11292] = 1032607420; +inp[11293] = 0; +inp[11294] = 1032103340; +inp[11295] = 0; +inp[11296] = 1031599507; +inp[11297] = 0; +inp[11298] = 1031095919; +inp[11299] = 0; +inp[11300] = 1030592577; +inp[11301] = 0; +inp[11302] = 1030089481; +inp[11303] = 0; +inp[11304] = 1029586630; +inp[11305] = 0; +inp[11306] = 1029084025; +inp[11307] = 0; +inp[11308] = 1028581665; +inp[11309] = 0; +inp[11310] = 1028079551; +inp[11311] = 0; +inp[11312] = 1027577681; +inp[11313] = 0; +inp[11314] = 1027076057; +inp[11315] = 0; +inp[11316] = 1026574677; +inp[11317] = 0; +inp[11318] = 1026073543; +inp[11319] = 0; +inp[11320] = 1025572652; +inp[11321] = 0; +inp[11322] = 1025072007; +inp[11323] = 0; +inp[11324] = 1024571605; +inp[11325] = 0; +inp[11326] = 1024071449; +inp[11327] = 0; +inp[11328] = 1023571536; +inp[11329] = 0; +inp[11330] = 1023071867; +inp[11331] = 0; +inp[11332] = 1022572442; +inp[11333] = 0; +inp[11334] = 1022073261; +inp[11335] = 0; +inp[11336] = 1021574324; +inp[11337] = 0; +inp[11338] = 1021075630; +inp[11339] = 0; +inp[11340] = 1020577179; +inp[11341] = 0; +inp[11342] = 1020078972; +inp[11343] = 0; +inp[11344] = 1019581008; +inp[11345] = 0; +inp[11346] = 1019083288; +inp[11347] = 0; +inp[11348] = 1018585810; +inp[11349] = 0; +inp[11350] = 1018088575; +inp[11351] = 0; +inp[11352] = 1017591583; +inp[11353] = 0; +inp[11354] = 1017094833; +inp[11355] = 0; +inp[11356] = 1016598326; +inp[11357] = 0; +inp[11358] = 1016102061; +inp[11359] = 0; +inp[11360] = 1015606039; +inp[11361] = 0; +inp[11362] = 1015110258; +inp[11363] = 0; +inp[11364] = 1014614720; +inp[11365] = 0; +inp[11366] = 1014119424; +inp[11367] = 0; +inp[11368] = 1013624369; +inp[11369] = 0; +inp[11370] = 1013129556; +inp[11371] = 0; +inp[11372] = 1012634985; +inp[11373] = 0; +inp[11374] = 1012140655; +inp[11375] = 0; +inp[11376] = 1011646566; +inp[11377] = 0; +inp[11378] = 1011152719; +inp[11379] = 0; +inp[11380] = 1010659112; +inp[11381] = 0; +inp[11382] = 1010165747; +inp[11383] = 0; +inp[11384] = 1009672622; +inp[11385] = 0; +inp[11386] = 1009179738; +inp[11387] = 0; +inp[11388] = 1073741824; +inp[11389] = 1073741824; +inp[11390] = 1073479711; +inp[11391] = 0; +inp[11392] = 1073217663; +inp[11393] = 0; +inp[11394] = 1072955679; +inp[11395] = 0; +inp[11396] = 1072693759; +inp[11397] = 0; +inp[11398] = 1072431903; +inp[11399] = 0; +inp[11400] = 1072170111; +inp[11401] = 0; +inp[11402] = 1071908383; +inp[11403] = 0; +inp[11404] = 1071646718; +inp[11405] = 0; +inp[11406] = 1071385118; +inp[11407] = 0; +inp[11408] = 1071123581; +inp[11409] = 0; +inp[11410] = 1070862108; +inp[11411] = 0; +inp[11412] = 1070600699; +inp[11413] = 0; +inp[11414] = 1070339354; +inp[11415] = 0; +inp[11416] = 1070078072; +inp[11417] = 0; +inp[11418] = 1069816855; +inp[11419] = 0; +inp[11420] = 1069555701; +inp[11421] = 0; +inp[11422] = 1069294611; +inp[11423] = 0; +inp[11424] = 1069033584; +inp[11425] = 0; +inp[11426] = 1068772622; +inp[11427] = 0; +inp[11428] = 1068511723; +inp[11429] = 0; +inp[11430] = 1068250887; +inp[11431] = 0; +inp[11432] = 1067990116; +inp[11433] = 0; +inp[11434] = 1067729408; +inp[11435] = 0; +inp[11436] = 1067468764; +inp[11437] = 0; +inp[11438] = 1067208183; +inp[11439] = 0; +inp[11440] = 1066947666; +inp[11441] = 0; +inp[11442] = 1066687212; +inp[11443] = 0; +inp[11444] = 1066426822; +inp[11445] = 0; +inp[11446] = 1066166496; +inp[11447] = 0; +inp[11448] = 1065906233; +inp[11449] = 0; +inp[11450] = 1065646034; +inp[11451] = 0; +inp[11452] = 1065385898; +inp[11453] = 0; +inp[11454] = 1065125826; +inp[11455] = 0; +inp[11456] = 1064865817; +inp[11457] = 0; +inp[11458] = 1064605872; +inp[11459] = 0; +inp[11460] = 1064345990; +inp[11461] = 0; +inp[11462] = 1064086172; +inp[11463] = 0; +inp[11464] = 1063826417; +inp[11465] = 0; +inp[11466] = 1063566725; +inp[11467] = 0; +inp[11468] = 1063307097; +inp[11469] = 0; +inp[11470] = 1063047532; +inp[11471] = 0; +inp[11472] = 1062788031; +inp[11473] = 0; +inp[11474] = 1062528593; +inp[11475] = 0; +inp[11476] = 1062269218; +inp[11477] = 0; +inp[11478] = 1062009907; +inp[11479] = 0; +inp[11480] = 1061750659; +inp[11481] = 0; +inp[11482] = 1061491474; +inp[11483] = 0; +inp[11484] = 1061232352; +inp[11485] = 0; +inp[11486] = 1060973294; +inp[11487] = 0; +inp[11488] = 1060714299; +inp[11489] = 0; +inp[11490] = 1060455367; +inp[11491] = 0; +inp[11492] = 1060196498; +inp[11493] = 0; +inp[11494] = 1059937693; +inp[11495] = 0; +inp[11496] = 1059678951; +inp[11497] = 0; +inp[11498] = 1059420272; +inp[11499] = 0; +inp[11500] = 1059161656; +inp[11501] = 0; +inp[11502] = 1058903103; +inp[11503] = 0; +inp[11504] = 1058644613; +inp[11505] = 0; +inp[11506] = 1058386187; +inp[11507] = 0; +inp[11508] = 1058127823; +inp[11509] = 0; +inp[11510] = 1057869523; +inp[11511] = 0; +inp[11512] = 1057611285; +inp[11513] = 0; +inp[11514] = 1057353111; +inp[11515] = 0; +inp[11516] = 1057094999; +inp[11517] = 0; +inp[11518] = 1056836951; +inp[11519] = 0; +inp[11520] = 1056578966; +inp[11521] = 0; +inp[11522] = 1056321043; +inp[11523] = 0; +inp[11524] = 1056063184; +inp[11525] = 0; +inp[11526] = 1055805388; +inp[11527] = 0; +inp[11528] = 1055547654; +inp[11529] = 0; +inp[11530] = 1055289983; +inp[11531] = 0; +inp[11532] = 1055032376; +inp[11533] = 0; +inp[11534] = 1054774831; +inp[11535] = 0; +inp[11536] = 1054517349; +inp[11537] = 0; +inp[11538] = 1054259930; +inp[11539] = 0; +inp[11540] = 1054002574; +inp[11541] = 0; +inp[11542] = 1053745280; +inp[11543] = 0; +inp[11544] = 1053488050; +inp[11545] = 0; +inp[11546] = 1053230882; +inp[11547] = 0; +inp[11548] = 1052973777; +inp[11549] = 0; +inp[11550] = 1052716734; +inp[11551] = 0; +inp[11552] = 1052459755; +inp[11553] = 0; +inp[11554] = 1052202838; +inp[11555] = 0; +inp[11556] = 1051945984; +inp[11557] = 0; +inp[11558] = 1051689192; +inp[11559] = 0; +inp[11560] = 1051432464; +inp[11561] = 0; +inp[11562] = 1051175798; +inp[11563] = 0; +inp[11564] = 1050919194; +inp[11565] = 0; +inp[11566] = 1050662654; +inp[11567] = 0; +inp[11568] = 1050406175; +inp[11569] = 0; +inp[11570] = 1050149760; +inp[11571] = 0; +inp[11572] = 1049893407; +inp[11573] = 0; +inp[11574] = 1049637117; +inp[11575] = 0; +inp[11576] = 1049380889; +inp[11577] = 0; +inp[11578] = 1049124724; +inp[11579] = 0; +inp[11580] = 1048868621; +inp[11581] = 0; +inp[11582] = 1048612581; +inp[11583] = 0; +inp[11584] = 1048356603; +inp[11585] = 0; +inp[11586] = 1048100688; +inp[11587] = 0; +inp[11588] = 1047844835; +inp[11589] = 0; +inp[11590] = 1047589045; +inp[11591] = 0; +inp[11592] = 1047333317; +inp[11593] = 0; +inp[11594] = 1047077652; +inp[11595] = 0; +inp[11596] = 1046822049; +inp[11597] = 0; +inp[11598] = 1046566508; +inp[11599] = 0; +inp[11600] = 1046311030; +inp[11601] = 0; +inp[11602] = 1046055614; +inp[11603] = 0; +inp[11604] = 1045800261; +inp[11605] = 0; +inp[11606] = 1045544969; +inp[11607] = 0; +inp[11608] = 1045289741; +inp[11609] = 0; +inp[11610] = 1045034574; +inp[11611] = 0; +inp[11612] = 1044779470; +inp[11613] = 0; +inp[11614] = 1044524428; +inp[11615] = 0; +inp[11616] = 1044269448; +inp[11617] = 0; +inp[11618] = 1044014531; +inp[11619] = 0; +inp[11620] = 1043759675; +inp[11621] = 0; +inp[11622] = 1043504882; +inp[11623] = 0; +inp[11624] = 1043250151; +inp[11625] = 0; +inp[11626] = 1042995483; +inp[11627] = 0; +inp[11628] = 1042740876; +inp[11629] = 0; +inp[11630] = 1042486332; +inp[11631] = 0; +inp[11632] = 1042231850; +inp[11633] = 0; +inp[11634] = 1041977430; +inp[11635] = 0; +inp[11636] = 1041723072; +inp[11637] = 0; +inp[11638] = 1041468776; +inp[11639] = 0; +inp[11640] = 1041214542; +inp[11641] = 0; +inp[11642] = 1040960370; +inp[11643] = 0; +inp[11644] = 1073741824; +inp[11645] = 1073741824; +inp[11646] = 1073610759; +inp[11647] = 0; +inp[11648] = 1073479711; +inp[11649] = 0; +inp[11650] = 1073348679; +inp[11651] = 0; +inp[11652] = 1073217663; +inp[11653] = 0; +inp[11654] = 1073086663; +inp[11655] = 0; +inp[11656] = 1072955679; +inp[11657] = 0; +inp[11658] = 1072824711; +inp[11659] = 0; +inp[11660] = 1072693759; +inp[11661] = 0; +inp[11662] = 1072562823; +inp[11663] = 0; +inp[11664] = 1072431903; +inp[11665] = 0; +inp[11666] = 1072300999; +inp[11667] = 0; +inp[11668] = 1072170111; +inp[11669] = 0; +inp[11670] = 1072039239; +inp[11671] = 0; +inp[11672] = 1071908383; +inp[11673] = 0; +inp[11674] = 1071777542; +inp[11675] = 0; +inp[11676] = 1071646718; +inp[11677] = 0; +inp[11678] = 1071515910; +inp[11679] = 0; +inp[11680] = 1071385118; +inp[11681] = 0; +inp[11682] = 1071254341; +inp[11683] = 0; +inp[11684] = 1071123581; +inp[11685] = 0; +inp[11686] = 1070992836; +inp[11687] = 0; +inp[11688] = 1070862108; +inp[11689] = 0; +inp[11690] = 1070731396; +inp[11691] = 0; +inp[11692] = 1070600699; +inp[11693] = 0; +inp[11694] = 1070470018; +inp[11695] = 0; +inp[11696] = 1070339354; +inp[11697] = 0; +inp[11698] = 1070208705; +inp[11699] = 0; +inp[11700] = 1070078072; +inp[11701] = 0; +inp[11702] = 1069947456; +inp[11703] = 0; +inp[11704] = 1069816855; +inp[11705] = 0; +inp[11706] = 1069686270; +inp[11707] = 0; +inp[11708] = 1069555701; +inp[11709] = 0; +inp[11710] = 1069425148; +inp[11711] = 0; +inp[11712] = 1069294611; +inp[11713] = 0; +inp[11714] = 1069164090; +inp[11715] = 0; +inp[11716] = 1069033584; +inp[11717] = 0; +inp[11718] = 1068903095; +inp[11719] = 0; +inp[11720] = 1068772622; +inp[11721] = 0; +inp[11722] = 1068642164; +inp[11723] = 0; +inp[11724] = 1068511723; +inp[11725] = 0; +inp[11726] = 1068381297; +inp[11727] = 0; +inp[11728] = 1068250887; +inp[11729] = 0; +inp[11730] = 1068120494; +inp[11731] = 0; +inp[11732] = 1067990116; +inp[11733] = 0; +inp[11734] = 1067859754; +inp[11735] = 0; +inp[11736] = 1067729408; +inp[11737] = 0; +inp[11738] = 1067599078; +inp[11739] = 0; +inp[11740] = 1067468764; +inp[11741] = 0; +inp[11742] = 1067338465; +inp[11743] = 0; +inp[11744] = 1067208183; +inp[11745] = 0; +inp[11746] = 1067077916; +inp[11747] = 0; +inp[11748] = 1066947666; +inp[11749] = 0; +inp[11750] = 1066817431; +inp[11751] = 0; +inp[11752] = 1066687212; +inp[11753] = 0; +inp[11754] = 1066557009; +inp[11755] = 0; +inp[11756] = 1066426822; +inp[11757] = 0; +inp[11758] = 1066296651; +inp[11759] = 0; +inp[11760] = 1066166496; +inp[11761] = 0; +inp[11762] = 1066036357; +inp[11763] = 0; +inp[11764] = 1065906233; +inp[11765] = 0; +inp[11766] = 1065776126; +inp[11767] = 0; +inp[11768] = 1065646034; +inp[11769] = 0; +inp[11770] = 1065515958; +inp[11771] = 0; +inp[11772] = 1065385898; +inp[11773] = 0; +inp[11774] = 1065255854; +inp[11775] = 0; +inp[11776] = 1065125826; +inp[11777] = 0; +inp[11778] = 1064995814; +inp[11779] = 0; +inp[11780] = 1064865817; +inp[11781] = 0; +inp[11782] = 1064735837; +inp[11783] = 0; +inp[11784] = 1064605872; +inp[11785] = 0; +inp[11786] = 1064475923; +inp[11787] = 0; +inp[11788] = 1064345990; +inp[11789] = 0; +inp[11790] = 1064216073; +inp[11791] = 0; +inp[11792] = 1064086172; +inp[11793] = 0; +inp[11794] = 1063956286; +inp[11795] = 0; +inp[11796] = 1063826417; +inp[11797] = 0; +inp[11798] = 1063696563; +inp[11799] = 0; +inp[11800] = 1063566725; +inp[11801] = 0; +inp[11802] = 1063436903; +inp[11803] = 0; +inp[11804] = 1063307097; +inp[11805] = 0; +inp[11806] = 1063177307; +inp[11807] = 0; +inp[11808] = 1063047532; +inp[11809] = 0; +inp[11810] = 1062917774; +inp[11811] = 0; +inp[11812] = 1062788031; +inp[11813] = 0; +inp[11814] = 1062658304; +inp[11815] = 0; +inp[11816] = 1062528593; +inp[11817] = 0; +inp[11818] = 1062398898; +inp[11819] = 0; +inp[11820] = 1062269218; +inp[11821] = 0; +inp[11822] = 1062139555; +inp[11823] = 0; +inp[11824] = 1062009907; +inp[11825] = 0; +inp[11826] = 1061880275; +inp[11827] = 0; +inp[11828] = 1061750659; +inp[11829] = 0; +inp[11830] = 1061621058; +inp[11831] = 0; +inp[11832] = 1061491474; +inp[11833] = 0; +inp[11834] = 1061361905; +inp[11835] = 0; +inp[11836] = 1061232352; +inp[11837] = 0; +inp[11838] = 1061102815; +inp[11839] = 0; +inp[11840] = 1060973294; +inp[11841] = 0; +inp[11842] = 1060843789; +inp[11843] = 0; +inp[11844] = 1060714299; +inp[11845] = 0; +inp[11846] = 1060584825; +inp[11847] = 0; +inp[11848] = 1060455367; +inp[11849] = 0; +inp[11850] = 1060325925; +inp[11851] = 0; +inp[11852] = 1060196498; +inp[11853] = 0; +inp[11854] = 1060067088; +inp[11855] = 0; +inp[11856] = 1059937693; +inp[11857] = 0; +inp[11858] = 1059808314; +inp[11859] = 0; +inp[11860] = 1059678951; +inp[11861] = 0; +inp[11862] = 1059549603; +inp[11863] = 0; +inp[11864] = 1059420272; +inp[11865] = 0; +inp[11866] = 1059290956; +inp[11867] = 0; +inp[11868] = 1059161656; +inp[11869] = 0; +inp[11870] = 1059032371; +inp[11871] = 0; +inp[11872] = 1058903103; +inp[11873] = 0; +inp[11874] = 1058773850; +inp[11875] = 0; +inp[11876] = 1058644613; +inp[11877] = 0; +inp[11878] = 1058515392; +inp[11879] = 0; +inp[11880] = 1058386187; +inp[11881] = 0; +inp[11882] = 1058256997; +inp[11883] = 0; +inp[11884] = 1058127823; +inp[11885] = 0; +inp[11886] = 1057998665; +inp[11887] = 0; +inp[11888] = 1057869523; +inp[11889] = 0; +inp[11890] = 1057740396; +inp[11891] = 0; +inp[11892] = 1057611285; +inp[11893] = 0; +inp[11894] = 1057482190; +inp[11895] = 0; +inp[11896] = 1057353111; +inp[11897] = 0; +inp[11898] = 1057224047; +inp[11899] = 0; +inp[11900] = 1073741824; +inp[11901] = 1073741824; +inp[11902] = 1073676289; +inp[11903] = 0; +inp[11904] = 1073610759; +inp[11905] = 0; +inp[11906] = 1073545233; +inp[11907] = 0; +inp[11908] = 1073479711; +inp[11909] = 0; +inp[11910] = 1073414193; +inp[11911] = 0; +inp[11912] = 1073348679; +inp[11913] = 0; +inp[11914] = 1073283169; +inp[11915] = 0; +inp[11916] = 1073217663; +inp[11917] = 0; +inp[11918] = 1073152161; +inp[11919] = 0; +inp[11920] = 1073086663; +inp[11921] = 0; +inp[11922] = 1073021169; +inp[11923] = 0; +inp[11924] = 1072955679; +inp[11925] = 0; +inp[11926] = 1072890193; +inp[11927] = 0; +inp[11928] = 1072824711; +inp[11929] = 0; +inp[11930] = 1072759233; +inp[11931] = 0; +inp[11932] = 1072693759; +inp[11933] = 0; +inp[11934] = 1072628289; +inp[11935] = 0; +inp[11936] = 1072562823; +inp[11937] = 0; +inp[11938] = 1072497361; +inp[11939] = 0; +inp[11940] = 1072431903; +inp[11941] = 0; +inp[11942] = 1072366449; +inp[11943] = 0; +inp[11944] = 1072300999; +inp[11945] = 0; +inp[11946] = 1072235553; +inp[11947] = 0; +inp[11948] = 1072170111; +inp[11949] = 0; +inp[11950] = 1072104673; +inp[11951] = 0; +inp[11952] = 1072039239; +inp[11953] = 0; +inp[11954] = 1071973809; +inp[11955] = 0; +inp[11956] = 1071908383; +inp[11957] = 0; +inp[11958] = 1071842961; +inp[11959] = 0; +inp[11960] = 1071777542; +inp[11961] = 0; +inp[11962] = 1071712128; +inp[11963] = 0; +inp[11964] = 1071646718; +inp[11965] = 0; +inp[11966] = 1071581312; +inp[11967] = 0; +inp[11968] = 1071515910; +inp[11969] = 0; +inp[11970] = 1071450512; +inp[11971] = 0; +inp[11972] = 1071385118; +inp[11973] = 0; +inp[11974] = 1071319727; +inp[11975] = 0; +inp[11976] = 1071254341; +inp[11977] = 0; +inp[11978] = 1071188959; +inp[11979] = 0; +inp[11980] = 1071123581; +inp[11981] = 0; +inp[11982] = 1071058207; +inp[11983] = 0; +inp[11984] = 1070992836; +inp[11985] = 0; +inp[11986] = 1070927470; +inp[11987] = 0; +inp[11988] = 1070862108; +inp[11989] = 0; +inp[11990] = 1070796750; +inp[11991] = 0; +inp[11992] = 1070731396; +inp[11993] = 0; +inp[11994] = 1070666045; +inp[11995] = 0; +inp[11996] = 1070600699; +inp[11997] = 0; +inp[11998] = 1070535357; +inp[11999] = 0; +inp[12000] = 1070470018; +inp[12001] = 0; +inp[12002] = 1070404684; +inp[12003] = 0; +inp[12004] = 1070339354; +inp[12005] = 0; +inp[12006] = 1070274027; +inp[12007] = 0; +inp[12008] = 1070208705; +inp[12009] = 0; +inp[12010] = 1070143387; +inp[12011] = 0; +inp[12012] = 1070078072; +inp[12013] = 0; +inp[12014] = 1070012762; +inp[12015] = 0; +inp[12016] = 1069947456; +inp[12017] = 0; +inp[12018] = 1069882153; +inp[12019] = 0; +inp[12020] = 1069816855; +inp[12021] = 0; +inp[12022] = 1069751560; +inp[12023] = 0; +inp[12024] = 1069686270; +inp[12025] = 0; +inp[12026] = 1069620983; +inp[12027] = 0; +inp[12028] = 1069555701; +inp[12029] = 0; +inp[12030] = 1069490422; +inp[12031] = 0; +inp[12032] = 1069425148; +inp[12033] = 0; +inp[12034] = 1069359877; +inp[12035] = 0; +inp[12036] = 1069294611; +inp[12037] = 0; +inp[12038] = 1069229348; +inp[12039] = 0; +inp[12040] = 1069164090; +inp[12041] = 0; +inp[12042] = 1069098835; +inp[12043] = 0; +inp[12044] = 1069033584; +inp[12045] = 0; +inp[12046] = 1068968338; +inp[12047] = 0; +inp[12048] = 1068903095; +inp[12049] = 0; +inp[12050] = 1068837856; +inp[12051] = 0; +inp[12052] = 1068772622; +inp[12053] = 0; +inp[12054] = 1068707391; +inp[12055] = 0; +inp[12056] = 1068642164; +inp[12057] = 0; +inp[12058] = 1068576941; +inp[12059] = 0; +inp[12060] = 1068511723; +inp[12061] = 0; +inp[12062] = 1068446508; +inp[12063] = 0; +inp[12064] = 1068381297; +inp[12065] = 0; +inp[12066] = 1068316090; +inp[12067] = 0; +inp[12068] = 1068250887; +inp[12069] = 0; +inp[12070] = 1068185689; +inp[12071] = 0; +inp[12072] = 1068120494; +inp[12073] = 0; +inp[12074] = 1068055303; +inp[12075] = 0; +inp[12076] = 1067990116; +inp[12077] = 0; +inp[12078] = 1067924933; +inp[12079] = 0; +inp[12080] = 1067859754; +inp[12081] = 0; +inp[12082] = 1067794579; +inp[12083] = 0; +inp[12084] = 1067729408; +inp[12085] = 0; +inp[12086] = 1067664241; +inp[12087] = 0; +inp[12088] = 1067599078; +inp[12089] = 0; +inp[12090] = 1067533919; +inp[12091] = 0; +inp[12092] = 1067468764; +inp[12093] = 0; +inp[12094] = 1067403612; +inp[12095] = 0; +inp[12096] = 1067338465; +inp[12097] = 0; +inp[12098] = 1067273322; +inp[12099] = 0; +inp[12100] = 1067208183; +inp[12101] = 0; +inp[12102] = 1067143048; +inp[12103] = 0; +inp[12104] = 1067077916; +inp[12105] = 0; +inp[12106] = 1067012789; +inp[12107] = 0; +inp[12108] = 1066947666; +inp[12109] = 0; +inp[12110] = 1066882546; +inp[12111] = 0; +inp[12112] = 1066817431; +inp[12113] = 0; +inp[12114] = 1066752320; +inp[12115] = 0; +inp[12116] = 1066687212; +inp[12117] = 0; +inp[12118] = 1066622109; +inp[12119] = 0; +inp[12120] = 1066557009; +inp[12121] = 0; +inp[12122] = 1066491914; +inp[12123] = 0; +inp[12124] = 1066426822; +inp[12125] = 0; +inp[12126] = 1066361735; +inp[12127] = 0; +inp[12128] = 1066296651; +inp[12129] = 0; +inp[12130] = 1066231572; +inp[12131] = 0; +inp[12132] = 1066166496; +inp[12133] = 0; +inp[12134] = 1066101424; +inp[12135] = 0; +inp[12136] = 1066036357; +inp[12137] = 0; +inp[12138] = 1065971293; +inp[12139] = 0; +inp[12140] = 1065906233; +inp[12141] = 0; +inp[12142] = 1065841178; +inp[12143] = 0; +inp[12144] = 1065776126; +inp[12145] = 0; +inp[12146] = 1065711078; +inp[12147] = 0; +inp[12148] = 1065646034; +inp[12149] = 0; +inp[12150] = 1065580994; +inp[12151] = 0; +inp[12152] = 1065515958; +inp[12153] = 0; +inp[12154] = 1065450926; +inp[12155] = 0; +inp[12156] = 1073741824; +inp[12157] = 1073741824; +inp[12158] = 1073709056; +inp[12159] = 0; +inp[12160] = 1073676289; +inp[12161] = 0; +inp[12162] = 1073643524; +inp[12163] = 0; +inp[12164] = 1073610759; +inp[12165] = 0; +inp[12166] = 1073577996; +inp[12167] = 0; +inp[12168] = 1073545233; +inp[12169] = 0; +inp[12170] = 1073512472; +inp[12171] = 0; +inp[12172] = 1073479711; +inp[12173] = 0; +inp[12174] = 1073446952; +inp[12175] = 0; +inp[12176] = 1073414193; +inp[12177] = 0; +inp[12178] = 1073381436; +inp[12179] = 0; +inp[12180] = 1073348679; +inp[12181] = 0; +inp[12182] = 1073315924; +inp[12183] = 0; +inp[12184] = 1073283169; +inp[12185] = 0; +inp[12186] = 1073250416; +inp[12187] = 0; +inp[12188] = 1073217663; +inp[12189] = 0; +inp[12190] = 1073184912; +inp[12191] = 0; +inp[12192] = 1073152161; +inp[12193] = 0; +inp[12194] = 1073119412; +inp[12195] = 0; +inp[12196] = 1073086663; +inp[12197] = 0; +inp[12198] = 1073053916; +inp[12199] = 0; +inp[12200] = 1073021169; +inp[12201] = 0; +inp[12202] = 1072988424; +inp[12203] = 0; +inp[12204] = 1072955679; +inp[12205] = 0; +inp[12206] = 1072922936; +inp[12207] = 0; +inp[12208] = 1072890193; +inp[12209] = 0; +inp[12210] = 1072857452; +inp[12211] = 0; +inp[12212] = 1072824711; +inp[12213] = 0; +inp[12214] = 1072791972; +inp[12215] = 0; +inp[12216] = 1072759233; +inp[12217] = 0; +inp[12218] = 1072726496; +inp[12219] = 0; +inp[12220] = 1072693759; +inp[12221] = 0; +inp[12222] = 1072661024; +inp[12223] = 0; +inp[12224] = 1072628289; +inp[12225] = 0; +inp[12226] = 1072595556; +inp[12227] = 0; +inp[12228] = 1072562823; +inp[12229] = 0; +inp[12230] = 1072530092; +inp[12231] = 0; +inp[12232] = 1072497361; +inp[12233] = 0; +inp[12234] = 1072464632; +inp[12235] = 0; +inp[12236] = 1072431903; +inp[12237] = 0; +inp[12238] = 1072399176; +inp[12239] = 0; +inp[12240] = 1072366449; +inp[12241] = 0; +inp[12242] = 1072333724; +inp[12243] = 0; +inp[12244] = 1072300999; +inp[12245] = 0; +inp[12246] = 1072268276; +inp[12247] = 0; +inp[12248] = 1072235553; +inp[12249] = 0; +inp[12250] = 1072202831; +inp[12251] = 0; +inp[12252] = 1072170111; +inp[12253] = 0; +inp[12254] = 1072137391; +inp[12255] = 0; +inp[12256] = 1072104673; +inp[12257] = 0; +inp[12258] = 1072071955; +inp[12259] = 0; +inp[12260] = 1072039239; +inp[12261] = 0; +inp[12262] = 1072006523; +inp[12263] = 0; +inp[12264] = 1071973809; +inp[12265] = 0; +inp[12266] = 1071941095; +inp[12267] = 0; +inp[12268] = 1071908383; +inp[12269] = 0; +inp[12270] = 1071875671; +inp[12271] = 0; +inp[12272] = 1071842961; +inp[12273] = 0; +inp[12274] = 1071810251; +inp[12275] = 0; +inp[12276] = 1071777542; +inp[12277] = 0; +inp[12278] = 1071744835; +inp[12279] = 0; +inp[12280] = 1071712128; +inp[12281] = 0; +inp[12282] = 1071679423; +inp[12283] = 0; +inp[12284] = 1071646718; +inp[12285] = 0; +inp[12286] = 1071614015; +inp[12287] = 0; +inp[12288] = 1071581312; +inp[12289] = 0; +inp[12290] = 1071548610; +inp[12291] = 0; +inp[12292] = 1071515910; +inp[12293] = 0; +inp[12294] = 1071483210; +inp[12295] = 0; +inp[12296] = 1071450512; +inp[12297] = 0; +inp[12298] = 1071417814; +inp[12299] = 0; +inp[12300] = 1071385118; +inp[12301] = 0; +inp[12302] = 1071352422; +inp[12303] = 0; +inp[12304] = 1071319727; +inp[12305] = 0; +inp[12306] = 1071287034; +inp[12307] = 0; +inp[12308] = 1071254341; +inp[12309] = 0; +inp[12310] = 1071221650; +inp[12311] = 0; +inp[12312] = 1071188959; +inp[12313] = 0; +inp[12314] = 1071156269; +inp[12315] = 0; +inp[12316] = 1071123581; +inp[12317] = 0; +inp[12318] = 1071090893; +inp[12319] = 0; +inp[12320] = 1071058207; +inp[12321] = 0; +inp[12322] = 1071025521; +inp[12323] = 0; +inp[12324] = 1070992836; +inp[12325] = 0; +inp[12326] = 1070960153; +inp[12327] = 0; +inp[12328] = 1070927470; +inp[12329] = 0; +inp[12330] = 1070894789; +inp[12331] = 0; +inp[12332] = 1070862108; +inp[12333] = 0; +inp[12334] = 1070829428; +inp[12335] = 0; +inp[12336] = 1070796750; +inp[12337] = 0; +inp[12338] = 1070764072; +inp[12339] = 0; +inp[12340] = 1070731396; +inp[12341] = 0; +inp[12342] = 1070698720; +inp[12343] = 0; +inp[12344] = 1070666045; +inp[12345] = 0; +inp[12346] = 1070633372; +inp[12347] = 0; +inp[12348] = 1070600699; +inp[12349] = 0; +inp[12350] = 1070568027; +inp[12351] = 0; +inp[12352] = 1070535357; +inp[12353] = 0; +inp[12354] = 1070502687; +inp[12355] = 0; +inp[12356] = 1070470018; +inp[12357] = 0; +inp[12358] = 1070437351; +inp[12359] = 0; +inp[12360] = 1070404684; +inp[12361] = 0; +inp[12362] = 1070372018; +inp[12363] = 0; +inp[12364] = 1070339354; +inp[12365] = 0; +inp[12366] = 1070306690; +inp[12367] = 0; +inp[12368] = 1070274027; +inp[12369] = 0; +inp[12370] = 1070241366; +inp[12371] = 0; +inp[12372] = 1070208705; +inp[12373] = 0; +inp[12374] = 1070176045; +inp[12375] = 0; +inp[12376] = 1070143387; +inp[12377] = 0; +inp[12378] = 1070110729; +inp[12379] = 0; +inp[12380] = 1070078072; +inp[12381] = 0; +inp[12382] = 1070045417; +inp[12383] = 0; +inp[12384] = 1070012762; +inp[12385] = 0; +inp[12386] = 1069980108; +inp[12387] = 0; +inp[12388] = 1069947456; +inp[12389] = 0; +inp[12390] = 1069914804; +inp[12391] = 0; +inp[12392] = 1069882153; +inp[12393] = 0; +inp[12394] = 1069849503; +inp[12395] = 0; +inp[12396] = 1069816855; +inp[12397] = 0; +inp[12398] = 1069784207; +inp[12399] = 0; +inp[12400] = 1069751560; +inp[12401] = 0; +inp[12402] = 1069718915; +inp[12403] = 0; +inp[12404] = 1069686270; +inp[12405] = 0; +inp[12406] = 1069653626; +inp[12407] = 0; +inp[12408] = 1069620983; +inp[12409] = 0; +inp[12410] = 1069588342; +inp[12411] = 0; +inp[12412] = 1073741824; +inp[12413] = 1073741824; +inp[12414] = 1073725440; +inp[12415] = 0; +inp[12416] = 1073709056; +inp[12417] = 0; +inp[12418] = 1073692673; +inp[12419] = 0; +inp[12420] = 1073676289; +inp[12421] = 0; +inp[12422] = 1073659907; +inp[12423] = 0; +inp[12424] = 1073643524; +inp[12425] = 0; +inp[12426] = 1073627142; +inp[12427] = 0; +inp[12428] = 1073610759; +inp[12429] = 0; +inp[12430] = 1073594378; +inp[12431] = 0; +inp[12432] = 1073577996; +inp[12433] = 0; +inp[12434] = 1073561615; +inp[12435] = 0; +inp[12436] = 1073545233; +inp[12437] = 0; +inp[12438] = 1073528853; +inp[12439] = 0; +inp[12440] = 1073512472; +inp[12441] = 0; +inp[12442] = 1073496092; +inp[12443] = 0; +inp[12444] = 1073479711; +inp[12445] = 0; +inp[12446] = 1073463332; +inp[12447] = 0; +inp[12448] = 1073446952; +inp[12449] = 0; +inp[12450] = 1073430573; +inp[12451] = 0; +inp[12452] = 1073414193; +inp[12453] = 0; +inp[12454] = 1073397815; +inp[12455] = 0; +inp[12456] = 1073381436; +inp[12457] = 0; +inp[12458] = 1073365058; +inp[12459] = 0; +inp[12460] = 1073348679; +inp[12461] = 0; +inp[12462] = 1073332302; +inp[12463] = 0; +inp[12464] = 1073315924; +inp[12465] = 0; +inp[12466] = 1073299547; +inp[12467] = 0; +inp[12468] = 1073283169; +inp[12469] = 0; +inp[12470] = 1073266793; +inp[12471] = 0; +inp[12472] = 1073250416; +inp[12473] = 0; +inp[12474] = 1073234040; +inp[12475] = 0; +inp[12476] = 1073217663; +inp[12477] = 0; +inp[12478] = 1073201288; +inp[12479] = 0; +inp[12480] = 1073184912; +inp[12481] = 0; +inp[12482] = 1073168537; +inp[12483] = 0; +inp[12484] = 1073152161; +inp[12485] = 0; +inp[12486] = 1073135787; +inp[12487] = 0; +inp[12488] = 1073119412; +inp[12489] = 0; +inp[12490] = 1073103038; +inp[12491] = 0; +inp[12492] = 1073086663; +inp[12493] = 0; +inp[12494] = 1073070290; +inp[12495] = 0; +inp[12496] = 1073053916; +inp[12497] = 0; +inp[12498] = 1073037543; +inp[12499] = 0; +inp[12500] = 1073021169; +inp[12501] = 0; +inp[12502] = 1073004797; +inp[12503] = 0; +inp[12504] = 1072988424; +inp[12505] = 0; +inp[12506] = 1072972052; +inp[12507] = 0; +inp[12508] = 1072955679; +inp[12509] = 0; +inp[12510] = 1072939308; +inp[12511] = 0; +inp[12512] = 1072922936; +inp[12513] = 0; +inp[12514] = 1072906565; +inp[12515] = 0; +inp[12516] = 1072890193; +inp[12517] = 0; +inp[12518] = 1072873823; +inp[12519] = 0; +inp[12520] = 1072857452; +inp[12521] = 0; +inp[12522] = 1072841082; +inp[12523] = 0; +inp[12524] = 1072824711; +inp[12525] = 0; +inp[12526] = 1072808342; +inp[12527] = 0; +inp[12528] = 1072791972; +inp[12529] = 0; +inp[12530] = 1072775602; +inp[12531] = 0; +inp[12532] = 1072759233; +inp[12533] = 0; +inp[12534] = 1072742864; +inp[12535] = 0; +inp[12536] = 1072726496; +inp[12537] = 0; +inp[12538] = 1072710127; +inp[12539] = 0; +inp[12540] = 1072693759; +inp[12541] = 0; +inp[12542] = 1072677391; +inp[12543] = 0; +inp[12544] = 1072661024; +inp[12545] = 0; +inp[12546] = 1072644656; +inp[12547] = 0; +inp[12548] = 1072628289; +inp[12549] = 0; +inp[12550] = 1072611922; +inp[12551] = 0; +inp[12552] = 1072595556; +inp[12553] = 0; +inp[12554] = 1072579189; +inp[12555] = 0; +inp[12556] = 1072562823; +inp[12557] = 0; +inp[12558] = 1072546457; +inp[12559] = 0; +inp[12560] = 1072530092; +inp[12561] = 0; +inp[12562] = 1072513726; +inp[12563] = 0; +inp[12564] = 1072497361; +inp[12565] = 0; +inp[12566] = 1072480996; +inp[12567] = 0; +inp[12568] = 1072464632; +inp[12569] = 0; +inp[12570] = 1072448267; +inp[12571] = 0; +inp[12572] = 1072431903; +inp[12573] = 0; +inp[12574] = 1072415539; +inp[12575] = 0; +inp[12576] = 1072399176; +inp[12577] = 0; +inp[12578] = 1072382812; +inp[12579] = 0; +inp[12580] = 1072366449; +inp[12581] = 0; +inp[12582] = 1072350086; +inp[12583] = 0; +inp[12584] = 1072333724; +inp[12585] = 0; +inp[12586] = 1072317361; +inp[12587] = 0; +inp[12588] = 1072300999; +inp[12589] = 0; +inp[12590] = 1072284637; +inp[12591] = 0; +inp[12592] = 1072268276; +inp[12593] = 0; +inp[12594] = 1072251914; +inp[12595] = 0; +inp[12596] = 1072235553; +inp[12597] = 0; +inp[12598] = 1072219192; +inp[12599] = 0; +inp[12600] = 1072202831; +inp[12601] = 0; +inp[12602] = 1072186471; +inp[12603] = 0; +inp[12604] = 1072170111; +inp[12605] = 0; +inp[12606] = 1072153751; +inp[12607] = 0; +inp[12608] = 1072137391; +inp[12609] = 0; +inp[12610] = 1072121032; +inp[12611] = 0; +inp[12612] = 1072104673; +inp[12613] = 0; +inp[12614] = 1072088314; +inp[12615] = 0; +inp[12616] = 1072071955; +inp[12617] = 0; +inp[12618] = 1072055597; +inp[12619] = 0; +inp[12620] = 1072039239; +inp[12621] = 0; +inp[12622] = 1072022881; +inp[12623] = 0; +inp[12624] = 1072006523; +inp[12625] = 0; +inp[12626] = 1071990166; +inp[12627] = 0; +inp[12628] = 1071973809; +inp[12629] = 0; +inp[12630] = 1071957452; +inp[12631] = 0; +inp[12632] = 1071941095; +inp[12633] = 0; +inp[12634] = 1071924739; +inp[12635] = 0; +inp[12636] = 1071908383; +inp[12637] = 0; +inp[12638] = 1071892027; +inp[12639] = 0; +inp[12640] = 1071875671; +inp[12641] = 0; +inp[12642] = 1071859316; +inp[12643] = 0; +inp[12644] = 1071842961; +inp[12645] = 0; +inp[12646] = 1071826606; +inp[12647] = 0; +inp[12648] = 1071810251; +inp[12649] = 0; +inp[12650] = 1071793897; +inp[12651] = 0; +inp[12652] = 1071777542; +inp[12653] = 0; +inp[12654] = 1071761188; +inp[12655] = 0; +inp[12656] = 1071744835; +inp[12657] = 0; +inp[12658] = 1071728481; +inp[12659] = 0; +inp[12660] = 1071712128; +inp[12661] = 0; +inp[12662] = 1071695775; +inp[12663] = 0; +inp[12664] = 1071679423; +inp[12665] = 0; +inp[12666] = 1071663070; +inp[12667] = 0; +inp[12668] = 1073741824; +inp[12669] = 1073741824; +inp[12670] = 1073733632; +inp[12671] = 0; +inp[12672] = 1073725440; +inp[12673] = 0; +inp[12674] = 1073717248; +inp[12675] = 0; +inp[12676] = 1073709056; +inp[12677] = 0; +inp[12678] = 1073700864; +inp[12679] = 0; +inp[12680] = 1073692673; +inp[12681] = 0; +inp[12682] = 1073684481; +inp[12683] = 0; +inp[12684] = 1073676289; +inp[12685] = 0; +inp[12686] = 1073668098; +inp[12687] = 0; +inp[12688] = 1073659907; +inp[12689] = 0; +inp[12690] = 1073651715; +inp[12691] = 0; +inp[12692] = 1073643524; +inp[12693] = 0; +inp[12694] = 1073635333; +inp[12695] = 0; +inp[12696] = 1073627142; +inp[12697] = 0; +inp[12698] = 1073618951; +inp[12699] = 0; +inp[12700] = 1073610759; +inp[12701] = 0; +inp[12702] = 1073602569; +inp[12703] = 0; +inp[12704] = 1073594378; +inp[12705] = 0; +inp[12706] = 1073586187; +inp[12707] = 0; +inp[12708] = 1073577996; +inp[12709] = 0; +inp[12710] = 1073569805; +inp[12711] = 0; +inp[12712] = 1073561615; +inp[12713] = 0; +inp[12714] = 1073553424; +inp[12715] = 0; +inp[12716] = 1073545233; +inp[12717] = 0; +inp[12718] = 1073537043; +inp[12719] = 0; +inp[12720] = 1073528853; +inp[12721] = 0; +inp[12722] = 1073520662; +inp[12723] = 0; +inp[12724] = 1073512472; +inp[12725] = 0; +inp[12726] = 1073504282; +inp[12727] = 0; +inp[12728] = 1073496092; +inp[12729] = 0; +inp[12730] = 1073487902; +inp[12731] = 0; +inp[12732] = 1073479711; +inp[12733] = 0; +inp[12734] = 1073471522; +inp[12735] = 0; +inp[12736] = 1073463332; +inp[12737] = 0; +inp[12738] = 1073455142; +inp[12739] = 0; +inp[12740] = 1073446952; +inp[12741] = 0; +inp[12742] = 1073438762; +inp[12743] = 0; +inp[12744] = 1073430573; +inp[12745] = 0; +inp[12746] = 1073422383; +inp[12747] = 0; +inp[12748] = 1073414193; +inp[12749] = 0; +inp[12750] = 1073406004; +inp[12751] = 0; +inp[12752] = 1073397815; +inp[12753] = 0; +inp[12754] = 1073389625; +inp[12755] = 0; +inp[12756] = 1073381436; +inp[12757] = 0; +inp[12758] = 1073373247; +inp[12759] = 0; +inp[12760] = 1073365058; +inp[12761] = 0; +inp[12762] = 1073356869; +inp[12763] = 0; +inp[12764] = 1073348679; +inp[12765] = 0; +inp[12766] = 1073340491; +inp[12767] = 0; +inp[12768] = 1073332302; +inp[12769] = 0; +inp[12770] = 1073324113; +inp[12771] = 0; +inp[12772] = 1073315924; +inp[12773] = 0; +inp[12774] = 1073307735; +inp[12775] = 0; +inp[12776] = 1073299547; +inp[12777] = 0; +inp[12778] = 1073291358; +inp[12779] = 0; +inp[12780] = 1073283169; +inp[12781] = 0; +inp[12782] = 1073274981; +inp[12783] = 0; +inp[12784] = 1073266793; +inp[12785] = 0; +inp[12786] = 1073258604; +inp[12787] = 0; +inp[12788] = 1073250416; +inp[12789] = 0; +inp[12790] = 1073242228; +inp[12791] = 0; +inp[12792] = 1073234040; +inp[12793] = 0; +inp[12794] = 1073225852; +inp[12795] = 0; +inp[12796] = 1073217663; +inp[12797] = 0; +inp[12798] = 1073209476; +inp[12799] = 0; +inp[12800] = 1073201288; +inp[12801] = 0; +inp[12802] = 1073193100; +inp[12803] = 0; +inp[12804] = 1073184912; +inp[12805] = 0; +inp[12806] = 1073176724; +inp[12807] = 0; +inp[12808] = 1073168537; +inp[12809] = 0; +inp[12810] = 1073160349; +inp[12811] = 0; +inp[12812] = 1073152161; +inp[12813] = 0; +inp[12814] = 1073143974; +inp[12815] = 0; +inp[12816] = 1073135787; +inp[12817] = 0; +inp[12818] = 1073127599; +inp[12819] = 0; +inp[12820] = 1073119412; +inp[12821] = 0; +inp[12822] = 1073111225; +inp[12823] = 0; +inp[12824] = 1073103038; +inp[12825] = 0; +inp[12826] = 1073094850; +inp[12827] = 0; +inp[12828] = 1073086663; +inp[12829] = 0; +inp[12830] = 1073078476; +inp[12831] = 0; +inp[12832] = 1073070290; +inp[12833] = 0; +inp[12834] = 1073062103; +inp[12835] = 0; +inp[12836] = 1073053916; +inp[12837] = 0; +inp[12838] = 1073045729; +inp[12839] = 0; +inp[12840] = 1073037543; +inp[12841] = 0; +inp[12842] = 1073029356; +inp[12843] = 0; +inp[12844] = 1073021169; +inp[12845] = 0; +inp[12846] = 1073012983; +inp[12847] = 0; +inp[12848] = 1073004797; +inp[12849] = 0; +inp[12850] = 1072996610; +inp[12851] = 0; +inp[12852] = 1072988424; +inp[12853] = 0; +inp[12854] = 1072980238; +inp[12855] = 0; +inp[12856] = 1072972052; +inp[12857] = 0; +inp[12858] = 1072963865; +inp[12859] = 0; +inp[12860] = 1072955679; +inp[12861] = 0; +inp[12862] = 1072947493; +inp[12863] = 0; +inp[12864] = 1072939308; +inp[12865] = 0; +inp[12866] = 1072931122; +inp[12867] = 0; +inp[12868] = 1072922936; +inp[12869] = 0; +inp[12870] = 1072914750; +inp[12871] = 0; +inp[12872] = 1072906565; +inp[12873] = 0; +inp[12874] = 1072898379; +inp[12875] = 0; +inp[12876] = 1072890193; +inp[12877] = 0; +inp[12878] = 1072882008; +inp[12879] = 0; +inp[12880] = 1072873823; +inp[12881] = 0; +inp[12882] = 1072865637; +inp[12883] = 0; +inp[12884] = 1072857452; +inp[12885] = 0; +inp[12886] = 1072849267; +inp[12887] = 0; +inp[12888] = 1072841082; +inp[12889] = 0; +inp[12890] = 1072832896; +inp[12891] = 0; +inp[12892] = 1072824711; +inp[12893] = 0; +inp[12894] = 1072816526; +inp[12895] = 0; +inp[12896] = 1072808342; +inp[12897] = 0; +inp[12898] = 1072800157; +inp[12899] = 0; +inp[12900] = 1072791972; +inp[12901] = 0; +inp[12902] = 1072783787; +inp[12903] = 0; +inp[12904] = 1072775602; +inp[12905] = 0; +inp[12906] = 1072767418; +inp[12907] = 0; +inp[12908] = 1072759233; +inp[12909] = 0; +inp[12910] = 1072751049; +inp[12911] = 0; +inp[12912] = 1072742864; +inp[12913] = 0; +inp[12914] = 1072734680; +inp[12915] = 0; +inp[12916] = 1072726496; +inp[12917] = 0; +inp[12918] = 1072718312; +inp[12919] = 0; +inp[12920] = 1072710127; +inp[12921] = 0; +inp[12922] = 1072701943; +inp[12923] = 0; +inp[12924] = 1073741824; +inp[12925] = 1073741824; +inp[12926] = 1073737728; +inp[12927] = 0; +inp[12928] = 1073733632; +inp[12929] = 0; +inp[12930] = 1073729536; +inp[12931] = 0; +inp[12932] = 1073725440; +inp[12933] = 0; +inp[12934] = 1073721344; +inp[12935] = 0; +inp[12936] = 1073717248; +inp[12937] = 0; +inp[12938] = 1073713152; +inp[12939] = 0; +inp[12940] = 1073709056; +inp[12941] = 0; +inp[12942] = 1073704960; +inp[12943] = 0; +inp[12944] = 1073700864; +inp[12945] = 0; +inp[12946] = 1073696768; +inp[12947] = 0; +inp[12948] = 1073692673; +inp[12949] = 0; +inp[12950] = 1073688577; +inp[12951] = 0; +inp[12952] = 1073684481; +inp[12953] = 0; +inp[12954] = 1073680385; +inp[12955] = 0; +inp[12956] = 1073676289; +inp[12957] = 0; +inp[12958] = 1073672194; +inp[12959] = 0; +inp[12960] = 1073668098; +inp[12961] = 0; +inp[12962] = 1073664002; +inp[12963] = 0; +inp[12964] = 1073659907; +inp[12965] = 0; +inp[12966] = 1073655811; +inp[12967] = 0; +inp[12968] = 1073651715; +inp[12969] = 0; +inp[12970] = 1073647620; +inp[12971] = 0; +inp[12972] = 1073643524; +inp[12973] = 0; +inp[12974] = 1073639428; +inp[12975] = 0; +inp[12976] = 1073635333; +inp[12977] = 0; +inp[12978] = 1073631237; +inp[12979] = 0; +inp[12980] = 1073627142; +inp[12981] = 0; +inp[12982] = 1073623046; +inp[12983] = 0; +inp[12984] = 1073618951; +inp[12985] = 0; +inp[12986] = 1073614855; +inp[12987] = 0; +inp[12988] = 1073610759; +inp[12989] = 0; +inp[12990] = 1073606664; +inp[12991] = 0; +inp[12992] = 1073602569; +inp[12993] = 0; +inp[12994] = 1073598473; +inp[12995] = 0; +inp[12996] = 1073594378; +inp[12997] = 0; +inp[12998] = 1073590282; +inp[12999] = 0; +inp[13000] = 1073586187; +inp[13001] = 0; +inp[13002] = 1073582091; +inp[13003] = 0; +inp[13004] = 1073577996; +inp[13005] = 0; +inp[13006] = 1073573901; +inp[13007] = 0; +inp[13008] = 1073569805; +inp[13009] = 0; +inp[13010] = 1073565710; +inp[13011] = 0; +inp[13012] = 1073561615; +inp[13013] = 0; +inp[13014] = 1073557519; +inp[13015] = 0; +inp[13016] = 1073553424; +inp[13017] = 0; +inp[13018] = 1073549329; +inp[13019] = 0; +inp[13020] = 1073545233; +inp[13021] = 0; +inp[13022] = 1073541138; +inp[13023] = 0; +inp[13024] = 1073537043; +inp[13025] = 0; +inp[13026] = 1073532948; +inp[13027] = 0; +inp[13028] = 1073528853; +inp[13029] = 0; +inp[13030] = 1073524757; +inp[13031] = 0; +inp[13032] = 1073520662; +inp[13033] = 0; +inp[13034] = 1073516567; +inp[13035] = 0; +inp[13036] = 1073512472; +inp[13037] = 0; +inp[13038] = 1073508377; +inp[13039] = 0; +inp[13040] = 1073504282; +inp[13041] = 0; +inp[13042] = 1073500187; +inp[13043] = 0; +inp[13044] = 1073496092; +inp[13045] = 0; +inp[13046] = 1073491997; +inp[13047] = 0; +inp[13048] = 1073487902; +inp[13049] = 0; +inp[13050] = 1073483807; +inp[13051] = 0; +inp[13052] = 1073479711; +inp[13053] = 0; +inp[13054] = 1073475617; +inp[13055] = 0; +inp[13056] = 1073471522; +inp[13057] = 0; +inp[13058] = 1073467427; +inp[13059] = 0; +inp[13060] = 1073463332; +inp[13061] = 0; +inp[13062] = 1073459237; +inp[13063] = 0; +inp[13064] = 1073455142; +inp[13065] = 0; +inp[13066] = 1073451047; +inp[13067] = 0; +inp[13068] = 1073446952; +inp[13069] = 0; +inp[13070] = 1073442857; +inp[13071] = 0; +inp[13072] = 1073438762; +inp[13073] = 0; +inp[13074] = 1073434667; +inp[13075] = 0; +inp[13076] = 1073430573; +inp[13077] = 0; +inp[13078] = 1073426478; +inp[13079] = 0; +inp[13080] = 1073422383; +inp[13081] = 0; +inp[13082] = 1073418288; +inp[13083] = 0; +inp[13084] = 1073414193; +inp[13085] = 0; +inp[13086] = 1073410099; +inp[13087] = 0; +inp[13088] = 1073406004; +inp[13089] = 0; +inp[13090] = 1073401909; +inp[13091] = 0; +inp[13092] = 1073397815; +inp[13093] = 0; +inp[13094] = 1073393720; +inp[13095] = 0; +inp[13096] = 1073389625; +inp[13097] = 0; +inp[13098] = 1073385531; +inp[13099] = 0; +inp[13100] = 1073381436; +inp[13101] = 0; +inp[13102] = 1073377341; +inp[13103] = 0; +inp[13104] = 1073373247; +inp[13105] = 0; +inp[13106] = 1073369152; +inp[13107] = 0; +inp[13108] = 1073365058; +inp[13109] = 0; +inp[13110] = 1073360963; +inp[13111] = 0; +inp[13112] = 1073356869; +inp[13113] = 0; +inp[13114] = 1073352774; +inp[13115] = 0; +inp[13116] = 1073348679; +inp[13117] = 0; +inp[13118] = 1073344585; +inp[13119] = 0; +inp[13120] = 1073340491; +inp[13121] = 0; +inp[13122] = 1073336396; +inp[13123] = 0; +inp[13124] = 1073332302; +inp[13125] = 0; +inp[13126] = 1073328207; +inp[13127] = 0; +inp[13128] = 1073324113; +inp[13129] = 0; +inp[13130] = 1073320018; +inp[13131] = 0; +inp[13132] = 1073315924; +inp[13133] = 0; +inp[13134] = 1073311830; +inp[13135] = 0; +inp[13136] = 1073307735; +inp[13137] = 0; +inp[13138] = 1073303641; +inp[13139] = 0; +inp[13140] = 1073299547; +inp[13141] = 0; +inp[13142] = 1073295452; +inp[13143] = 0; +inp[13144] = 1073291358; +inp[13145] = 0; +inp[13146] = 1073287264; +inp[13147] = 0; +inp[13148] = 1073283169; +inp[13149] = 0; +inp[13150] = 1073279075; +inp[13151] = 0; +inp[13152] = 1073274981; +inp[13153] = 0; +inp[13154] = 1073270887; +inp[13155] = 0; +inp[13156] = 1073266793; +inp[13157] = 0; +inp[13158] = 1073262698; +inp[13159] = 0; +inp[13160] = 1073258604; +inp[13161] = 0; +inp[13162] = 1073254510; +inp[13163] = 0; +inp[13164] = 1073250416; +inp[13165] = 0; +inp[13166] = 1073246322; +inp[13167] = 0; +inp[13168] = 1073242228; +inp[13169] = 0; +inp[13170] = 1073238134; +inp[13171] = 0; +inp[13172] = 1073234040; +inp[13173] = 0; +inp[13174] = 1073229946; +inp[13175] = 0; +inp[13176] = 1073225852; +inp[13177] = 0; +inp[13178] = 1073221757; +inp[13179] = 0; +inp[13180] = 1073741824; +inp[13181] = 1073741824; +inp[13182] = 1073739776; +inp[13183] = 0; +inp[13184] = 1073737728; +inp[13185] = 0; +inp[13186] = 1073735680; +inp[13187] = 0; +inp[13188] = 1073733632; +inp[13189] = 0; +inp[13190] = 1073731584; +inp[13191] = 0; +inp[13192] = 1073729536; +inp[13193] = 0; +inp[13194] = 1073727488; +inp[13195] = 0; +inp[13196] = 1073725440; +inp[13197] = 0; +inp[13198] = 1073723392; +inp[13199] = 0; +inp[13200] = 1073721344; +inp[13201] = 0; +inp[13202] = 1073719296; +inp[13203] = 0; +inp[13204] = 1073717248; +inp[13205] = 0; +inp[13206] = 1073715200; +inp[13207] = 0; +inp[13208] = 1073713152; +inp[13209] = 0; +inp[13210] = 1073711104; +inp[13211] = 0; +inp[13212] = 1073709056; +inp[13213] = 0; +inp[13214] = 1073707008; +inp[13215] = 0; +inp[13216] = 1073704960; +inp[13217] = 0; +inp[13218] = 1073702912; +inp[13219] = 0; +inp[13220] = 1073700864; +inp[13221] = 0; +inp[13222] = 1073698816; +inp[13223] = 0; +inp[13224] = 1073696768; +inp[13225] = 0; +inp[13226] = 1073694721; +inp[13227] = 0; +inp[13228] = 1073692673; +inp[13229] = 0; +inp[13230] = 1073690625; +inp[13231] = 0; +inp[13232] = 1073688577; +inp[13233] = 0; +inp[13234] = 1073686529; +inp[13235] = 0; +inp[13236] = 1073684481; +inp[13237] = 0; +inp[13238] = 1073682433; +inp[13239] = 0; +inp[13240] = 1073680385; +inp[13241] = 0; +inp[13242] = 1073678337; +inp[13243] = 0; +inp[13244] = 1073676289; +inp[13245] = 0; +inp[13246] = 1073674242; +inp[13247] = 0; +inp[13248] = 1073672194; +inp[13249] = 0; +inp[13250] = 1073670146; +inp[13251] = 0; +inp[13252] = 1073668098; +inp[13253] = 0; +inp[13254] = 1073666050; +inp[13255] = 0; +inp[13256] = 1073664002; +inp[13257] = 0; +inp[13258] = 1073661954; +inp[13259] = 0; +inp[13260] = 1073659907; +inp[13261] = 0; +inp[13262] = 1073657859; +inp[13263] = 0; +inp[13264] = 1073655811; +inp[13265] = 0; +inp[13266] = 1073653763; +inp[13267] = 0; +inp[13268] = 1073651715; +inp[13269] = 0; +inp[13270] = 1073649667; +inp[13271] = 0; +inp[13272] = 1073647620; +inp[13273] = 0; +inp[13274] = 1073645572; +inp[13275] = 0; +inp[13276] = 1073643524; +inp[13277] = 0; +inp[13278] = 1073641476; +inp[13279] = 0; +inp[13280] = 1073639428; +inp[13281] = 0; +inp[13282] = 1073637381; +inp[13283] = 0; +inp[13284] = 1073635333; +inp[13285] = 0; +inp[13286] = 1073633285; +inp[13287] = 0; +inp[13288] = 1073631237; +inp[13289] = 0; +inp[13290] = 1073629189; +inp[13291] = 0; +inp[13292] = 1073627142; +inp[13293] = 0; +inp[13294] = 1073625094; +inp[13295] = 0; +inp[13296] = 1073623046; +inp[13297] = 0; +inp[13298] = 1073620998; +inp[13299] = 0; +inp[13300] = 1073618951; +inp[13301] = 0; +inp[13302] = 1073616903; +inp[13303] = 0; +inp[13304] = 1073614855; +inp[13305] = 0; +inp[13306] = 1073612807; +inp[13307] = 0; +inp[13308] = 1073610759; +inp[13309] = 0; +inp[13310] = 1073608712; +inp[13311] = 0; +inp[13312] = 1073606664; +inp[13313] = 0; +inp[13314] = 1073604616; +inp[13315] = 0; +inp[13316] = 1073602569; +inp[13317] = 0; +inp[13318] = 1073600521; +inp[13319] = 0; +inp[13320] = 1073598473; +inp[13321] = 0; +inp[13322] = 1073596425; +inp[13323] = 0; +inp[13324] = 1073594378; +inp[13325] = 0; +inp[13326] = 1073592330; +inp[13327] = 0; +inp[13328] = 1073590282; +inp[13329] = 0; +inp[13330] = 1073588234; +inp[13331] = 0; +inp[13332] = 1073586187; +inp[13333] = 0; +inp[13334] = 1073584139; +inp[13335] = 0; +inp[13336] = 1073582091; +inp[13337] = 0; +inp[13338] = 1073580044; +inp[13339] = 0; +inp[13340] = 1073577996; +inp[13341] = 0; +inp[13342] = 1073575948; +inp[13343] = 0; +inp[13344] = 1073573901; +inp[13345] = 0; +inp[13346] = 1073571853; +inp[13347] = 0; +inp[13348] = 1073569805; +inp[13349] = 0; +inp[13350] = 1073567758; +inp[13351] = 0; +inp[13352] = 1073565710; +inp[13353] = 0; +inp[13354] = 1073563662; +inp[13355] = 0; +inp[13356] = 1073561615; +inp[13357] = 0; +inp[13358] = 1073559567; +inp[13359] = 0; +inp[13360] = 1073557519; +inp[13361] = 0; +inp[13362] = 1073555472; +inp[13363] = 0; +inp[13364] = 1073553424; +inp[13365] = 0; +inp[13366] = 1073551376; +inp[13367] = 0; +inp[13368] = 1073549329; +inp[13369] = 0; +inp[13370] = 1073547281; +inp[13371] = 0; +inp[13372] = 1073545233; +inp[13373] = 0; +inp[13374] = 1073543186; +inp[13375] = 0; +inp[13376] = 1073541138; +inp[13377] = 0; +inp[13378] = 1073539091; +inp[13379] = 0; +inp[13380] = 1073537043; +inp[13381] = 0; +inp[13382] = 1073534995; +inp[13383] = 0; +inp[13384] = 1073532948; +inp[13385] = 0; +inp[13386] = 1073530900; +inp[13387] = 0; +inp[13388] = 1073528853; +inp[13389] = 0; +inp[13390] = 1073526805; +inp[13391] = 0; +inp[13392] = 1073524757; +inp[13393] = 0; +inp[13394] = 1073522710; +inp[13395] = 0; +inp[13396] = 1073520662; +inp[13397] = 0; +inp[13398] = 1073518615; +inp[13399] = 0; +inp[13400] = 1073516567; +inp[13401] = 0; +inp[13402] = 1073514520; +inp[13403] = 0; +inp[13404] = 1073512472; +inp[13405] = 0; +inp[13406] = 1073510424; +inp[13407] = 0; +inp[13408] = 1073508377; +inp[13409] = 0; +inp[13410] = 1073506329; +inp[13411] = 0; +inp[13412] = 1073504282; +inp[13413] = 0; +inp[13414] = 1073502234; +inp[13415] = 0; +inp[13416] = 1073500187; +inp[13417] = 0; +inp[13418] = 1073498139; +inp[13419] = 0; +inp[13420] = 1073496092; +inp[13421] = 0; +inp[13422] = 1073494044; +inp[13423] = 0; +inp[13424] = 1073491997; +inp[13425] = 0; +inp[13426] = 1073489949; +inp[13427] = 0; +inp[13428] = 1073487902; +inp[13429] = 0; +inp[13430] = 1073485854; +inp[13431] = 0; +inp[13432] = 1073483807; +inp[13433] = 0; +inp[13434] = 1073481759; +inp[13435] = 0; +inp[13436] = 1073741824; +inp[13437] = 1073741824; +inp[13438] = 1073740800; +inp[13439] = 0; +inp[13440] = 1073739776; +inp[13441] = 0; +inp[13442] = 1073738752; +inp[13443] = 0; +inp[13444] = 1073737728; +inp[13445] = 0; +inp[13446] = 1073736704; +inp[13447] = 0; +inp[13448] = 1073735680; +inp[13449] = 0; +inp[13450] = 1073734656; +inp[13451] = 0; +inp[13452] = 1073733632; +inp[13453] = 0; +inp[13454] = 1073732608; +inp[13455] = 0; +inp[13456] = 1073731584; +inp[13457] = 0; +inp[13458] = 1073730560; +inp[13459] = 0; +inp[13460] = 1073729536; +inp[13461] = 0; +inp[13462] = 1073728512; +inp[13463] = 0; +inp[13464] = 1073727488; +inp[13465] = 0; +inp[13466] = 1073726464; +inp[13467] = 0; +inp[13468] = 1073725440; +inp[13469] = 0; +inp[13470] = 1073724416; +inp[13471] = 0; +inp[13472] = 1073723392; +inp[13473] = 0; +inp[13474] = 1073722368; +inp[13475] = 0; +inp[13476] = 1073721344; +inp[13477] = 0; +inp[13478] = 1073720320; +inp[13479] = 0; +inp[13480] = 1073719296; +inp[13481] = 0; +inp[13482] = 1073718272; +inp[13483] = 0; +inp[13484] = 1073717248; +inp[13485] = 0; +inp[13486] = 1073716224; +inp[13487] = 0; +inp[13488] = 1073715200; +inp[13489] = 0; +inp[13490] = 1073714176; +inp[13491] = 0; +inp[13492] = 1073713152; +inp[13493] = 0; +inp[13494] = 1073712128; +inp[13495] = 0; +inp[13496] = 1073711104; +inp[13497] = 0; +inp[13498] = 1073710080; +inp[13499] = 0; +inp[13500] = 1073709056; +inp[13501] = 0; +inp[13502] = 1073708032; +inp[13503] = 0; +inp[13504] = 1073707008; +inp[13505] = 0; +inp[13506] = 1073705984; +inp[13507] = 0; +inp[13508] = 1073704960; +inp[13509] = 0; +inp[13510] = 1073703936; +inp[13511] = 0; +inp[13512] = 1073702912; +inp[13513] = 0; +inp[13514] = 1073701888; +inp[13515] = 0; +inp[13516] = 1073700864; +inp[13517] = 0; +inp[13518] = 1073699840; +inp[13519] = 0; +inp[13520] = 1073698816; +inp[13521] = 0; +inp[13522] = 1073697792; +inp[13523] = 0; +inp[13524] = 1073696768; +inp[13525] = 0; +inp[13526] = 1073695744; +inp[13527] = 0; +inp[13528] = 1073694721; +inp[13529] = 0; +inp[13530] = 1073693697; +inp[13531] = 0; +inp[13532] = 1073692673; +inp[13533] = 0; +inp[13534] = 1073691649; +inp[13535] = 0; +inp[13536] = 1073690625; +inp[13537] = 0; +inp[13538] = 1073689601; +inp[13539] = 0; +inp[13540] = 1073688577; +inp[13541] = 0; +inp[13542] = 1073687553; +inp[13543] = 0; +inp[13544] = 1073686529; +inp[13545] = 0; +inp[13546] = 1073685505; +inp[13547] = 0; +inp[13548] = 1073684481; +inp[13549] = 0; +inp[13550] = 1073683457; +inp[13551] = 0; +inp[13552] = 1073682433; +inp[13553] = 0; +inp[13554] = 1073681409; +inp[13555] = 0; +inp[13556] = 1073680385; +inp[13557] = 0; +inp[13558] = 1073679361; +inp[13559] = 0; +inp[13560] = 1073678337; +inp[13561] = 0; +inp[13562] = 1073677313; +inp[13563] = 0; +inp[13564] = 1073676289; +inp[13565] = 0; +inp[13566] = 1073675266; +inp[13567] = 0; +inp[13568] = 1073674242; +inp[13569] = 0; +inp[13570] = 1073673218; +inp[13571] = 0; +inp[13572] = 1073672194; +inp[13573] = 0; +inp[13574] = 1073671170; +inp[13575] = 0; +inp[13576] = 1073670146; +inp[13577] = 0; +inp[13578] = 1073669122; +inp[13579] = 0; +inp[13580] = 1073668098; +inp[13581] = 0; +inp[13582] = 1073667074; +inp[13583] = 0; +inp[13584] = 1073666050; +inp[13585] = 0; +inp[13586] = 1073665026; +inp[13587] = 0; +inp[13588] = 1073664002; +inp[13589] = 0; +inp[13590] = 1073662978; +inp[13591] = 0; +inp[13592] = 1073661954; +inp[13593] = 0; +inp[13594] = 1073660931; +inp[13595] = 0; +inp[13596] = 1073659907; +inp[13597] = 0; +inp[13598] = 1073658883; +inp[13599] = 0; +inp[13600] = 1073657859; +inp[13601] = 0; +inp[13602] = 1073656835; +inp[13603] = 0; +inp[13604] = 1073655811; +inp[13605] = 0; +inp[13606] = 1073654787; +inp[13607] = 0; +inp[13608] = 1073653763; +inp[13609] = 0; +inp[13610] = 1073652739; +inp[13611] = 0; +inp[13612] = 1073651715; +inp[13613] = 0; +inp[13614] = 1073650691; +inp[13615] = 0; +inp[13616] = 1073649667; +inp[13617] = 0; +inp[13618] = 1073648644; +inp[13619] = 0; +inp[13620] = 1073647620; +inp[13621] = 0; +inp[13622] = 1073646596; +inp[13623] = 0; +inp[13624] = 1073645572; +inp[13625] = 0; +inp[13626] = 1073644548; +inp[13627] = 0; +inp[13628] = 1073643524; +inp[13629] = 0; +inp[13630] = 1073642500; +inp[13631] = 0; +inp[13632] = 1073641476; +inp[13633] = 0; +inp[13634] = 1073640452; +inp[13635] = 0; +inp[13636] = 1073639428; +inp[13637] = 0; +inp[13638] = 1073638404; +inp[13639] = 0; +inp[13640] = 1073637381; +inp[13641] = 0; +inp[13642] = 1073636357; +inp[13643] = 0; +inp[13644] = 1073635333; +inp[13645] = 0; +inp[13646] = 1073634309; +inp[13647] = 0; +inp[13648] = 1073633285; +inp[13649] = 0; +inp[13650] = 1073632261; +inp[13651] = 0; +inp[13652] = 1073631237; +inp[13653] = 0; +inp[13654] = 1073630213; +inp[13655] = 0; +inp[13656] = 1073629189; +inp[13657] = 0; +inp[13658] = 1073628166; +inp[13659] = 0; +inp[13660] = 1073627142; +inp[13661] = 0; +inp[13662] = 1073626118; +inp[13663] = 0; +inp[13664] = 1073625094; +inp[13665] = 0; +inp[13666] = 1073624070; +inp[13667] = 0; +inp[13668] = 1073623046; +inp[13669] = 0; +inp[13670] = 1073622022; +inp[13671] = 0; +inp[13672] = 1073620998; +inp[13673] = 0; +inp[13674] = 1073619974; +inp[13675] = 0; +inp[13676] = 1073618951; +inp[13677] = 0; +inp[13678] = 1073617927; +inp[13679] = 0; +inp[13680] = 1073616903; +inp[13681] = 0; +inp[13682] = 1073615879; +inp[13683] = 0; +inp[13684] = 1073614855; +inp[13685] = 0; +inp[13686] = 1073613831; +inp[13687] = 0; +inp[13688] = 1073612807; +inp[13689] = 0; +inp[13690] = 1073611783; +inp[13691] = 0; +inp[13692] = 1073741824; +inp[13693] = 1073741824; +inp[13694] = 1073741312; +inp[13695] = 0; +inp[13696] = 1073740800; +inp[13697] = 0; +inp[13698] = 1073740288; +inp[13699] = 0; +inp[13700] = 1073739776; +inp[13701] = 0; +inp[13702] = 1073739264; +inp[13703] = 0; +inp[13704] = 1073738752; +inp[13705] = 0; +inp[13706] = 1073738240; +inp[13707] = 0; +inp[13708] = 1073737728; +inp[13709] = 0; +inp[13710] = 1073737216; +inp[13711] = 0; +inp[13712] = 1073736704; +inp[13713] = 0; +inp[13714] = 1073736192; +inp[13715] = 0; +inp[13716] = 1073735680; +inp[13717] = 0; +inp[13718] = 1073735168; +inp[13719] = 0; +inp[13720] = 1073734656; +inp[13721] = 0; +inp[13722] = 1073734144; +inp[13723] = 0; +inp[13724] = 1073733632; +inp[13725] = 0; +inp[13726] = 1073733120; +inp[13727] = 0; +inp[13728] = 1073732608; +inp[13729] = 0; +inp[13730] = 1073732096; +inp[13731] = 0; +inp[13732] = 1073731584; +inp[13733] = 0; +inp[13734] = 1073731072; +inp[13735] = 0; +inp[13736] = 1073730560; +inp[13737] = 0; +inp[13738] = 1073730048; +inp[13739] = 0; +inp[13740] = 1073729536; +inp[13741] = 0; +inp[13742] = 1073729024; +inp[13743] = 0; +inp[13744] = 1073728512; +inp[13745] = 0; +inp[13746] = 1073728000; +inp[13747] = 0; +inp[13748] = 1073727488; +inp[13749] = 0; +inp[13750] = 1073726976; +inp[13751] = 0; +inp[13752] = 1073726464; +inp[13753] = 0; +inp[13754] = 1073725952; +inp[13755] = 0; +inp[13756] = 1073725440; +inp[13757] = 0; +inp[13758] = 1073724928; +inp[13759] = 0; +inp[13760] = 1073724416; +inp[13761] = 0; +inp[13762] = 1073723904; +inp[13763] = 0; +inp[13764] = 1073723392; +inp[13765] = 0; +inp[13766] = 1073722880; +inp[13767] = 0; +inp[13768] = 1073722368; +inp[13769] = 0; +inp[13770] = 1073721856; +inp[13771] = 0; +inp[13772] = 1073721344; +inp[13773] = 0; +inp[13774] = 1073720832; +inp[13775] = 0; +inp[13776] = 1073720320; +inp[13777] = 0; +inp[13778] = 1073719808; +inp[13779] = 0; +inp[13780] = 1073719296; +inp[13781] = 0; +inp[13782] = 1073718784; +inp[13783] = 0; +inp[13784] = 1073718272; +inp[13785] = 0; +inp[13786] = 1073717760; +inp[13787] = 0; +inp[13788] = 1073717248; +inp[13789] = 0; +inp[13790] = 1073716736; +inp[13791] = 0; +inp[13792] = 1073716224; +inp[13793] = 0; +inp[13794] = 1073715712; +inp[13795] = 0; +inp[13796] = 1073715200; +inp[13797] = 0; +inp[13798] = 1073714688; +inp[13799] = 0; +inp[13800] = 1073714176; +inp[13801] = 0; +inp[13802] = 1073713664; +inp[13803] = 0; +inp[13804] = 1073713152; +inp[13805] = 0; +inp[13806] = 1073712640; +inp[13807] = 0; +inp[13808] = 1073712128; +inp[13809] = 0; +inp[13810] = 1073711616; +inp[13811] = 0; +inp[13812] = 1073711104; +inp[13813] = 0; +inp[13814] = 1073710592; +inp[13815] = 0; +inp[13816] = 1073710080; +inp[13817] = 0; +inp[13818] = 1073709568; +inp[13819] = 0; +inp[13820] = 1073709056; +inp[13821] = 0; +inp[13822] = 1073708544; +inp[13823] = 0; +inp[13824] = 1073708032; +inp[13825] = 0; +inp[13826] = 1073707520; +inp[13827] = 0; +inp[13828] = 1073707008; +inp[13829] = 0; +inp[13830] = 1073706496; +inp[13831] = 0; +inp[13832] = 1073705984; +inp[13833] = 0; +inp[13834] = 1073705472; +inp[13835] = 0; +inp[13836] = 1073704960; +inp[13837] = 0; +inp[13838] = 1073704448; +inp[13839] = 0; +inp[13840] = 1073703936; +inp[13841] = 0; +inp[13842] = 1073703424; +inp[13843] = 0; +inp[13844] = 1073702912; +inp[13845] = 0; +inp[13846] = 1073702400; +inp[13847] = 0; +inp[13848] = 1073701888; +inp[13849] = 0; +inp[13850] = 1073701376; +inp[13851] = 0; +inp[13852] = 1073700864; +inp[13853] = 0; +inp[13854] = 1073700352; +inp[13855] = 0; +inp[13856] = 1073699840; +inp[13857] = 0; +inp[13858] = 1073699328; +inp[13859] = 0; +inp[13860] = 1073698816; +inp[13861] = 0; +inp[13862] = 1073698304; +inp[13863] = 0; +inp[13864] = 1073697792; +inp[13865] = 0; +inp[13866] = 1073697280; +inp[13867] = 0; +inp[13868] = 1073696768; +inp[13869] = 0; +inp[13870] = 1073696256; +inp[13871] = 0; +inp[13872] = 1073695744; +inp[13873] = 0; +inp[13874] = 1073695233; +inp[13875] = 0; +inp[13876] = 1073694721; +inp[13877] = 0; +inp[13878] = 1073694209; +inp[13879] = 0; +inp[13880] = 1073693697; +inp[13881] = 0; +inp[13882] = 1073693185; +inp[13883] = 0; +inp[13884] = 1073692673; +inp[13885] = 0; +inp[13886] = 1073692161; +inp[13887] = 0; +inp[13888] = 1073691649; +inp[13889] = 0; +inp[13890] = 1073691137; +inp[13891] = 0; +inp[13892] = 1073690625; +inp[13893] = 0; +inp[13894] = 1073690113; +inp[13895] = 0; +inp[13896] = 1073689601; +inp[13897] = 0; +inp[13898] = 1073689089; +inp[13899] = 0; +inp[13900] = 1073688577; +inp[13901] = 0; +inp[13902] = 1073688065; +inp[13903] = 0; +inp[13904] = 1073687553; +inp[13905] = 0; +inp[13906] = 1073687041; +inp[13907] = 0; +inp[13908] = 1073686529; +inp[13909] = 0; +inp[13910] = 1073686017; +inp[13911] = 0; +inp[13912] = 1073685505; +inp[13913] = 0; +inp[13914] = 1073684993; +inp[13915] = 0; +inp[13916] = 1073684481; +inp[13917] = 0; +inp[13918] = 1073683969; +inp[13919] = 0; +inp[13920] = 1073683457; +inp[13921] = 0; +inp[13922] = 1073682945; +inp[13923] = 0; +inp[13924] = 1073682433; +inp[13925] = 0; +inp[13926] = 1073681921; +inp[13927] = 0; +inp[13928] = 1073681409; +inp[13929] = 0; +inp[13930] = 1073680897; +inp[13931] = 0; +inp[13932] = 1073680385; +inp[13933] = 0; +inp[13934] = 1073679873; +inp[13935] = 0; +inp[13936] = 1073679361; +inp[13937] = 0; +inp[13938] = 1073678849; +inp[13939] = 0; +inp[13940] = 1073678337; +inp[13941] = 0; +inp[13942] = 1073677825; +inp[13943] = 0; +inp[13944] = 1073677313; +inp[13945] = 0; +inp[13946] = 1073676801; +inp[13947] = 0; +inp[13948] = 1073741824; +inp[13949] = 1073741824; +inp[13950] = 1073741568; +inp[13951] = 0; +inp[13952] = 1073741312; +inp[13953] = 0; +inp[13954] = 1073741056; +inp[13955] = 0; +inp[13956] = 1073740800; +inp[13957] = 0; +inp[13958] = 1073740544; +inp[13959] = 0; +inp[13960] = 1073740288; +inp[13961] = 0; +inp[13962] = 1073740032; +inp[13963] = 0; +inp[13964] = 1073739776; +inp[13965] = 0; +inp[13966] = 1073739520; +inp[13967] = 0; +inp[13968] = 1073739264; +inp[13969] = 0; +inp[13970] = 1073739008; +inp[13971] = 0; +inp[13972] = 1073738752; +inp[13973] = 0; +inp[13974] = 1073738496; +inp[13975] = 0; +inp[13976] = 1073738240; +inp[13977] = 0; +inp[13978] = 1073737984; +inp[13979] = 0; +inp[13980] = 1073737728; +inp[13981] = 0; +inp[13982] = 1073737472; +inp[13983] = 0; +inp[13984] = 1073737216; +inp[13985] = 0; +inp[13986] = 1073736960; +inp[13987] = 0; +inp[13988] = 1073736704; +inp[13989] = 0; +inp[13990] = 1073736448; +inp[13991] = 0; +inp[13992] = 1073736192; +inp[13993] = 0; +inp[13994] = 1073735936; +inp[13995] = 0; +inp[13996] = 1073735680; +inp[13997] = 0; +inp[13998] = 1073735424; +inp[13999] = 0; +inp[14000] = 1073735168; +inp[14001] = 0; +inp[14002] = 1073734912; +inp[14003] = 0; +inp[14004] = 1073734656; +inp[14005] = 0; +inp[14006] = 1073734400; +inp[14007] = 0; +inp[14008] = 1073734144; +inp[14009] = 0; +inp[14010] = 1073733888; +inp[14011] = 0; +inp[14012] = 1073733632; +inp[14013] = 0; +inp[14014] = 1073733376; +inp[14015] = 0; +inp[14016] = 1073733120; +inp[14017] = 0; +inp[14018] = 1073732864; +inp[14019] = 0; +inp[14020] = 1073732608; +inp[14021] = 0; +inp[14022] = 1073732352; +inp[14023] = 0; +inp[14024] = 1073732096; +inp[14025] = 0; +inp[14026] = 1073731840; +inp[14027] = 0; +inp[14028] = 1073731584; +inp[14029] = 0; +inp[14030] = 1073731328; +inp[14031] = 0; +inp[14032] = 1073731072; +inp[14033] = 0; +inp[14034] = 1073730816; +inp[14035] = 0; +inp[14036] = 1073730560; +inp[14037] = 0; +inp[14038] = 1073730304; +inp[14039] = 0; +inp[14040] = 1073730048; +inp[14041] = 0; +inp[14042] = 1073729792; +inp[14043] = 0; +inp[14044] = 1073729536; +inp[14045] = 0; +inp[14046] = 1073729280; +inp[14047] = 0; +inp[14048] = 1073729024; +inp[14049] = 0; +inp[14050] = 1073728768; +inp[14051] = 0; +inp[14052] = 1073728512; +inp[14053] = 0; +inp[14054] = 1073728256; +inp[14055] = 0; +inp[14056] = 1073728000; +inp[14057] = 0; +inp[14058] = 1073727744; +inp[14059] = 0; +inp[14060] = 1073727488; +inp[14061] = 0; +inp[14062] = 1073727232; +inp[14063] = 0; +inp[14064] = 1073726976; +inp[14065] = 0; +inp[14066] = 1073726720; +inp[14067] = 0; +inp[14068] = 1073726464; +inp[14069] = 0; +inp[14070] = 1073726208; +inp[14071] = 0; +inp[14072] = 1073725952; +inp[14073] = 0; +inp[14074] = 1073725696; +inp[14075] = 0; +inp[14076] = 1073725440; +inp[14077] = 0; +inp[14078] = 1073725184; +inp[14079] = 0; +inp[14080] = 1073724928; +inp[14081] = 0; +inp[14082] = 1073724672; +inp[14083] = 0; +inp[14084] = 1073724416; +inp[14085] = 0; +inp[14086] = 1073724160; +inp[14087] = 0; +inp[14088] = 1073723904; +inp[14089] = 0; +inp[14090] = 1073723648; +inp[14091] = 0; +inp[14092] = 1073723392; +inp[14093] = 0; +inp[14094] = 1073723136; +inp[14095] = 0; +inp[14096] = 1073722880; +inp[14097] = 0; +inp[14098] = 1073722624; +inp[14099] = 0; +inp[14100] = 1073722368; +inp[14101] = 0; +inp[14102] = 1073722112; +inp[14103] = 0; +inp[14104] = 1073721856; +inp[14105] = 0; +inp[14106] = 1073721600; +inp[14107] = 0; +inp[14108] = 1073721344; +inp[14109] = 0; +inp[14110] = 1073721088; +inp[14111] = 0; +inp[14112] = 1073720832; +inp[14113] = 0; +inp[14114] = 1073720576; +inp[14115] = 0; +inp[14116] = 1073720320; +inp[14117] = 0; +inp[14118] = 1073720064; +inp[14119] = 0; +inp[14120] = 1073719808; +inp[14121] = 0; +inp[14122] = 1073719552; +inp[14123] = 0; +inp[14124] = 1073719296; +inp[14125] = 0; +inp[14126] = 1073719040; +inp[14127] = 0; +inp[14128] = 1073718784; +inp[14129] = 0; +inp[14130] = 1073718528; +inp[14131] = 0; +inp[14132] = 1073718272; +inp[14133] = 0; +inp[14134] = 1073718016; +inp[14135] = 0; +inp[14136] = 1073717760; +inp[14137] = 0; +inp[14138] = 1073717504; +inp[14139] = 0; +inp[14140] = 1073717248; +inp[14141] = 0; +inp[14142] = 1073716992; +inp[14143] = 0; +inp[14144] = 1073716736; +inp[14145] = 0; +inp[14146] = 1073716480; +inp[14147] = 0; +inp[14148] = 1073716224; +inp[14149] = 0; +inp[14150] = 1073715968; +inp[14151] = 0; +inp[14152] = 1073715712; +inp[14153] = 0; +inp[14154] = 1073715456; +inp[14155] = 0; +inp[14156] = 1073715200; +inp[14157] = 0; +inp[14158] = 1073714944; +inp[14159] = 0; +inp[14160] = 1073714688; +inp[14161] = 0; +inp[14162] = 1073714432; +inp[14163] = 0; +inp[14164] = 1073714176; +inp[14165] = 0; +inp[14166] = 1073713920; +inp[14167] = 0; +inp[14168] = 1073713664; +inp[14169] = 0; +inp[14170] = 1073713408; +inp[14171] = 0; +inp[14172] = 1073713152; +inp[14173] = 0; +inp[14174] = 1073712896; +inp[14175] = 0; +inp[14176] = 1073712640; +inp[14177] = 0; +inp[14178] = 1073712384; +inp[14179] = 0; +inp[14180] = 1073712128; +inp[14181] = 0; +inp[14182] = 1073711872; +inp[14183] = 0; +inp[14184] = 1073711616; +inp[14185] = 0; +inp[14186] = 1073711360; +inp[14187] = 0; +inp[14188] = 1073711104; +inp[14189] = 0; +inp[14190] = 1073710848; +inp[14191] = 0; +inp[14192] = 1073710592; +inp[14193] = 0; +inp[14194] = 1073710336; +inp[14195] = 0; +inp[14196] = 1073710080; +inp[14197] = 0; +inp[14198] = 1073709824; +inp[14199] = 0; +inp[14200] = 1073709568; +inp[14201] = 0; +inp[14202] = 1073709312; +inp[14203] = 0; +inp[14204] = 1073741824; +inp[14205] = 1073741824; +inp[14206] = 1073741696; +inp[14207] = 0; +inp[14208] = 1073741568; +inp[14209] = 0; +inp[14210] = 1073741440; +inp[14211] = 0; +inp[14212] = 1073741312; +inp[14213] = 0; +inp[14214] = 1073741184; +inp[14215] = 0; +inp[14216] = 1073741056; +inp[14217] = 0; +inp[14218] = 1073740928; +inp[14219] = 0; +inp[14220] = 1073740800; +inp[14221] = 0; +inp[14222] = 1073740672; +inp[14223] = 0; +inp[14224] = 1073740544; +inp[14225] = 0; +inp[14226] = 1073740416; +inp[14227] = 0; +inp[14228] = 1073740288; +inp[14229] = 0; +inp[14230] = 1073740160; +inp[14231] = 0; +inp[14232] = 1073740032; +inp[14233] = 0; +inp[14234] = 1073739904; +inp[14235] = 0; +inp[14236] = 1073739776; +inp[14237] = 0; +inp[14238] = 1073739648; +inp[14239] = 0; +inp[14240] = 1073739520; +inp[14241] = 0; +inp[14242] = 1073739392; +inp[14243] = 0; +inp[14244] = 1073739264; +inp[14245] = 0; +inp[14246] = 1073739136; +inp[14247] = 0; +inp[14248] = 1073739008; +inp[14249] = 0; +inp[14250] = 1073738880; +inp[14251] = 0; +inp[14252] = 1073738752; +inp[14253] = 0; +inp[14254] = 1073738624; +inp[14255] = 0; +inp[14256] = 1073738496; +inp[14257] = 0; +inp[14258] = 1073738368; +inp[14259] = 0; +inp[14260] = 1073738240; +inp[14261] = 0; +inp[14262] = 1073738112; +inp[14263] = 0; +inp[14264] = 1073737984; +inp[14265] = 0; +inp[14266] = 1073737856; +inp[14267] = 0; +inp[14268] = 1073737728; +inp[14269] = 0; +inp[14270] = 1073737600; +inp[14271] = 0; +inp[14272] = 1073737472; +inp[14273] = 0; +inp[14274] = 1073737344; +inp[14275] = 0; +inp[14276] = 1073737216; +inp[14277] = 0; +inp[14278] = 1073737088; +inp[14279] = 0; +inp[14280] = 1073736960; +inp[14281] = 0; +inp[14282] = 1073736832; +inp[14283] = 0; +inp[14284] = 1073736704; +inp[14285] = 0; +inp[14286] = 1073736576; +inp[14287] = 0; +inp[14288] = 1073736448; +inp[14289] = 0; +inp[14290] = 1073736320; +inp[14291] = 0; +inp[14292] = 1073736192; +inp[14293] = 0; +inp[14294] = 1073736064; +inp[14295] = 0; +inp[14296] = 1073735936; +inp[14297] = 0; +inp[14298] = 1073735808; +inp[14299] = 0; +inp[14300] = 1073735680; +inp[14301] = 0; +inp[14302] = 1073735552; +inp[14303] = 0; +inp[14304] = 1073735424; +inp[14305] = 0; +inp[14306] = 1073735296; +inp[14307] = 0; +inp[14308] = 1073735168; +inp[14309] = 0; +inp[14310] = 1073735040; +inp[14311] = 0; +inp[14312] = 1073734912; +inp[14313] = 0; +inp[14314] = 1073734784; +inp[14315] = 0; +inp[14316] = 1073734656; +inp[14317] = 0; +inp[14318] = 1073734528; +inp[14319] = 0; +inp[14320] = 1073734400; +inp[14321] = 0; +inp[14322] = 1073734272; +inp[14323] = 0; +inp[14324] = 1073734144; +inp[14325] = 0; +inp[14326] = 1073734016; +inp[14327] = 0; +inp[14328] = 1073733888; +inp[14329] = 0; +inp[14330] = 1073733760; +inp[14331] = 0; +inp[14332] = 1073733632; +inp[14333] = 0; +inp[14334] = 1073733504; +inp[14335] = 0; +inp[14336] = 1073733376; +inp[14337] = 0; +inp[14338] = 1073733248; +inp[14339] = 0; +inp[14340] = 1073733120; +inp[14341] = 0; +inp[14342] = 1073732992; +inp[14343] = 0; +inp[14344] = 1073732864; +inp[14345] = 0; +inp[14346] = 1073732736; +inp[14347] = 0; +inp[14348] = 1073732608; +inp[14349] = 0; +inp[14350] = 1073732480; +inp[14351] = 0; +inp[14352] = 1073732352; +inp[14353] = 0; +inp[14354] = 1073732224; +inp[14355] = 0; +inp[14356] = 1073732096; +inp[14357] = 0; +inp[14358] = 1073731968; +inp[14359] = 0; +inp[14360] = 1073731840; +inp[14361] = 0; +inp[14362] = 1073731712; +inp[14363] = 0; +inp[14364] = 1073731584; +inp[14365] = 0; +inp[14366] = 1073731456; +inp[14367] = 0; +inp[14368] = 1073731328; +inp[14369] = 0; +inp[14370] = 1073731200; +inp[14371] = 0; +inp[14372] = 1073731072; +inp[14373] = 0; +inp[14374] = 1073730944; +inp[14375] = 0; +inp[14376] = 1073730816; +inp[14377] = 0; +inp[14378] = 1073730688; +inp[14379] = 0; +inp[14380] = 1073730560; +inp[14381] = 0; +inp[14382] = 1073730432; +inp[14383] = 0; +inp[14384] = 1073730304; +inp[14385] = 0; +inp[14386] = 1073730176; +inp[14387] = 0; +inp[14388] = 1073730048; +inp[14389] = 0; +inp[14390] = 1073729920; +inp[14391] = 0; +inp[14392] = 1073729792; +inp[14393] = 0; +inp[14394] = 1073729664; +inp[14395] = 0; +inp[14396] = 1073729536; +inp[14397] = 0; +inp[14398] = 1073729408; +inp[14399] = 0; +inp[14400] = 1073729280; +inp[14401] = 0; +inp[14402] = 1073729152; +inp[14403] = 0; +inp[14404] = 1073729024; +inp[14405] = 0; +inp[14406] = 1073728896; +inp[14407] = 0; +inp[14408] = 1073728768; +inp[14409] = 0; +inp[14410] = 1073728640; +inp[14411] = 0; +inp[14412] = 1073728512; +inp[14413] = 0; +inp[14414] = 1073728384; +inp[14415] = 0; +inp[14416] = 1073728256; +inp[14417] = 0; +inp[14418] = 1073728128; +inp[14419] = 0; +inp[14420] = 1073728000; +inp[14421] = 0; +inp[14422] = 1073727872; +inp[14423] = 0; +inp[14424] = 1073727744; +inp[14425] = 0; +inp[14426] = 1073727616; +inp[14427] = 0; +inp[14428] = 1073727488; +inp[14429] = 0; +inp[14430] = 1073727360; +inp[14431] = 0; +inp[14432] = 1073727232; +inp[14433] = 0; +inp[14434] = 1073727104; +inp[14435] = 0; +inp[14436] = 1073726976; +inp[14437] = 0; +inp[14438] = 1073726848; +inp[14439] = 0; +inp[14440] = 1073726720; +inp[14441] = 0; +inp[14442] = 1073726592; +inp[14443] = 0; +inp[14444] = 1073726464; +inp[14445] = 0; +inp[14446] = 1073726336; +inp[14447] = 0; +inp[14448] = 1073726208; +inp[14449] = 0; +inp[14450] = 1073726080; +inp[14451] = 0; +inp[14452] = 1073725952; +inp[14453] = 0; +inp[14454] = 1073725824; +inp[14455] = 0; +inp[14456] = 1073725696; +inp[14457] = 0; +inp[14458] = 1073725568; +inp[14459] = 0; +inp[14460] = 1073741824; +inp[14461] = 1073741824; +inp[14462] = 1073741760; +inp[14463] = 0; +inp[14464] = 1073741696; +inp[14465] = 0; +inp[14466] = 1073741632; +inp[14467] = 0; +inp[14468] = 1073741568; +inp[14469] = 0; +inp[14470] = 1073741504; +inp[14471] = 0; +inp[14472] = 1073741440; +inp[14473] = 0; +inp[14474] = 1073741376; +inp[14475] = 0; +inp[14476] = 1073741312; +inp[14477] = 0; +inp[14478] = 1073741248; +inp[14479] = 0; +inp[14480] = 1073741184; +inp[14481] = 0; +inp[14482] = 1073741120; +inp[14483] = 0; +inp[14484] = 1073741056; +inp[14485] = 0; +inp[14486] = 1073740992; +inp[14487] = 0; +inp[14488] = 1073740928; +inp[14489] = 0; +inp[14490] = 1073740864; +inp[14491] = 0; +inp[14492] = 1073740800; +inp[14493] = 0; +inp[14494] = 1073740736; +inp[14495] = 0; +inp[14496] = 1073740672; +inp[14497] = 0; +inp[14498] = 1073740608; +inp[14499] = 0; +inp[14500] = 1073740544; +inp[14501] = 0; +inp[14502] = 1073740480; +inp[14503] = 0; +inp[14504] = 1073740416; +inp[14505] = 0; +inp[14506] = 1073740352; +inp[14507] = 0; +inp[14508] = 1073740288; +inp[14509] = 0; +inp[14510] = 1073740224; +inp[14511] = 0; +inp[14512] = 1073740160; +inp[14513] = 0; +inp[14514] = 1073740096; +inp[14515] = 0; +inp[14516] = 1073740032; +inp[14517] = 0; +inp[14518] = 1073739968; +inp[14519] = 0; +inp[14520] = 1073739904; +inp[14521] = 0; +inp[14522] = 1073739840; +inp[14523] = 0; +inp[14524] = 1073739776; +inp[14525] = 0; +inp[14526] = 1073739712; +inp[14527] = 0; +inp[14528] = 1073739648; +inp[14529] = 0; +inp[14530] = 1073739584; +inp[14531] = 0; +inp[14532] = 1073739520; +inp[14533] = 0; +inp[14534] = 1073739456; +inp[14535] = 0; +inp[14536] = 1073739392; +inp[14537] = 0; +inp[14538] = 1073739328; +inp[14539] = 0; +inp[14540] = 1073739264; +inp[14541] = 0; +inp[14542] = 1073739200; +inp[14543] = 0; +inp[14544] = 1073739136; +inp[14545] = 0; +inp[14546] = 1073739072; +inp[14547] = 0; +inp[14548] = 1073739008; +inp[14549] = 0; +inp[14550] = 1073738944; +inp[14551] = 0; +inp[14552] = 1073738880; +inp[14553] = 0; +inp[14554] = 1073738816; +inp[14555] = 0; +inp[14556] = 1073738752; +inp[14557] = 0; +inp[14558] = 1073738688; +inp[14559] = 0; +inp[14560] = 1073738624; +inp[14561] = 0; +inp[14562] = 1073738560; +inp[14563] = 0; +inp[14564] = 1073738496; +inp[14565] = 0; +inp[14566] = 1073738432; +inp[14567] = 0; +inp[14568] = 1073738368; +inp[14569] = 0; +inp[14570] = 1073738304; +inp[14571] = 0; +inp[14572] = 1073738240; +inp[14573] = 0; +inp[14574] = 1073738176; +inp[14575] = 0; +inp[14576] = 1073738112; +inp[14577] = 0; +inp[14578] = 1073738048; +inp[14579] = 0; +inp[14580] = 1073737984; +inp[14581] = 0; +inp[14582] = 1073737920; +inp[14583] = 0; +inp[14584] = 1073737856; +inp[14585] = 0; +inp[14586] = 1073737792; +inp[14587] = 0; +inp[14588] = 1073737728; +inp[14589] = 0; +inp[14590] = 1073737664; +inp[14591] = 0; +inp[14592] = 1073737600; +inp[14593] = 0; +inp[14594] = 1073737536; +inp[14595] = 0; +inp[14596] = 1073737472; +inp[14597] = 0; +inp[14598] = 1073737408; +inp[14599] = 0; +inp[14600] = 1073737344; +inp[14601] = 0; +inp[14602] = 1073737280; +inp[14603] = 0; +inp[14604] = 1073737216; +inp[14605] = 0; +inp[14606] = 1073737152; +inp[14607] = 0; +inp[14608] = 1073737088; +inp[14609] = 0; +inp[14610] = 1073737024; +inp[14611] = 0; +inp[14612] = 1073736960; +inp[14613] = 0; +inp[14614] = 1073736896; +inp[14615] = 0; +inp[14616] = 1073736832; +inp[14617] = 0; +inp[14618] = 1073736768; +inp[14619] = 0; +inp[14620] = 1073736704; +inp[14621] = 0; +inp[14622] = 1073736640; +inp[14623] = 0; +inp[14624] = 1073736576; +inp[14625] = 0; +inp[14626] = 1073736512; +inp[14627] = 0; +inp[14628] = 1073736448; +inp[14629] = 0; +inp[14630] = 1073736384; +inp[14631] = 0; +inp[14632] = 1073736320; +inp[14633] = 0; +inp[14634] = 1073736256; +inp[14635] = 0; +inp[14636] = 1073736192; +inp[14637] = 0; +inp[14638] = 1073736128; +inp[14639] = 0; +inp[14640] = 1073736064; +inp[14641] = 0; +inp[14642] = 1073736000; +inp[14643] = 0; +inp[14644] = 1073735936; +inp[14645] = 0; +inp[14646] = 1073735872; +inp[14647] = 0; +inp[14648] = 1073735808; +inp[14649] = 0; +inp[14650] = 1073735744; +inp[14651] = 0; +inp[14652] = 1073735680; +inp[14653] = 0; +inp[14654] = 1073735616; +inp[14655] = 0; +inp[14656] = 1073735552; +inp[14657] = 0; +inp[14658] = 1073735488; +inp[14659] = 0; +inp[14660] = 1073735424; +inp[14661] = 0; +inp[14662] = 1073735360; +inp[14663] = 0; +inp[14664] = 1073735296; +inp[14665] = 0; +inp[14666] = 1073735232; +inp[14667] = 0; +inp[14668] = 1073735168; +inp[14669] = 0; +inp[14670] = 1073735104; +inp[14671] = 0; +inp[14672] = 1073735040; +inp[14673] = 0; +inp[14674] = 1073734976; +inp[14675] = 0; +inp[14676] = 1073734912; +inp[14677] = 0; +inp[14678] = 1073734848; +inp[14679] = 0; +inp[14680] = 1073734784; +inp[14681] = 0; +inp[14682] = 1073734720; +inp[14683] = 0; +inp[14684] = 1073734656; +inp[14685] = 0; +inp[14686] = 1073734592; +inp[14687] = 0; +inp[14688] = 1073734528; +inp[14689] = 0; +inp[14690] = 1073734464; +inp[14691] = 0; +inp[14692] = 1073734400; +inp[14693] = 0; +inp[14694] = 1073734336; +inp[14695] = 0; +inp[14696] = 1073734272; +inp[14697] = 0; +inp[14698] = 1073734208; +inp[14699] = 0; +inp[14700] = 1073734144; +inp[14701] = 0; +inp[14702] = 1073734080; +inp[14703] = 0; +inp[14704] = 1073734016; +inp[14705] = 0; +inp[14706] = 1073733952; +inp[14707] = 0; +inp[14708] = 1073733888; +inp[14709] = 0; +inp[14710] = 1073733824; +inp[14711] = 0; +inp[14712] = 1073733760; +inp[14713] = 0; +inp[14714] = 1073733696; +inp[14715] = 0; +inp[14716] = 1073741824; +inp[14717] = 1073741824; +inp[14718] = 1073741792; +inp[14719] = 0; +inp[14720] = 1073741760; +inp[14721] = 0; +inp[14722] = 1073741728; +inp[14723] = 0; +inp[14724] = 1073741696; +inp[14725] = 0; +inp[14726] = 1073741664; +inp[14727] = 0; +inp[14728] = 1073741632; +inp[14729] = 0; +inp[14730] = 1073741600; +inp[14731] = 0; +inp[14732] = 1073741568; +inp[14733] = 0; +inp[14734] = 1073741536; +inp[14735] = 0; +inp[14736] = 1073741504; +inp[14737] = 0; +inp[14738] = 1073741472; +inp[14739] = 0; +inp[14740] = 1073741440; +inp[14741] = 0; +inp[14742] = 1073741408; +inp[14743] = 0; +inp[14744] = 1073741376; +inp[14745] = 0; +inp[14746] = 1073741344; +inp[14747] = 0; +inp[14748] = 1073741312; +inp[14749] = 0; +inp[14750] = 1073741280; +inp[14751] = 0; +inp[14752] = 1073741248; +inp[14753] = 0; +inp[14754] = 1073741216; +inp[14755] = 0; +inp[14756] = 1073741184; +inp[14757] = 0; +inp[14758] = 1073741152; +inp[14759] = 0; +inp[14760] = 1073741120; +inp[14761] = 0; +inp[14762] = 1073741088; +inp[14763] = 0; +inp[14764] = 1073741056; +inp[14765] = 0; +inp[14766] = 1073741024; +inp[14767] = 0; +inp[14768] = 1073740992; +inp[14769] = 0; +inp[14770] = 1073740960; +inp[14771] = 0; +inp[14772] = 1073740928; +inp[14773] = 0; +inp[14774] = 1073740896; +inp[14775] = 0; +inp[14776] = 1073740864; +inp[14777] = 0; +inp[14778] = 1073740832; +inp[14779] = 0; +inp[14780] = 1073740800; +inp[14781] = 0; +inp[14782] = 1073740768; +inp[14783] = 0; +inp[14784] = 1073740736; +inp[14785] = 0; +inp[14786] = 1073740704; +inp[14787] = 0; +inp[14788] = 1073740672; +inp[14789] = 0; +inp[14790] = 1073740640; +inp[14791] = 0; +inp[14792] = 1073740608; +inp[14793] = 0; +inp[14794] = 1073740576; +inp[14795] = 0; +inp[14796] = 1073740544; +inp[14797] = 0; +inp[14798] = 1073740512; +inp[14799] = 0; +inp[14800] = 1073740480; +inp[14801] = 0; +inp[14802] = 1073740448; +inp[14803] = 0; +inp[14804] = 1073740416; +inp[14805] = 0; +inp[14806] = 1073740384; +inp[14807] = 0; +inp[14808] = 1073740352; +inp[14809] = 0; +inp[14810] = 1073740320; +inp[14811] = 0; +inp[14812] = 1073740288; +inp[14813] = 0; +inp[14814] = 1073740256; +inp[14815] = 0; +inp[14816] = 1073740224; +inp[14817] = 0; +inp[14818] = 1073740192; +inp[14819] = 0; +inp[14820] = 1073740160; +inp[14821] = 0; +inp[14822] = 1073740128; +inp[14823] = 0; +inp[14824] = 1073740096; +inp[14825] = 0; +inp[14826] = 1073740064; +inp[14827] = 0; +inp[14828] = 1073740032; +inp[14829] = 0; +inp[14830] = 1073740000; +inp[14831] = 0; +inp[14832] = 1073739968; +inp[14833] = 0; +inp[14834] = 1073739936; +inp[14835] = 0; +inp[14836] = 1073739904; +inp[14837] = 0; +inp[14838] = 1073739872; +inp[14839] = 0; +inp[14840] = 1073739840; +inp[14841] = 0; +inp[14842] = 1073739808; +inp[14843] = 0; +inp[14844] = 1073739776; +inp[14845] = 0; +inp[14846] = 1073739744; +inp[14847] = 0; +inp[14848] = 1073739712; +inp[14849] = 0; +inp[14850] = 1073739680; +inp[14851] = 0; +inp[14852] = 1073739648; +inp[14853] = 0; +inp[14854] = 1073739616; +inp[14855] = 0; +inp[14856] = 1073739584; +inp[14857] = 0; +inp[14858] = 1073739552; +inp[14859] = 0; +inp[14860] = 1073739520; +inp[14861] = 0; +inp[14862] = 1073739488; +inp[14863] = 0; +inp[14864] = 1073739456; +inp[14865] = 0; +inp[14866] = 1073739424; +inp[14867] = 0; +inp[14868] = 1073739392; +inp[14869] = 0; +inp[14870] = 1073739360; +inp[14871] = 0; +inp[14872] = 1073739328; +inp[14873] = 0; +inp[14874] = 1073739296; +inp[14875] = 0; +inp[14876] = 1073739264; +inp[14877] = 0; +inp[14878] = 1073739232; +inp[14879] = 0; +inp[14880] = 1073739200; +inp[14881] = 0; +inp[14882] = 1073739168; +inp[14883] = 0; +inp[14884] = 1073739136; +inp[14885] = 0; +inp[14886] = 1073739104; +inp[14887] = 0; +inp[14888] = 1073739072; +inp[14889] = 0; +inp[14890] = 1073739040; +inp[14891] = 0; +inp[14892] = 1073739008; +inp[14893] = 0; +inp[14894] = 1073738976; +inp[14895] = 0; +inp[14896] = 1073738944; +inp[14897] = 0; +inp[14898] = 1073738912; +inp[14899] = 0; +inp[14900] = 1073738880; +inp[14901] = 0; +inp[14902] = 1073738848; +inp[14903] = 0; +inp[14904] = 1073738816; +inp[14905] = 0; +inp[14906] = 1073738784; +inp[14907] = 0; +inp[14908] = 1073738752; +inp[14909] = 0; +inp[14910] = 1073738720; +inp[14911] = 0; +inp[14912] = 1073738688; +inp[14913] = 0; +inp[14914] = 1073738656; +inp[14915] = 0; +inp[14916] = 1073738624; +inp[14917] = 0; +inp[14918] = 1073738592; +inp[14919] = 0; +inp[14920] = 1073738560; +inp[14921] = 0; +inp[14922] = 1073738528; +inp[14923] = 0; +inp[14924] = 1073738496; +inp[14925] = 0; +inp[14926] = 1073738464; +inp[14927] = 0; +inp[14928] = 1073738432; +inp[14929] = 0; +inp[14930] = 1073738400; +inp[14931] = 0; +inp[14932] = 1073738368; +inp[14933] = 0; +inp[14934] = 1073738336; +inp[14935] = 0; +inp[14936] = 1073738304; +inp[14937] = 0; +inp[14938] = 1073738272; +inp[14939] = 0; +inp[14940] = 1073738240; +inp[14941] = 0; +inp[14942] = 1073738208; +inp[14943] = 0; +inp[14944] = 1073738176; +inp[14945] = 0; +inp[14946] = 1073738144; +inp[14947] = 0; +inp[14948] = 1073738112; +inp[14949] = 0; +inp[14950] = 1073738080; +inp[14951] = 0; +inp[14952] = 1073738048; +inp[14953] = 0; +inp[14954] = 1073738016; +inp[14955] = 0; +inp[14956] = 1073737984; +inp[14957] = 0; +inp[14958] = 1073737952; +inp[14959] = 0; +inp[14960] = 1073737920; +inp[14961] = 0; +inp[14962] = 1073737888; +inp[14963] = 0; +inp[14964] = 1073737856; +inp[14965] = 0; +inp[14966] = 1073737824; +inp[14967] = 0; +inp[14968] = 1073737792; +inp[14969] = 0; +inp[14970] = 1073737760; +inp[14971] = 0; +inp[14972] = 1073741824; +inp[14973] = 1073741824; +inp[14974] = 1073741808; +inp[14975] = 0; +inp[14976] = 1073741792; +inp[14977] = 0; +inp[14978] = 1073741776; +inp[14979] = 0; +inp[14980] = 1073741760; +inp[14981] = 0; +inp[14982] = 1073741744; +inp[14983] = 0; +inp[14984] = 1073741728; +inp[14985] = 0; +inp[14986] = 1073741712; +inp[14987] = 0; +inp[14988] = 1073741696; +inp[14989] = 0; +inp[14990] = 1073741680; +inp[14991] = 0; +inp[14992] = 1073741664; +inp[14993] = 0; +inp[14994] = 1073741648; +inp[14995] = 0; +inp[14996] = 1073741632; +inp[14997] = 0; +inp[14998] = 1073741616; +inp[14999] = 0; +inp[15000] = 1073741600; +inp[15001] = 0; +inp[15002] = 1073741584; +inp[15003] = 0; +inp[15004] = 1073741568; +inp[15005] = 0; +inp[15006] = 1073741552; +inp[15007] = 0; +inp[15008] = 1073741536; +inp[15009] = 0; +inp[15010] = 1073741520; +inp[15011] = 0; +inp[15012] = 1073741504; +inp[15013] = 0; +inp[15014] = 1073741488; +inp[15015] = 0; +inp[15016] = 1073741472; +inp[15017] = 0; +inp[15018] = 1073741456; +inp[15019] = 0; +inp[15020] = 1073741440; +inp[15021] = 0; +inp[15022] = 1073741424; +inp[15023] = 0; +inp[15024] = 1073741408; +inp[15025] = 0; +inp[15026] = 1073741392; +inp[15027] = 0; +inp[15028] = 1073741376; +inp[15029] = 0; +inp[15030] = 1073741360; +inp[15031] = 0; +inp[15032] = 1073741344; +inp[15033] = 0; +inp[15034] = 1073741328; +inp[15035] = 0; +inp[15036] = 1073741312; +inp[15037] = 0; +inp[15038] = 1073741296; +inp[15039] = 0; +inp[15040] = 1073741280; +inp[15041] = 0; +inp[15042] = 1073741264; +inp[15043] = 0; +inp[15044] = 1073741248; +inp[15045] = 0; +inp[15046] = 1073741232; +inp[15047] = 0; +inp[15048] = 1073741216; +inp[15049] = 0; +inp[15050] = 1073741200; +inp[15051] = 0; +inp[15052] = 1073741184; +inp[15053] = 0; +inp[15054] = 1073741168; +inp[15055] = 0; +inp[15056] = 1073741152; +inp[15057] = 0; +inp[15058] = 1073741136; +inp[15059] = 0; +inp[15060] = 1073741120; +inp[15061] = 0; +inp[15062] = 1073741104; +inp[15063] = 0; +inp[15064] = 1073741088; +inp[15065] = 0; +inp[15066] = 1073741072; +inp[15067] = 0; +inp[15068] = 1073741056; +inp[15069] = 0; +inp[15070] = 1073741040; +inp[15071] = 0; +inp[15072] = 1073741024; +inp[15073] = 0; +inp[15074] = 1073741008; +inp[15075] = 0; +inp[15076] = 1073740992; +inp[15077] = 0; +inp[15078] = 1073740976; +inp[15079] = 0; +inp[15080] = 1073740960; +inp[15081] = 0; +inp[15082] = 1073740944; +inp[15083] = 0; +inp[15084] = 1073740928; +inp[15085] = 0; +inp[15086] = 1073740912; +inp[15087] = 0; +inp[15088] = 1073740896; +inp[15089] = 0; +inp[15090] = 1073740880; +inp[15091] = 0; +inp[15092] = 1073740864; +inp[15093] = 0; +inp[15094] = 1073740848; +inp[15095] = 0; +inp[15096] = 1073740832; +inp[15097] = 0; +inp[15098] = 1073740816; +inp[15099] = 0; +inp[15100] = 1073740800; +inp[15101] = 0; +inp[15102] = 1073740784; +inp[15103] = 0; +inp[15104] = 1073740768; +inp[15105] = 0; +inp[15106] = 1073740752; +inp[15107] = 0; +inp[15108] = 1073740736; +inp[15109] = 0; +inp[15110] = 1073740720; +inp[15111] = 0; +inp[15112] = 1073740704; +inp[15113] = 0; +inp[15114] = 1073740688; +inp[15115] = 0; +inp[15116] = 1073740672; +inp[15117] = 0; +inp[15118] = 1073740656; +inp[15119] = 0; +inp[15120] = 1073740640; +inp[15121] = 0; +inp[15122] = 1073740624; +inp[15123] = 0; +inp[15124] = 1073740608; +inp[15125] = 0; +inp[15126] = 1073740592; +inp[15127] = 0; +inp[15128] = 1073740576; +inp[15129] = 0; +inp[15130] = 1073740560; +inp[15131] = 0; +inp[15132] = 1073740544; +inp[15133] = 0; +inp[15134] = 1073740528; +inp[15135] = 0; +inp[15136] = 1073740512; +inp[15137] = 0; +inp[15138] = 1073740496; +inp[15139] = 0; +inp[15140] = 1073740480; +inp[15141] = 0; +inp[15142] = 1073740464; +inp[15143] = 0; +inp[15144] = 1073740448; +inp[15145] = 0; +inp[15146] = 1073740432; +inp[15147] = 0; +inp[15148] = 1073740416; +inp[15149] = 0; +inp[15150] = 1073740400; +inp[15151] = 0; +inp[15152] = 1073740384; +inp[15153] = 0; +inp[15154] = 1073740368; +inp[15155] = 0; +inp[15156] = 1073740352; +inp[15157] = 0; +inp[15158] = 1073740336; +inp[15159] = 0; +inp[15160] = 1073740320; +inp[15161] = 0; +inp[15162] = 1073740304; +inp[15163] = 0; +inp[15164] = 1073740288; +inp[15165] = 0; +inp[15166] = 1073740272; +inp[15167] = 0; +inp[15168] = 1073740256; +inp[15169] = 0; +inp[15170] = 1073740240; +inp[15171] = 0; +inp[15172] = 1073740224; +inp[15173] = 0; +inp[15174] = 1073740208; +inp[15175] = 0; +inp[15176] = 1073740192; +inp[15177] = 0; +inp[15178] = 1073740176; +inp[15179] = 0; +inp[15180] = 1073740160; +inp[15181] = 0; +inp[15182] = 1073740144; +inp[15183] = 0; +inp[15184] = 1073740128; +inp[15185] = 0; +inp[15186] = 1073740112; +inp[15187] = 0; +inp[15188] = 1073740096; +inp[15189] = 0; +inp[15190] = 1073740080; +inp[15191] = 0; +inp[15192] = 1073740064; +inp[15193] = 0; +inp[15194] = 1073740048; +inp[15195] = 0; +inp[15196] = 1073740032; +inp[15197] = 0; +inp[15198] = 1073740016; +inp[15199] = 0; +inp[15200] = 1073740000; +inp[15201] = 0; +inp[15202] = 1073739984; +inp[15203] = 0; +inp[15204] = 1073739968; +inp[15205] = 0; +inp[15206] = 1073739952; +inp[15207] = 0; +inp[15208] = 1073739936; +inp[15209] = 0; +inp[15210] = 1073739920; +inp[15211] = 0; +inp[15212] = 1073739904; +inp[15213] = 0; +inp[15214] = 1073739888; +inp[15215] = 0; +inp[15216] = 1073739872; +inp[15217] = 0; +inp[15218] = 1073739856; +inp[15219] = 0; +inp[15220] = 1073739840; +inp[15221] = 0; +inp[15222] = 1073739824; +inp[15223] = 0; +inp[15224] = 1073739808; +inp[15225] = 0; +inp[15226] = 1073739792; +inp[15227] = 0; +inp[15228] = 1073741824; +inp[15229] = 1073741824; +inp[15230] = 1073741816; +inp[15231] = 0; +inp[15232] = 1073741808; +inp[15233] = 0; +inp[15234] = 1073741800; +inp[15235] = 0; +inp[15236] = 1073741792; +inp[15237] = 0; +inp[15238] = 1073741784; +inp[15239] = 0; +inp[15240] = 1073741776; +inp[15241] = 0; +inp[15242] = 1073741768; +inp[15243] = 0; +inp[15244] = 1073741760; +inp[15245] = 0; +inp[15246] = 1073741752; +inp[15247] = 0; +inp[15248] = 1073741744; +inp[15249] = 0; +inp[15250] = 1073741736; +inp[15251] = 0; +inp[15252] = 1073741728; +inp[15253] = 0; +inp[15254] = 1073741720; +inp[15255] = 0; +inp[15256] = 1073741712; +inp[15257] = 0; +inp[15258] = 1073741704; +inp[15259] = 0; +inp[15260] = 1073741696; +inp[15261] = 0; +inp[15262] = 1073741688; +inp[15263] = 0; +inp[15264] = 1073741680; +inp[15265] = 0; +inp[15266] = 1073741672; +inp[15267] = 0; +inp[15268] = 1073741664; +inp[15269] = 0; +inp[15270] = 1073741656; +inp[15271] = 0; +inp[15272] = 1073741648; +inp[15273] = 0; +inp[15274] = 1073741640; +inp[15275] = 0; +inp[15276] = 1073741632; +inp[15277] = 0; +inp[15278] = 1073741624; +inp[15279] = 0; +inp[15280] = 1073741616; +inp[15281] = 0; +inp[15282] = 1073741608; +inp[15283] = 0; +inp[15284] = 1073741600; +inp[15285] = 0; +inp[15286] = 1073741592; +inp[15287] = 0; +inp[15288] = 1073741584; +inp[15289] = 0; +inp[15290] = 1073741576; +inp[15291] = 0; +inp[15292] = 1073741568; +inp[15293] = 0; +inp[15294] = 1073741560; +inp[15295] = 0; +inp[15296] = 1073741552; +inp[15297] = 0; +inp[15298] = 1073741544; +inp[15299] = 0; +inp[15300] = 1073741536; +inp[15301] = 0; +inp[15302] = 1073741528; +inp[15303] = 0; +inp[15304] = 1073741520; +inp[15305] = 0; +inp[15306] = 1073741512; +inp[15307] = 0; +inp[15308] = 1073741504; +inp[15309] = 0; +inp[15310] = 1073741496; +inp[15311] = 0; +inp[15312] = 1073741488; +inp[15313] = 0; +inp[15314] = 1073741480; +inp[15315] = 0; +inp[15316] = 1073741472; +inp[15317] = 0; +inp[15318] = 1073741464; +inp[15319] = 0; +inp[15320] = 1073741456; +inp[15321] = 0; +inp[15322] = 1073741448; +inp[15323] = 0; +inp[15324] = 1073741440; +inp[15325] = 0; +inp[15326] = 1073741432; +inp[15327] = 0; +inp[15328] = 1073741424; +inp[15329] = 0; +inp[15330] = 1073741416; +inp[15331] = 0; +inp[15332] = 1073741408; +inp[15333] = 0; +inp[15334] = 1073741400; +inp[15335] = 0; +inp[15336] = 1073741392; +inp[15337] = 0; +inp[15338] = 1073741384; +inp[15339] = 0; +inp[15340] = 1073741376; +inp[15341] = 0; +inp[15342] = 1073741368; +inp[15343] = 0; +inp[15344] = 1073741360; +inp[15345] = 0; +inp[15346] = 1073741352; +inp[15347] = 0; +inp[15348] = 1073741344; +inp[15349] = 0; +inp[15350] = 1073741336; +inp[15351] = 0; +inp[15352] = 1073741328; +inp[15353] = 0; +inp[15354] = 1073741320; +inp[15355] = 0; +inp[15356] = 1073741312; +inp[15357] = 0; +inp[15358] = 1073741304; +inp[15359] = 0; +inp[15360] = 1073741296; +inp[15361] = 0; +inp[15362] = 1073741288; +inp[15363] = 0; +inp[15364] = 1073741280; +inp[15365] = 0; +inp[15366] = 1073741272; +inp[15367] = 0; +inp[15368] = 1073741264; +inp[15369] = 0; +inp[15370] = 1073741256; +inp[15371] = 0; +inp[15372] = 1073741248; +inp[15373] = 0; +inp[15374] = 1073741240; +inp[15375] = 0; +inp[15376] = 1073741232; +inp[15377] = 0; +inp[15378] = 1073741224; +inp[15379] = 0; +inp[15380] = 1073741216; +inp[15381] = 0; +inp[15382] = 1073741208; +inp[15383] = 0; +inp[15384] = 1073741200; +inp[15385] = 0; +inp[15386] = 1073741192; +inp[15387] = 0; +inp[15388] = 1073741184; +inp[15389] = 0; +inp[15390] = 1073741176; +inp[15391] = 0; +inp[15392] = 1073741168; +inp[15393] = 0; +inp[15394] = 1073741160; +inp[15395] = 0; +inp[15396] = 1073741152; +inp[15397] = 0; +inp[15398] = 1073741144; +inp[15399] = 0; +inp[15400] = 1073741136; +inp[15401] = 0; +inp[15402] = 1073741128; +inp[15403] = 0; +inp[15404] = 1073741120; +inp[15405] = 0; +inp[15406] = 1073741112; +inp[15407] = 0; +inp[15408] = 1073741104; +inp[15409] = 0; +inp[15410] = 1073741096; +inp[15411] = 0; +inp[15412] = 1073741088; +inp[15413] = 0; +inp[15414] = 1073741080; +inp[15415] = 0; +inp[15416] = 1073741072; +inp[15417] = 0; +inp[15418] = 1073741064; +inp[15419] = 0; +inp[15420] = 1073741056; +inp[15421] = 0; +inp[15422] = 1073741048; +inp[15423] = 0; +inp[15424] = 1073741040; +inp[15425] = 0; +inp[15426] = 1073741032; +inp[15427] = 0; +inp[15428] = 1073741024; +inp[15429] = 0; +inp[15430] = 1073741016; +inp[15431] = 0; +inp[15432] = 1073741008; +inp[15433] = 0; +inp[15434] = 1073741000; +inp[15435] = 0; +inp[15436] = 1073740992; +inp[15437] = 0; +inp[15438] = 1073740984; +inp[15439] = 0; +inp[15440] = 1073740976; +inp[15441] = 0; +inp[15442] = 1073740968; +inp[15443] = 0; +inp[15444] = 1073740960; +inp[15445] = 0; +inp[15446] = 1073740952; +inp[15447] = 0; +inp[15448] = 1073740944; +inp[15449] = 0; +inp[15450] = 1073740936; +inp[15451] = 0; +inp[15452] = 1073740928; +inp[15453] = 0; +inp[15454] = 1073740920; +inp[15455] = 0; +inp[15456] = 1073740912; +inp[15457] = 0; +inp[15458] = 1073740904; +inp[15459] = 0; +inp[15460] = 1073740896; +inp[15461] = 0; +inp[15462] = 1073740888; +inp[15463] = 0; +inp[15464] = 1073740880; +inp[15465] = 0; +inp[15466] = 1073740872; +inp[15467] = 0; +inp[15468] = 1073740864; +inp[15469] = 0; +inp[15470] = 1073740856; +inp[15471] = 0; +inp[15472] = 1073740848; +inp[15473] = 0; +inp[15474] = 1073740840; +inp[15475] = 0; +inp[15476] = 1073740832; +inp[15477] = 0; +inp[15478] = 1073740824; +inp[15479] = 0; +inp[15480] = 1073740816; +inp[15481] = 0; +inp[15482] = 1073740808; +inp[15483] = 0; +inp[15484] = 1073741824; +inp[15485] = 1073741824; +inp[15486] = 1073741820; +inp[15487] = 0; +inp[15488] = 1073741816; +inp[15489] = 0; +inp[15490] = 1073741812; +inp[15491] = 0; +inp[15492] = 1073741808; +inp[15493] = 0; +inp[15494] = 1073741804; +inp[15495] = 0; +inp[15496] = 1073741800; +inp[15497] = 0; +inp[15498] = 1073741796; +inp[15499] = 0; +inp[15500] = 1073741792; +inp[15501] = 0; +inp[15502] = 1073741788; +inp[15503] = 0; +inp[15504] = 1073741784; +inp[15505] = 0; +inp[15506] = 1073741780; +inp[15507] = 0; +inp[15508] = 1073741776; +inp[15509] = 0; +inp[15510] = 1073741772; +inp[15511] = 0; +inp[15512] = 1073741768; +inp[15513] = 0; +inp[15514] = 1073741764; +inp[15515] = 0; +inp[15516] = 1073741760; +inp[15517] = 0; +inp[15518] = 1073741756; +inp[15519] = 0; +inp[15520] = 1073741752; +inp[15521] = 0; +inp[15522] = 1073741748; +inp[15523] = 0; +inp[15524] = 1073741744; +inp[15525] = 0; +inp[15526] = 1073741740; +inp[15527] = 0; +inp[15528] = 1073741736; +inp[15529] = 0; +inp[15530] = 1073741732; +inp[15531] = 0; +inp[15532] = 1073741728; +inp[15533] = 0; +inp[15534] = 1073741724; +inp[15535] = 0; +inp[15536] = 1073741720; +inp[15537] = 0; +inp[15538] = 1073741716; +inp[15539] = 0; +inp[15540] = 1073741712; +inp[15541] = 0; +inp[15542] = 1073741708; +inp[15543] = 0; +inp[15544] = 1073741704; +inp[15545] = 0; +inp[15546] = 1073741700; +inp[15547] = 0; +inp[15548] = 1073741696; +inp[15549] = 0; +inp[15550] = 1073741692; +inp[15551] = 0; +inp[15552] = 1073741688; +inp[15553] = 0; +inp[15554] = 1073741684; +inp[15555] = 0; +inp[15556] = 1073741680; +inp[15557] = 0; +inp[15558] = 1073741676; +inp[15559] = 0; +inp[15560] = 1073741672; +inp[15561] = 0; +inp[15562] = 1073741668; +inp[15563] = 0; +inp[15564] = 1073741664; +inp[15565] = 0; +inp[15566] = 1073741660; +inp[15567] = 0; +inp[15568] = 1073741656; +inp[15569] = 0; +inp[15570] = 1073741652; +inp[15571] = 0; +inp[15572] = 1073741648; +inp[15573] = 0; +inp[15574] = 1073741644; +inp[15575] = 0; +inp[15576] = 1073741640; +inp[15577] = 0; +inp[15578] = 1073741636; +inp[15579] = 0; +inp[15580] = 1073741632; +inp[15581] = 0; +inp[15582] = 1073741628; +inp[15583] = 0; +inp[15584] = 1073741624; +inp[15585] = 0; +inp[15586] = 1073741620; +inp[15587] = 0; +inp[15588] = 1073741616; +inp[15589] = 0; +inp[15590] = 1073741612; +inp[15591] = 0; +inp[15592] = 1073741608; +inp[15593] = 0; +inp[15594] = 1073741604; +inp[15595] = 0; +inp[15596] = 1073741600; +inp[15597] = 0; +inp[15598] = 1073741596; +inp[15599] = 0; +inp[15600] = 1073741592; +inp[15601] = 0; +inp[15602] = 1073741588; +inp[15603] = 0; +inp[15604] = 1073741584; +inp[15605] = 0; +inp[15606] = 1073741580; +inp[15607] = 0; +inp[15608] = 1073741576; +inp[15609] = 0; +inp[15610] = 1073741572; +inp[15611] = 0; +inp[15612] = 1073741568; +inp[15613] = 0; +inp[15614] = 1073741564; +inp[15615] = 0; +inp[15616] = 1073741560; +inp[15617] = 0; +inp[15618] = 1073741556; +inp[15619] = 0; +inp[15620] = 1073741552; +inp[15621] = 0; +inp[15622] = 1073741548; +inp[15623] = 0; +inp[15624] = 1073741544; +inp[15625] = 0; +inp[15626] = 1073741540; +inp[15627] = 0; +inp[15628] = 1073741536; +inp[15629] = 0; +inp[15630] = 1073741532; +inp[15631] = 0; +inp[15632] = 1073741528; +inp[15633] = 0; +inp[15634] = 1073741524; +inp[15635] = 0; +inp[15636] = 1073741520; +inp[15637] = 0; +inp[15638] = 1073741516; +inp[15639] = 0; +inp[15640] = 1073741512; +inp[15641] = 0; +inp[15642] = 1073741508; +inp[15643] = 0; +inp[15644] = 1073741504; +inp[15645] = 0; +inp[15646] = 1073741500; +inp[15647] = 0; +inp[15648] = 1073741496; +inp[15649] = 0; +inp[15650] = 1073741492; +inp[15651] = 0; +inp[15652] = 1073741488; +inp[15653] = 0; +inp[15654] = 1073741484; +inp[15655] = 0; +inp[15656] = 1073741480; +inp[15657] = 0; +inp[15658] = 1073741476; +inp[15659] = 0; +inp[15660] = 1073741472; +inp[15661] = 0; +inp[15662] = 1073741468; +inp[15663] = 0; +inp[15664] = 1073741464; +inp[15665] = 0; +inp[15666] = 1073741460; +inp[15667] = 0; +inp[15668] = 1073741456; +inp[15669] = 0; +inp[15670] = 1073741452; +inp[15671] = 0; +inp[15672] = 1073741448; +inp[15673] = 0; +inp[15674] = 1073741444; +inp[15675] = 0; +inp[15676] = 1073741440; +inp[15677] = 0; +inp[15678] = 1073741436; +inp[15679] = 0; +inp[15680] = 1073741432; +inp[15681] = 0; +inp[15682] = 1073741428; +inp[15683] = 0; +inp[15684] = 1073741424; +inp[15685] = 0; +inp[15686] = 1073741420; +inp[15687] = 0; +inp[15688] = 1073741416; +inp[15689] = 0; +inp[15690] = 1073741412; +inp[15691] = 0; +inp[15692] = 1073741408; +inp[15693] = 0; +inp[15694] = 1073741404; +inp[15695] = 0; +inp[15696] = 1073741400; +inp[15697] = 0; +inp[15698] = 1073741396; +inp[15699] = 0; +inp[15700] = 1073741392; +inp[15701] = 0; +inp[15702] = 1073741388; +inp[15703] = 0; +inp[15704] = 1073741384; +inp[15705] = 0; +inp[15706] = 1073741380; +inp[15707] = 0; +inp[15708] = 1073741376; +inp[15709] = 0; +inp[15710] = 1073741372; +inp[15711] = 0; +inp[15712] = 1073741368; +inp[15713] = 0; +inp[15714] = 1073741364; +inp[15715] = 0; +inp[15716] = 1073741360; +inp[15717] = 0; +inp[15718] = 1073741356; +inp[15719] = 0; +inp[15720] = 1073741352; +inp[15721] = 0; +inp[15722] = 1073741348; +inp[15723] = 0; +inp[15724] = 1073741344; +inp[15725] = 0; +inp[15726] = 1073741340; +inp[15727] = 0; +inp[15728] = 1073741336; +inp[15729] = 0; +inp[15730] = 1073741332; +inp[15731] = 0; +inp[15732] = 1073741328; +inp[15733] = 0; +inp[15734] = 1073741324; +inp[15735] = 0; +inp[15736] = 1073741320; +inp[15737] = 0; +inp[15738] = 1073741316; +inp[15739] = 0; +inp[15740] = 1073741824; +inp[15741] = 1073741824; +inp[15742] = 1073741822; +inp[15743] = 0; +inp[15744] = 1073741820; +inp[15745] = 0; +inp[15746] = 1073741818; +inp[15747] = 0; +inp[15748] = 1073741816; +inp[15749] = 0; +inp[15750] = 1073741814; +inp[15751] = 0; +inp[15752] = 1073741812; +inp[15753] = 0; +inp[15754] = 1073741810; +inp[15755] = 0; +inp[15756] = 1073741808; +inp[15757] = 0; +inp[15758] = 1073741806; +inp[15759] = 0; +inp[15760] = 1073741804; +inp[15761] = 0; +inp[15762] = 1073741802; +inp[15763] = 0; +inp[15764] = 1073741800; +inp[15765] = 0; +inp[15766] = 1073741798; +inp[15767] = 0; +inp[15768] = 1073741796; +inp[15769] = 0; +inp[15770] = 1073741794; +inp[15771] = 0; +inp[15772] = 1073741792; +inp[15773] = 0; +inp[15774] = 1073741790; +inp[15775] = 0; +inp[15776] = 1073741788; +inp[15777] = 0; +inp[15778] = 1073741786; +inp[15779] = 0; +inp[15780] = 1073741784; +inp[15781] = 0; +inp[15782] = 1073741782; +inp[15783] = 0; +inp[15784] = 1073741780; +inp[15785] = 0; +inp[15786] = 1073741778; +inp[15787] = 0; +inp[15788] = 1073741776; +inp[15789] = 0; +inp[15790] = 1073741774; +inp[15791] = 0; +inp[15792] = 1073741772; +inp[15793] = 0; +inp[15794] = 1073741770; +inp[15795] = 0; +inp[15796] = 1073741768; +inp[15797] = 0; +inp[15798] = 1073741766; +inp[15799] = 0; +inp[15800] = 1073741764; +inp[15801] = 0; +inp[15802] = 1073741762; +inp[15803] = 0; +inp[15804] = 1073741760; +inp[15805] = 0; +inp[15806] = 1073741758; +inp[15807] = 0; +inp[15808] = 1073741756; +inp[15809] = 0; +inp[15810] = 1073741754; +inp[15811] = 0; +inp[15812] = 1073741752; +inp[15813] = 0; +inp[15814] = 1073741750; +inp[15815] = 0; +inp[15816] = 1073741748; +inp[15817] = 0; +inp[15818] = 1073741746; +inp[15819] = 0; +inp[15820] = 1073741744; +inp[15821] = 0; +inp[15822] = 1073741742; +inp[15823] = 0; +inp[15824] = 1073741740; +inp[15825] = 0; +inp[15826] = 1073741738; +inp[15827] = 0; +inp[15828] = 1073741736; +inp[15829] = 0; +inp[15830] = 1073741734; +inp[15831] = 0; +inp[15832] = 1073741732; +inp[15833] = 0; +inp[15834] = 1073741730; +inp[15835] = 0; +inp[15836] = 1073741728; +inp[15837] = 0; +inp[15838] = 1073741726; +inp[15839] = 0; +inp[15840] = 1073741724; +inp[15841] = 0; +inp[15842] = 1073741722; +inp[15843] = 0; +inp[15844] = 1073741720; +inp[15845] = 0; +inp[15846] = 1073741718; +inp[15847] = 0; +inp[15848] = 1073741716; +inp[15849] = 0; +inp[15850] = 1073741714; +inp[15851] = 0; +inp[15852] = 1073741712; +inp[15853] = 0; +inp[15854] = 1073741710; +inp[15855] = 0; +inp[15856] = 1073741708; +inp[15857] = 0; +inp[15858] = 1073741706; +inp[15859] = 0; +inp[15860] = 1073741704; +inp[15861] = 0; +inp[15862] = 1073741702; +inp[15863] = 0; +inp[15864] = 1073741700; +inp[15865] = 0; +inp[15866] = 1073741698; +inp[15867] = 0; +inp[15868] = 1073741696; +inp[15869] = 0; +inp[15870] = 1073741694; +inp[15871] = 0; +inp[15872] = 1073741692; +inp[15873] = 0; +inp[15874] = 1073741690; +inp[15875] = 0; +inp[15876] = 1073741688; +inp[15877] = 0; +inp[15878] = 1073741686; +inp[15879] = 0; +inp[15880] = 1073741684; +inp[15881] = 0; +inp[15882] = 1073741682; +inp[15883] = 0; +inp[15884] = 1073741680; +inp[15885] = 0; +inp[15886] = 1073741678; +inp[15887] = 0; +inp[15888] = 1073741676; +inp[15889] = 0; +inp[15890] = 1073741674; +inp[15891] = 0; +inp[15892] = 1073741672; +inp[15893] = 0; +inp[15894] = 1073741670; +inp[15895] = 0; +inp[15896] = 1073741668; +inp[15897] = 0; +inp[15898] = 1073741666; +inp[15899] = 0; +inp[15900] = 1073741664; +inp[15901] = 0; +inp[15902] = 1073741662; +inp[15903] = 0; +inp[15904] = 1073741660; +inp[15905] = 0; +inp[15906] = 1073741658; +inp[15907] = 0; +inp[15908] = 1073741656; +inp[15909] = 0; +inp[15910] = 1073741654; +inp[15911] = 0; +inp[15912] = 1073741652; +inp[15913] = 0; +inp[15914] = 1073741650; +inp[15915] = 0; +inp[15916] = 1073741648; +inp[15917] = 0; +inp[15918] = 1073741646; +inp[15919] = 0; +inp[15920] = 1073741644; +inp[15921] = 0; +inp[15922] = 1073741642; +inp[15923] = 0; +inp[15924] = 1073741640; +inp[15925] = 0; +inp[15926] = 1073741638; +inp[15927] = 0; +inp[15928] = 1073741636; +inp[15929] = 0; +inp[15930] = 1073741634; +inp[15931] = 0; +inp[15932] = 1073741632; +inp[15933] = 0; +inp[15934] = 1073741630; +inp[15935] = 0; +inp[15936] = 1073741628; +inp[15937] = 0; +inp[15938] = 1073741626; +inp[15939] = 0; +inp[15940] = 1073741624; +inp[15941] = 0; +inp[15942] = 1073741622; +inp[15943] = 0; +inp[15944] = 1073741620; +inp[15945] = 0; +inp[15946] = 1073741618; +inp[15947] = 0; +inp[15948] = 1073741616; +inp[15949] = 0; +inp[15950] = 1073741614; +inp[15951] = 0; +inp[15952] = 1073741612; +inp[15953] = 0; +inp[15954] = 1073741610; +inp[15955] = 0; +inp[15956] = 1073741608; +inp[15957] = 0; +inp[15958] = 1073741606; +inp[15959] = 0; +inp[15960] = 1073741604; +inp[15961] = 0; +inp[15962] = 1073741602; +inp[15963] = 0; +inp[15964] = 1073741600; +inp[15965] = 0; +inp[15966] = 1073741598; +inp[15967] = 0; +inp[15968] = 1073741596; +inp[15969] = 0; +inp[15970] = 1073741594; +inp[15971] = 0; +inp[15972] = 1073741592; +inp[15973] = 0; +inp[15974] = 1073741590; +inp[15975] = 0; +inp[15976] = 1073741588; +inp[15977] = 0; +inp[15978] = 1073741586; +inp[15979] = 0; +inp[15980] = 1073741584; +inp[15981] = 0; +inp[15982] = 1073741582; +inp[15983] = 0; +inp[15984] = 1073741580; +inp[15985] = 0; +inp[15986] = 1073741578; +inp[15987] = 0; +inp[15988] = 1073741576; +inp[15989] = 0; +inp[15990] = 1073741574; +inp[15991] = 0; +inp[15992] = 1073741572; +inp[15993] = 0; +inp[15994] = 1073741570; +inp[15995] = 0; +inp[15996] = 1073741824; +inp[15997] = 1073741824; +inp[15998] = 1073741823; +inp[15999] = 0; +inp[16000] = 1073741822; +inp[16001] = 0; +inp[16002] = 1073741821; +inp[16003] = 0; +inp[16004] = 1073741820; +inp[16005] = 0; +inp[16006] = 1073741819; +inp[16007] = 0; +inp[16008] = 1073741818; +inp[16009] = 0; +inp[16010] = 1073741817; +inp[16011] = 0; +inp[16012] = 1073741816; +inp[16013] = 0; +inp[16014] = 1073741815; +inp[16015] = 0; +inp[16016] = 1073741814; +inp[16017] = 0; +inp[16018] = 1073741813; +inp[16019] = 0; +inp[16020] = 1073741812; +inp[16021] = 0; +inp[16022] = 1073741811; +inp[16023] = 0; +inp[16024] = 1073741810; +inp[16025] = 0; +inp[16026] = 1073741809; +inp[16027] = 0; +inp[16028] = 1073741808; +inp[16029] = 0; +inp[16030] = 1073741807; +inp[16031] = 0; +inp[16032] = 1073741806; +inp[16033] = 0; +inp[16034] = 1073741805; +inp[16035] = 0; +inp[16036] = 1073741804; +inp[16037] = 0; +inp[16038] = 1073741803; +inp[16039] = 0; +inp[16040] = 1073741802; +inp[16041] = 0; +inp[16042] = 1073741801; +inp[16043] = 0; +inp[16044] = 1073741800; +inp[16045] = 0; +inp[16046] = 1073741799; +inp[16047] = 0; +inp[16048] = 1073741798; +inp[16049] = 0; +inp[16050] = 1073741797; +inp[16051] = 0; +inp[16052] = 1073741796; +inp[16053] = 0; +inp[16054] = 1073741795; +inp[16055] = 0; +inp[16056] = 1073741794; +inp[16057] = 0; +inp[16058] = 1073741793; +inp[16059] = 0; +inp[16060] = 1073741792; +inp[16061] = 0; +inp[16062] = 1073741791; +inp[16063] = 0; +inp[16064] = 1073741790; +inp[16065] = 0; +inp[16066] = 1073741789; +inp[16067] = 0; +inp[16068] = 1073741788; +inp[16069] = 0; +inp[16070] = 1073741787; +inp[16071] = 0; +inp[16072] = 1073741786; +inp[16073] = 0; +inp[16074] = 1073741785; +inp[16075] = 0; +inp[16076] = 1073741784; +inp[16077] = 0; +inp[16078] = 1073741783; +inp[16079] = 0; +inp[16080] = 1073741782; +inp[16081] = 0; +inp[16082] = 1073741781; +inp[16083] = 0; +inp[16084] = 1073741780; +inp[16085] = 0; +inp[16086] = 1073741779; +inp[16087] = 0; +inp[16088] = 1073741778; +inp[16089] = 0; +inp[16090] = 1073741777; +inp[16091] = 0; +inp[16092] = 1073741776; +inp[16093] = 0; +inp[16094] = 1073741775; +inp[16095] = 0; +inp[16096] = 1073741774; +inp[16097] = 0; +inp[16098] = 1073741773; +inp[16099] = 0; +inp[16100] = 1073741772; +inp[16101] = 0; +inp[16102] = 1073741771; +inp[16103] = 0; +inp[16104] = 1073741770; +inp[16105] = 0; +inp[16106] = 1073741769; +inp[16107] = 0; +inp[16108] = 1073741768; +inp[16109] = 0; +inp[16110] = 1073741767; +inp[16111] = 0; +inp[16112] = 1073741766; +inp[16113] = 0; +inp[16114] = 1073741765; +inp[16115] = 0; +inp[16116] = 1073741764; +inp[16117] = 0; +inp[16118] = 1073741763; +inp[16119] = 0; +inp[16120] = 1073741762; +inp[16121] = 0; +inp[16122] = 1073741761; +inp[16123] = 0; +inp[16124] = 1073741760; +inp[16125] = 0; +inp[16126] = 1073741759; +inp[16127] = 0; +inp[16128] = 1073741758; +inp[16129] = 0; +inp[16130] = 1073741757; +inp[16131] = 0; +inp[16132] = 1073741756; +inp[16133] = 0; +inp[16134] = 1073741755; +inp[16135] = 0; +inp[16136] = 1073741754; +inp[16137] = 0; +inp[16138] = 1073741753; +inp[16139] = 0; +inp[16140] = 1073741752; +inp[16141] = 0; +inp[16142] = 1073741751; +inp[16143] = 0; +inp[16144] = 1073741750; +inp[16145] = 0; +inp[16146] = 1073741749; +inp[16147] = 0; +inp[16148] = 1073741748; +inp[16149] = 0; +inp[16150] = 1073741747; +inp[16151] = 0; +inp[16152] = 1073741746; +inp[16153] = 0; +inp[16154] = 1073741745; +inp[16155] = 0; +inp[16156] = 1073741744; +inp[16157] = 0; +inp[16158] = 1073741743; +inp[16159] = 0; +inp[16160] = 1073741742; +inp[16161] = 0; +inp[16162] = 1073741741; +inp[16163] = 0; +inp[16164] = 1073741740; +inp[16165] = 0; +inp[16166] = 1073741739; +inp[16167] = 0; +inp[16168] = 1073741738; +inp[16169] = 0; +inp[16170] = 1073741737; +inp[16171] = 0; +inp[16172] = 1073741736; +inp[16173] = 0; +inp[16174] = 1073741735; +inp[16175] = 0; +inp[16176] = 1073741734; +inp[16177] = 0; +inp[16178] = 1073741733; +inp[16179] = 0; +inp[16180] = 1073741732; +inp[16181] = 0; +inp[16182] = 1073741731; +inp[16183] = 0; +inp[16184] = 1073741730; +inp[16185] = 0; +inp[16186] = 1073741729; +inp[16187] = 0; +inp[16188] = 1073741728; +inp[16189] = 0; +inp[16190] = 1073741727; +inp[16191] = 0; +inp[16192] = 1073741726; +inp[16193] = 0; +inp[16194] = 1073741725; +inp[16195] = 0; +inp[16196] = 1073741724; +inp[16197] = 0; +inp[16198] = 1073741723; +inp[16199] = 0; +inp[16200] = 1073741722; +inp[16201] = 0; +inp[16202] = 1073741721; +inp[16203] = 0; +inp[16204] = 1073741720; +inp[16205] = 0; +inp[16206] = 1073741719; +inp[16207] = 0; +inp[16208] = 1073741718; +inp[16209] = 0; +inp[16210] = 1073741717; +inp[16211] = 0; +inp[16212] = 1073741716; +inp[16213] = 0; +inp[16214] = 1073741715; +inp[16215] = 0; +inp[16216] = 1073741714; +inp[16217] = 0; +inp[16218] = 1073741713; +inp[16219] = 0; +inp[16220] = 1073741712; +inp[16221] = 0; +inp[16222] = 1073741711; +inp[16223] = 0; +inp[16224] = 1073741710; +inp[16225] = 0; +inp[16226] = 1073741709; +inp[16227] = 0; +inp[16228] = 1073741708; +inp[16229] = 0; +inp[16230] = 1073741707; +inp[16231] = 0; +inp[16232] = 1073741706; +inp[16233] = 0; +inp[16234] = 1073741705; +inp[16235] = 0; +inp[16236] = 1073741704; +inp[16237] = 0; +inp[16238] = 1073741703; +inp[16239] = 0; +inp[16240] = 1073741702; +inp[16241] = 0; +inp[16242] = 1073741701; +inp[16243] = 0; +inp[16244] = 1073741700; +inp[16245] = 0; +inp[16246] = 1073741699; +inp[16247] = 0; +inp[16248] = 1073741698; +inp[16249] = 0; +inp[16250] = 1073741697; +inp[16251] = 0; +inp[16252] = 1073741824; +inp[16253] = 1073741824; +inp[16254] = 1073741823; +inp[16255] = 0; +inp[16256] = 1073741823; +inp[16257] = 0; +inp[16258] = 1073741822; +inp[16259] = 0; +inp[16260] = 1073741822; +inp[16261] = 0; +inp[16262] = 1073741821; +inp[16263] = 0; +inp[16264] = 1073741821; +inp[16265] = 0; +inp[16266] = 1073741820; +inp[16267] = 0; +inp[16268] = 1073741820; +inp[16269] = 0; +inp[16270] = 1073741819; +inp[16271] = 0; +inp[16272] = 1073741819; +inp[16273] = 0; +inp[16274] = 1073741818; +inp[16275] = 0; +inp[16276] = 1073741818; +inp[16277] = 0; +inp[16278] = 1073741817; +inp[16279] = 0; +inp[16280] = 1073741817; +inp[16281] = 0; +inp[16282] = 1073741816; +inp[16283] = 0; +inp[16284] = 1073741816; +inp[16285] = 0; +inp[16286] = 1073741815; +inp[16287] = 0; +inp[16288] = 1073741815; +inp[16289] = 0; +inp[16290] = 1073741814; +inp[16291] = 0; +inp[16292] = 1073741814; +inp[16293] = 0; +inp[16294] = 1073741813; +inp[16295] = 0; +inp[16296] = 1073741813; +inp[16297] = 0; +inp[16298] = 1073741812; +inp[16299] = 0; +inp[16300] = 1073741812; +inp[16301] = 0; +inp[16302] = 1073741811; +inp[16303] = 0; +inp[16304] = 1073741811; +inp[16305] = 0; +inp[16306] = 1073741810; +inp[16307] = 0; +inp[16308] = 1073741810; +inp[16309] = 0; +inp[16310] = 1073741809; +inp[16311] = 0; +inp[16312] = 1073741809; +inp[16313] = 0; +inp[16314] = 1073741808; +inp[16315] = 0; +inp[16316] = 1073741808; +inp[16317] = 0; +inp[16318] = 1073741807; +inp[16319] = 0; +inp[16320] = 1073741807; +inp[16321] = 0; +inp[16322] = 1073741806; +inp[16323] = 0; +inp[16324] = 1073741806; +inp[16325] = 0; +inp[16326] = 1073741805; +inp[16327] = 0; +inp[16328] = 1073741805; +inp[16329] = 0; +inp[16330] = 1073741804; +inp[16331] = 0; +inp[16332] = 1073741804; +inp[16333] = 0; +inp[16334] = 1073741803; +inp[16335] = 0; +inp[16336] = 1073741803; +inp[16337] = 0; +inp[16338] = 1073741802; +inp[16339] = 0; +inp[16340] = 1073741802; +inp[16341] = 0; +inp[16342] = 1073741801; +inp[16343] = 0; +inp[16344] = 1073741801; +inp[16345] = 0; +inp[16346] = 1073741800; +inp[16347] = 0; +inp[16348] = 1073741800; +inp[16349] = 0; +inp[16350] = 1073741799; +inp[16351] = 0; +inp[16352] = 1073741799; +inp[16353] = 0; +inp[16354] = 1073741798; +inp[16355] = 0; +inp[16356] = 1073741798; +inp[16357] = 0; +inp[16358] = 1073741797; +inp[16359] = 0; +inp[16360] = 1073741797; +inp[16361] = 0; +inp[16362] = 1073741796; +inp[16363] = 0; +inp[16364] = 1073741796; +inp[16365] = 0; +inp[16366] = 1073741795; +inp[16367] = 0; +inp[16368] = 1073741795; +inp[16369] = 0; +inp[16370] = 1073741794; +inp[16371] = 0; +inp[16372] = 1073741794; +inp[16373] = 0; +inp[16374] = 1073741793; +inp[16375] = 0; +inp[16376] = 1073741793; +inp[16377] = 0; +inp[16378] = 1073741792; +inp[16379] = 0; +inp[16380] = 1073741792; +inp[16381] = 0; +inp[16382] = 1073741791; +inp[16383] = 0; +inp[16384] = 1073741791; +inp[16385] = 0; +inp[16386] = 1073741790; +inp[16387] = 0; +inp[16388] = 1073741790; +inp[16389] = 0; +inp[16390] = 1073741789; +inp[16391] = 0; +inp[16392] = 1073741789; +inp[16393] = 0; +inp[16394] = 1073741788; +inp[16395] = 0; +inp[16396] = 1073741788; +inp[16397] = 0; +inp[16398] = 1073741787; +inp[16399] = 0; +inp[16400] = 1073741787; +inp[16401] = 0; +inp[16402] = 1073741786; +inp[16403] = 0; +inp[16404] = 1073741786; +inp[16405] = 0; +inp[16406] = 1073741785; +inp[16407] = 0; +inp[16408] = 1073741785; +inp[16409] = 0; +inp[16410] = 1073741784; +inp[16411] = 0; +inp[16412] = 1073741784; +inp[16413] = 0; +inp[16414] = 1073741783; +inp[16415] = 0; +inp[16416] = 1073741783; +inp[16417] = 0; +inp[16418] = 1073741782; +inp[16419] = 0; +inp[16420] = 1073741782; +inp[16421] = 0; +inp[16422] = 1073741781; +inp[16423] = 0; +inp[16424] = 1073741781; +inp[16425] = 0; +inp[16426] = 1073741780; +inp[16427] = 0; +inp[16428] = 1073741780; +inp[16429] = 0; +inp[16430] = 1073741779; +inp[16431] = 0; +inp[16432] = 1073741779; +inp[16433] = 0; +inp[16434] = 1073741778; +inp[16435] = 0; +inp[16436] = 1073741778; +inp[16437] = 0; +inp[16438] = 1073741777; +inp[16439] = 0; +inp[16440] = 1073741777; +inp[16441] = 0; +inp[16442] = 1073741776; +inp[16443] = 0; +inp[16444] = 1073741776; +inp[16445] = 0; +inp[16446] = 1073741775; +inp[16447] = 0; +inp[16448] = 1073741775; +inp[16449] = 0; +inp[16450] = 1073741774; +inp[16451] = 0; +inp[16452] = 1073741774; +inp[16453] = 0; +inp[16454] = 1073741773; +inp[16455] = 0; +inp[16456] = 1073741773; +inp[16457] = 0; +inp[16458] = 1073741772; +inp[16459] = 0; +inp[16460] = 1073741772; +inp[16461] = 0; +inp[16462] = 1073741771; +inp[16463] = 0; +inp[16464] = 1073741771; +inp[16465] = 0; +inp[16466] = 1073741770; +inp[16467] = 0; +inp[16468] = 1073741770; +inp[16469] = 0; +inp[16470] = 1073741769; +inp[16471] = 0; +inp[16472] = 1073741769; +inp[16473] = 0; +inp[16474] = 1073741768; +inp[16475] = 0; +inp[16476] = 1073741768; +inp[16477] = 0; +inp[16478] = 1073741767; +inp[16479] = 0; +inp[16480] = 1073741767; +inp[16481] = 0; +inp[16482] = 1073741766; +inp[16483] = 0; +inp[16484] = 1073741766; +inp[16485] = 0; +inp[16486] = 1073741765; +inp[16487] = 0; +inp[16488] = 1073741765; +inp[16489] = 0; +inp[16490] = 1073741764; +inp[16491] = 0; +inp[16492] = 1073741764; +inp[16493] = 0; +inp[16494] = 1073741763; +inp[16495] = 0; +inp[16496] = 1073741763; +inp[16497] = 0; +inp[16498] = 1073741762; +inp[16499] = 0; +inp[16500] = 1073741762; +inp[16501] = 0; +inp[16502] = 1073741761; +inp[16503] = 0; +inp[16504] = 1073741761; +inp[16505] = 0; +inp[16506] = 1073741760; +inp[16507] = 0; +inp[16508] = 1073741824; +inp[16509] = 1073741824; +inp[16510] = 1073741823; +inp[16511] = 0; +inp[16512] = 1073741823; +inp[16513] = 0; +inp[16514] = 1073741823; +inp[16515] = 0; +inp[16516] = 1073741823; +inp[16517] = 0; +inp[16518] = 1073741822; +inp[16519] = 0; +inp[16520] = 1073741822; +inp[16521] = 0; +inp[16522] = 1073741822; +inp[16523] = 0; +inp[16524] = 1073741822; +inp[16525] = 0; +inp[16526] = 1073741821; +inp[16527] = 0; +inp[16528] = 1073741821; +inp[16529] = 0; +inp[16530] = 1073741821; +inp[16531] = 0; +inp[16532] = 1073741821; +inp[16533] = 0; +inp[16534] = 1073741820; +inp[16535] = 0; +inp[16536] = 1073741820; +inp[16537] = 0; +inp[16538] = 1073741820; +inp[16539] = 0; +inp[16540] = 1073741820; +inp[16541] = 0; +inp[16542] = 1073741819; +inp[16543] = 0; +inp[16544] = 1073741819; +inp[16545] = 0; +inp[16546] = 1073741819; +inp[16547] = 0; +inp[16548] = 1073741819; +inp[16549] = 0; +inp[16550] = 1073741818; +inp[16551] = 0; +inp[16552] = 1073741818; +inp[16553] = 0; +inp[16554] = 1073741818; +inp[16555] = 0; +inp[16556] = 1073741818; +inp[16557] = 0; +inp[16558] = 1073741817; +inp[16559] = 0; +inp[16560] = 1073741817; +inp[16561] = 0; +inp[16562] = 1073741817; +inp[16563] = 0; +inp[16564] = 1073741817; +inp[16565] = 0; +inp[16566] = 1073741816; +inp[16567] = 0; +inp[16568] = 1073741816; +inp[16569] = 0; +inp[16570] = 1073741816; +inp[16571] = 0; +inp[16572] = 1073741816; +inp[16573] = 0; +inp[16574] = 1073741815; +inp[16575] = 0; +inp[16576] = 1073741815; +inp[16577] = 0; +inp[16578] = 1073741815; +inp[16579] = 0; +inp[16580] = 1073741815; +inp[16581] = 0; +inp[16582] = 1073741814; +inp[16583] = 0; +inp[16584] = 1073741814; +inp[16585] = 0; +inp[16586] = 1073741814; +inp[16587] = 0; +inp[16588] = 1073741814; +inp[16589] = 0; +inp[16590] = 1073741813; +inp[16591] = 0; +inp[16592] = 1073741813; +inp[16593] = 0; +inp[16594] = 1073741813; +inp[16595] = 0; +inp[16596] = 1073741813; +inp[16597] = 0; +inp[16598] = 1073741812; +inp[16599] = 0; +inp[16600] = 1073741812; +inp[16601] = 0; +inp[16602] = 1073741812; +inp[16603] = 0; +inp[16604] = 1073741812; +inp[16605] = 0; +inp[16606] = 1073741811; +inp[16607] = 0; +inp[16608] = 1073741811; +inp[16609] = 0; +inp[16610] = 1073741811; +inp[16611] = 0; +inp[16612] = 1073741811; +inp[16613] = 0; +inp[16614] = 1073741810; +inp[16615] = 0; +inp[16616] = 1073741810; +inp[16617] = 0; +inp[16618] = 1073741810; +inp[16619] = 0; +inp[16620] = 1073741810; +inp[16621] = 0; +inp[16622] = 1073741809; +inp[16623] = 0; +inp[16624] = 1073741809; +inp[16625] = 0; +inp[16626] = 1073741809; +inp[16627] = 0; +inp[16628] = 1073741809; +inp[16629] = 0; +inp[16630] = 1073741808; +inp[16631] = 0; +inp[16632] = 1073741808; +inp[16633] = 0; +inp[16634] = 1073741808; +inp[16635] = 0; +inp[16636] = 1073741808; +inp[16637] = 0; +inp[16638] = 1073741807; +inp[16639] = 0; +inp[16640] = 1073741807; +inp[16641] = 0; +inp[16642] = 1073741807; +inp[16643] = 0; +inp[16644] = 1073741807; +inp[16645] = 0; +inp[16646] = 1073741806; +inp[16647] = 0; +inp[16648] = 1073741806; +inp[16649] = 0; +inp[16650] = 1073741806; +inp[16651] = 0; +inp[16652] = 1073741806; +inp[16653] = 0; +inp[16654] = 1073741805; +inp[16655] = 0; +inp[16656] = 1073741805; +inp[16657] = 0; +inp[16658] = 1073741805; +inp[16659] = 0; +inp[16660] = 1073741805; +inp[16661] = 0; +inp[16662] = 1073741804; +inp[16663] = 0; +inp[16664] = 1073741804; +inp[16665] = 0; +inp[16666] = 1073741804; +inp[16667] = 0; +inp[16668] = 1073741804; +inp[16669] = 0; +inp[16670] = 1073741803; +inp[16671] = 0; +inp[16672] = 1073741803; +inp[16673] = 0; +inp[16674] = 1073741803; +inp[16675] = 0; +inp[16676] = 1073741803; +inp[16677] = 0; +inp[16678] = 1073741802; +inp[16679] = 0; +inp[16680] = 1073741802; +inp[16681] = 0; +inp[16682] = 1073741802; +inp[16683] = 0; +inp[16684] = 1073741802; +inp[16685] = 0; +inp[16686] = 1073741801; +inp[16687] = 0; +inp[16688] = 1073741801; +inp[16689] = 0; +inp[16690] = 1073741801; +inp[16691] = 0; +inp[16692] = 1073741801; +inp[16693] = 0; +inp[16694] = 1073741800; +inp[16695] = 0; +inp[16696] = 1073741800; +inp[16697] = 0; +inp[16698] = 1073741800; +inp[16699] = 0; +inp[16700] = 1073741800; +inp[16701] = 0; +inp[16702] = 1073741799; +inp[16703] = 0; +inp[16704] = 1073741799; +inp[16705] = 0; +inp[16706] = 1073741799; +inp[16707] = 0; +inp[16708] = 1073741799; +inp[16709] = 0; +inp[16710] = 1073741798; +inp[16711] = 0; +inp[16712] = 1073741798; +inp[16713] = 0; +inp[16714] = 1073741798; +inp[16715] = 0; +inp[16716] = 1073741798; +inp[16717] = 0; +inp[16718] = 1073741797; +inp[16719] = 0; +inp[16720] = 1073741797; +inp[16721] = 0; +inp[16722] = 1073741797; +inp[16723] = 0; +inp[16724] = 1073741797; +inp[16725] = 0; +inp[16726] = 1073741796; +inp[16727] = 0; +inp[16728] = 1073741796; +inp[16729] = 0; +inp[16730] = 1073741796; +inp[16731] = 0; +inp[16732] = 1073741796; +inp[16733] = 0; +inp[16734] = 1073741795; +inp[16735] = 0; +inp[16736] = 1073741795; +inp[16737] = 0; +inp[16738] = 1073741795; +inp[16739] = 0; +inp[16740] = 1073741795; +inp[16741] = 0; +inp[16742] = 1073741794; +inp[16743] = 0; +inp[16744] = 1073741794; +inp[16745] = 0; +inp[16746] = 1073741794; +inp[16747] = 0; +inp[16748] = 1073741794; +inp[16749] = 0; +inp[16750] = 1073741793; +inp[16751] = 0; +inp[16752] = 1073741793; +inp[16753] = 0; +inp[16754] = 1073741793; +inp[16755] = 0; +inp[16756] = 1073741793; +inp[16757] = 0; +inp[16758] = 1073741792; +inp[16759] = 0; +inp[16760] = 1073741792; +inp[16761] = 0; +inp[16762] = 1073741792; +inp[16763] = 0; +inp[16764] = 1073741824; +inp[16765] = 1073741824; +inp[16766] = 395007542; +inp[16767] = 395007542; +inp[16768] = 145315153; +inp[16769] = 145315153; +inp[16770] = 53458457; +inp[16771] = 53458457; +inp[16772] = 19666267; +inp[16773] = 19666267; +inp[16774] = 7234815; +inp[16775] = 7234815; +inp[16776] = 2661539; +inp[16777] = 2661539; +inp[16778] = 979125; +inp[16779] = 979125; +inp[16780] = 360200; +inp[16781] = 360200; +inp[16782] = 132510; +inp[16783] = 132510; +inp[16784] = 48747; +inp[16785] = 48747; +inp[16786] = 17933; +inp[16787] = 17933; +inp[16788] = 6597; +inp[16789] = 6597; +inp[16790] = 2427; +inp[16791] = 2427; +inp[16792] = 892; +inp[16793] = 892; +inp[16794] = 328; +inp[16795] = 328; +inp[16796] = 120; +inp[16797] = 120; +inp[16798] = 44; +inp[16799] = 44; +inp[16800] = 16; +inp[16801] = 16; +inp[16802] = 6; +inp[16803] = 6; +inp[16804] = 2; +inp[16805] = 2; +inp[16806] = 0; +inp[16807] = 0; +inp[16808] = 0; +inp[16809] = 0; +inp[16810] = 0; +inp[16811] = 0; +inp[16812] = 0; +inp[16813] = 0; +inp[16814] = 0; +inp[16815] = 0; +inp[16816] = 0; +inp[16817] = 0; +inp[16818] = 0; +inp[16819] = 0; +inp[16820] = 0; +inp[16821] = 0; +inp[16822] = 0; +inp[16823] = 0; +inp[16824] = 0; +inp[16825] = 0; +inp[16826] = 0; +inp[16827] = 0; +inp[16828] = 0; +inp[16829] = 0; +inp[16830] = 0; +inp[16831] = 0; +inp[16832] = 0; +inp[16833] = 0; +inp[16834] = 0; +inp[16835] = 0; +inp[16836] = 0; +inp[16837] = 0; +inp[16838] = 0; +inp[16839] = 0; +inp[16840] = 0; +inp[16841] = 0; +inp[16842] = 0; +inp[16843] = 0; +inp[16844] = 0; +inp[16845] = 0; +inp[16846] = 0; +inp[16847] = 0; +inp[16848] = 0; +inp[16849] = 0; +inp[16850] = 0; +inp[16851] = 0; +inp[16852] = 0; +inp[16853] = 0; +inp[16854] = 0; +inp[16855] = 0; +inp[16856] = 0; +inp[16857] = 0; +inp[16858] = 0; +inp[16859] = 0; +inp[16860] = 0; +inp[16861] = 0; +inp[16862] = 0; +inp[16863] = 0; +inp[16864] = 0; +inp[16865] = 0; +inp[16866] = 0; +inp[16867] = 0; +inp[16868] = 0; +inp[16869] = 0; +inp[16870] = 0; +inp[16871] = 0; +inp[16872] = 0; +inp[16873] = 0; +inp[16874] = 0; +inp[16875] = 0; +inp[16876] = 0; +inp[16877] = 0; +inp[16878] = 0; +inp[16879] = 0; +inp[16880] = 0; +inp[16881] = 0; +inp[16882] = 0; +inp[16883] = 0; +inp[16884] = 0; +inp[16885] = 0; +inp[16886] = 0; +inp[16887] = 0; +inp[16888] = 0; +inp[16889] = 0; +inp[16890] = 0; +inp[16891] = 0; +inp[16892] = 0; +inp[16893] = 0; +inp[16894] = 0; +inp[16895] = 0; +inp[16896] = 0; +inp[16897] = 0; +inp[16898] = 0; +inp[16899] = 0; +inp[16900] = 0; +inp[16901] = 0; +inp[16902] = 0; +inp[16903] = 0; +inp[16904] = 0; +inp[16905] = 0; +inp[16906] = 0; +inp[16907] = 0; +inp[16908] = 0; +inp[16909] = 0; +inp[16910] = 0; +inp[16911] = 0; +inp[16912] = 0; +inp[16913] = 0; +inp[16914] = 0; +inp[16915] = 0; +inp[16916] = 0; +inp[16917] = 0; +inp[16918] = 0; +inp[16919] = 0; +inp[16920] = 0; +inp[16921] = 0; +inp[16922] = 0; +inp[16923] = 0; +inp[16924] = 0; +inp[16925] = 0; +inp[16926] = 0; +inp[16927] = 0; +inp[16928] = 0; +inp[16929] = 0; +inp[16930] = 0; +inp[16931] = 0; +inp[16932] = 0; +inp[16933] = 0; +inp[16934] = 0; +inp[16935] = 0; +inp[16936] = 0; +inp[16937] = 0; +inp[16938] = 0; +inp[16939] = 0; +inp[16940] = 0; +inp[16941] = 0; +inp[16942] = 0; +inp[16943] = 0; +inp[16944] = 0; +inp[16945] = 0; +inp[16946] = 0; +inp[16947] = 0; +inp[16948] = 0; +inp[16949] = 0; +inp[16950] = 0; +inp[16951] = 0; +inp[16952] = 0; +inp[16953] = 0; +inp[16954] = 0; +inp[16955] = 0; +inp[16956] = 0; +inp[16957] = 0; +inp[16958] = 0; +inp[16959] = 0; +inp[16960] = 0; +inp[16961] = 0; +inp[16962] = 0; +inp[16963] = 0; +inp[16964] = 0; +inp[16965] = 0; +inp[16966] = 0; +inp[16967] = 0; +inp[16968] = 0; +inp[16969] = 0; +inp[16970] = 0; +inp[16971] = 0; +inp[16972] = 0; +inp[16973] = 0; +inp[16974] = 0; +inp[16975] = 0; +inp[16976] = 0; +inp[16977] = 0; +inp[16978] = 0; +inp[16979] = 0; +inp[16980] = 0; +inp[16981] = 0; +inp[16982] = 0; +inp[16983] = 0; +inp[16984] = 0; +inp[16985] = 0; +inp[16986] = 0; +inp[16987] = 0; +inp[16988] = 0; +inp[16989] = 0; +inp[16990] = 0; +inp[16991] = 0; +inp[16992] = 0; +inp[16993] = 0; +inp[16994] = 0; +inp[16995] = 0; +inp[16996] = 0; +inp[16997] = 0; +inp[16998] = 0; +inp[16999] = 0; +inp[17000] = 0; +inp[17001] = 0; +inp[17002] = 0; +inp[17003] = 0; +inp[17004] = 0; +inp[17005] = 0; +inp[17006] = 0; +inp[17007] = 0; +inp[17008] = 0; +inp[17009] = 0; +inp[17010] = 0; +inp[17011] = 0; +inp[17012] = 0; +inp[17013] = 0; +inp[17014] = 0; +inp[17015] = 0; +inp[17016] = 0; +inp[17017] = 0; +inp[17018] = 0; +inp[17019] = 0; +inp[17020] = 0; +inp[17021] = 0; +inp[17022] = 0; +inp[17023] = 0; +inp[17024] = 0; +inp[17025] = 0; +inp[17026] = 0; +inp[17027] = 0; +inp[17028] = 0; +inp[17029] = 0; +inp[17030] = 0; +inp[17031] = 0; +inp[17032] = 0; +inp[17033] = 0; +inp[17034] = 0; +inp[17035] = 0; +inp[17036] = 0; +inp[17037] = 0; +inp[17038] = 0; +inp[17039] = 0; +inp[17040] = 0; +inp[17041] = 0; +inp[17042] = 0; +inp[17043] = 0; +inp[17044] = 0; +inp[17045] = 0; +inp[17046] = 0; +inp[17047] = 0; +inp[17048] = 0; +inp[17049] = 0; +inp[17050] = 0; +inp[17051] = 0; +inp[17052] = 0; +inp[17053] = 0; +inp[17054] = 0; +inp[17055] = 0; +inp[17056] = 0; +inp[17057] = 0; +inp[17058] = 0; +inp[17059] = 0; +inp[17060] = 0; +inp[17061] = 0; +inp[17062] = 0; +inp[17063] = 0; +inp[17064] = 0; +inp[17065] = 0; +inp[17066] = 0; +inp[17067] = 0; +inp[17068] = 0; +inp[17069] = 0; +inp[17070] = 0; +inp[17071] = 0; +inp[17072] = 0; +inp[17073] = 0; +inp[17074] = 0; +inp[17075] = 0; +inp[17076] = 0; +inp[17077] = 0; +inp[17078] = 0; +inp[17079] = 0; +inp[17080] = 0; +inp[17081] = 0; +inp[17082] = 0; +inp[17083] = 0; +inp[17084] = 0; +inp[17085] = 0; +inp[17086] = 0; +inp[17087] = 0; +inp[17088] = 0; +inp[17089] = 0; +inp[17090] = 0; +inp[17091] = 0; +inp[17092] = 0; +inp[17093] = 0; +inp[17094] = 0; +inp[17095] = 0; +inp[17096] = 0; +inp[17097] = 0; +inp[17098] = 0; +inp[17099] = 0; +inp[17100] = 0; +inp[17101] = 0; +inp[17102] = 0; +inp[17103] = 0; +inp[17104] = 0; +inp[17105] = 0; +inp[17106] = 0; +inp[17107] = 0; +inp[17108] = 0; +inp[17109] = 0; +inp[17110] = 0; +inp[17111] = 0; +inp[17112] = 0; +inp[17113] = 0; +inp[17114] = 0; +inp[17115] = 0; +inp[17116] = 0; +inp[17117] = 0; +inp[17118] = 0; +inp[17119] = 0; +inp[17120] = 0; +inp[17121] = 0; +inp[17122] = 0; +inp[17123] = 0; +inp[17124] = 0; +inp[17125] = 0; +inp[17126] = 0; +inp[17127] = 0; +inp[17128] = 0; +inp[17129] = 0; +inp[17130] = 0; +inp[17131] = 0; +inp[17132] = 0; +inp[17133] = 0; +inp[17134] = 0; +inp[17135] = 0; +inp[17136] = 0; +inp[17137] = 0; +inp[17138] = 0; +inp[17139] = 0; +inp[17140] = 0; +inp[17141] = 0; +inp[17142] = 0; +inp[17143] = 0; +inp[17144] = 0; +inp[17145] = 0; +inp[17146] = 0; +inp[17147] = 0; +inp[17148] = 0; +inp[17149] = 0; +inp[17150] = 0; +inp[17151] = 0; +inp[17152] = 0; +inp[17153] = 0; +inp[17154] = 0; +inp[17155] = 0; +inp[17156] = 0; +inp[17157] = 0; +inp[17158] = 0; +inp[17159] = 0; +inp[17160] = 0; +inp[17161] = 0; +inp[17162] = 0; +inp[17163] = 0; +inp[17164] = 0; +inp[17165] = 0; +inp[17166] = 0; +inp[17167] = 0; +inp[17168] = 0; +inp[17169] = 0; +inp[17170] = 0; +inp[17171] = 0; +inp[17172] = 0; +inp[17173] = 0; +inp[17174] = 0; +inp[17175] = 0; +inp[17176] = 0; +inp[17177] = 0; +inp[17178] = 0; +inp[17179] = 0; +inp[17180] = 0; +inp[17181] = 0; +inp[17182] = 0; +inp[17183] = 0; +inp[17184] = 0; +inp[17185] = 0; +inp[17186] = 0; +inp[17187] = 0; +inp[17188] = 0; +inp[17189] = 0; +inp[17190] = 0; +inp[17191] = 0; +inp[17192] = 0; +inp[17193] = 0; +inp[17194] = 0; +inp[17195] = 0; +inp[17196] = 0; +inp[17197] = 0; +inp[17198] = 0; +inp[17199] = 0; +inp[17200] = 0; +inp[17201] = 0; +inp[17202] = 0; +inp[17203] = 0; +inp[17204] = 0; +inp[17205] = 0; +inp[17206] = 0; +inp[17207] = 0; +inp[17208] = 0; +inp[17209] = 0; +inp[17210] = 0; +inp[17211] = 0; +inp[17212] = 0; +inp[17213] = 0; +inp[17214] = 0; +inp[17215] = 0; +inp[17216] = 0; +inp[17217] = 0; +inp[17218] = 0; +inp[17219] = 0; +inp[17220] = 0; +inp[17221] = 0; +inp[17222] = 0; +inp[17223] = 0; +inp[17224] = 0; +inp[17225] = 0; +inp[17226] = 0; +inp[17227] = 0; +inp[17228] = 0; +inp[17229] = 0; +inp[17230] = 0; +inp[17231] = 0; +inp[17232] = 0; +inp[17233] = 0; +inp[17234] = 0; +inp[17235] = 0; +inp[17236] = 0; +inp[17237] = 0; +inp[17238] = 0; +inp[17239] = 0; +inp[17240] = 0; +inp[17241] = 0; +inp[17242] = 0; +inp[17243] = 0; +inp[17244] = 0; +inp[17245] = 0; +inp[17246] = 0; +inp[17247] = 0; +inp[17248] = 0; +inp[17249] = 0; +inp[17250] = 0; +inp[17251] = 0; +inp[17252] = 0; +inp[17253] = 0; +inp[17254] = 0; +inp[17255] = 0; +inp[17256] = 0; +inp[17257] = 0; +inp[17258] = 0; +inp[17259] = 0; +inp[17260] = 0; +inp[17261] = 0; +inp[17262] = 0; +inp[17263] = 0; +inp[17264] = 0; +inp[17265] = 0; +inp[17266] = 0; +inp[17267] = 0; +inp[17268] = 0; +inp[17269] = 0; +inp[17270] = 0; +inp[17271] = 0; +inp[17272] = 0; +inp[17273] = 0; +inp[17274] = 0; +inp[17275] = 0; +inp[17276] = 1073741824; +inp[17277] = 1073741824; +inp[17278] = 651257336; +inp[17279] = 145315153; +inp[17280] = 395007542; +inp[17281] = 19666267; +inp[17282] = 239584185; +inp[17283] = 2661539; +inp[17284] = 145315153; +inp[17285] = 360200; +inp[17286] = 88138096; +inp[17287] = 48747; +inp[17288] = 53458457; +inp[17289] = 6597; +inp[17290] = 32424193; +inp[17291] = 892; +inp[17292] = 19666267; +inp[17293] = 120; +inp[17294] = 11928194; +inp[17295] = 16; +inp[17296] = 7234815; +inp[17297] = 2; +inp[17298] = 4388137; +inp[17299] = 0; +inp[17300] = 2661539; +inp[17301] = 0; +inp[17302] = 1614305; +inp[17303] = 0; +inp[17304] = 979125; +inp[17305] = 0; +inp[17306] = 593869; +inp[17307] = 0; +inp[17308] = 360200; +inp[17309] = 0; +inp[17310] = 218472; +inp[17311] = 0; +inp[17312] = 132510; +inp[17313] = 0; +inp[17314] = 80371; +inp[17315] = 0; +inp[17316] = 48747; +inp[17317] = 0; +inp[17318] = 29567; +inp[17319] = 0; +inp[17320] = 17933; +inp[17321] = 0; +inp[17322] = 10877; +inp[17323] = 0; +inp[17324] = 6597; +inp[17325] = 0; +inp[17326] = 4001; +inp[17327] = 0; +inp[17328] = 2427; +inp[17329] = 0; +inp[17330] = 1472; +inp[17331] = 0; +inp[17332] = 892; +inp[17333] = 0; +inp[17334] = 541; +inp[17335] = 0; +inp[17336] = 328; +inp[17337] = 0; +inp[17338] = 199; +inp[17339] = 0; +inp[17340] = 120; +inp[17341] = 0; +inp[17342] = 73; +inp[17343] = 0; +inp[17344] = 44; +inp[17345] = 0; +inp[17346] = 26; +inp[17347] = 0; +inp[17348] = 16; +inp[17349] = 0; +inp[17350] = 9; +inp[17351] = 0; +inp[17352] = 6; +inp[17353] = 0; +inp[17354] = 3; +inp[17355] = 0; +inp[17356] = 2; +inp[17357] = 0; +inp[17358] = 1; +inp[17359] = 0; +inp[17360] = 0; +inp[17361] = 0; +inp[17362] = 0; +inp[17363] = 0; +inp[17364] = 0; +inp[17365] = 0; +inp[17366] = 0; +inp[17367] = 0; +inp[17368] = 0; +inp[17369] = 0; +inp[17370] = 0; +inp[17371] = 0; +inp[17372] = 0; +inp[17373] = 0; +inp[17374] = 0; +inp[17375] = 0; +inp[17376] = 0; +inp[17377] = 0; +inp[17378] = 0; +inp[17379] = 0; +inp[17380] = 0; +inp[17381] = 0; +inp[17382] = 0; +inp[17383] = 0; +inp[17384] = 0; +inp[17385] = 0; +inp[17386] = 0; +inp[17387] = 0; +inp[17388] = 0; +inp[17389] = 0; +inp[17390] = 0; +inp[17391] = 0; +inp[17392] = 0; +inp[17393] = 0; +inp[17394] = 0; +inp[17395] = 0; +inp[17396] = 0; +inp[17397] = 0; +inp[17398] = 0; +inp[17399] = 0; +inp[17400] = 0; +inp[17401] = 0; +inp[17402] = 0; +inp[17403] = 0; +inp[17404] = 0; +inp[17405] = 0; +inp[17406] = 0; +inp[17407] = 0; +inp[17408] = 0; +inp[17409] = 0; +inp[17410] = 0; +inp[17411] = 0; +inp[17412] = 0; +inp[17413] = 0; +inp[17414] = 0; +inp[17415] = 0; +inp[17416] = 0; +inp[17417] = 0; +inp[17418] = 0; +inp[17419] = 0; +inp[17420] = 0; +inp[17421] = 0; +inp[17422] = 0; +inp[17423] = 0; +inp[17424] = 0; +inp[17425] = 0; +inp[17426] = 0; +inp[17427] = 0; +inp[17428] = 0; +inp[17429] = 0; +inp[17430] = 0; +inp[17431] = 0; +inp[17432] = 0; +inp[17433] = 0; +inp[17434] = 0; +inp[17435] = 0; +inp[17436] = 0; +inp[17437] = 0; +inp[17438] = 0; +inp[17439] = 0; +inp[17440] = 0; +inp[17441] = 0; +inp[17442] = 0; +inp[17443] = 0; +inp[17444] = 0; +inp[17445] = 0; +inp[17446] = 0; +inp[17447] = 0; +inp[17448] = 0; +inp[17449] = 0; +inp[17450] = 0; +inp[17451] = 0; +inp[17452] = 0; +inp[17453] = 0; +inp[17454] = 0; +inp[17455] = 0; +inp[17456] = 0; +inp[17457] = 0; +inp[17458] = 0; +inp[17459] = 0; +inp[17460] = 0; +inp[17461] = 0; +inp[17462] = 0; +inp[17463] = 0; +inp[17464] = 0; +inp[17465] = 0; +inp[17466] = 0; +inp[17467] = 0; +inp[17468] = 0; +inp[17469] = 0; +inp[17470] = 0; +inp[17471] = 0; +inp[17472] = 0; +inp[17473] = 0; +inp[17474] = 0; +inp[17475] = 0; +inp[17476] = 0; +inp[17477] = 0; +inp[17478] = 0; +inp[17479] = 0; +inp[17480] = 0; +inp[17481] = 0; +inp[17482] = 0; +inp[17483] = 0; +inp[17484] = 0; +inp[17485] = 0; +inp[17486] = 0; +inp[17487] = 0; +inp[17488] = 0; +inp[17489] = 0; +inp[17490] = 0; +inp[17491] = 0; +inp[17492] = 0; +inp[17493] = 0; +inp[17494] = 0; +inp[17495] = 0; +inp[17496] = 0; +inp[17497] = 0; +inp[17498] = 0; +inp[17499] = 0; +inp[17500] = 0; +inp[17501] = 0; +inp[17502] = 0; +inp[17503] = 0; +inp[17504] = 0; +inp[17505] = 0; +inp[17506] = 0; +inp[17507] = 0; +inp[17508] = 0; +inp[17509] = 0; +inp[17510] = 0; +inp[17511] = 0; +inp[17512] = 0; +inp[17513] = 0; +inp[17514] = 0; +inp[17515] = 0; +inp[17516] = 0; +inp[17517] = 0; +inp[17518] = 0; +inp[17519] = 0; +inp[17520] = 0; +inp[17521] = 0; +inp[17522] = 0; +inp[17523] = 0; +inp[17524] = 0; +inp[17525] = 0; +inp[17526] = 0; +inp[17527] = 0; +inp[17528] = 0; +inp[17529] = 0; +inp[17530] = 0; +inp[17531] = 0; +inp[17532] = 0; +inp[17533] = 0; +inp[17534] = 0; +inp[17535] = 0; +inp[17536] = 0; +inp[17537] = 0; +inp[17538] = 0; +inp[17539] = 0; +inp[17540] = 0; +inp[17541] = 0; +inp[17542] = 0; +inp[17543] = 0; +inp[17544] = 0; +inp[17545] = 0; +inp[17546] = 0; +inp[17547] = 0; +inp[17548] = 0; +inp[17549] = 0; +inp[17550] = 0; +inp[17551] = 0; +inp[17552] = 0; +inp[17553] = 0; +inp[17554] = 0; +inp[17555] = 0; +inp[17556] = 0; +inp[17557] = 0; +inp[17558] = 0; +inp[17559] = 0; +inp[17560] = 0; +inp[17561] = 0; +inp[17562] = 0; +inp[17563] = 0; +inp[17564] = 0; +inp[17565] = 0; +inp[17566] = 0; +inp[17567] = 0; +inp[17568] = 0; +inp[17569] = 0; +inp[17570] = 0; +inp[17571] = 0; +inp[17572] = 0; +inp[17573] = 0; +inp[17574] = 0; +inp[17575] = 0; +inp[17576] = 0; +inp[17577] = 0; +inp[17578] = 0; +inp[17579] = 0; +inp[17580] = 0; +inp[17581] = 0; +inp[17582] = 0; +inp[17583] = 0; +inp[17584] = 0; +inp[17585] = 0; +inp[17586] = 0; +inp[17587] = 0; +inp[17588] = 0; +inp[17589] = 0; +inp[17590] = 0; +inp[17591] = 0; +inp[17592] = 0; +inp[17593] = 0; +inp[17594] = 0; +inp[17595] = 0; +inp[17596] = 0; +inp[17597] = 0; +inp[17598] = 0; +inp[17599] = 0; +inp[17600] = 0; +inp[17601] = 0; +inp[17602] = 0; +inp[17603] = 0; +inp[17604] = 0; +inp[17605] = 0; +inp[17606] = 0; +inp[17607] = 0; +inp[17608] = 0; +inp[17609] = 0; +inp[17610] = 0; +inp[17611] = 0; +inp[17612] = 0; +inp[17613] = 0; +inp[17614] = 0; +inp[17615] = 0; +inp[17616] = 0; +inp[17617] = 0; +inp[17618] = 0; +inp[17619] = 0; +inp[17620] = 0; +inp[17621] = 0; +inp[17622] = 0; +inp[17623] = 0; +inp[17624] = 0; +inp[17625] = 0; +inp[17626] = 0; +inp[17627] = 0; +inp[17628] = 0; +inp[17629] = 0; +inp[17630] = 0; +inp[17631] = 0; +inp[17632] = 0; +inp[17633] = 0; +inp[17634] = 0; +inp[17635] = 0; +inp[17636] = 0; +inp[17637] = 0; +inp[17638] = 0; +inp[17639] = 0; +inp[17640] = 0; +inp[17641] = 0; +inp[17642] = 0; +inp[17643] = 0; +inp[17644] = 0; +inp[17645] = 0; +inp[17646] = 0; +inp[17647] = 0; +inp[17648] = 0; +inp[17649] = 0; +inp[17650] = 0; +inp[17651] = 0; +inp[17652] = 0; +inp[17653] = 0; +inp[17654] = 0; +inp[17655] = 0; +inp[17656] = 0; +inp[17657] = 0; +inp[17658] = 0; +inp[17659] = 0; +inp[17660] = 0; +inp[17661] = 0; +inp[17662] = 0; +inp[17663] = 0; +inp[17664] = 0; +inp[17665] = 0; +inp[17666] = 0; +inp[17667] = 0; +inp[17668] = 0; +inp[17669] = 0; +inp[17670] = 0; +inp[17671] = 0; +inp[17672] = 0; +inp[17673] = 0; +inp[17674] = 0; +inp[17675] = 0; +inp[17676] = 0; +inp[17677] = 0; +inp[17678] = 0; +inp[17679] = 0; +inp[17680] = 0; +inp[17681] = 0; +inp[17682] = 0; +inp[17683] = 0; +inp[17684] = 0; +inp[17685] = 0; +inp[17686] = 0; +inp[17687] = 0; +inp[17688] = 0; +inp[17689] = 0; +inp[17690] = 0; +inp[17691] = 0; +inp[17692] = 0; +inp[17693] = 0; +inp[17694] = 0; +inp[17695] = 0; +inp[17696] = 0; +inp[17697] = 0; +inp[17698] = 0; +inp[17699] = 0; +inp[17700] = 0; +inp[17701] = 0; +inp[17702] = 0; +inp[17703] = 0; +inp[17704] = 0; +inp[17705] = 0; +inp[17706] = 0; +inp[17707] = 0; +inp[17708] = 0; +inp[17709] = 0; +inp[17710] = 0; +inp[17711] = 0; +inp[17712] = 0; +inp[17713] = 0; +inp[17714] = 0; +inp[17715] = 0; +inp[17716] = 0; +inp[17717] = 0; +inp[17718] = 0; +inp[17719] = 0; +inp[17720] = 0; +inp[17721] = 0; +inp[17722] = 0; +inp[17723] = 0; +inp[17724] = 0; +inp[17725] = 0; +inp[17726] = 0; +inp[17727] = 0; +inp[17728] = 0; +inp[17729] = 0; +inp[17730] = 0; +inp[17731] = 0; +inp[17732] = 0; +inp[17733] = 0; +inp[17734] = 0; +inp[17735] = 0; +inp[17736] = 0; +inp[17737] = 0; +inp[17738] = 0; +inp[17739] = 0; +inp[17740] = 0; +inp[17741] = 0; +inp[17742] = 0; +inp[17743] = 0; +inp[17744] = 0; +inp[17745] = 0; +inp[17746] = 0; +inp[17747] = 0; +inp[17748] = 0; +inp[17749] = 0; +inp[17750] = 0; +inp[17751] = 0; +inp[17752] = 0; +inp[17753] = 0; +inp[17754] = 0; +inp[17755] = 0; +inp[17756] = 0; +inp[17757] = 0; +inp[17758] = 0; +inp[17759] = 0; +inp[17760] = 0; +inp[17761] = 0; +inp[17762] = 0; +inp[17763] = 0; +inp[17764] = 0; +inp[17765] = 0; +inp[17766] = 0; +inp[17767] = 0; +inp[17768] = 0; +inp[17769] = 0; +inp[17770] = 0; +inp[17771] = 0; +inp[17772] = 0; +inp[17773] = 0; +inp[17774] = 0; +inp[17775] = 0; +inp[17776] = 0; +inp[17777] = 0; +inp[17778] = 0; +inp[17779] = 0; +inp[17780] = 0; +inp[17781] = 0; +inp[17782] = 0; +inp[17783] = 0; +inp[17784] = 0; +inp[17785] = 0; +inp[17786] = 0; +inp[17787] = 0; +inp[17788] = 1073741824; +inp[17789] = 1073741824; +inp[17790] = 836230973; +inp[17791] = 19666267; +inp[17792] = 651257336; +inp[17793] = 360200; +inp[17794] = 507199723; +inp[17795] = 6597; +inp[17796] = 395007542; +inp[17797] = 120; +inp[17798] = 307632183; +inp[17799] = 2; +inp[17800] = 239584185; +inp[17801] = 0; +inp[17802] = 186588351; +inp[17803] = 0; +inp[17804] = 145315153; +inp[17805] = 0; +inp[17806] = 113171555; +inp[17807] = 0; +inp[17808] = 88138096; +inp[17809] = 0; +inp[17810] = 68642018; +inp[17811] = 0; +inp[17812] = 53458457; +inp[17813] = 0; +inp[17814] = 41633488; +inp[17815] = 0; +inp[17816] = 32424193; +inp[17817] = 0; +inp[17818] = 25251987; +inp[17819] = 0; +inp[17820] = 19666267; +inp[17821] = 0; +inp[17822] = 15316104; +inp[17823] = 0; +inp[17824] = 11928194; +inp[17825] = 0; +inp[17826] = 9289686; +inp[17827] = 0; +inp[17828] = 7234815; +inp[17829] = 0; +inp[17830] = 5634479; +inp[17831] = 0; +inp[17832] = 4388137; +inp[17833] = 0; +inp[17834] = 3417484; +inp[17835] = 0; +inp[17836] = 2661539; +inp[17837] = 0; +inp[17838] = 2072809; +inp[17839] = 0; +inp[17840] = 1614305; +inp[17841] = 0; +inp[17842] = 1257222; +inp[17843] = 0; +inp[17844] = 979125; +inp[17845] = 0; +inp[17846] = 762543; +inp[17847] = 0; +inp[17848] = 593869; +inp[17849] = 0; +inp[17850] = 462506; +inp[17851] = 0; +inp[17852] = 360200; +inp[17853] = 0; +inp[17854] = 280524; +inp[17855] = 0; +inp[17856] = 218472; +inp[17857] = 0; +inp[17858] = 170146; +inp[17859] = 0; +inp[17860] = 132510; +inp[17861] = 0; +inp[17862] = 103199; +inp[17863] = 0; +inp[17864] = 80371; +inp[17865] = 0; +inp[17866] = 62593; +inp[17867] = 0; +inp[17868] = 48747; +inp[17869] = 0; +inp[17870] = 37964; +inp[17871] = 0; +inp[17872] = 29567; +inp[17873] = 0; +inp[17874] = 23026; +inp[17875] = 0; +inp[17876] = 17933; +inp[17877] = 0; +inp[17878] = 13966; +inp[17879] = 0; +inp[17880] = 10877; +inp[17881] = 0; +inp[17882] = 8471; +inp[17883] = 0; +inp[17884] = 6597; +inp[17885] = 0; +inp[17886] = 5137; +inp[17887] = 0; +inp[17888] = 4001; +inp[17889] = 0; +inp[17890] = 3116; +inp[17891] = 0; +inp[17892] = 2427; +inp[17893] = 0; +inp[17894] = 1890; +inp[17895] = 0; +inp[17896] = 1472; +inp[17897] = 0; +inp[17898] = 1146; +inp[17899] = 0; +inp[17900] = 892; +inp[17901] = 0; +inp[17902] = 695; +inp[17903] = 0; +inp[17904] = 541; +inp[17905] = 0; +inp[17906] = 421; +inp[17907] = 0; +inp[17908] = 328; +inp[17909] = 0; +inp[17910] = 255; +inp[17911] = 0; +inp[17912] = 199; +inp[17913] = 0; +inp[17914] = 155; +inp[17915] = 0; +inp[17916] = 120; +inp[17917] = 0; +inp[17918] = 94; +inp[17919] = 0; +inp[17920] = 73; +inp[17921] = 0; +inp[17922] = 57; +inp[17923] = 0; +inp[17924] = 44; +inp[17925] = 0; +inp[17926] = 34; +inp[17927] = 0; +inp[17928] = 26; +inp[17929] = 0; +inp[17930] = 20; +inp[17931] = 0; +inp[17932] = 16; +inp[17933] = 0; +inp[17934] = 12; +inp[17935] = 0; +inp[17936] = 9; +inp[17937] = 0; +inp[17938] = 7; +inp[17939] = 0; +inp[17940] = 6; +inp[17941] = 0; +inp[17942] = 4; +inp[17943] = 0; +inp[17944] = 3; +inp[17945] = 0; +inp[17946] = 2; +inp[17947] = 0; +inp[17948] = 2; +inp[17949] = 0; +inp[17950] = 1; +inp[17951] = 0; +inp[17952] = 1; +inp[17953] = 0; +inp[17954] = 1; +inp[17955] = 0; +inp[17956] = 0; +inp[17957] = 0; +inp[17958] = 0; +inp[17959] = 0; +inp[17960] = 0; +inp[17961] = 0; +inp[17962] = 0; +inp[17963] = 0; +inp[17964] = 0; +inp[17965] = 0; +inp[17966] = 0; +inp[17967] = 0; +inp[17968] = 0; +inp[17969] = 0; +inp[17970] = 0; +inp[17971] = 0; +inp[17972] = 0; +inp[17973] = 0; +inp[17974] = 0; +inp[17975] = 0; +inp[17976] = 0; +inp[17977] = 0; +inp[17978] = 0; +inp[17979] = 0; +inp[17980] = 0; +inp[17981] = 0; +inp[17982] = 0; +inp[17983] = 0; +inp[17984] = 0; +inp[17985] = 0; +inp[17986] = 0; +inp[17987] = 0; +inp[17988] = 0; +inp[17989] = 0; +inp[17990] = 0; +inp[17991] = 0; +inp[17992] = 0; +inp[17993] = 0; +inp[17994] = 0; +inp[17995] = 0; +inp[17996] = 0; +inp[17997] = 0; +inp[17998] = 0; +inp[17999] = 0; +inp[18000] = 0; +inp[18001] = 0; +inp[18002] = 0; +inp[18003] = 0; +inp[18004] = 0; +inp[18005] = 0; +inp[18006] = 0; +inp[18007] = 0; +inp[18008] = 0; +inp[18009] = 0; +inp[18010] = 0; +inp[18011] = 0; +inp[18012] = 0; +inp[18013] = 0; +inp[18014] = 0; +inp[18015] = 0; +inp[18016] = 0; +inp[18017] = 0; +inp[18018] = 0; +inp[18019] = 0; +inp[18020] = 0; +inp[18021] = 0; +inp[18022] = 0; +inp[18023] = 0; +inp[18024] = 0; +inp[18025] = 0; +inp[18026] = 0; +inp[18027] = 0; +inp[18028] = 0; +inp[18029] = 0; +inp[18030] = 0; +inp[18031] = 0; +inp[18032] = 0; +inp[18033] = 0; +inp[18034] = 0; +inp[18035] = 0; +inp[18036] = 0; +inp[18037] = 0; +inp[18038] = 0; +inp[18039] = 0; +inp[18040] = 0; +inp[18041] = 0; +inp[18042] = 0; +inp[18043] = 0; +inp[18044] = 0; +inp[18045] = 0; +inp[18046] = 0; +inp[18047] = 0; +inp[18048] = 0; +inp[18049] = 0; +inp[18050] = 0; +inp[18051] = 0; +inp[18052] = 0; +inp[18053] = 0; +inp[18054] = 0; +inp[18055] = 0; +inp[18056] = 0; +inp[18057] = 0; +inp[18058] = 0; +inp[18059] = 0; +inp[18060] = 0; +inp[18061] = 0; +inp[18062] = 0; +inp[18063] = 0; +inp[18064] = 0; +inp[18065] = 0; +inp[18066] = 0; +inp[18067] = 0; +inp[18068] = 0; +inp[18069] = 0; +inp[18070] = 0; +inp[18071] = 0; +inp[18072] = 0; +inp[18073] = 0; +inp[18074] = 0; +inp[18075] = 0; +inp[18076] = 0; +inp[18077] = 0; +inp[18078] = 0; +inp[18079] = 0; +inp[18080] = 0; +inp[18081] = 0; +inp[18082] = 0; +inp[18083] = 0; +inp[18084] = 0; +inp[18085] = 0; +inp[18086] = 0; +inp[18087] = 0; +inp[18088] = 0; +inp[18089] = 0; +inp[18090] = 0; +inp[18091] = 0; +inp[18092] = 0; +inp[18093] = 0; +inp[18094] = 0; +inp[18095] = 0; +inp[18096] = 0; +inp[18097] = 0; +inp[18098] = 0; +inp[18099] = 0; +inp[18100] = 0; +inp[18101] = 0; +inp[18102] = 0; +inp[18103] = 0; +inp[18104] = 0; +inp[18105] = 0; +inp[18106] = 0; +inp[18107] = 0; +inp[18108] = 0; +inp[18109] = 0; +inp[18110] = 0; +inp[18111] = 0; +inp[18112] = 0; +inp[18113] = 0; +inp[18114] = 0; +inp[18115] = 0; +inp[18116] = 0; +inp[18117] = 0; +inp[18118] = 0; +inp[18119] = 0; +inp[18120] = 0; +inp[18121] = 0; +inp[18122] = 0; +inp[18123] = 0; +inp[18124] = 0; +inp[18125] = 0; +inp[18126] = 0; +inp[18127] = 0; +inp[18128] = 0; +inp[18129] = 0; +inp[18130] = 0; +inp[18131] = 0; +inp[18132] = 0; +inp[18133] = 0; +inp[18134] = 0; +inp[18135] = 0; +inp[18136] = 0; +inp[18137] = 0; +inp[18138] = 0; +inp[18139] = 0; +inp[18140] = 0; +inp[18141] = 0; +inp[18142] = 0; +inp[18143] = 0; +inp[18144] = 0; +inp[18145] = 0; +inp[18146] = 0; +inp[18147] = 0; +inp[18148] = 0; +inp[18149] = 0; +inp[18150] = 0; +inp[18151] = 0; +inp[18152] = 0; +inp[18153] = 0; +inp[18154] = 0; +inp[18155] = 0; +inp[18156] = 0; +inp[18157] = 0; +inp[18158] = 0; +inp[18159] = 0; +inp[18160] = 0; +inp[18161] = 0; +inp[18162] = 0; +inp[18163] = 0; +inp[18164] = 0; +inp[18165] = 0; +inp[18166] = 0; +inp[18167] = 0; +inp[18168] = 0; +inp[18169] = 0; +inp[18170] = 0; +inp[18171] = 0; +inp[18172] = 0; +inp[18173] = 0; +inp[18174] = 0; +inp[18175] = 0; +inp[18176] = 0; +inp[18177] = 0; +inp[18178] = 0; +inp[18179] = 0; +inp[18180] = 0; +inp[18181] = 0; +inp[18182] = 0; +inp[18183] = 0; +inp[18184] = 0; +inp[18185] = 0; +inp[18186] = 0; +inp[18187] = 0; +inp[18188] = 0; +inp[18189] = 0; +inp[18190] = 0; +inp[18191] = 0; +inp[18192] = 0; +inp[18193] = 0; +inp[18194] = 0; +inp[18195] = 0; +inp[18196] = 0; +inp[18197] = 0; +inp[18198] = 0; +inp[18199] = 0; +inp[18200] = 0; +inp[18201] = 0; +inp[18202] = 0; +inp[18203] = 0; +inp[18204] = 0; +inp[18205] = 0; +inp[18206] = 0; +inp[18207] = 0; +inp[18208] = 0; +inp[18209] = 0; +inp[18210] = 0; +inp[18211] = 0; +inp[18212] = 0; +inp[18213] = 0; +inp[18214] = 0; +inp[18215] = 0; +inp[18216] = 0; +inp[18217] = 0; +inp[18218] = 0; +inp[18219] = 0; +inp[18220] = 0; +inp[18221] = 0; +inp[18222] = 0; +inp[18223] = 0; +inp[18224] = 0; +inp[18225] = 0; +inp[18226] = 0; +inp[18227] = 0; +inp[18228] = 0; +inp[18229] = 0; +inp[18230] = 0; +inp[18231] = 0; +inp[18232] = 0; +inp[18233] = 0; +inp[18234] = 0; +inp[18235] = 0; +inp[18236] = 0; +inp[18237] = 0; +inp[18238] = 0; +inp[18239] = 0; +inp[18240] = 0; +inp[18241] = 0; +inp[18242] = 0; +inp[18243] = 0; +inp[18244] = 0; +inp[18245] = 0; +inp[18246] = 0; +inp[18247] = 0; +inp[18248] = 0; +inp[18249] = 0; +inp[18250] = 0; +inp[18251] = 0; +inp[18252] = 0; +inp[18253] = 0; +inp[18254] = 0; +inp[18255] = 0; +inp[18256] = 0; +inp[18257] = 0; +inp[18258] = 0; +inp[18259] = 0; +inp[18260] = 0; +inp[18261] = 0; +inp[18262] = 0; +inp[18263] = 0; +inp[18264] = 0; +inp[18265] = 0; +inp[18266] = 0; +inp[18267] = 0; +inp[18268] = 0; +inp[18269] = 0; +inp[18270] = 0; +inp[18271] = 0; +inp[18272] = 0; +inp[18273] = 0; +inp[18274] = 0; +inp[18275] = 0; +inp[18276] = 0; +inp[18277] = 0; +inp[18278] = 0; +inp[18279] = 0; +inp[18280] = 0; +inp[18281] = 0; +inp[18282] = 0; +inp[18283] = 0; +inp[18284] = 0; +inp[18285] = 0; +inp[18286] = 0; +inp[18287] = 0; +inp[18288] = 0; +inp[18289] = 0; +inp[18290] = 0; +inp[18291] = 0; +inp[18292] = 0; +inp[18293] = 0; +inp[18294] = 0; +inp[18295] = 0; +inp[18296] = 0; +inp[18297] = 0; +inp[18298] = 0; +inp[18299] = 0; +inp[18300] = 1073741824; +inp[18301] = 1073741824; +inp[18302] = 947573833; +inp[18303] = 360200; +inp[18304] = 836230973; +inp[18305] = 120; +inp[18306] = 737971243; +inp[18307] = 0; +inp[18308] = 651257336; +inp[18309] = 0; +inp[18310] = 574732582; +inp[18311] = 0; +inp[18312] = 507199723; +inp[18313] = 0; +inp[18314] = 447602185; +inp[18315] = 0; +inp[18316] = 395007542; +inp[18317] = 0; +inp[18318] = 348592932; +inp[18319] = 0; +inp[18320] = 307632183; +inp[18321] = 0; +inp[18322] = 271484448; +inp[18323] = 0; +inp[18324] = 239584185; +inp[18325] = 0; +inp[18326] = 211432301; +inp[18327] = 0; +inp[18328] = 186588351; +inp[18329] = 0; +inp[18330] = 164663641; +inp[18331] = 0; +inp[18332] = 145315153; +inp[18333] = 0; +inp[18334] = 128240173; +inp[18335] = 0; +inp[18336] = 113171555; +inp[18337] = 0; +inp[18338] = 99873547; +inp[18339] = 0; +inp[18340] = 88138096; +inp[18341] = 0; +inp[18342] = 77781596; +inp[18343] = 0; +inp[18344] = 68642018; +inp[18345] = 0; +inp[18346] = 60576368; +inp[18347] = 0; +inp[18348] = 53458457; +inp[18349] = 0; +inp[18350] = 47176923; +inp[18351] = 0; +inp[18352] = 41633488; +inp[18353] = 0; +inp[18354] = 36741424; +inp[18355] = 0; +inp[18356] = 32424193; +inp[18357] = 0; +inp[18358] = 28614250; +inp[18359] = 0; +inp[18360] = 25251987; +inp[18361] = 0; +inp[18362] = 22284800; +inp[18363] = 0; +inp[18364] = 19666267; +inp[18365] = 0; +inp[18366] = 17355420; +inp[18367] = 0; +inp[18368] = 15316104; +inp[18369] = 0; +inp[18370] = 13516414; +inp[18371] = 0; +inp[18372] = 11928194; +inp[18373] = 0; +inp[18374] = 10526594; +inp[18375] = 0; +inp[18376] = 9289686; +inp[18377] = 0; +inp[18378] = 8198119; +inp[18379] = 0; +inp[18380] = 7234815; +inp[18381] = 0; +inp[18382] = 6384702; +inp[18383] = 0; +inp[18384] = 5634479; +inp[18385] = 0; +inp[18386] = 4972411; +inp[18387] = 0; +inp[18388] = 4388137; +inp[18389] = 0; +inp[18390] = 3872517; +inp[18391] = 0; +inp[18392] = 3417484; +inp[18393] = 0; +inp[18394] = 3015919; +inp[18395] = 0; +inp[18396] = 2661539; +inp[18397] = 0; +inp[18398] = 2348800; +inp[18399] = 0; +inp[18400] = 2072809; +inp[18401] = 0; +inp[18402] = 1829247; +inp[18403] = 0; +inp[18404] = 1614305; +inp[18405] = 0; +inp[18406] = 1424619; +inp[18407] = 0; +inp[18408] = 1257222; +inp[18409] = 0; +inp[18410] = 1109494; +inp[18411] = 0; +inp[18412] = 979125; +inp[18413] = 0; +inp[18414] = 864075; +inp[18415] = 0; +inp[18416] = 762543; +inp[18417] = 0; +inp[18418] = 672942; +inp[18419] = 0; +inp[18420] = 593869; +inp[18421] = 0; +inp[18422] = 524088; +inp[18423] = 0; +inp[18424] = 462506; +inp[18425] = 0; +inp[18426] = 408160; +inp[18427] = 0; +inp[18428] = 360200; +inp[18429] = 0; +inp[18430] = 317875; +inp[18431] = 0; +inp[18432] = 280524; +inp[18433] = 0; +inp[18434] = 247561; +inp[18435] = 0; +inp[18436] = 218472; +inp[18437] = 0; +inp[18438] = 192801; +inp[18439] = 0; +inp[18440] = 170146; +inp[18441] = 0; +inp[18442] = 150153; +inp[18443] = 0; +inp[18444] = 132510; +inp[18445] = 0; +inp[18446] = 116939; +inp[18447] = 0; +inp[18448] = 103199; +inp[18449] = 0; +inp[18450] = 91072; +inp[18451] = 0; +inp[18452] = 80371; +inp[18453] = 0; +inp[18454] = 70927; +inp[18455] = 0; +inp[18456] = 62593; +inp[18457] = 0; +inp[18458] = 55238; +inp[18459] = 0; +inp[18460] = 48747; +inp[18461] = 0; +inp[18462] = 43019; +inp[18463] = 0; +inp[18464] = 37964; +inp[18465] = 0; +inp[18466] = 33503; +inp[18467] = 0; +inp[18468] = 29567; +inp[18469] = 0; +inp[18470] = 26092; +inp[18471] = 0; +inp[18472] = 23026; +inp[18473] = 0; +inp[18474] = 20321; +inp[18475] = 0; +inp[18476] = 17933; +inp[18477] = 0; +inp[18478] = 15826; +inp[18479] = 0; +inp[18480] = 13966; +inp[18481] = 0; +inp[18482] = 12325; +inp[18483] = 0; +inp[18484] = 10877; +inp[18485] = 0; +inp[18486] = 9599; +inp[18487] = 0; +inp[18488] = 8471; +inp[18489] = 0; +inp[18490] = 7475; +inp[18491] = 0; +inp[18492] = 6597; +inp[18493] = 0; +inp[18494] = 5822; +inp[18495] = 0; +inp[18496] = 5137; +inp[18497] = 0; +inp[18498] = 4534; +inp[18499] = 0; +inp[18500] = 4001; +inp[18501] = 0; +inp[18502] = 3531; +inp[18503] = 0; +inp[18504] = 3116; +inp[18505] = 0; +inp[18506] = 2750; +inp[18507] = 0; +inp[18508] = 2427; +inp[18509] = 0; +inp[18510] = 2141; +inp[18511] = 0; +inp[18512] = 1890; +inp[18513] = 0; +inp[18514] = 1668; +inp[18515] = 0; +inp[18516] = 1472; +inp[18517] = 0; +inp[18518] = 1299; +inp[18519] = 0; +inp[18520] = 1146; +inp[18521] = 0; +inp[18522] = 1011; +inp[18523] = 0; +inp[18524] = 892; +inp[18525] = 0; +inp[18526] = 787; +inp[18527] = 0; +inp[18528] = 695; +inp[18529] = 0; +inp[18530] = 613; +inp[18531] = 0; +inp[18532] = 541; +inp[18533] = 0; +inp[18534] = 477; +inp[18535] = 0; +inp[18536] = 421; +inp[18537] = 0; +inp[18538] = 372; +inp[18539] = 0; +inp[18540] = 328; +inp[18541] = 0; +inp[18542] = 289; +inp[18543] = 0; +inp[18544] = 255; +inp[18545] = 0; +inp[18546] = 225; +inp[18547] = 0; +inp[18548] = 199; +inp[18549] = 0; +inp[18550] = 175; +inp[18551] = 0; +inp[18552] = 155; +inp[18553] = 0; +inp[18554] = 136; +inp[18555] = 0; +inp[18556] = 120; +inp[18557] = 0; +inp[18558] = 106; +inp[18559] = 0; +inp[18560] = 94; +inp[18561] = 0; +inp[18562] = 83; +inp[18563] = 0; +inp[18564] = 73; +inp[18565] = 0; +inp[18566] = 64; +inp[18567] = 0; +inp[18568] = 57; +inp[18569] = 0; +inp[18570] = 50; +inp[18571] = 0; +inp[18572] = 44; +inp[18573] = 0; +inp[18574] = 39; +inp[18575] = 0; +inp[18576] = 34; +inp[18577] = 0; +inp[18578] = 30; +inp[18579] = 0; +inp[18580] = 26; +inp[18581] = 0; +inp[18582] = 23; +inp[18583] = 0; +inp[18584] = 20; +inp[18585] = 0; +inp[18586] = 18; +inp[18587] = 0; +inp[18588] = 16; +inp[18589] = 0; +inp[18590] = 14; +inp[18591] = 0; +inp[18592] = 12; +inp[18593] = 0; +inp[18594] = 11; +inp[18595] = 0; +inp[18596] = 9; +inp[18597] = 0; +inp[18598] = 8; +inp[18599] = 0; +inp[18600] = 7; +inp[18601] = 0; +inp[18602] = 6; +inp[18603] = 0; +inp[18604] = 6; +inp[18605] = 0; +inp[18606] = 5; +inp[18607] = 0; +inp[18608] = 4; +inp[18609] = 0; +inp[18610] = 4; +inp[18611] = 0; +inp[18612] = 3; +inp[18613] = 0; +inp[18614] = 3; +inp[18615] = 0; +inp[18616] = 2; +inp[18617] = 0; +inp[18618] = 2; +inp[18619] = 0; +inp[18620] = 2; +inp[18621] = 0; +inp[18622] = 1; +inp[18623] = 0; +inp[18624] = 1; +inp[18625] = 0; +inp[18626] = 1; +inp[18627] = 0; +inp[18628] = 1; +inp[18629] = 0; +inp[18630] = 1; +inp[18631] = 0; +inp[18632] = 1; +inp[18633] = 0; +inp[18634] = 0; +inp[18635] = 0; +inp[18636] = 0; +inp[18637] = 0; +inp[18638] = 0; +inp[18639] = 0; +inp[18640] = 0; +inp[18641] = 0; +inp[18642] = 0; +inp[18643] = 0; +inp[18644] = 0; +inp[18645] = 0; +inp[18646] = 0; +inp[18647] = 0; +inp[18648] = 0; +inp[18649] = 0; +inp[18650] = 0; +inp[18651] = 0; +inp[18652] = 0; +inp[18653] = 0; +inp[18654] = 0; +inp[18655] = 0; +inp[18656] = 0; +inp[18657] = 0; +inp[18658] = 0; +inp[18659] = 0; +inp[18660] = 0; +inp[18661] = 0; +inp[18662] = 0; +inp[18663] = 0; +inp[18664] = 0; +inp[18665] = 0; +inp[18666] = 0; +inp[18667] = 0; +inp[18668] = 0; +inp[18669] = 0; +inp[18670] = 0; +inp[18671] = 0; +inp[18672] = 0; +inp[18673] = 0; +inp[18674] = 0; +inp[18675] = 0; +inp[18676] = 0; +inp[18677] = 0; +inp[18678] = 0; +inp[18679] = 0; +inp[18680] = 0; +inp[18681] = 0; +inp[18682] = 0; +inp[18683] = 0; +inp[18684] = 0; +inp[18685] = 0; +inp[18686] = 0; +inp[18687] = 0; +inp[18688] = 0; +inp[18689] = 0; +inp[18690] = 0; +inp[18691] = 0; +inp[18692] = 0; +inp[18693] = 0; +inp[18694] = 0; +inp[18695] = 0; +inp[18696] = 0; +inp[18697] = 0; +inp[18698] = 0; +inp[18699] = 0; +inp[18700] = 0; +inp[18701] = 0; +inp[18702] = 0; +inp[18703] = 0; +inp[18704] = 0; +inp[18705] = 0; +inp[18706] = 0; +inp[18707] = 0; +inp[18708] = 0; +inp[18709] = 0; +inp[18710] = 0; +inp[18711] = 0; +inp[18712] = 0; +inp[18713] = 0; +inp[18714] = 0; +inp[18715] = 0; +inp[18716] = 0; +inp[18717] = 0; +inp[18718] = 0; +inp[18719] = 0; +inp[18720] = 0; +inp[18721] = 0; +inp[18722] = 0; +inp[18723] = 0; +inp[18724] = 0; +inp[18725] = 0; +inp[18726] = 0; +inp[18727] = 0; +inp[18728] = 0; +inp[18729] = 0; +inp[18730] = 0; +inp[18731] = 0; +inp[18732] = 0; +inp[18733] = 0; +inp[18734] = 0; +inp[18735] = 0; +inp[18736] = 0; +inp[18737] = 0; +inp[18738] = 0; +inp[18739] = 0; +inp[18740] = 0; +inp[18741] = 0; +inp[18742] = 0; +inp[18743] = 0; +inp[18744] = 0; +inp[18745] = 0; +inp[18746] = 0; +inp[18747] = 0; +inp[18748] = 0; +inp[18749] = 0; +inp[18750] = 0; +inp[18751] = 0; +inp[18752] = 0; +inp[18753] = 0; +inp[18754] = 0; +inp[18755] = 0; +inp[18756] = 0; +inp[18757] = 0; +inp[18758] = 0; +inp[18759] = 0; +inp[18760] = 0; +inp[18761] = 0; +inp[18762] = 0; +inp[18763] = 0; +inp[18764] = 0; +inp[18765] = 0; +inp[18766] = 0; +inp[18767] = 0; +inp[18768] = 0; +inp[18769] = 0; +inp[18770] = 0; +inp[18771] = 0; +inp[18772] = 0; +inp[18773] = 0; +inp[18774] = 0; +inp[18775] = 0; +inp[18776] = 0; +inp[18777] = 0; +inp[18778] = 0; +inp[18779] = 0; +inp[18780] = 0; +inp[18781] = 0; +inp[18782] = 0; +inp[18783] = 0; +inp[18784] = 0; +inp[18785] = 0; +inp[18786] = 0; +inp[18787] = 0; +inp[18788] = 0; +inp[18789] = 0; +inp[18790] = 0; +inp[18791] = 0; +inp[18792] = 0; +inp[18793] = 0; +inp[18794] = 0; +inp[18795] = 0; +inp[18796] = 0; +inp[18797] = 0; +inp[18798] = 0; +inp[18799] = 0; +inp[18800] = 0; +inp[18801] = 0; +inp[18802] = 0; +inp[18803] = 0; +inp[18804] = 0; +inp[18805] = 0; +inp[18806] = 0; +inp[18807] = 0; +inp[18808] = 0; +inp[18809] = 0; +inp[18810] = 0; +inp[18811] = 0; +inp[18812] = 1073741824; +inp[18813] = 1073741824; +inp[18814] = 1008687095; +inp[18815] = 120; +inp[18816] = 947573833; +inp[18817] = 0; +inp[18818] = 890163237; +inp[18819] = 0; +inp[18820] = 836230973; +inp[18821] = 0; +inp[18822] = 785566299; +inp[18823] = 0; +inp[18824] = 737971243; +inp[18825] = 0; +inp[18826] = 693259826; +inp[18827] = 0; +inp[18828] = 651257336; +inp[18829] = 0; +inp[18830] = 611799649; +inp[18831] = 0; +inp[18832] = 574732582; +inp[18833] = 0; +inp[18834] = 539911295; +inp[18835] = 0; +inp[18836] = 507199723; +inp[18837] = 0; +inp[18838] = 476470046; +inp[18839] = 0; +inp[18840] = 447602185; +inp[18841] = 0; +inp[18842] = 420483339; +inp[18843] = 0; +inp[18844] = 395007542; +inp[18845] = 0; +inp[18846] = 371075245; +inp[18847] = 0; +inp[18848] = 348592932; +inp[18849] = 0; +inp[18850] = 327472754; +inp[18851] = 0; +inp[18852] = 307632183; +inp[18853] = 0; +inp[18854] = 288993691; +inp[18855] = 0; +inp[18856] = 271484448; +inp[18857] = 0; +inp[18858] = 255036037; +inp[18859] = 0; +inp[18860] = 239584185; +inp[18861] = 0; +inp[18862] = 225068513; +inp[18863] = 0; +inp[18864] = 211432301; +inp[18865] = 0; +inp[18866] = 198622265; +inp[18867] = 0; +inp[18868] = 186588351; +inp[18869] = 0; +inp[18870] = 175283534; +inp[18871] = 0; +inp[18872] = 164663641; +inp[18873] = 0; +inp[18874] = 154687176; +inp[18875] = 0; +inp[18876] = 145315153; +inp[18877] = 0; +inp[18878] = 136510953; +inp[18879] = 0; +inp[18880] = 128240173; +inp[18881] = 0; +inp[18882] = 120470493; +inp[18883] = 0; +inp[18884] = 113171555; +inp[18885] = 0; +inp[18886] = 106314837; +inp[18887] = 0; +inp[18888] = 99873547; +inp[18889] = 0; +inp[18890] = 93822514; +inp[18891] = 0; +inp[18892] = 88138096; +inp[18893] = 0; +inp[18894] = 82798078; +inp[18895] = 0; +inp[18896] = 77781596; +inp[18897] = 0; +inp[18898] = 73069048; +inp[18899] = 0; +inp[18900] = 68642018; +inp[18901] = 0; +inp[18902] = 64483208; +inp[18903] = 0; +inp[18904] = 60576368; +inp[18905] = 0; +inp[18906] = 56906231; +inp[18907] = 0; +inp[18908] = 53458457; +inp[18909] = 0; +inp[18910] = 50219573; +inp[18911] = 0; +inp[18912] = 47176923; +inp[18913] = 0; +inp[18914] = 44318617; +inp[18915] = 0; +inp[18916] = 41633488; +inp[18917] = 0; +inp[18918] = 39111043; +inp[18919] = 0; +inp[18920] = 36741424; +inp[18921] = 0; +inp[18922] = 34515374; +inp[18923] = 0; +inp[18924] = 32424193; +inp[18925] = 0; +inp[18926] = 30459710; +inp[18927] = 0; +inp[18928] = 28614250; +inp[18929] = 0; +inp[18930] = 26880600; +inp[18931] = 0; +inp[18932] = 25251987; +inp[18933] = 0; +inp[18934] = 23722046; +inp[18935] = 0; +inp[18936] = 22284800; +inp[18937] = 0; +inp[18938] = 20934632; +inp[18939] = 0; +inp[18940] = 19666267; +inp[18941] = 0; +inp[18942] = 18474748; +inp[18943] = 0; +inp[18944] = 17355420; +inp[18945] = 0; +inp[18946] = 16303908; +inp[18947] = 0; +inp[18948] = 15316104; +inp[18949] = 0; +inp[18950] = 14388148; +inp[18951] = 0; +inp[18952] = 13516414; +inp[18953] = 0; +inp[18954] = 12697496; +inp[18955] = 0; +inp[18956] = 11928194; +inp[18957] = 0; +inp[18958] = 11205501; +inp[18959] = 0; +inp[18960] = 10526594; +inp[18961] = 0; +inp[18962] = 9888820; +inp[18963] = 0; +inp[18964] = 9289686; +inp[18965] = 0; +inp[18966] = 8726853; +inp[18967] = 0; +inp[18968] = 8198119; +inp[18969] = 0; +inp[18970] = 7701421; +inp[18971] = 0; +inp[18972] = 7234815; +inp[18973] = 0; +inp[18974] = 6796480; +inp[18975] = 0; +inp[18976] = 6384702; +inp[18977] = 0; +inp[18978] = 5997872; +inp[18979] = 0; +inp[18980] = 5634479; +inp[18981] = 0; +inp[18982] = 5293104; +inp[18983] = 0; +inp[18984] = 4972411; +inp[18985] = 0; +inp[18986] = 4671147; +inp[18987] = 0; +inp[18988] = 4388137; +inp[18989] = 0; +inp[18990] = 4122273; +inp[18991] = 0; +inp[18992] = 3872517; +inp[18993] = 0; +inp[18994] = 3637893; +inp[18995] = 0; +inp[18996] = 3417484; +inp[18997] = 0; +inp[18998] = 3210429; +inp[18999] = 0; +inp[19000] = 3015919; +inp[19001] = 0; +inp[19002] = 2833194; +inp[19003] = 0; +inp[19004] = 2661539; +inp[19005] = 0; +inp[19006] = 2500285; +inp[19007] = 0; +inp[19008] = 2348800; +inp[19009] = 0; +inp[19010] = 2206494; +inp[19011] = 0; +inp[19012] = 2072809; +inp[19013] = 0; +inp[19014] = 1947224; +inp[19015] = 0; +inp[19016] = 1829247; +inp[19017] = 0; +inp[19018] = 1718419; +inp[19019] = 0; +inp[19020] = 1614305; +inp[19021] = 0; +inp[19022] = 1516499; +inp[19023] = 0; +inp[19024] = 1424619; +inp[19025] = 0; +inp[19026] = 1338306; +inp[19027] = 0; +inp[19028] = 1257222; +inp[19029] = 0; +inp[19030] = 1181051; +inp[19031] = 0; +inp[19032] = 1109494; +inp[19033] = 0; +inp[19034] = 1042273; +inp[19035] = 0; +inp[19036] = 979125; +inp[19037] = 0; +inp[19038] = 919803; +inp[19039] = 0; +inp[19040] = 864075; +inp[19041] = 0; +inp[19042] = 811723; +inp[19043] = 0; +inp[19044] = 762543; +inp[19045] = 0; +inp[19046] = 716343; +inp[19047] = 0; +inp[19048] = 672942; +inp[19049] = 0; +inp[19050] = 632171; +inp[19051] = 0; +inp[19052] = 593869; +inp[19053] = 0; +inp[19054] = 557889; +inp[19055] = 0; +inp[19056] = 524088; +inp[19057] = 0; +inp[19058] = 492335; +inp[19059] = 0; +inp[19060] = 462506; +inp[19061] = 0; +inp[19062] = 434484; +inp[19063] = 0; +inp[19064] = 408160; +inp[19065] = 0; +inp[19066] = 383431; +inp[19067] = 0; +inp[19068] = 360200; +inp[19069] = 0; +inp[19070] = 338376; +inp[19071] = 0; +inp[19072] = 317875; +inp[19073] = 0; +inp[19074] = 298616; +inp[19075] = 0; +inp[19076] = 280524; +inp[19077] = 0; +inp[19078] = 263528; +inp[19079] = 0; +inp[19080] = 247561; +inp[19081] = 0; +inp[19082] = 232562; +inp[19083] = 0; +inp[19084] = 218472; +inp[19085] = 0; +inp[19086] = 205235; +inp[19087] = 0; +inp[19088] = 192801; +inp[19089] = 0; +inp[19090] = 181120; +inp[19091] = 0; +inp[19092] = 170146; +inp[19093] = 0; +inp[19094] = 159837; +inp[19095] = 0; +inp[19096] = 150153; +inp[19097] = 0; +inp[19098] = 141056; +inp[19099] = 0; +inp[19100] = 132510; +inp[19101] = 0; +inp[19102] = 124481; +inp[19103] = 0; +inp[19104] = 116939; +inp[19105] = 0; +inp[19106] = 109854; +inp[19107] = 0; +inp[19108] = 103199; +inp[19109] = 0; +inp[19110] = 96946; +inp[19111] = 0; +inp[19112] = 91072; +inp[19113] = 0; +inp[19114] = 85555; +inp[19115] = 0; +inp[19116] = 80371; +inp[19117] = 0; +inp[19118] = 75502; +inp[19119] = 0; +inp[19120] = 70927; +inp[19121] = 0; +inp[19122] = 66630; +inp[19123] = 0; +inp[19124] = 62593; +inp[19125] = 0; +inp[19126] = 58801; +inp[19127] = 0; +inp[19128] = 55238; +inp[19129] = 0; +inp[19130] = 51891; +inp[19131] = 0; +inp[19132] = 48747; +inp[19133] = 0; +inp[19134] = 45794; +inp[19135] = 0; +inp[19136] = 43019; +inp[19137] = 0; +inp[19138] = 40413; +inp[19139] = 0; +inp[19140] = 37964; +inp[19141] = 0; +inp[19142] = 35664; +inp[19143] = 0; +inp[19144] = 33503; +inp[19145] = 0; +inp[19146] = 31473; +inp[19147] = 0; +inp[19148] = 29567; +inp[19149] = 0; +inp[19150] = 27775; +inp[19151] = 0; +inp[19152] = 26092; +inp[19153] = 0; +inp[19154] = 24511; +inp[19155] = 0; +inp[19156] = 23026; +inp[19157] = 0; +inp[19158] = 21631; +inp[19159] = 0; +inp[19160] = 20321; +inp[19161] = 0; +inp[19162] = 19089; +inp[19163] = 0; +inp[19164] = 17933; +inp[19165] = 0; +inp[19166] = 16846; +inp[19167] = 0; +inp[19168] = 15826; +inp[19169] = 0; +inp[19170] = 14867; +inp[19171] = 0; +inp[19172] = 13966; +inp[19173] = 0; +inp[19174] = 13120; +inp[19175] = 0; +inp[19176] = 12325; +inp[19177] = 0; +inp[19178] = 11578; +inp[19179] = 0; +inp[19180] = 10877; +inp[19181] = 0; +inp[19182] = 10218; +inp[19183] = 0; +inp[19184] = 9599; +inp[19185] = 0; +inp[19186] = 9017; +inp[19187] = 0; +inp[19188] = 8471; +inp[19189] = 0; +inp[19190] = 7957; +inp[19191] = 0; +inp[19192] = 7475; +inp[19193] = 0; +inp[19194] = 7022; +inp[19195] = 0; +inp[19196] = 6597; +inp[19197] = 0; +inp[19198] = 6197; +inp[19199] = 0; +inp[19200] = 5822; +inp[19201] = 0; +inp[19202] = 5469; +inp[19203] = 0; +inp[19204] = 5137; +inp[19205] = 0; +inp[19206] = 4826; +inp[19207] = 0; +inp[19208] = 4534; +inp[19209] = 0; +inp[19210] = 4259; +inp[19211] = 0; +inp[19212] = 4001; +inp[19213] = 0; +inp[19214] = 3759; +inp[19215] = 0; +inp[19216] = 3531; +inp[19217] = 0; +inp[19218] = 3317; +inp[19219] = 0; +inp[19220] = 3116; +inp[19221] = 0; +inp[19222] = 2927; +inp[19223] = 0; +inp[19224] = 2750; +inp[19225] = 0; +inp[19226] = 2583; +inp[19227] = 0; +inp[19228] = 2427; +inp[19229] = 0; +inp[19230] = 2279; +inp[19231] = 0; +inp[19232] = 2141; +inp[19233] = 0; +inp[19234] = 2012; +inp[19235] = 0; +inp[19236] = 1890; +inp[19237] = 0; +inp[19238] = 1775; +inp[19239] = 0; +inp[19240] = 1668; +inp[19241] = 0; +inp[19242] = 1566; +inp[19243] = 0; +inp[19244] = 1472; +inp[19245] = 0; +inp[19246] = 1382; +inp[19247] = 0; +inp[19248] = 1299; +inp[19249] = 0; +inp[19250] = 1220; +inp[19251] = 0; +inp[19252] = 1146; +inp[19253] = 0; +inp[19254] = 1076; +inp[19255] = 0; +inp[19256] = 1011; +inp[19257] = 0; +inp[19258] = 950; +inp[19259] = 0; +inp[19260] = 892; +inp[19261] = 0; +inp[19262] = 838; +inp[19263] = 0; +inp[19264] = 787; +inp[19265] = 0; +inp[19266] = 740; +inp[19267] = 0; +inp[19268] = 695; +inp[19269] = 0; +inp[19270] = 653; +inp[19271] = 0; +inp[19272] = 613; +inp[19273] = 0; +inp[19274] = 576; +inp[19275] = 0; +inp[19276] = 541; +inp[19277] = 0; +inp[19278] = 508; +inp[19279] = 0; +inp[19280] = 477; +inp[19281] = 0; +inp[19282] = 448; +inp[19283] = 0; +inp[19284] = 421; +inp[19285] = 0; +inp[19286] = 396; +inp[19287] = 0; +inp[19288] = 372; +inp[19289] = 0; +inp[19290] = 349; +inp[19291] = 0; +inp[19292] = 328; +inp[19293] = 0; +inp[19294] = 308; +inp[19295] = 0; +inp[19296] = 289; +inp[19297] = 0; +inp[19298] = 272; +inp[19299] = 0; +inp[19300] = 255; +inp[19301] = 0; +inp[19302] = 240; +inp[19303] = 0; +inp[19304] = 225; +inp[19305] = 0; +inp[19306] = 212; +inp[19307] = 0; +inp[19308] = 199; +inp[19309] = 0; +inp[19310] = 187; +inp[19311] = 0; +inp[19312] = 175; +inp[19313] = 0; +inp[19314] = 165; +inp[19315] = 0; +inp[19316] = 155; +inp[19317] = 0; +inp[19318] = 145; +inp[19319] = 0; +inp[19320] = 136; +inp[19321] = 0; +inp[19322] = 128; +inp[19323] = 0; +inp[19324] = 1073741824; +inp[19325] = 1073741824; +inp[19326] = 1040706261; +inp[19327] = 0; +inp[19328] = 1008687095; +inp[19329] = 0; +inp[19330] = 977653056; +inp[19331] = 0; +inp[19332] = 947573833; +inp[19333] = 0; +inp[19334] = 918420051; +inp[19335] = 0; +inp[19336] = 890163237; +inp[19337] = 0; +inp[19338] = 862775793; +inp[19339] = 0; +inp[19340] = 836230973; +inp[19341] = 0; +inp[19342] = 810502851; +inp[19343] = 0; +inp[19344] = 785566299; +inp[19345] = 0; +inp[19346] = 761396965; +inp[19347] = 0; +inp[19348] = 737971243; +inp[19349] = 0; +inp[19350] = 715266255; +inp[19351] = 0; +inp[19352] = 693259826; +inp[19353] = 0; +inp[19354] = 671930463; +inp[19355] = 0; +inp[19356] = 651257336; +inp[19357] = 0; +inp[19358] = 631220255; +inp[19359] = 0; +inp[19360] = 611799649; +inp[19361] = 0; +inp[19362] = 592976553; +inp[19363] = 0; +inp[19364] = 574732582; +inp[19365] = 0; +inp[19366] = 557049919; +inp[19367] = 0; +inp[19368] = 539911295; +inp[19369] = 0; +inp[19370] = 523299971; +inp[19371] = 0; +inp[19372] = 507199723; +inp[19373] = 0; +inp[19374] = 491594828; +inp[19375] = 0; +inp[19376] = 476470046; +inp[19377] = 0; +inp[19378] = 461810603; +inp[19379] = 0; +inp[19380] = 447602185; +inp[19381] = 0; +inp[19382] = 433830913; +inp[19383] = 0; +inp[19384] = 420483339; +inp[19385] = 0; +inp[19386] = 407546427; +inp[19387] = 0; +inp[19388] = 395007542; +inp[19389] = 0; +inp[19390] = 382854437; +inp[19391] = 0; +inp[19392] = 371075245; +inp[19393] = 0; +inp[19394] = 359658459; +inp[19395] = 0; +inp[19396] = 348592932; +inp[19397] = 0; +inp[19398] = 337867855; +inp[19399] = 0; +inp[19400] = 327472754; +inp[19401] = 0; +inp[19402] = 317397476; +inp[19403] = 0; +inp[19404] = 307632183; +inp[19405] = 0; +inp[19406] = 298167335; +inp[19407] = 0; +inp[19408] = 288993691; +inp[19409] = 0; +inp[19410] = 280102290; +inp[19411] = 0; +inp[19412] = 271484448; +inp[19413] = 0; +inp[19414] = 263131750; +inp[19415] = 0; +inp[19416] = 255036037; +inp[19417] = 0; +inp[19418] = 247189403; +inp[19419] = 0; +inp[19420] = 239584185; +inp[19421] = 0; +inp[19422] = 232212954; +inp[19423] = 0; +inp[19424] = 225068513; +inp[19425] = 0; +inp[19426] = 218143882; +inp[19427] = 0; +inp[19428] = 211432301; +inp[19429] = 0; +inp[19430] = 204927213; +inp[19431] = 0; +inp[19432] = 198622265; +inp[19433] = 0; +inp[19434] = 192511301; +inp[19435] = 0; +inp[19436] = 186588351; +inp[19437] = 0; +inp[19438] = 180847630; +inp[19439] = 0; +inp[19440] = 175283534; +inp[19441] = 0; +inp[19442] = 169890626; +inp[19443] = 0; +inp[19444] = 164663641; +inp[19445] = 0; +inp[19446] = 159597474; +inp[19447] = 0; +inp[19448] = 154687176; +inp[19449] = 0; +inp[19450] = 149927952; +inp[19451] = 0; +inp[19452] = 145315153; +inp[19453] = 0; +inp[19454] = 140844276; +inp[19455] = 0; +inp[19456] = 136510953; +inp[19457] = 0; +inp[19458] = 132310953; +inp[19459] = 0; +inp[19460] = 128240173; +inp[19461] = 0; +inp[19462] = 124294637; +inp[19463] = 0; +inp[19464] = 120470493; +inp[19465] = 0; +inp[19466] = 116764006; +inp[19467] = 0; +inp[19468] = 113171555; +inp[19469] = 0; +inp[19470] = 109689632; +inp[19471] = 0; +inp[19472] = 106314837; +inp[19473] = 0; +inp[19474] = 103043874; +inp[19475] = 0; +inp[19476] = 99873547; +inp[19477] = 0; +inp[19478] = 96800761; +inp[19479] = 0; +inp[19480] = 93822514; +inp[19481] = 0; +inp[19482] = 90935899; +inp[19483] = 0; +inp[19484] = 88138096; +inp[19485] = 0; +inp[19486] = 85426372; +inp[19487] = 0; +inp[19488] = 82798078; +inp[19489] = 0; +inp[19490] = 80250649; +inp[19491] = 0; +inp[19492] = 77781596; +inp[19493] = 0; +inp[19494] = 75388508; +inp[19495] = 0; +inp[19496] = 73069048; +inp[19497] = 0; +inp[19498] = 70820949; +inp[19499] = 0; +inp[19500] = 68642018; +inp[19501] = 0; +inp[19502] = 66530125; +inp[19503] = 0; +inp[19504] = 64483208; +inp[19505] = 0; +inp[19506] = 62499268; +inp[19507] = 0; +inp[19508] = 60576368; +inp[19509] = 0; +inp[19510] = 58712629; +inp[19511] = 0; +inp[19512] = 56906231; +inp[19513] = 0; +inp[19514] = 55155411; +inp[19515] = 0; +inp[19516] = 53458457; +inp[19517] = 0; +inp[19518] = 51813713; +inp[19519] = 0; +inp[19520] = 50219573; +inp[19521] = 0; +inp[19522] = 48674479; +inp[19523] = 0; +inp[19524] = 47176923; +inp[19525] = 0; +inp[19526] = 45725441; +inp[19527] = 0; +inp[19528] = 44318617; +inp[19529] = 0; +inp[19530] = 42955077; +inp[19531] = 0; +inp[19532] = 41633488; +inp[19533] = 0; +inp[19534] = 40352560; +inp[19535] = 0; +inp[19536] = 39111043; +inp[19537] = 0; +inp[19538] = 37907722; +inp[19539] = 0; +inp[19540] = 36741424; +inp[19541] = 0; +inp[19542] = 35611009; +inp[19543] = 0; +inp[19544] = 34515374; +inp[19545] = 0; +inp[19546] = 33453447; +inp[19547] = 0; +inp[19548] = 32424193; +inp[19549] = 0; +inp[19550] = 31426605; +inp[19551] = 0; +inp[19552] = 30459710; +inp[19553] = 0; +inp[19554] = 29522564; +inp[19555] = 0; +inp[19556] = 28614250; +inp[19557] = 0; +inp[19558] = 27733882; +inp[19559] = 0; +inp[19560] = 26880600; +inp[19561] = 0; +inp[19562] = 26053571; +inp[19563] = 0; +inp[19564] = 25251987; +inp[19565] = 0; +inp[19566] = 24475065; +inp[19567] = 0; +inp[19568] = 23722046; +inp[19569] = 0; +inp[19570] = 22992196; +inp[19571] = 0; +inp[19572] = 22284800; +inp[19573] = 0; +inp[19574] = 21599169; +inp[19575] = 0; +inp[19576] = 20934632; +inp[19577] = 0; +inp[19578] = 20290541; +inp[19579] = 0; +inp[19580] = 19666267; +inp[19581] = 0; +inp[19582] = 19061200; +inp[19583] = 0; +inp[19584] = 18474748; +inp[19585] = 0; +inp[19586] = 17906340; +inp[19587] = 0; +inp[19588] = 17355420; +inp[19589] = 0; +inp[19590] = 16821450; +inp[19591] = 0; +inp[19592] = 16303908; +inp[19593] = 0; +inp[19594] = 15802289; +inp[19595] = 0; +inp[19596] = 15316104; +inp[19597] = 0; +inp[19598] = 14844877; +inp[19599] = 0; +inp[19600] = 14388148; +inp[19601] = 0; +inp[19602] = 13945471; +inp[19603] = 0; +inp[19604] = 13516414; +inp[19605] = 0; +inp[19606] = 13100558; +inp[19607] = 0; +inp[19608] = 12697496; +inp[19609] = 0; +inp[19610] = 12306835; +inp[19611] = 0; +inp[19612] = 11928194; +inp[19613] = 0; +inp[19614] = 11561202; +inp[19615] = 0; +inp[19616] = 11205501; +inp[19617] = 0; +inp[19618] = 10860744; +inp[19619] = 0; +inp[19620] = 10526594; +inp[19621] = 0; +inp[19622] = 10202725; +inp[19623] = 0; +inp[19624] = 9888820; +inp[19625] = 0; +inp[19626] = 9584573; +inp[19627] = 0; +inp[19628] = 9289686; +inp[19629] = 0; +inp[19630] = 9003873; +inp[19631] = 0; +inp[19632] = 8726853; +inp[19633] = 0; +inp[19634] = 8458356; +inp[19635] = 0; +inp[19636] = 8198119; +inp[19637] = 0; +inp[19638] = 7945890; +inp[19639] = 0; +inp[19640] = 7701421; +inp[19641] = 0; +inp[19642] = 7464473; +inp[19643] = 0; +inp[19644] = 7234815; +inp[19645] = 0; +inp[19646] = 7012223; +inp[19647] = 0; +inp[19648] = 6796480; +inp[19649] = 0; +inp[19650] = 6587374; +inp[19651] = 0; +inp[19652] = 6384702; +inp[19653] = 0; +inp[19654] = 6188265; +inp[19655] = 0; +inp[19656] = 5997872; +inp[19657] = 0; +inp[19658] = 5813337; +inp[19659] = 0; +inp[19660] = 5634479; +inp[19661] = 0; +inp[19662] = 5461125; +inp[19663] = 0; +inp[19664] = 5293104; +inp[19665] = 0; +inp[19666] = 5130252; +inp[19667] = 0; +inp[19668] = 4972411; +inp[19669] = 0; +inp[19670] = 4819426; +inp[19671] = 0; +inp[19672] = 4671147; +inp[19673] = 0; +inp[19674] = 4527431; +inp[19675] = 0; +inp[19676] = 4388137; +inp[19677] = 0; +inp[19678] = 4253128; +inp[19679] = 0; +inp[19680] = 4122273; +inp[19681] = 0; +inp[19682] = 3995444; +inp[19683] = 0; +inp[19684] = 3872517; +inp[19685] = 0; +inp[19686] = 3753372; +inp[19687] = 0; +inp[19688] = 3637893; +inp[19689] = 0; +inp[19690] = 3525967; +inp[19691] = 0; +inp[19692] = 3417484; +inp[19693] = 0; +inp[19694] = 3312339; +inp[19695] = 0; +inp[19696] = 3210429; +inp[19697] = 0; +inp[19698] = 3111655; +inp[19699] = 0; +inp[19700] = 3015919; +inp[19701] = 0; +inp[19702] = 2923129; +inp[19703] = 0; +inp[19704] = 2833194; +inp[19705] = 0; +inp[19706] = 2746026; +inp[19707] = 0; +inp[19708] = 2661539; +inp[19709] = 0; +inp[19710] = 2579652; +inp[19711] = 0; +inp[19712] = 2500285; +inp[19713] = 0; +inp[19714] = 2423359; +inp[19715] = 0; +inp[19716] = 2348800; +inp[19717] = 0; +inp[19718] = 2276535; +inp[19719] = 0; +inp[19720] = 2206494; +inp[19721] = 0; +inp[19722] = 2138607; +inp[19723] = 0; +inp[19724] = 2072809; +inp[19725] = 0; +inp[19726] = 2009035; +inp[19727] = 0; +inp[19728] = 1947224; +inp[19729] = 0; +inp[19730] = 1887314; +inp[19731] = 0; +inp[19732] = 1829247; +inp[19733] = 0; +inp[19734] = 1772967; +inp[19735] = 0; +inp[19736] = 1718419; +inp[19737] = 0; +inp[19738] = 1665549; +inp[19739] = 0; +inp[19740] = 1614305; +inp[19741] = 0; +inp[19742] = 1564638; +inp[19743] = 0; +inp[19744] = 1516499; +inp[19745] = 0; +inp[19746] = 1469841; +inp[19747] = 0; +inp[19748] = 1424619; +inp[19749] = 0; +inp[19750] = 1380788; +inp[19751] = 0; +inp[19752] = 1338306; +inp[19753] = 0; +inp[19754] = 1297130; +inp[19755] = 0; +inp[19756] = 1257222; +inp[19757] = 0; +inp[19758] = 1218541; +inp[19759] = 0; +inp[19760] = 1181051; +inp[19761] = 0; +inp[19762] = 1144714; +inp[19763] = 0; +inp[19764] = 1109494; +inp[19765] = 0; +inp[19766] = 1075359; +inp[19767] = 0; +inp[19768] = 1042273; +inp[19769] = 0; +inp[19770] = 1010206; +inp[19771] = 0; +inp[19772] = 979125; +inp[19773] = 0; +inp[19774] = 949001; +inp[19775] = 0; +inp[19776] = 919803; +inp[19777] = 0; +inp[19778] = 891504; +inp[19779] = 0; +inp[19780] = 864075; +inp[19781] = 0; +inp[19782] = 837490; +inp[19783] = 0; +inp[19784] = 811723; +inp[19785] = 0; +inp[19786] = 786749; +inp[19787] = 0; +inp[19788] = 762543; +inp[19789] = 0; +inp[19790] = 739082; +inp[19791] = 0; +inp[19792] = 716343; +inp[19793] = 0; +inp[19794] = 694304; +inp[19795] = 0; +inp[19796] = 672942; +inp[19797] = 0; +inp[19798] = 652238; +inp[19799] = 0; +inp[19800] = 632171; +inp[19801] = 0; +inp[19802] = 612721; +inp[19803] = 0; +inp[19804] = 593869; +inp[19805] = 0; +inp[19806] = 575598; +inp[19807] = 0; +inp[19808] = 557889; +inp[19809] = 0; +inp[19810] = 540724; +inp[19811] = 0; +inp[19812] = 524088; +inp[19813] = 0; +inp[19814] = 507963; +inp[19815] = 0; +inp[19816] = 492335; +inp[19817] = 0; +inp[19818] = 477187; +inp[19819] = 0; +inp[19820] = 462506; +inp[19821] = 0; +inp[19822] = 448276; +inp[19823] = 0; +inp[19824] = 434484; +inp[19825] = 0; +inp[19826] = 421116; +inp[19827] = 0; +inp[19828] = 408160; +inp[19829] = 0; +inp[19830] = 395602; +inp[19831] = 0; +inp[19832] = 383431; +inp[19833] = 0; +inp[19834] = 371634; +inp[19835] = 0; +inp[19836] = 1073741824; +inp[19837] = 1073741824; +inp[19838] = 1057094999; +inp[19839] = 0; +inp[19840] = 1040706261; +inp[19841] = 0; +inp[19842] = 1024571605; +inp[19843] = 0; +inp[19844] = 1008687095; +inp[19845] = 0; +inp[19846] = 993048851; +inp[19847] = 0; +inp[19848] = 977653056; +inp[19849] = 0; +inp[19850] = 962495950; +inp[19851] = 0; +inp[19852] = 947573833; +inp[19853] = 0; +inp[19854] = 932883063; +inp[19855] = 0; +inp[19856] = 918420051; +inp[19857] = 0; +inp[19858] = 904181268; +inp[19859] = 0; +inp[19860] = 890163237; +inp[19861] = 0; +inp[19862] = 876362535; +inp[19863] = 0; +inp[19864] = 862775793; +inp[19865] = 0; +inp[19866] = 849399695; +inp[19867] = 0; +inp[19868] = 836230973; +inp[19869] = 0; +inp[19870] = 823266413; +inp[19871] = 0; +inp[19872] = 810502851; +inp[19873] = 0; +inp[19874] = 797937169; +inp[19875] = 0; +inp[19876] = 785566299; +inp[19877] = 0; +inp[19878] = 773387223; +inp[19879] = 0; +inp[19880] = 761396965; +inp[19881] = 0; +inp[19882] = 749592599; +inp[19883] = 0; +inp[19884] = 737971243; +inp[19885] = 0; +inp[19886] = 726530060; +inp[19887] = 0; +inp[19888] = 715266255; +inp[19889] = 0; +inp[19890] = 704177080; +inp[19891] = 0; +inp[19892] = 693259826; +inp[19893] = 0; +inp[19894] = 682511829; +inp[19895] = 0; +inp[19896] = 671930463; +inp[19897] = 0; +inp[19898] = 661513147; +inp[19899] = 0; +inp[19900] = 651257336; +inp[19901] = 0; +inp[19902] = 641160527; +inp[19903] = 0; +inp[19904] = 631220255; +inp[19905] = 0; +inp[19906] = 621434092; +inp[19907] = 0; +inp[19908] = 611799649; +inp[19909] = 0; +inp[19910] = 602314575; +inp[19911] = 0; +inp[19912] = 592976553; +inp[19913] = 0; +inp[19914] = 583783303; +inp[19915] = 0; +inp[19916] = 574732582; +inp[19917] = 0; +inp[19918] = 565822179; +inp[19919] = 0; +inp[19920] = 557049919; +inp[19921] = 0; +inp[19922] = 548413661; +inp[19923] = 0; +inp[19924] = 539911295; +inp[19925] = 0; +inp[19926] = 531540746; +inp[19927] = 0; +inp[19928] = 523299971; +inp[19929] = 0; +inp[19930] = 515186957; +inp[19931] = 0; +inp[19932] = 507199723; +inp[19933] = 0; +inp[19934] = 499336321; +inp[19935] = 0; +inp[19936] = 491594828; +inp[19937] = 0; +inp[19938] = 483973357; +inp[19939] = 0; +inp[19940] = 476470046; +inp[19941] = 0; +inp[19942] = 469083062; +inp[19943] = 0; +inp[19944] = 461810603; +inp[19945] = 0; +inp[19946] = 454650894; +inp[19947] = 0; +inp[19948] = 447602185; +inp[19949] = 0; +inp[19950] = 440662756; +inp[19951] = 0; +inp[19952] = 433830913; +inp[19953] = 0; +inp[19954] = 427104988; +inp[19955] = 0; +inp[19956] = 420483339; +inp[19957] = 0; +inp[19958] = 413964349; +inp[19959] = 0; +inp[19960] = 407546427; +inp[19961] = 0; +inp[19962] = 401228005; +inp[19963] = 0; +inp[19964] = 395007542; +inp[19965] = 0; +inp[19966] = 388883517; +inp[19967] = 0; +inp[19968] = 382854437; +inp[19969] = 0; +inp[19970] = 376918829; +inp[19971] = 0; +inp[19972] = 371075245; +inp[19973] = 0; +inp[19974] = 365322256; +inp[19975] = 0; +inp[19976] = 359658459; +inp[19977] = 0; +inp[19978] = 354082472; +inp[19979] = 0; +inp[19980] = 348592932; +inp[19981] = 0; +inp[19982] = 343188499; +inp[19983] = 0; +inp[19984] = 337867855; +inp[19985] = 0; +inp[19986] = 332629699; +inp[19987] = 0; +inp[19988] = 327472754; +inp[19989] = 0; +inp[19990] = 322395759; +inp[19991] = 0; +inp[19992] = 317397476; +inp[19993] = 0; +inp[19994] = 312476685; +inp[19995] = 0; +inp[19996] = 307632183; +inp[19997] = 0; +inp[19998] = 302862788; +inp[19999] = 0; +inp[20000] = 298167335; +inp[20001] = 0; +inp[20002] = 293544679; +inp[20003] = 0; +inp[20004] = 288993691; +inp[20005] = 0; +inp[20006] = 284513259; +inp[20007] = 0; +inp[20008] = 280102290; +inp[20009] = 0; +inp[20010] = 275759706; +inp[20011] = 0; +inp[20012] = 271484448; +inp[20013] = 0; +inp[20014] = 267275472; +inp[20015] = 0; +inp[20016] = 263131750; +inp[20017] = 0; +inp[20018] = 259052270; +inp[20019] = 0; +inp[20020] = 255036037; +inp[20021] = 0; +inp[20022] = 251082070; +inp[20023] = 0; +inp[20024] = 247189403; +inp[20025] = 0; +inp[20026] = 243357087; +inp[20027] = 0; +inp[20028] = 239584185; +inp[20029] = 0; +inp[20030] = 235869776; +inp[20031] = 0; +inp[20032] = 232212954; +inp[20033] = 0; +inp[20034] = 228612826; +inp[20035] = 0; +inp[20036] = 225068513; +inp[20037] = 0; +inp[20038] = 221579149; +inp[20039] = 0; +inp[20040] = 218143882; +inp[20041] = 0; +inp[20042] = 214761875; +inp[20043] = 0; +inp[20044] = 211432301; +inp[20045] = 0; +inp[20046] = 208154347; +inp[20047] = 0; +inp[20048] = 204927213; +inp[20049] = 0; +inp[20050] = 201750111; +inp[20051] = 0; +inp[20052] = 198622265; +inp[20053] = 0; +inp[20054] = 195542912; +inp[20055] = 0; +inp[20056] = 192511301; +inp[20057] = 0; +inp[20058] = 189526689; +inp[20059] = 0; +inp[20060] = 186588351; +inp[20061] = 0; +inp[20062] = 183695566; +inp[20063] = 0; +inp[20064] = 180847630; +inp[20065] = 0; +inp[20066] = 178043848; +inp[20067] = 0; +inp[20068] = 175283534; +inp[20069] = 0; +inp[20070] = 172566014; +inp[20071] = 0; +inp[20072] = 169890626; +inp[20073] = 0; +inp[20074] = 167256716; +inp[20075] = 0; +inp[20076] = 164663641; +inp[20077] = 0; +inp[20078] = 162110768; +inp[20079] = 0; +inp[20080] = 159597474; +inp[20081] = 0; +inp[20082] = 157123144; +inp[20083] = 0; +inp[20084] = 154687176; +inp[20085] = 0; +inp[20086] = 152288973; +inp[20087] = 0; +inp[20088] = 149927952; +inp[20089] = 0; +inp[20090] = 147603534; +inp[20091] = 0; +inp[20092] = 145315153; +inp[20093] = 0; +inp[20094] = 143062251; +inp[20095] = 0; +inp[20096] = 140844276; +inp[20097] = 0; +inp[20098] = 138660688; +inp[20099] = 0; +inp[20100] = 136510953; +inp[20101] = 0; +inp[20102] = 134394547; +inp[20103] = 0; +inp[20104] = 132310953; +inp[20105] = 0; +inp[20106] = 130259662; +inp[20107] = 0; +inp[20108] = 128240173; +inp[20109] = 0; +inp[20110] = 126251993; +inp[20111] = 0; +inp[20112] = 124294637; +inp[20113] = 0; +inp[20114] = 122367628; +inp[20115] = 0; +inp[20116] = 120470493; +inp[20117] = 0; +inp[20118] = 118602771; +inp[20119] = 0; +inp[20120] = 116764006; +inp[20121] = 0; +inp[20122] = 114953748; +inp[20123] = 0; +inp[20124] = 113171555; +inp[20125] = 0; +inp[20126] = 111416993; +inp[20127] = 0; +inp[20128] = 109689632; +inp[20129] = 0; +inp[20130] = 107989052; +inp[20131] = 0; +inp[20132] = 106314837; +inp[20133] = 0; +inp[20134] = 104666578; +inp[20135] = 0; +inp[20136] = 103043874; +inp[20137] = 0; +inp[20138] = 101446326; +inp[20139] = 0; +inp[20140] = 99873547; +inp[20141] = 0; +inp[20142] = 98325151; +inp[20143] = 0; +inp[20144] = 96800761; +inp[20145] = 0; +inp[20146] = 95300004; +inp[20147] = 0; +inp[20148] = 93822514; +inp[20149] = 0; +inp[20150] = 92367931; +inp[20151] = 0; +inp[20152] = 90935899; +inp[20153] = 0; +inp[20154] = 89526069; +inp[20155] = 0; +inp[20156] = 88138096; +inp[20157] = 0; +inp[20158] = 86771641; +inp[20159] = 0; +inp[20160] = 85426372; +inp[20161] = 0; +inp[20162] = 84101958; +inp[20163] = 0; +inp[20164] = 82798078; +inp[20165] = 0; +inp[20166] = 81514413; +inp[20167] = 0; +inp[20168] = 80250649; +inp[20169] = 0; +inp[20170] = 79006478; +inp[20171] = 0; +inp[20172] = 77781596; +inp[20173] = 0; +inp[20174] = 76575704; +inp[20175] = 0; +inp[20176] = 75388508; +inp[20177] = 0; +inp[20178] = 74219718; +inp[20179] = 0; +inp[20180] = 73069048; +inp[20181] = 0; +inp[20182] = 71936217; +inp[20183] = 0; +inp[20184] = 70820949; +inp[20185] = 0; +inp[20186] = 69722972; +inp[20187] = 0; +inp[20188] = 68642018; +inp[20189] = 0; +inp[20190] = 67577822; +inp[20191] = 0; +inp[20192] = 66530125; +inp[20193] = 0; +inp[20194] = 65498671; +inp[20195] = 0; +inp[20196] = 64483208; +inp[20197] = 0; +inp[20198] = 63483489; +inp[20199] = 0; +inp[20200] = 62499268; +inp[20201] = 0; +inp[20202] = 61530307; +inp[20203] = 0; +inp[20204] = 60576368; +inp[20205] = 0; +inp[20206] = 59637218; +inp[20207] = 0; +inp[20208] = 58712629; +inp[20209] = 0; +inp[20210] = 57802374; +inp[20211] = 0; +inp[20212] = 56906231; +inp[20213] = 0; +inp[20214] = 56023982; +inp[20215] = 0; +inp[20216] = 55155411; +inp[20217] = 0; +inp[20218] = 54300305; +inp[20219] = 0; +inp[20220] = 53458457; +inp[20221] = 0; +inp[20222] = 52629661; +inp[20223] = 0; +inp[20224] = 51813713; +inp[20225] = 0; +inp[20226] = 51010416; +inp[20227] = 0; +inp[20228] = 50219573; +inp[20229] = 0; +inp[20230] = 49440991; +inp[20231] = 0; +inp[20232] = 48674479; +inp[20233] = 0; +inp[20234] = 47919851; +inp[20235] = 0; +inp[20236] = 47176923; +inp[20237] = 0; +inp[20238] = 46445512; +inp[20239] = 0; +inp[20240] = 45725441; +inp[20241] = 0; +inp[20242] = 45016534; +inp[20243] = 0; +inp[20244] = 44318617; +inp[20245] = 0; +inp[20246] = 43631521; +inp[20247] = 0; +inp[20248] = 42955077; +inp[20249] = 0; +inp[20250] = 42289120; +inp[20251] = 0; +inp[20252] = 41633488; +inp[20253] = 0; +inp[20254] = 40988021; +inp[20255] = 0; +inp[20256] = 40352560; +inp[20257] = 0; +inp[20258] = 39726952; +inp[20259] = 0; +inp[20260] = 39111043; +inp[20261] = 0; +inp[20262] = 38504682; +inp[20263] = 0; +inp[20264] = 37907722; +inp[20265] = 0; +inp[20266] = 37320018; +inp[20267] = 0; +inp[20268] = 36741424; +inp[20269] = 0; +inp[20270] = 36171801; +inp[20271] = 0; +inp[20272] = 35611009; +inp[20273] = 0; +inp[20274] = 35058912; +inp[20275] = 0; +inp[20276] = 34515374; +inp[20277] = 0; +inp[20278] = 33980263; +inp[20279] = 0; +inp[20280] = 33453447; +inp[20281] = 0; +inp[20282] = 32934800; +inp[20283] = 0; +inp[20284] = 32424193; +inp[20285] = 0; +inp[20286] = 31921503; +inp[20287] = 0; +inp[20288] = 31426605; +inp[20289] = 0; +inp[20290] = 30939381; +inp[20291] = 0; +inp[20292] = 30459710; +inp[20293] = 0; +inp[20294] = 29987476; +inp[20295] = 0; +inp[20296] = 29522564; +inp[20297] = 0; +inp[20298] = 29064859; +inp[20299] = 0; +inp[20300] = 28614250; +inp[20301] = 0; +inp[20302] = 28170627; +inp[20303] = 0; +inp[20304] = 27733882; +inp[20305] = 0; +inp[20306] = 27303908; +inp[20307] = 0; +inp[20308] = 26880600; +inp[20309] = 0; +inp[20310] = 26463855; +inp[20311] = 0; +inp[20312] = 26053571; +inp[20313] = 0; +inp[20314] = 25649648; +inp[20315] = 0; +inp[20316] = 25251987; +inp[20317] = 0; +inp[20318] = 24860491; +inp[20319] = 0; +inp[20320] = 24475065; +inp[20321] = 0; +inp[20322] = 24095614; +inp[20323] = 0; +inp[20324] = 23722046; +inp[20325] = 0; +inp[20326] = 23354270; +inp[20327] = 0; +inp[20328] = 22992196; +inp[20329] = 0; +inp[20330] = 22635735; +inp[20331] = 0; +inp[20332] = 22284800; +inp[20333] = 0; +inp[20334] = 21939306; +inp[20335] = 0; +inp[20336] = 21599169; +inp[20337] = 0; +inp[20338] = 21264305; +inp[20339] = 0; +inp[20340] = 20934632; +inp[20341] = 0; +inp[20342] = 20610071; +inp[20343] = 0; +inp[20344] = 20290541; +inp[20345] = 0; +inp[20346] = 19975966; +inp[20347] = 0; +inp[20348] = 1073741824; +inp[20349] = 1073741824; +inp[20350] = 1065385898; +inp[20351] = 0; +inp[20352] = 1057094999; +inp[20353] = 0; +inp[20354] = 1048868621; +inp[20355] = 0; +inp[20356] = 1040706261; +inp[20357] = 0; +inp[20358] = 1032607420; +inp[20359] = 0; +inp[20360] = 1024571605; +inp[20361] = 0; +inp[20362] = 1016598326; +inp[20363] = 0; +inp[20364] = 1008687095; +inp[20365] = 0; +inp[20366] = 1000837430; +inp[20367] = 0; +inp[20368] = 993048851; +inp[20369] = 0; +inp[20370] = 985320884; +inp[20371] = 0; +inp[20372] = 977653056; +inp[20373] = 0; +inp[20374] = 970044899; +inp[20375] = 0; +inp[20376] = 962495950; +inp[20377] = 0; +inp[20378] = 955005747; +inp[20379] = 0; +inp[20380] = 947573833; +inp[20381] = 0; +inp[20382] = 940199755; +inp[20383] = 0; +inp[20384] = 932883063; +inp[20385] = 0; +inp[20386] = 925623309; +inp[20387] = 0; +inp[20388] = 918420051; +inp[20389] = 0; +inp[20390] = 911272850; +inp[20391] = 0; +inp[20392] = 904181268; +inp[20393] = 0; +inp[20394] = 897144874; +inp[20395] = 0; +inp[20396] = 890163237; +inp[20397] = 0; +inp[20398] = 883235932; +inp[20399] = 0; +inp[20400] = 876362535; +inp[20401] = 0; +inp[20402] = 869542628; +inp[20403] = 0; +inp[20404] = 862775793; +inp[20405] = 0; +inp[20406] = 856061619; +inp[20407] = 0; +inp[20408] = 849399695; +inp[20409] = 0; +inp[20410] = 842789614; +inp[20411] = 0; +inp[20412] = 836230973; +inp[20413] = 0; +inp[20414] = 829723372; +inp[20415] = 0; +inp[20416] = 823266413; +inp[20417] = 0; +inp[20418] = 816859703; +inp[20419] = 0; +inp[20420] = 810502851; +inp[20421] = 0; +inp[20422] = 804195467; +inp[20423] = 0; +inp[20424] = 797937169; +inp[20425] = 0; +inp[20426] = 791727572; +inp[20427] = 0; +inp[20428] = 785566299; +inp[20429] = 0; +inp[20430] = 779452974; +inp[20431] = 0; +inp[20432] = 773387223; +inp[20433] = 0; +inp[20434] = 767368676; +inp[20435] = 0; +inp[20436] = 761396965; +inp[20437] = 0; +inp[20438] = 755471727; +inp[20439] = 0; +inp[20440] = 749592599; +inp[20441] = 0; +inp[20442] = 743759224; +inp[20443] = 0; +inp[20444] = 737971243; +inp[20445] = 0; +inp[20446] = 732228306; +inp[20447] = 0; +inp[20448] = 726530060; +inp[20449] = 0; +inp[20450] = 720876158; +inp[20451] = 0; +inp[20452] = 715266255; +inp[20453] = 0; +inp[20454] = 709700009; +inp[20455] = 0; +inp[20456] = 704177080; +inp[20457] = 0; +inp[20458] = 698697130; +inp[20459] = 0; +inp[20460] = 693259826; +inp[20461] = 0; +inp[20462] = 687864835; +inp[20463] = 0; +inp[20464] = 682511829; +inp[20465] = 0; +inp[20466] = 677200479; +inp[20467] = 0; +inp[20468] = 671930463; +inp[20469] = 0; +inp[20470] = 666701459; +inp[20471] = 0; +inp[20472] = 661513147; +inp[20473] = 0; +inp[20474] = 656365211; +inp[20475] = 0; +inp[20476] = 651257336; +inp[20477] = 0; +inp[20478] = 646189212; +inp[20479] = 0; +inp[20480] = 641160527; +inp[20481] = 0; +inp[20482] = 636170976; +inp[20483] = 0; +inp[20484] = 631220255; +inp[20485] = 0; +inp[20486] = 626308060; +inp[20487] = 0; +inp[20488] = 621434092; +inp[20489] = 0; +inp[20490] = 616598053; +inp[20491] = 0; +inp[20492] = 611799649; +inp[20493] = 0; +inp[20494] = 607038586; +inp[20495] = 0; +inp[20496] = 602314575; +inp[20497] = 0; +inp[20498] = 597627325; +inp[20499] = 0; +inp[20500] = 592976553; +inp[20501] = 0; +inp[20502] = 588361972; +inp[20503] = 0; +inp[20504] = 583783303; +inp[20505] = 0; +inp[20506] = 579240266; +inp[20507] = 0; +inp[20508] = 574732582; +inp[20509] = 0; +inp[20510] = 570259978; +inp[20511] = 0; +inp[20512] = 565822179; +inp[20513] = 0; +inp[20514] = 561418916; +inp[20515] = 0; +inp[20516] = 557049919; +inp[20517] = 0; +inp[20518] = 552714923; +inp[20519] = 0; +inp[20520] = 548413661; +inp[20521] = 0; +inp[20522] = 544145872; +inp[20523] = 0; +inp[20524] = 539911295; +inp[20525] = 0; +inp[20526] = 535709672; +inp[20527] = 0; +inp[20528] = 531540746; +inp[20529] = 0; +inp[20530] = 527404264; +inp[20531] = 0; +inp[20532] = 523299971; +inp[20533] = 0; +inp[20534] = 519227618; +inp[20535] = 0; +inp[20536] = 515186957; +inp[20537] = 0; +inp[20538] = 511177740; +inp[20539] = 0; +inp[20540] = 507199723; +inp[20541] = 0; +inp[20542] = 503252664; +inp[20543] = 0; +inp[20544] = 499336321; +inp[20545] = 0; +inp[20546] = 495450454; +inp[20547] = 0; +inp[20548] = 491594828; +inp[20549] = 0; +inp[20550] = 487769207; +inp[20551] = 0; +inp[20552] = 483973357; +inp[20553] = 0; +inp[20554] = 480207047; +inp[20555] = 0; +inp[20556] = 476470046; +inp[20557] = 0; +inp[20558] = 472762126; +inp[20559] = 0; +inp[20560] = 469083062; +inp[20561] = 0; +inp[20562] = 465432629; +inp[20563] = 0; +inp[20564] = 461810603; +inp[20565] = 0; +inp[20566] = 458216765; +inp[20567] = 0; +inp[20568] = 454650894; +inp[20569] = 0; +inp[20570] = 451112772; +inp[20571] = 0; +inp[20572] = 447602185; +inp[20573] = 0; +inp[20574] = 444118917; +inp[20575] = 0; +inp[20576] = 440662756; +inp[20577] = 0; +inp[20578] = 437233491; +inp[20579] = 0; +inp[20580] = 433830913; +inp[20581] = 0; +inp[20582] = 430454814; +inp[20583] = 0; +inp[20584] = 427104988; +inp[20585] = 0; +inp[20586] = 423781231; +inp[20587] = 0; +inp[20588] = 420483339; +inp[20589] = 0; +inp[20590] = 417211112; +inp[20591] = 0; +inp[20592] = 413964349; +inp[20593] = 0; +inp[20594] = 410742853; +inp[20595] = 0; +inp[20596] = 407546427; +inp[20597] = 0; +inp[20598] = 404374876; +inp[20599] = 0; +inp[20600] = 401228005; +inp[20601] = 0; +inp[20602] = 398105624; +inp[20603] = 0; +inp[20604] = 395007542; +inp[20605] = 0; +inp[20606] = 391933569; +inp[20607] = 0; +inp[20608] = 388883517; +inp[20609] = 0; +inp[20610] = 385857202; +inp[20611] = 0; +inp[20612] = 382854437; +inp[20613] = 0; +inp[20614] = 379875040; +inp[20615] = 0; +inp[20616] = 376918829; +inp[20617] = 0; +inp[20618] = 373985624; +inp[20619] = 0; +inp[20620] = 371075245; +inp[20621] = 0; +inp[20622] = 368187514; +inp[20623] = 0; +inp[20624] = 365322256; +inp[20625] = 0; +inp[20626] = 362479296; +inp[20627] = 0; +inp[20628] = 359658459; +inp[20629] = 0; +inp[20630] = 356859575; +inp[20631] = 0; +inp[20632] = 354082472; +inp[20633] = 0; +inp[20634] = 351326980; +inp[20635] = 0; +inp[20636] = 348592932; +inp[20637] = 0; +inp[20638] = 345880160; +inp[20639] = 0; +inp[20640] = 343188499; +inp[20641] = 0; +inp[20642] = 340517785; +inp[20643] = 0; +inp[20644] = 337867855; +inp[20645] = 0; +inp[20646] = 335238546; +inp[20647] = 0; +inp[20648] = 332629699; +inp[20649] = 0; +inp[20650] = 330041155; +inp[20651] = 0; +inp[20652] = 327472754; +inp[20653] = 0; +inp[20654] = 324924341; +inp[20655] = 0; +inp[20656] = 322395759; +inp[20657] = 0; +inp[20658] = 319886856; +inp[20659] = 0; +inp[20660] = 317397476; +inp[20661] = 0; +inp[20662] = 314927470; +inp[20663] = 0; +inp[20664] = 312476685; +inp[20665] = 0; +inp[20666] = 310044972; +inp[20667] = 0; +inp[20668] = 307632183; +inp[20669] = 0; +inp[20670] = 305238170; +inp[20671] = 0; +inp[20672] = 302862788; +inp[20673] = 0; +inp[20674] = 300505891; +inp[20675] = 0; +inp[20676] = 298167335; +inp[20677] = 0; +inp[20678] = 295846979; +inp[20679] = 0; +inp[20680] = 293544679; +inp[20681] = 0; +inp[20682] = 291260297; +inp[20683] = 0; +inp[20684] = 288993691; +inp[20685] = 0; +inp[20686] = 286744724; +inp[20687] = 0; +inp[20688] = 284513259; +inp[20689] = 0; +inp[20690] = 282299159; +inp[20691] = 0; +inp[20692] = 280102290; +inp[20693] = 0; +inp[20694] = 277922516; +inp[20695] = 0; +inp[20696] = 275759706; +inp[20697] = 0; +inp[20698] = 273613727; +inp[20699] = 0; +inp[20700] = 271484448; +inp[20701] = 0; +inp[20702] = 269371740; +inp[20703] = 0; +inp[20704] = 267275472; +inp[20705] = 0; +inp[20706] = 265195518; +inp[20707] = 0; +inp[20708] = 263131750; +inp[20709] = 0; +inp[20710] = 261084042; +inp[20711] = 0; +inp[20712] = 259052270; +inp[20713] = 0; +inp[20714] = 257036309; +inp[20715] = 0; +inp[20716] = 255036037; +inp[20717] = 0; +inp[20718] = 253051331; +inp[20719] = 0; +inp[20720] = 251082070; +inp[20721] = 0; +inp[20722] = 249128134; +inp[20723] = 0; +inp[20724] = 247189403; +inp[20725] = 0; +inp[20726] = 245265760; +inp[20727] = 0; +inp[20728] = 243357087; +inp[20729] = 0; +inp[20730] = 241463267; +inp[20731] = 0; +inp[20732] = 239584185; +inp[20733] = 0; +inp[20734] = 237719726; +inp[20735] = 0; +inp[20736] = 235869776; +inp[20737] = 0; +inp[20738] = 234034223; +inp[20739] = 0; +inp[20740] = 232212954; +inp[20741] = 0; +inp[20742] = 230405859; +inp[20743] = 0; +inp[20744] = 228612826; +inp[20745] = 0; +inp[20746] = 226833747; +inp[20747] = 0; +inp[20748] = 225068513; +inp[20749] = 0; +inp[20750] = 223317016; +inp[20751] = 0; +inp[20752] = 221579149; +inp[20753] = 0; +inp[20754] = 219854806; +inp[20755] = 0; +inp[20756] = 218143882; +inp[20757] = 0; +inp[20758] = 216446273; +inp[20759] = 0; +inp[20760] = 214761875; +inp[20761] = 0; +inp[20762] = 213090585; +inp[20763] = 0; +inp[20764] = 211432301; +inp[20765] = 0; +inp[20766] = 209786922; +inp[20767] = 0; +inp[20768] = 208154347; +inp[20769] = 0; +inp[20770] = 206534477; +inp[20771] = 0; +inp[20772] = 204927213; +inp[20773] = 0; +inp[20774] = 203332457; +inp[20775] = 0; +inp[20776] = 201750111; +inp[20777] = 0; +inp[20778] = 200180079; +inp[20779] = 0; +inp[20780] = 198622265; +inp[20781] = 0; +inp[20782] = 197076575; +inp[20783] = 0; +inp[20784] = 195542912; +inp[20785] = 0; +inp[20786] = 194021185; +inp[20787] = 0; +inp[20788] = 192511301; +inp[20789] = 0; +inp[20790] = 191013166; +inp[20791] = 0; +inp[20792] = 189526689; +inp[20793] = 0; +inp[20794] = 188051781; +inp[20795] = 0; +inp[20796] = 186588351; +inp[20797] = 0; +inp[20798] = 185136308; +inp[20799] = 0; +inp[20800] = 183695566; +inp[20801] = 0; +inp[20802] = 182266036; +inp[20803] = 0; +inp[20804] = 180847630; +inp[20805] = 0; +inp[20806] = 179440263; +inp[20807] = 0; +inp[20808] = 178043848; +inp[20809] = 0; +inp[20810] = 176658300; +inp[20811] = 0; +inp[20812] = 175283534; +inp[20813] = 0; +inp[20814] = 173919467; +inp[20815] = 0; +inp[20816] = 172566014; +inp[20817] = 0; +inp[20818] = 171223095; +inp[20819] = 0; +inp[20820] = 169890626; +inp[20821] = 0; +inp[20822] = 168568527; +inp[20823] = 0; +inp[20824] = 167256716; +inp[20825] = 0; +inp[20826] = 165955114; +inp[20827] = 0; +inp[20828] = 164663641; +inp[20829] = 0; +inp[20830] = 163382219; +inp[20831] = 0; +inp[20832] = 162110768; +inp[20833] = 0; +inp[20834] = 160849212; +inp[20835] = 0; +inp[20836] = 159597474; +inp[20837] = 0; +inp[20838] = 158355476; +inp[20839] = 0; +inp[20840] = 157123144; +inp[20841] = 0; +inp[20842] = 155900402; +inp[20843] = 0; +inp[20844] = 154687176; +inp[20845] = 0; +inp[20846] = 153483390; +inp[20847] = 0; +inp[20848] = 152288973; +inp[20849] = 0; +inp[20850] = 151103851; +inp[20851] = 0; +inp[20852] = 149927952; +inp[20853] = 0; +inp[20854] = 148761203; +inp[20855] = 0; +inp[20856] = 147603534; +inp[20857] = 0; +inp[20858] = 146454874; +inp[20859] = 0; +inp[20860] = 1073741824; +inp[20861] = 1073741824; +inp[20862] = 1069555701; +inp[20863] = 0; +inp[20864] = 1065385898; +inp[20865] = 0; +inp[20866] = 1061232352; +inp[20867] = 0; +inp[20868] = 1057094999; +inp[20869] = 0; +inp[20870] = 1052973777; +inp[20871] = 0; +inp[20872] = 1048868621; +inp[20873] = 0; +inp[20874] = 1044779470; +inp[20875] = 0; +inp[20876] = 1040706261; +inp[20877] = 0; +inp[20878] = 1036648931; +inp[20879] = 0; +inp[20880] = 1032607420; +inp[20881] = 0; +inp[20882] = 1028581665; +inp[20883] = 0; +inp[20884] = 1024571605; +inp[20885] = 0; +inp[20886] = 1020577179; +inp[20887] = 0; +inp[20888] = 1016598326; +inp[20889] = 0; +inp[20890] = 1012634985; +inp[20891] = 0; +inp[20892] = 1008687095; +inp[20893] = 0; +inp[20894] = 1004754597; +inp[20895] = 0; +inp[20896] = 1000837430; +inp[20897] = 0; +inp[20898] = 996935534; +inp[20899] = 0; +inp[20900] = 993048851; +inp[20901] = 0; +inp[20902] = 989177321; +inp[20903] = 0; +inp[20904] = 985320884; +inp[20905] = 0; +inp[20906] = 981479482; +inp[20907] = 0; +inp[20908] = 977653056; +inp[20909] = 0; +inp[20910] = 973841548; +inp[20911] = 0; +inp[20912] = 970044899; +inp[20913] = 0; +inp[20914] = 966263053; +inp[20915] = 0; +inp[20916] = 962495950; +inp[20917] = 0; +inp[20918] = 958743534; +inp[20919] = 0; +inp[20920] = 955005747; +inp[20921] = 0; +inp[20922] = 951282532; +inp[20923] = 0; +inp[20924] = 947573833; +inp[20925] = 0; +inp[20926] = 943879593; +inp[20927] = 0; +inp[20928] = 940199755; +inp[20929] = 0; +inp[20930] = 936534264; +inp[20931] = 0; +inp[20932] = 932883063; +inp[20933] = 0; +inp[20934] = 929246096; +inp[20935] = 0; +inp[20936] = 925623309; +inp[20937] = 0; +inp[20938] = 922014646; +inp[20939] = 0; +inp[20940] = 918420051; +inp[20941] = 0; +inp[20942] = 914839471; +inp[20943] = 0; +inp[20944] = 911272850; +inp[20945] = 0; +inp[20946] = 907720134; +inp[20947] = 0; +inp[20948] = 904181268; +inp[20949] = 0; +inp[20950] = 900656200; +inp[20951] = 0; +inp[20952] = 897144874; +inp[20953] = 0; +inp[20954] = 893647237; +inp[20955] = 0; +inp[20956] = 890163237; +inp[20957] = 0; +inp[20958] = 886692819; +inp[20959] = 0; +inp[20960] = 883235932; +inp[20961] = 0; +inp[20962] = 879792521; +inp[20963] = 0; +inp[20964] = 876362535; +inp[20965] = 0; +inp[20966] = 872945921; +inp[20967] = 0; +inp[20968] = 869542628; +inp[20969] = 0; +inp[20970] = 866152602; +inp[20971] = 0; +inp[20972] = 862775793; +inp[20973] = 0; +inp[20974] = 859412149; +inp[20975] = 0; +inp[20976] = 856061619; +inp[20977] = 0; +inp[20978] = 852724151; +inp[20979] = 0; +inp[20980] = 849399695; +inp[20981] = 0; +inp[20982] = 846088199; +inp[20983] = 0; +inp[20984] = 842789614; +inp[20985] = 0; +inp[20986] = 839503888; +inp[20987] = 0; +inp[20988] = 836230973; +inp[20989] = 0; +inp[20990] = 832970817; +inp[20991] = 0; +inp[20992] = 829723372; +inp[20993] = 0; +inp[20994] = 826488587; +inp[20995] = 0; +inp[20996] = 823266413; +inp[20997] = 0; +inp[20998] = 820056802; +inp[20999] = 0; +inp[21000] = 816859703; +inp[21001] = 0; +inp[21002] = 813675069; +inp[21003] = 0; +inp[21004] = 810502851; +inp[21005] = 0; +inp[21006] = 807342999; +inp[21007] = 0; +inp[21008] = 804195467; +inp[21009] = 0; +inp[21010] = 801060206; +inp[21011] = 0; +inp[21012] = 797937169; +inp[21013] = 0; +inp[21014] = 794826306; +inp[21015] = 0; +inp[21016] = 791727572; +inp[21017] = 0; +inp[21018] = 788640919; +inp[21019] = 0; +inp[21020] = 785566299; +inp[21021] = 0; +inp[21022] = 782503667; +inp[21023] = 0; +inp[21024] = 779452974; +inp[21025] = 0; +inp[21026] = 776414175; +inp[21027] = 0; +inp[21028] = 773387223; +inp[21029] = 0; +inp[21030] = 770372072; +inp[21031] = 0; +inp[21032] = 767368676; +inp[21033] = 0; +inp[21034] = 764376989; +inp[21035] = 0; +inp[21036] = 761396965; +inp[21037] = 0; +inp[21038] = 758428560; +inp[21039] = 0; +inp[21040] = 755471727; +inp[21041] = 0; +inp[21042] = 752526422; +inp[21043] = 0; +inp[21044] = 749592599; +inp[21045] = 0; +inp[21046] = 746670215; +inp[21047] = 0; +inp[21048] = 743759224; +inp[21049] = 0; +inp[21050] = 740859581; +inp[21051] = 0; +inp[21052] = 737971243; +inp[21053] = 0; +inp[21054] = 735094166; +inp[21055] = 0; +inp[21056] = 732228306; +inp[21057] = 0; +inp[21058] = 729373618; +inp[21059] = 0; +inp[21060] = 726530060; +inp[21061] = 0; +inp[21062] = 723697587; +inp[21063] = 0; +inp[21064] = 720876158; +inp[21065] = 0; +inp[21066] = 718065728; +inp[21067] = 0; +inp[21068] = 715266255; +inp[21069] = 0; +inp[21070] = 712477696; +inp[21071] = 0; +inp[21072] = 709700009; +inp[21073] = 0; +inp[21074] = 706933151; +inp[21075] = 0; +inp[21076] = 704177080; +inp[21077] = 0; +inp[21078] = 701431753; +inp[21079] = 0; +inp[21080] = 698697130; +inp[21081] = 0; +inp[21082] = 695973168; +inp[21083] = 0; +inp[21084] = 693259826; +inp[21085] = 0; +inp[21086] = 690557062; +inp[21087] = 0; +inp[21088] = 687864835; +inp[21089] = 0; +inp[21090] = 685183104; +inp[21091] = 0; +inp[21092] = 682511829; +inp[21093] = 0; +inp[21094] = 679850967; +inp[21095] = 0; +inp[21096] = 677200479; +inp[21097] = 0; +inp[21098] = 674560325; +inp[21099] = 0; +inp[21100] = 671930463; +inp[21101] = 0; +inp[21102] = 669310855; +inp[21103] = 0; +inp[21104] = 666701459; +inp[21105] = 0; +inp[21106] = 664102236; +inp[21107] = 0; +inp[21108] = 661513147; +inp[21109] = 0; +inp[21110] = 658934152; +inp[21111] = 0; +inp[21112] = 656365211; +inp[21113] = 0; +inp[21114] = 653806286; +inp[21115] = 0; +inp[21116] = 651257336; +inp[21117] = 0; +inp[21118] = 648718325; +inp[21119] = 0; +inp[21120] = 646189212; +inp[21121] = 0; +inp[21122] = 643669959; +inp[21123] = 0; +inp[21124] = 641160527; +inp[21125] = 0; +inp[21126] = 638660879; +inp[21127] = 0; +inp[21128] = 636170976; +inp[21129] = 0; +inp[21130] = 633690781; +inp[21131] = 0; +inp[21132] = 631220255; +inp[21133] = 0; +inp[21134] = 628759360; +inp[21135] = 0; +inp[21136] = 626308060; +inp[21137] = 0; +inp[21138] = 623866316; +inp[21139] = 0; +inp[21140] = 621434092; +inp[21141] = 0; +inp[21142] = 619011350; +inp[21143] = 0; +inp[21144] = 616598053; +inp[21145] = 0; +inp[21146] = 614194165; +inp[21147] = 0; +inp[21148] = 611799649; +inp[21149] = 0; +inp[21150] = 609414468; +inp[21151] = 0; +inp[21152] = 607038586; +inp[21153] = 0; +inp[21154] = 604671967; +inp[21155] = 0; +inp[21156] = 602314575; +inp[21157] = 0; +inp[21158] = 599966373; +inp[21159] = 0; +inp[21160] = 597627325; +inp[21161] = 0; +inp[21162] = 595297397; +inp[21163] = 0; +inp[21164] = 592976553; +inp[21165] = 0; +inp[21166] = 590664756; +inp[21167] = 0; +inp[21168] = 588361972; +inp[21169] = 0; +inp[21170] = 586068167; +inp[21171] = 0; +inp[21172] = 583783303; +inp[21173] = 0; +inp[21174] = 581507348; +inp[21175] = 0; +inp[21176] = 579240266; +inp[21177] = 0; +inp[21178] = 576982022; +inp[21179] = 0; +inp[21180] = 574732582; +inp[21181] = 0; +inp[21182] = 572491912; +inp[21183] = 0; +inp[21184] = 570259978; +inp[21185] = 0; +inp[21186] = 568036745; +inp[21187] = 0; +inp[21188] = 565822179; +inp[21189] = 0; +inp[21190] = 563616248; +inp[21191] = 0; +inp[21192] = 561418916; +inp[21193] = 0; +inp[21194] = 559230151; +inp[21195] = 0; +inp[21196] = 557049919; +inp[21197] = 0; +inp[21198] = 554878188; +inp[21199] = 0; +inp[21200] = 552714923; +inp[21201] = 0; +inp[21202] = 550560091; +inp[21203] = 0; +inp[21204] = 548413661; +inp[21205] = 0; +inp[21206] = 546275599; +inp[21207] = 0; +inp[21208] = 544145872; +inp[21209] = 0; +inp[21210] = 542024448; +inp[21211] = 0; +inp[21212] = 539911295; +inp[21213] = 0; +inp[21214] = 537806381; +inp[21215] = 0; +inp[21216] = 535709672; +inp[21217] = 0; +inp[21218] = 533621138; +inp[21219] = 0; +inp[21220] = 531540746; +inp[21221] = 0; +inp[21222] = 529468465; +inp[21223] = 0; +inp[21224] = 527404264; +inp[21225] = 0; +inp[21226] = 525348109; +inp[21227] = 0; +inp[21228] = 523299971; +inp[21229] = 0; +inp[21230] = 521259818; +inp[21231] = 0; +inp[21232] = 519227618; +inp[21233] = 0; +inp[21234] = 517203342; +inp[21235] = 0; +inp[21236] = 515186957; +inp[21237] = 0; +inp[21238] = 513178433; +inp[21239] = 0; +inp[21240] = 511177740; +inp[21241] = 0; +inp[21242] = 509184847; +inp[21243] = 0; +inp[21244] = 507199723; +inp[21245] = 0; +inp[21246] = 505222339; +inp[21247] = 0; +inp[21248] = 503252664; +inp[21249] = 0; +inp[21250] = 501290668; +inp[21251] = 0; +inp[21252] = 499336321; +inp[21253] = 0; +inp[21254] = 497389593; +inp[21255] = 0; +inp[21256] = 495450454; +inp[21257] = 0; +inp[21258] = 493518876; +inp[21259] = 0; +inp[21260] = 491594828; +inp[21261] = 0; +inp[21262] = 489678282; +inp[21263] = 0; +inp[21264] = 487769207; +inp[21265] = 0; +inp[21266] = 485867575; +inp[21267] = 0; +inp[21268] = 483973357; +inp[21269] = 0; +inp[21270] = 482086524; +inp[21271] = 0; +inp[21272] = 480207047; +inp[21273] = 0; +inp[21274] = 478334897; +inp[21275] = 0; +inp[21276] = 476470046; +inp[21277] = 0; +inp[21278] = 474612465; +inp[21279] = 0; +inp[21280] = 472762126; +inp[21281] = 0; +inp[21282] = 470919001; +inp[21283] = 0; +inp[21284] = 469083062; +inp[21285] = 0; +inp[21286] = 467254281; +inp[21287] = 0; +inp[21288] = 465432629; +inp[21289] = 0; +inp[21290] = 463618079; +inp[21291] = 0; +inp[21292] = 461810603; +inp[21293] = 0; +inp[21294] = 460010175; +inp[21295] = 0; +inp[21296] = 458216765; +inp[21297] = 0; +inp[21298] = 456430347; +inp[21299] = 0; +inp[21300] = 454650894; +inp[21301] = 0; +inp[21302] = 452878378; +inp[21303] = 0; +inp[21304] = 451112772; +inp[21305] = 0; +inp[21306] = 449354050; +inp[21307] = 0; +inp[21308] = 447602185; +inp[21309] = 0; +inp[21310] = 445857149; +inp[21311] = 0; +inp[21312] = 444118917; +inp[21313] = 0; +inp[21314] = 442387461; +inp[21315] = 0; +inp[21316] = 440662756; +inp[21317] = 0; +inp[21318] = 438944775; +inp[21319] = 0; +inp[21320] = 437233491; +inp[21321] = 0; +inp[21322] = 435528880; +inp[21323] = 0; +inp[21324] = 433830913; +inp[21325] = 0; +inp[21326] = 432139567; +inp[21327] = 0; +inp[21328] = 430454814; +inp[21329] = 0; +inp[21330] = 428776630; +inp[21331] = 0; +inp[21332] = 427104988; +inp[21333] = 0; +inp[21334] = 425439864; +inp[21335] = 0; +inp[21336] = 423781231; +inp[21337] = 0; +inp[21338] = 422129065; +inp[21339] = 0; +inp[21340] = 420483339; +inp[21341] = 0; +inp[21342] = 418844030; +inp[21343] = 0; +inp[21344] = 417211112; +inp[21345] = 0; +inp[21346] = 415584560; +inp[21347] = 0; +inp[21348] = 413964349; +inp[21349] = 0; +inp[21350] = 412350455; +inp[21351] = 0; +inp[21352] = 410742853; +inp[21353] = 0; +inp[21354] = 409141519; +inp[21355] = 0; +inp[21356] = 407546427; +inp[21357] = 0; +inp[21358] = 405957554; +inp[21359] = 0; +inp[21360] = 404374876; +inp[21361] = 0; +inp[21362] = 402798367; +inp[21363] = 0; +inp[21364] = 401228005; +inp[21365] = 0; +inp[21366] = 399663766; +inp[21367] = 0; +inp[21368] = 398105624; +inp[21369] = 0; +inp[21370] = 396553557; +inp[21371] = 0; +inp[21372] = 1073741824; +inp[21373] = 1073741824; +inp[21374] = 1071646718; +inp[21375] = 0; +inp[21376] = 1069555701; +inp[21377] = 0; +inp[21378] = 1067468764; +inp[21379] = 0; +inp[21380] = 1065385898; +inp[21381] = 0; +inp[21382] = 1063307097; +inp[21383] = 0; +inp[21384] = 1061232352; +inp[21385] = 0; +inp[21386] = 1059161656; +inp[21387] = 0; +inp[21388] = 1057094999; +inp[21389] = 0; +inp[21390] = 1055032376; +inp[21391] = 0; +inp[21392] = 1052973777; +inp[21393] = 0; +inp[21394] = 1050919194; +inp[21395] = 0; +inp[21396] = 1048868621; +inp[21397] = 0; +inp[21398] = 1046822049; +inp[21399] = 0; +inp[21400] = 1044779470; +inp[21401] = 0; +inp[21402] = 1042740876; +inp[21403] = 0; +inp[21404] = 1040706261; +inp[21405] = 0; +inp[21406] = 1038675615; +inp[21407] = 0; +inp[21408] = 1036648931; +inp[21409] = 0; +inp[21410] = 1034626202; +inp[21411] = 0; +inp[21412] = 1032607420; +inp[21413] = 0; +inp[21414] = 1030592577; +inp[21415] = 0; +inp[21416] = 1028581665; +inp[21417] = 0; +inp[21418] = 1026574677; +inp[21419] = 0; +inp[21420] = 1024571605; +inp[21421] = 0; +inp[21422] = 1022572442; +inp[21423] = 0; +inp[21424] = 1020577179; +inp[21425] = 0; +inp[21426] = 1018585810; +inp[21427] = 0; +inp[21428] = 1016598326; +inp[21429] = 0; +inp[21430] = 1014614720; +inp[21431] = 0; +inp[21432] = 1012634985; +inp[21433] = 0; +inp[21434] = 1010659112; +inp[21435] = 0; +inp[21436] = 1008687095; +inp[21437] = 0; +inp[21438] = 1006718926; +inp[21439] = 0; +inp[21440] = 1004754597; +inp[21441] = 0; +inp[21442] = 1002794101; +inp[21443] = 0; +inp[21444] = 1000837430; +inp[21445] = 0; +inp[21446] = 998884577; +inp[21447] = 0; +inp[21448] = 996935534; +inp[21449] = 0; +inp[21450] = 994990295; +inp[21451] = 0; +inp[21452] = 993048851; +inp[21453] = 0; +inp[21454] = 991111195; +inp[21455] = 0; +inp[21456] = 989177321; +inp[21457] = 0; +inp[21458] = 987247219; +inp[21459] = 0; +inp[21460] = 985320884; +inp[21461] = 0; +inp[21462] = 983398307; +inp[21463] = 0; +inp[21464] = 981479482; +inp[21465] = 0; +inp[21466] = 979564400; +inp[21467] = 0; +inp[21468] = 977653056; +inp[21469] = 0; +inp[21470] = 975745441; +inp[21471] = 0; +inp[21472] = 973841548; +inp[21473] = 0; +inp[21474] = 971941370; +inp[21475] = 0; +inp[21476] = 970044899; +inp[21477] = 0; +inp[21478] = 968152129; +inp[21479] = 0; +inp[21480] = 966263053; +inp[21481] = 0; +inp[21482] = 964377662; +inp[21483] = 0; +inp[21484] = 962495950; +inp[21485] = 0; +inp[21486] = 960617910; +inp[21487] = 0; +inp[21488] = 958743534; +inp[21489] = 0; +inp[21490] = 956872815; +inp[21491] = 0; +inp[21492] = 955005747; +inp[21493] = 0; +inp[21494] = 953142322; +inp[21495] = 0; +inp[21496] = 951282532; +inp[21497] = 0; +inp[21498] = 949426372; +inp[21499] = 0; +inp[21500] = 947573833; +inp[21501] = 0; +inp[21502] = 945724909; +inp[21503] = 0; +inp[21504] = 943879593; +inp[21505] = 0; +inp[21506] = 942037877; +inp[21507] = 0; +inp[21508] = 940199755; +inp[21509] = 0; +inp[21510] = 938365220; +inp[21511] = 0; +inp[21512] = 936534264; +inp[21513] = 0; +inp[21514] = 934706880; +inp[21515] = 0; +inp[21516] = 932883063; +inp[21517] = 0; +inp[21518] = 931062804; +inp[21519] = 0; +inp[21520] = 929246096; +inp[21521] = 0; +inp[21522] = 927432934; +inp[21523] = 0; +inp[21524] = 925623309; +inp[21525] = 0; +inp[21526] = 923817215; +inp[21527] = 0; +inp[21528] = 922014646; +inp[21529] = 0; +inp[21530] = 920215593; +inp[21531] = 0; +inp[21532] = 918420051; +inp[21533] = 0; +inp[21534] = 916628013; +inp[21535] = 0; +inp[21536] = 914839471; +inp[21537] = 0; +inp[21538] = 913054419; +inp[21539] = 0; +inp[21540] = 911272850; +inp[21541] = 0; +inp[21542] = 909494757; +inp[21543] = 0; +inp[21544] = 907720134; +inp[21545] = 0; +inp[21546] = 905948973; +inp[21547] = 0; +inp[21548] = 904181268; +inp[21549] = 0; +inp[21550] = 902417013; +inp[21551] = 0; +inp[21552] = 900656200; +inp[21553] = 0; +inp[21554] = 898898822; +inp[21555] = 0; +inp[21556] = 897144874; +inp[21557] = 0; +inp[21558] = 895394348; +inp[21559] = 0; +inp[21560] = 893647237; +inp[21561] = 0; +inp[21562] = 891903536; +inp[21563] = 0; +inp[21564] = 890163237; +inp[21565] = 0; +inp[21566] = 888426334; +inp[21567] = 0; +inp[21568] = 886692819; +inp[21569] = 0; +inp[21570] = 884962688; +inp[21571] = 0; +inp[21572] = 883235932; +inp[21573] = 0; +inp[21574] = 881512545; +inp[21575] = 0; +inp[21576] = 879792521; +inp[21577] = 0; +inp[21578] = 878075853; +inp[21579] = 0; +inp[21580] = 876362535; +inp[21581] = 0; +inp[21582] = 874652560; +inp[21583] = 0; +inp[21584] = 872945921; +inp[21585] = 0; +inp[21586] = 871242613; +inp[21587] = 0; +inp[21588] = 869542628; +inp[21589] = 0; +inp[21590] = 867845960; +inp[21591] = 0; +inp[21592] = 866152602; +inp[21593] = 0; +inp[21594] = 864462549; +inp[21595] = 0; +inp[21596] = 862775793; +inp[21597] = 0; +inp[21598] = 861092329; +inp[21599] = 0; +inp[21600] = 859412149; +inp[21601] = 0; +inp[21602] = 857735248; +inp[21603] = 0; +inp[21604] = 856061619; +inp[21605] = 0; +inp[21606] = 854391255; +inp[21607] = 0; +inp[21608] = 852724151; +inp[21609] = 0; +inp[21610] = 851060299; +inp[21611] = 0; +inp[21612] = 849399695; +inp[21613] = 0; +inp[21614] = 847742330; +inp[21615] = 0; +inp[21616] = 846088199; +inp[21617] = 0; +inp[21618] = 844437296; +inp[21619] = 0; +inp[21620] = 842789614; +inp[21621] = 0; +inp[21622] = 841145147; +inp[21623] = 0; +inp[21624] = 839503888; +inp[21625] = 0; +inp[21626] = 837865832; +inp[21627] = 0; +inp[21628] = 836230973; +inp[21629] = 0; +inp[21630] = 834599303; +inp[21631] = 0; +inp[21632] = 832970817; +inp[21633] = 0; +inp[21634] = 831345509; +inp[21635] = 0; +inp[21636] = 829723372; +inp[21637] = 0; +inp[21638] = 828104400; +inp[21639] = 0; +inp[21640] = 826488587; +inp[21641] = 0; +inp[21642] = 824875927; +inp[21643] = 0; +inp[21644] = 823266413; +inp[21645] = 0; +inp[21646] = 821660040; +inp[21647] = 0; +inp[21648] = 820056802; +inp[21649] = 0; +inp[21650] = 818456691; +inp[21651] = 0; +inp[21652] = 816859703; +inp[21653] = 0; +inp[21654] = 815265831; +inp[21655] = 0; +inp[21656] = 813675069; +inp[21657] = 0; +inp[21658] = 812087411; +inp[21659] = 0; +inp[21660] = 810502851; +inp[21661] = 0; +inp[21662] = 808921382; +inp[21663] = 0; +inp[21664] = 807342999; +inp[21665] = 0; +inp[21666] = 805767696; +inp[21667] = 0; +inp[21668] = 804195467; +inp[21669] = 0; +inp[21670] = 802626306; +inp[21671] = 0; +inp[21672] = 801060206; +inp[21673] = 0; +inp[21674] = 799497163; +inp[21675] = 0; +inp[21676] = 797937169; +inp[21677] = 0; +inp[21678] = 796380218; +inp[21679] = 0; +inp[21680] = 794826306; +inp[21681] = 0; +inp[21682] = 793275426; +inp[21683] = 0; +inp[21684] = 791727572; +inp[21685] = 0; +inp[21686] = 790182738; +inp[21687] = 0; +inp[21688] = 788640919; +inp[21689] = 0; +inp[21690] = 787102108; +inp[21691] = 0; +inp[21692] = 785566299; +inp[21693] = 0; +inp[21694] = 784033488; +inp[21695] = 0; +inp[21696] = 782503667; +inp[21697] = 0; +inp[21698] = 780976831; +inp[21699] = 0; +inp[21700] = 779452974; +inp[21701] = 0; +inp[21702] = 777932091; +inp[21703] = 0; +inp[21704] = 776414175; +inp[21705] = 0; +inp[21706] = 774899221; +inp[21707] = 0; +inp[21708] = 773387223; +inp[21709] = 0; +inp[21710] = 771878175; +inp[21711] = 0; +inp[21712] = 770372072; +inp[21713] = 0; +inp[21714] = 768868907; +inp[21715] = 0; +inp[21716] = 767368676; +inp[21717] = 0; +inp[21718] = 765871371; +inp[21719] = 0; +inp[21720] = 764376989; +inp[21721] = 0; +inp[21722] = 762885522; +inp[21723] = 0; +inp[21724] = 761396965; +inp[21725] = 0; +inp[21726] = 759911313; +inp[21727] = 0; +inp[21728] = 758428560; +inp[21729] = 0; +inp[21730] = 756948700; +inp[21731] = 0; +inp[21732] = 755471727; +inp[21733] = 0; +inp[21734] = 753997636; +inp[21735] = 0; +inp[21736] = 752526422; +inp[21737] = 0; +inp[21738] = 751058078; +inp[21739] = 0; +inp[21740] = 749592599; +inp[21741] = 0; +inp[21742] = 748129980; +inp[21743] = 0; +inp[21744] = 746670215; +inp[21745] = 0; +inp[21746] = 745213298; +inp[21747] = 0; +inp[21748] = 743759224; +inp[21749] = 0; +inp[21750] = 742307986; +inp[21751] = 0; +inp[21752] = 740859581; +inp[21753] = 0; +inp[21754] = 739414002; +inp[21755] = 0; +inp[21756] = 737971243; +inp[21757] = 0; +inp[21758] = 736531300; +inp[21759] = 0; +inp[21760] = 735094166; +inp[21761] = 0; +inp[21762] = 733659836; +inp[21763] = 0; +inp[21764] = 732228306; +inp[21765] = 0; +inp[21766] = 730799568; +inp[21767] = 0; +inp[21768] = 729373618; +inp[21769] = 0; +inp[21770] = 727950450; +inp[21771] = 0; +inp[21772] = 726530060; +inp[21773] = 0; +inp[21774] = 725112440; +inp[21775] = 0; +inp[21776] = 723697587; +inp[21777] = 0; +inp[21778] = 722285495; +inp[21779] = 0; +inp[21780] = 720876158; +inp[21781] = 0; +inp[21782] = 719469571; +inp[21783] = 0; +inp[21784] = 718065728; +inp[21785] = 0; +inp[21786] = 716664625; +inp[21787] = 0; +inp[21788] = 715266255; +inp[21789] = 0; +inp[21790] = 713870614; +inp[21791] = 0; +inp[21792] = 712477696; +inp[21793] = 0; +inp[21794] = 711087496; +inp[21795] = 0; +inp[21796] = 709700009; +inp[21797] = 0; +inp[21798] = 708315229; +inp[21799] = 0; +inp[21800] = 706933151; +inp[21801] = 0; +inp[21802] = 705553769; +inp[21803] = 0; +inp[21804] = 704177080; +inp[21805] = 0; +inp[21806] = 702803076; +inp[21807] = 0; +inp[21808] = 701431753; +inp[21809] = 0; +inp[21810] = 700063106; +inp[21811] = 0; +inp[21812] = 698697130; +inp[21813] = 0; +inp[21814] = 697333819; +inp[21815] = 0; +inp[21816] = 695973168; +inp[21817] = 0; +inp[21818] = 694615172; +inp[21819] = 0; +inp[21820] = 693259826; +inp[21821] = 0; +inp[21822] = 691907124; +inp[21823] = 0; +inp[21824] = 690557062; +inp[21825] = 0; +inp[21826] = 689209634; +inp[21827] = 0; +inp[21828] = 687864835; +inp[21829] = 0; +inp[21830] = 686522660; +inp[21831] = 0; +inp[21832] = 685183104; +inp[21833] = 0; +inp[21834] = 683846162; +inp[21835] = 0; +inp[21836] = 682511829; +inp[21837] = 0; +inp[21838] = 681180099; +inp[21839] = 0; +inp[21840] = 679850967; +inp[21841] = 0; +inp[21842] = 678524429; +inp[21843] = 0; +inp[21844] = 677200479; +inp[21845] = 0; +inp[21846] = 675879113; +inp[21847] = 0; +inp[21848] = 674560325; +inp[21849] = 0; +inp[21850] = 673244110; +inp[21851] = 0; +inp[21852] = 671930463; +inp[21853] = 0; +inp[21854] = 670619380; +inp[21855] = 0; +inp[21856] = 669310855; +inp[21857] = 0; +inp[21858] = 668004883; +inp[21859] = 0; +inp[21860] = 666701459; +inp[21861] = 0; +inp[21862] = 665400579; +inp[21863] = 0; +inp[21864] = 664102236; +inp[21865] = 0; +inp[21866] = 662806428; +inp[21867] = 0; +inp[21868] = 661513147; +inp[21869] = 0; +inp[21870] = 660222390; +inp[21871] = 0; +inp[21872] = 658934152; +inp[21873] = 0; +inp[21874] = 657648427; +inp[21875] = 0; +inp[21876] = 656365211; +inp[21877] = 0; +inp[21878] = 655084499; +inp[21879] = 0; +inp[21880] = 653806286; +inp[21881] = 0; +inp[21882] = 652530566; +inp[21883] = 0; +inp[21884] = 1073741824; +inp[21885] = 1073741824; +inp[21886] = 1072693759; +inp[21887] = 0; +inp[21888] = 1071646718; +inp[21889] = 0; +inp[21890] = 1070600699; +inp[21891] = 0; +inp[21892] = 1069555701; +inp[21893] = 0; +inp[21894] = 1068511723; +inp[21895] = 0; +inp[21896] = 1067468764; +inp[21897] = 0; +inp[21898] = 1066426822; +inp[21899] = 0; +inp[21900] = 1065385898; +inp[21901] = 0; +inp[21902] = 1064345990; +inp[21903] = 0; +inp[21904] = 1063307097; +inp[21905] = 0; +inp[21906] = 1062269218; +inp[21907] = 0; +inp[21908] = 1061232352; +inp[21909] = 0; +inp[21910] = 1060196498; +inp[21911] = 0; +inp[21912] = 1059161656; +inp[21913] = 0; +inp[21914] = 1058127823; +inp[21915] = 0; +inp[21916] = 1057094999; +inp[21917] = 0; +inp[21918] = 1056063184; +inp[21919] = 0; +inp[21920] = 1055032376; +inp[21921] = 0; +inp[21922] = 1054002574; +inp[21923] = 0; +inp[21924] = 1052973777; +inp[21925] = 0; +inp[21926] = 1051945984; +inp[21927] = 0; +inp[21928] = 1050919194; +inp[21929] = 0; +inp[21930] = 1049893407; +inp[21931] = 0; +inp[21932] = 1048868621; +inp[21933] = 0; +inp[21934] = 1047844835; +inp[21935] = 0; +inp[21936] = 1046822049; +inp[21937] = 0; +inp[21938] = 1045800261; +inp[21939] = 0; +inp[21940] = 1044779470; +inp[21941] = 0; +inp[21942] = 1043759675; +inp[21943] = 0; +inp[21944] = 1042740876; +inp[21945] = 0; +inp[21946] = 1041723072; +inp[21947] = 0; +inp[21948] = 1040706261; +inp[21949] = 0; +inp[21950] = 1039690442; +inp[21951] = 0; +inp[21952] = 1038675615; +inp[21953] = 0; +inp[21954] = 1037661778; +inp[21955] = 0; +inp[21956] = 1036648931; +inp[21957] = 0; +inp[21958] = 1035637073; +inp[21959] = 0; +inp[21960] = 1034626202; +inp[21961] = 0; +inp[21962] = 1033616318; +inp[21963] = 0; +inp[21964] = 1032607420; +inp[21965] = 0; +inp[21966] = 1031599507; +inp[21967] = 0; +inp[21968] = 1030592577; +inp[21969] = 0; +inp[21970] = 1029586630; +inp[21971] = 0; +inp[21972] = 1028581665; +inp[21973] = 0; +inp[21974] = 1027577681; +inp[21975] = 0; +inp[21976] = 1026574677; +inp[21977] = 0; +inp[21978] = 1025572652; +inp[21979] = 0; +inp[21980] = 1024571605; +inp[21981] = 0; +inp[21982] = 1023571536; +inp[21983] = 0; +inp[21984] = 1022572442; +inp[21985] = 0; +inp[21986] = 1021574324; +inp[21987] = 0; +inp[21988] = 1020577179; +inp[21989] = 0; +inp[21990] = 1019581008; +inp[21991] = 0; +inp[21992] = 1018585810; +inp[21993] = 0; +inp[21994] = 1017591583; +inp[21995] = 0; +inp[21996] = 1016598326; +inp[21997] = 0; +inp[21998] = 1015606039; +inp[21999] = 0; +inp[22000] = 1014614720; +inp[22001] = 0; +inp[22002] = 1013624369; +inp[22003] = 0; +inp[22004] = 1012634985; +inp[22005] = 0; +inp[22006] = 1011646566; +inp[22007] = 0; +inp[22008] = 1010659112; +inp[22009] = 0; +inp[22010] = 1009672622; +inp[22011] = 0; +inp[22012] = 1008687095; +inp[22013] = 0; +inp[22014] = 1007702530; +inp[22015] = 0; +inp[22016] = 1006718926; +inp[22017] = 0; +inp[22018] = 1005736282; +inp[22019] = 0; +inp[22020] = 1004754597; +inp[22021] = 0; +inp[22022] = 1003773870; +inp[22023] = 0; +inp[22024] = 1002794101; +inp[22025] = 0; +inp[22026] = 1001815287; +inp[22027] = 0; +inp[22028] = 1000837430; +inp[22029] = 0; +inp[22030] = 999860527; +inp[22031] = 0; +inp[22032] = 998884577; +inp[22033] = 0; +inp[22034] = 997909580; +inp[22035] = 0; +inp[22036] = 996935534; +inp[22037] = 0; +inp[22038] = 995962440; +inp[22039] = 0; +inp[22040] = 994990295; +inp[22041] = 0; +inp[22042] = 994019099; +inp[22043] = 0; +inp[22044] = 993048851; +inp[22045] = 0; +inp[22046] = 992079550; +inp[22047] = 0; +inp[22048] = 991111195; +inp[22049] = 0; +inp[22050] = 990143786; +inp[22051] = 0; +inp[22052] = 989177321; +inp[22053] = 0; +inp[22054] = 988211799; +inp[22055] = 0; +inp[22056] = 987247219; +inp[22057] = 0; +inp[22058] = 986283581; +inp[22059] = 0; +inp[22060] = 985320884; +inp[22061] = 0; +inp[22062] = 984359126; +inp[22063] = 0; +inp[22064] = 983398307; +inp[22065] = 0; +inp[22066] = 982438426; +inp[22067] = 0; +inp[22068] = 981479482; +inp[22069] = 0; +inp[22070] = 980521473; +inp[22071] = 0; +inp[22072] = 979564400; +inp[22073] = 0; +inp[22074] = 978608261; +inp[22075] = 0; +inp[22076] = 977653056; +inp[22077] = 0; +inp[22078] = 976698782; +inp[22079] = 0; +inp[22080] = 975745441; +inp[22081] = 0; +inp[22082] = 974793029; +inp[22083] = 0; +inp[22084] = 973841548; +inp[22085] = 0; +inp[22086] = 972890995; +inp[22087] = 0; +inp[22088] = 971941370; +inp[22089] = 0; +inp[22090] = 970992671; +inp[22091] = 0; +inp[22092] = 970044899; +inp[22093] = 0; +inp[22094] = 969098052; +inp[22095] = 0; +inp[22096] = 968152129; +inp[22097] = 0; +inp[22098] = 967207130; +inp[22099] = 0; +inp[22100] = 966263053; +inp[22101] = 0; +inp[22102] = 965319897; +inp[22103] = 0; +inp[22104] = 964377662; +inp[22105] = 0; +inp[22106] = 963436347; +inp[22107] = 0; +inp[22108] = 962495950; +inp[22109] = 0; +inp[22110] = 961556471; +inp[22111] = 0; +inp[22112] = 960617910; +inp[22113] = 0; +inp[22114] = 959680264; +inp[22115] = 0; +inp[22116] = 958743534; +inp[22117] = 0; +inp[22118] = 957807718; +inp[22119] = 0; +inp[22120] = 956872815; +inp[22121] = 0; +inp[22122] = 955938825; +inp[22123] = 0; +inp[22124] = 955005747; +inp[22125] = 0; +inp[22126] = 954073579; +inp[22127] = 0; +inp[22128] = 953142322; +inp[22129] = 0; +inp[22130] = 952211973; +inp[22131] = 0; +inp[22132] = 951282532; +inp[22133] = 0; +inp[22134] = 950353999; +inp[22135] = 0; +inp[22136] = 949426372; +inp[22137] = 0; +inp[22138] = 948499650; +inp[22139] = 0; +inp[22140] = 947573833; +inp[22141] = 0; +inp[22142] = 946648920; +inp[22143] = 0; +inp[22144] = 945724909; +inp[22145] = 0; +inp[22146] = 944801801; +inp[22147] = 0; +inp[22148] = 943879593; +inp[22149] = 0; +inp[22150] = 942958286; +inp[22151] = 0; +inp[22152] = 942037877; +inp[22153] = 0; +inp[22154] = 941118368; +inp[22155] = 0; +inp[22156] = 940199755; +inp[22157] = 0; +inp[22158] = 939282040; +inp[22159] = 0; +inp[22160] = 938365220; +inp[22161] = 0; +inp[22162] = 937449295; +inp[22163] = 0; +inp[22164] = 936534264; +inp[22165] = 0; +inp[22166] = 935620126; +inp[22167] = 0; +inp[22168] = 934706880; +inp[22169] = 0; +inp[22170] = 933794526; +inp[22171] = 0; +inp[22172] = 932883063; +inp[22173] = 0; +inp[22174] = 931972489; +inp[22175] = 0; +inp[22176] = 931062804; +inp[22177] = 0; +inp[22178] = 930154006; +inp[22179] = 0; +inp[22180] = 929246096; +inp[22181] = 0; +inp[22182] = 928339072; +inp[22183] = 0; +inp[22184] = 927432934; +inp[22185] = 0; +inp[22186] = 926527680; +inp[22187] = 0; +inp[22188] = 925623309; +inp[22189] = 0; +inp[22190] = 924719821; +inp[22191] = 0; +inp[22192] = 923817215; +inp[22193] = 0; +inp[22194] = 922915491; +inp[22195] = 0; +inp[22196] = 922014646; +inp[22197] = 0; +inp[22198] = 921114680; +inp[22199] = 0; +inp[22200] = 920215593; +inp[22201] = 0; +inp[22202] = 919317384; +inp[22203] = 0; +inp[22204] = 918420051; +inp[22205] = 0; +inp[22206] = 917523595; +inp[22207] = 0; +inp[22208] = 916628013; +inp[22209] = 0; +inp[22210] = 915733305; +inp[22211] = 0; +inp[22212] = 914839471; +inp[22213] = 0; +inp[22214] = 913946509; +inp[22215] = 0; +inp[22216] = 913054419; +inp[22217] = 0; +inp[22218] = 912163199; +inp[22219] = 0; +inp[22220] = 911272850; +inp[22221] = 0; +inp[22222] = 910383369; +inp[22223] = 0; +inp[22224] = 909494757; +inp[22225] = 0; +inp[22226] = 908607012; +inp[22227] = 0; +inp[22228] = 907720134; +inp[22229] = 0; +inp[22230] = 906834121; +inp[22231] = 0; +inp[22232] = 905948973; +inp[22233] = 0; +inp[22234] = 905064689; +inp[22235] = 0; +inp[22236] = 904181268; +inp[22237] = 0; +inp[22238] = 903298710; +inp[22239] = 0; +inp[22240] = 902417013; +inp[22241] = 0; +inp[22242] = 901536176; +inp[22243] = 0; +inp[22244] = 900656200; +inp[22245] = 0; +inp[22246] = 899777082; +inp[22247] = 0; +inp[22248] = 898898822; +inp[22249] = 0; +inp[22250] = 898021420; +inp[22251] = 0; +inp[22252] = 897144874; +inp[22253] = 0; +inp[22254] = 896269183; +inp[22255] = 0; +inp[22256] = 895394348; +inp[22257] = 0; +inp[22258] = 894520366; +inp[22259] = 0; +inp[22260] = 893647237; +inp[22261] = 0; +inp[22262] = 892774961; +inp[22263] = 0; +inp[22264] = 891903536; +inp[22265] = 0; +inp[22266] = 891032962; +inp[22267] = 0; +inp[22268] = 890163237; +inp[22269] = 0; +inp[22270] = 889294361; +inp[22271] = 0; +inp[22272] = 888426334; +inp[22273] = 0; +inp[22274] = 887559153; +inp[22275] = 0; +inp[22276] = 886692819; +inp[22277] = 0; +inp[22278] = 885827331; +inp[22279] = 0; +inp[22280] = 884962688; +inp[22281] = 0; +inp[22282] = 884098888; +inp[22283] = 0; +inp[22284] = 883235932; +inp[22285] = 0; +inp[22286] = 882373818; +inp[22287] = 0; +inp[22288] = 881512545; +inp[22289] = 0; +inp[22290] = 880652113; +inp[22291] = 0; +inp[22292] = 879792521; +inp[22293] = 0; +inp[22294] = 878933768; +inp[22295] = 0; +inp[22296] = 878075853; +inp[22297] = 0; +inp[22298] = 877218776; +inp[22299] = 0; +inp[22300] = 876362535; +inp[22301] = 0; +inp[22302] = 875507130; +inp[22303] = 0; +inp[22304] = 874652560; +inp[22305] = 0; +inp[22306] = 873798824; +inp[22307] = 0; +inp[22308] = 872945921; +inp[22309] = 0; +inp[22310] = 872093851; +inp[22311] = 0; +inp[22312] = 871242613; +inp[22313] = 0; +inp[22314] = 870392205; +inp[22315] = 0; +inp[22316] = 869542628; +inp[22317] = 0; +inp[22318] = 868693880; +inp[22319] = 0; +inp[22320] = 867845960; +inp[22321] = 0; +inp[22322] = 866998868; +inp[22323] = 0; +inp[22324] = 866152602; +inp[22325] = 0; +inp[22326] = 865307163; +inp[22327] = 0; +inp[22328] = 864462549; +inp[22329] = 0; +inp[22330] = 863618759; +inp[22331] = 0; +inp[22332] = 862775793; +inp[22333] = 0; +inp[22334] = 861933650; +inp[22335] = 0; +inp[22336] = 861092329; +inp[22337] = 0; +inp[22338] = 860251829; +inp[22339] = 0; +inp[22340] = 859412149; +inp[22341] = 0; +inp[22342] = 858573289; +inp[22343] = 0; +inp[22344] = 857735248; +inp[22345] = 0; +inp[22346] = 856898025; +inp[22347] = 0; +inp[22348] = 856061619; +inp[22349] = 0; +inp[22350] = 855226029; +inp[22351] = 0; +inp[22352] = 854391255; +inp[22353] = 0; +inp[22354] = 853557296; +inp[22355] = 0; +inp[22356] = 852724151; +inp[22357] = 0; +inp[22358] = 851891819; +inp[22359] = 0; +inp[22360] = 851060299; +inp[22361] = 0; +inp[22362] = 850229592; +inp[22363] = 0; +inp[22364] = 849399695; +inp[22365] = 0; +inp[22366] = 848570608; +inp[22367] = 0; +inp[22368] = 847742330; +inp[22369] = 0; +inp[22370] = 846914861; +inp[22371] = 0; +inp[22372] = 846088199; +inp[22373] = 0; +inp[22374] = 845262344; +inp[22375] = 0; +inp[22376] = 844437296; +inp[22377] = 0; +inp[22378] = 843613052; +inp[22379] = 0; +inp[22380] = 842789614; +inp[22381] = 0; +inp[22382] = 841966979; +inp[22383] = 0; +inp[22384] = 841145147; +inp[22385] = 0; +inp[22386] = 840324117; +inp[22387] = 0; +inp[22388] = 839503888; +inp[22389] = 0; +inp[22390] = 838684460; +inp[22391] = 0; +inp[22392] = 837865832; +inp[22393] = 0; +inp[22394] = 837048004; +inp[22395] = 0; +inp[22396] = 1073741824; +inp[22397] = 1073741824; +inp[22398] = 1073217663; +inp[22399] = 0; +inp[22400] = 1072693759; +inp[22401] = 0; +inp[22402] = 1072170111; +inp[22403] = 0; +inp[22404] = 1071646718; +inp[22405] = 0; +inp[22406] = 1071123581; +inp[22407] = 0; +inp[22408] = 1070600699; +inp[22409] = 0; +inp[22410] = 1070078072; +inp[22411] = 0; +inp[22412] = 1069555701; +inp[22413] = 0; +inp[22414] = 1069033584; +inp[22415] = 0; +inp[22416] = 1068511723; +inp[22417] = 0; +inp[22418] = 1067990116; +inp[22419] = 0; +inp[22420] = 1067468764; +inp[22421] = 0; +inp[22422] = 1066947666; +inp[22423] = 0; +inp[22424] = 1066426822; +inp[22425] = 0; +inp[22426] = 1065906233; +inp[22427] = 0; +inp[22428] = 1065385898; +inp[22429] = 0; +inp[22430] = 1064865817; +inp[22431] = 0; +inp[22432] = 1064345990; +inp[22433] = 0; +inp[22434] = 1063826417; +inp[22435] = 0; +inp[22436] = 1063307097; +inp[22437] = 0; +inp[22438] = 1062788031; +inp[22439] = 0; +inp[22440] = 1062269218; +inp[22441] = 0; +inp[22442] = 1061750659; +inp[22443] = 0; +inp[22444] = 1061232352; +inp[22445] = 0; +inp[22446] = 1060714299; +inp[22447] = 0; +inp[22448] = 1060196498; +inp[22449] = 0; +inp[22450] = 1059678951; +inp[22451] = 0; +inp[22452] = 1059161656; +inp[22453] = 0; +inp[22454] = 1058644613; +inp[22455] = 0; +inp[22456] = 1058127823; +inp[22457] = 0; +inp[22458] = 1057611285; +inp[22459] = 0; +inp[22460] = 1057094999; +inp[22461] = 0; +inp[22462] = 1056578966; +inp[22463] = 0; +inp[22464] = 1056063184; +inp[22465] = 0; +inp[22466] = 1055547654; +inp[22467] = 0; +inp[22468] = 1055032376; +inp[22469] = 0; +inp[22470] = 1054517349; +inp[22471] = 0; +inp[22472] = 1054002574; +inp[22473] = 0; +inp[22474] = 1053488050; +inp[22475] = 0; +inp[22476] = 1052973777; +inp[22477] = 0; +inp[22478] = 1052459755; +inp[22479] = 0; +inp[22480] = 1051945984; +inp[22481] = 0; +inp[22482] = 1051432464; +inp[22483] = 0; +inp[22484] = 1050919194; +inp[22485] = 0; +inp[22486] = 1050406175; +inp[22487] = 0; +inp[22488] = 1049893407; +inp[22489] = 0; +inp[22490] = 1049380889; +inp[22491] = 0; +inp[22492] = 1048868621; +inp[22493] = 0; +inp[22494] = 1048356603; +inp[22495] = 0; +inp[22496] = 1047844835; +inp[22497] = 0; +inp[22498] = 1047333317; +inp[22499] = 0; +inp[22500] = 1046822049; +inp[22501] = 0; +inp[22502] = 1046311030; +inp[22503] = 0; +inp[22504] = 1045800261; +inp[22505] = 0; +inp[22506] = 1045289741; +inp[22507] = 0; +inp[22508] = 1044779470; +inp[22509] = 0; +inp[22510] = 1044269448; +inp[22511] = 0; +inp[22512] = 1043759675; +inp[22513] = 0; +inp[22514] = 1043250151; +inp[22515] = 0; +inp[22516] = 1042740876; +inp[22517] = 0; +inp[22518] = 1042231850; +inp[22519] = 0; +inp[22520] = 1041723072; +inp[22521] = 0; +inp[22522] = 1041214542; +inp[22523] = 0; +inp[22524] = 1040706261; +inp[22525] = 0; +inp[22526] = 1040198227; +inp[22527] = 0; +inp[22528] = 1039690442; +inp[22529] = 0; +inp[22530] = 1039182905; +inp[22531] = 0; +inp[22532] = 1038675615; +inp[22533] = 0; +inp[22534] = 1038168573; +inp[22535] = 0; +inp[22536] = 1037661778; +inp[22537] = 0; +inp[22538] = 1037155231; +inp[22539] = 0; +inp[22540] = 1036648931; +inp[22541] = 0; +inp[22542] = 1036142879; +inp[22543] = 0; +inp[22544] = 1035637073; +inp[22545] = 0; +inp[22546] = 1035131514; +inp[22547] = 0; +inp[22548] = 1034626202; +inp[22549] = 0; +inp[22550] = 1034121137; +inp[22551] = 0; +inp[22552] = 1033616318; +inp[22553] = 0; +inp[22554] = 1033111746; +inp[22555] = 0; +inp[22556] = 1032607420; +inp[22557] = 0; +inp[22558] = 1032103340; +inp[22559] = 0; +inp[22560] = 1031599507; +inp[22561] = 0; +inp[22562] = 1031095919; +inp[22563] = 0; +inp[22564] = 1030592577; +inp[22565] = 0; +inp[22566] = 1030089481; +inp[22567] = 0; +inp[22568] = 1029586630; +inp[22569] = 0; +inp[22570] = 1029084025; +inp[22571] = 0; +inp[22572] = 1028581665; +inp[22573] = 0; +inp[22574] = 1028079551; +inp[22575] = 0; +inp[22576] = 1027577681; +inp[22577] = 0; +inp[22578] = 1027076057; +inp[22579] = 0; +inp[22580] = 1026574677; +inp[22581] = 0; +inp[22582] = 1026073543; +inp[22583] = 0; +inp[22584] = 1025572652; +inp[22585] = 0; +inp[22586] = 1025072007; +inp[22587] = 0; +inp[22588] = 1024571605; +inp[22589] = 0; +inp[22590] = 1024071449; +inp[22591] = 0; +inp[22592] = 1023571536; +inp[22593] = 0; +inp[22594] = 1023071867; +inp[22595] = 0; +inp[22596] = 1022572442; +inp[22597] = 0; +inp[22598] = 1022073261; +inp[22599] = 0; +inp[22600] = 1021574324; +inp[22601] = 0; +inp[22602] = 1021075630; +inp[22603] = 0; +inp[22604] = 1020577179; +inp[22605] = 0; +inp[22606] = 1020078972; +inp[22607] = 0; +inp[22608] = 1019581008; +inp[22609] = 0; +inp[22610] = 1019083288; +inp[22611] = 0; +inp[22612] = 1018585810; +inp[22613] = 0; +inp[22614] = 1018088575; +inp[22615] = 0; +inp[22616] = 1017591583; +inp[22617] = 0; +inp[22618] = 1017094833; +inp[22619] = 0; +inp[22620] = 1016598326; +inp[22621] = 0; +inp[22622] = 1016102061; +inp[22623] = 0; +inp[22624] = 1015606039; +inp[22625] = 0; +inp[22626] = 1015110258; +inp[22627] = 0; +inp[22628] = 1014614720; +inp[22629] = 0; +inp[22630] = 1014119424; +inp[22631] = 0; +inp[22632] = 1013624369; +inp[22633] = 0; +inp[22634] = 1013129556; +inp[22635] = 0; +inp[22636] = 1012634985; +inp[22637] = 0; +inp[22638] = 1012140655; +inp[22639] = 0; +inp[22640] = 1011646566; +inp[22641] = 0; +inp[22642] = 1011152719; +inp[22643] = 0; +inp[22644] = 1010659112; +inp[22645] = 0; +inp[22646] = 1010165747; +inp[22647] = 0; +inp[22648] = 1009672622; +inp[22649] = 0; +inp[22650] = 1009179738; +inp[22651] = 0; +inp[22652] = 1008687095; +inp[22653] = 0; +inp[22654] = 1008194692; +inp[22655] = 0; +inp[22656] = 1007702530; +inp[22657] = 0; +inp[22658] = 1007210608; +inp[22659] = 0; +inp[22660] = 1006718926; +inp[22661] = 0; +inp[22662] = 1006227484; +inp[22663] = 0; +inp[22664] = 1005736282; +inp[22665] = 0; +inp[22666] = 1005245319; +inp[22667] = 0; +inp[22668] = 1004754597; +inp[22669] = 0; +inp[22670] = 1004264114; +inp[22671] = 0; +inp[22672] = 1003773870; +inp[22673] = 0; +inp[22674] = 1003283866; +inp[22675] = 0; +inp[22676] = 1002794101; +inp[22677] = 0; +inp[22678] = 1002304575; +inp[22679] = 0; +inp[22680] = 1001815287; +inp[22681] = 0; +inp[22682] = 1001326239; +inp[22683] = 0; +inp[22684] = 1000837430; +inp[22685] = 0; +inp[22686] = 1000348859; +inp[22687] = 0; +inp[22688] = 999860527; +inp[22689] = 0; +inp[22690] = 999372433; +inp[22691] = 0; +inp[22692] = 998884577; +inp[22693] = 0; +inp[22694] = 998396959; +inp[22695] = 0; +inp[22696] = 997909580; +inp[22697] = 0; +inp[22698] = 997422438; +inp[22699] = 0; +inp[22700] = 996935534; +inp[22701] = 0; +inp[22702] = 996448868; +inp[22703] = 0; +inp[22704] = 995962440; +inp[22705] = 0; +inp[22706] = 995476249; +inp[22707] = 0; +inp[22708] = 994990295; +inp[22709] = 0; +inp[22710] = 994504578; +inp[22711] = 0; +inp[22712] = 994019099; +inp[22713] = 0; +inp[22714] = 993533857; +inp[22715] = 0; +inp[22716] = 993048851; +inp[22717] = 0; +inp[22718] = 992564082; +inp[22719] = 0; +inp[22720] = 992079550; +inp[22721] = 0; +inp[22722] = 991595255; +inp[22723] = 0; +inp[22724] = 991111195; +inp[22725] = 0; +inp[22726] = 990627373; +inp[22727] = 0; +inp[22728] = 990143786; +inp[22729] = 0; +inp[22730] = 989660435; +inp[22731] = 0; +inp[22732] = 989177321; +inp[22733] = 0; +inp[22734] = 988694442; +inp[22735] = 0; +inp[22736] = 988211799; +inp[22737] = 0; +inp[22738] = 987729391; +inp[22739] = 0; +inp[22740] = 987247219; +inp[22741] = 0; +inp[22742] = 986765282; +inp[22743] = 0; +inp[22744] = 986283581; +inp[22745] = 0; +inp[22746] = 985802115; +inp[22747] = 0; +inp[22748] = 985320884; +inp[22749] = 0; +inp[22750] = 984839887; +inp[22751] = 0; +inp[22752] = 984359126; +inp[22753] = 0; +inp[22754] = 983878599; +inp[22755] = 0; +inp[22756] = 983398307; +inp[22757] = 0; +inp[22758] = 982918249; +inp[22759] = 0; +inp[22760] = 982438426; +inp[22761] = 0; +inp[22762] = 981958837; +inp[22763] = 0; +inp[22764] = 981479482; +inp[22765] = 0; +inp[22766] = 981000361; +inp[22767] = 0; +inp[22768] = 980521473; +inp[22769] = 0; +inp[22770] = 980042820; +inp[22771] = 0; +inp[22772] = 979564400; +inp[22773] = 0; +inp[22774] = 979086214; +inp[22775] = 0; +inp[22776] = 978608261; +inp[22777] = 0; +inp[22778] = 978130542; +inp[22779] = 0; +inp[22780] = 977653056; +inp[22781] = 0; +inp[22782] = 977175803; +inp[22783] = 0; +inp[22784] = 976698782; +inp[22785] = 0; +inp[22786] = 976221995; +inp[22787] = 0; +inp[22788] = 975745441; +inp[22789] = 0; +inp[22790] = 975269119; +inp[22791] = 0; +inp[22792] = 974793029; +inp[22793] = 0; +inp[22794] = 974317172; +inp[22795] = 0; +inp[22796] = 973841548; +inp[22797] = 0; +inp[22798] = 973366155; +inp[22799] = 0; +inp[22800] = 972890995; +inp[22801] = 0; +inp[22802] = 972416066; +inp[22803] = 0; +inp[22804] = 971941370; +inp[22805] = 0; +inp[22806] = 971466905; +inp[22807] = 0; +inp[22808] = 970992671; +inp[22809] = 0; +inp[22810] = 970518670; +inp[22811] = 0; +inp[22812] = 970044899; +inp[22813] = 0; +inp[22814] = 969571360; +inp[22815] = 0; +inp[22816] = 969098052; +inp[22817] = 0; +inp[22818] = 968624975; +inp[22819] = 0; +inp[22820] = 968152129; +inp[22821] = 0; +inp[22822] = 967679514; +inp[22823] = 0; +inp[22824] = 967207130; +inp[22825] = 0; +inp[22826] = 966734976; +inp[22827] = 0; +inp[22828] = 966263053; +inp[22829] = 0; +inp[22830] = 965791360; +inp[22831] = 0; +inp[22832] = 965319897; +inp[22833] = 0; +inp[22834] = 964848664; +inp[22835] = 0; +inp[22836] = 964377662; +inp[22837] = 0; +inp[22838] = 963906889; +inp[22839] = 0; +inp[22840] = 963436347; +inp[22841] = 0; +inp[22842] = 962966033; +inp[22843] = 0; +inp[22844] = 962495950; +inp[22845] = 0; +inp[22846] = 962026096; +inp[22847] = 0; +inp[22848] = 961556471; +inp[22849] = 0; +inp[22850] = 961087076; +inp[22851] = 0; +inp[22852] = 960617910; +inp[22853] = 0; +inp[22854] = 960148972; +inp[22855] = 0; +inp[22856] = 959680264; +inp[22857] = 0; +inp[22858] = 959211785; +inp[22859] = 0; +inp[22860] = 958743534; +inp[22861] = 0; +inp[22862] = 958275512; +inp[22863] = 0; +inp[22864] = 957807718; +inp[22865] = 0; +inp[22866] = 957340153; +inp[22867] = 0; +inp[22868] = 956872815; +inp[22869] = 0; +inp[22870] = 956405706; +inp[22871] = 0; +inp[22872] = 955938825; +inp[22873] = 0; +inp[22874] = 955472172; +inp[22875] = 0; +inp[22876] = 955005747; +inp[22877] = 0; +inp[22878] = 954539549; +inp[22879] = 0; +inp[22880] = 954073579; +inp[22881] = 0; +inp[22882] = 953607837; +inp[22883] = 0; +inp[22884] = 953142322; +inp[22885] = 0; +inp[22886] = 952677034; +inp[22887] = 0; +inp[22888] = 952211973; +inp[22889] = 0; +inp[22890] = 951747139; +inp[22891] = 0; +inp[22892] = 951282532; +inp[22893] = 0; +inp[22894] = 950818152; +inp[22895] = 0; +inp[22896] = 950353999; +inp[22897] = 0; +inp[22898] = 949890072; +inp[22899] = 0; +inp[22900] = 949426372; +inp[22901] = 0; +inp[22902] = 948962898; +inp[22903] = 0; +inp[22904] = 948499650; +inp[22905] = 0; +inp[22906] = 948036629; +inp[22907] = 0; +inp[22908] = 1073741824; +inp[22909] = 1073741824; +inp[22910] = 1073479711; +inp[22911] = 0; +inp[22912] = 1073217663; +inp[22913] = 0; +inp[22914] = 1072955679; +inp[22915] = 0; +inp[22916] = 1072693759; +inp[22917] = 0; +inp[22918] = 1072431903; +inp[22919] = 0; +inp[22920] = 1072170111; +inp[22921] = 0; +inp[22922] = 1071908383; +inp[22923] = 0; +inp[22924] = 1071646718; +inp[22925] = 0; +inp[22926] = 1071385118; +inp[22927] = 0; +inp[22928] = 1071123581; +inp[22929] = 0; +inp[22930] = 1070862108; +inp[22931] = 0; +inp[22932] = 1070600699; +inp[22933] = 0; +inp[22934] = 1070339354; +inp[22935] = 0; +inp[22936] = 1070078072; +inp[22937] = 0; +inp[22938] = 1069816855; +inp[22939] = 0; +inp[22940] = 1069555701; +inp[22941] = 0; +inp[22942] = 1069294611; +inp[22943] = 0; +inp[22944] = 1069033584; +inp[22945] = 0; +inp[22946] = 1068772622; +inp[22947] = 0; +inp[22948] = 1068511723; +inp[22949] = 0; +inp[22950] = 1068250887; +inp[22951] = 0; +inp[22952] = 1067990116; +inp[22953] = 0; +inp[22954] = 1067729408; +inp[22955] = 0; +inp[22956] = 1067468764; +inp[22957] = 0; +inp[22958] = 1067208183; +inp[22959] = 0; +inp[22960] = 1066947666; +inp[22961] = 0; +inp[22962] = 1066687212; +inp[22963] = 0; +inp[22964] = 1066426822; +inp[22965] = 0; +inp[22966] = 1066166496; +inp[22967] = 0; +inp[22968] = 1065906233; +inp[22969] = 0; +inp[22970] = 1065646034; +inp[22971] = 0; +inp[22972] = 1065385898; +inp[22973] = 0; +inp[22974] = 1065125826; +inp[22975] = 0; +inp[22976] = 1064865817; +inp[22977] = 0; +inp[22978] = 1064605872; +inp[22979] = 0; +inp[22980] = 1064345990; +inp[22981] = 0; +inp[22982] = 1064086172; +inp[22983] = 0; +inp[22984] = 1063826417; +inp[22985] = 0; +inp[22986] = 1063566725; +inp[22987] = 0; +inp[22988] = 1063307097; +inp[22989] = 0; +inp[22990] = 1063047532; +inp[22991] = 0; +inp[22992] = 1062788031; +inp[22993] = 0; +inp[22994] = 1062528593; +inp[22995] = 0; +inp[22996] = 1062269218; +inp[22997] = 0; +inp[22998] = 1062009907; +inp[22999] = 0; +inp[23000] = 1061750659; +inp[23001] = 0; +inp[23002] = 1061491474; +inp[23003] = 0; +inp[23004] = 1061232352; +inp[23005] = 0; +inp[23006] = 1060973294; +inp[23007] = 0; +inp[23008] = 1060714299; +inp[23009] = 0; +inp[23010] = 1060455367; +inp[23011] = 0; +inp[23012] = 1060196498; +inp[23013] = 0; +inp[23014] = 1059937693; +inp[23015] = 0; +inp[23016] = 1059678951; +inp[23017] = 0; +inp[23018] = 1059420272; +inp[23019] = 0; +inp[23020] = 1059161656; +inp[23021] = 0; +inp[23022] = 1058903103; +inp[23023] = 0; +inp[23024] = 1058644613; +inp[23025] = 0; +inp[23026] = 1058386187; +inp[23027] = 0; +inp[23028] = 1058127823; +inp[23029] = 0; +inp[23030] = 1057869523; +inp[23031] = 0; +inp[23032] = 1057611285; +inp[23033] = 0; +inp[23034] = 1057353111; +inp[23035] = 0; +inp[23036] = 1057094999; +inp[23037] = 0; +inp[23038] = 1056836951; +inp[23039] = 0; +inp[23040] = 1056578966; +inp[23041] = 0; +inp[23042] = 1056321043; +inp[23043] = 0; +inp[23044] = 1056063184; +inp[23045] = 0; +inp[23046] = 1055805388; +inp[23047] = 0; +inp[23048] = 1055547654; +inp[23049] = 0; +inp[23050] = 1055289983; +inp[23051] = 0; +inp[23052] = 1055032376; +inp[23053] = 0; +inp[23054] = 1054774831; +inp[23055] = 0; +inp[23056] = 1054517349; +inp[23057] = 0; +inp[23058] = 1054259930; +inp[23059] = 0; +inp[23060] = 1054002574; +inp[23061] = 0; +inp[23062] = 1053745280; +inp[23063] = 0; +inp[23064] = 1053488050; +inp[23065] = 0; +inp[23066] = 1053230882; +inp[23067] = 0; +inp[23068] = 1052973777; +inp[23069] = 0; +inp[23070] = 1052716734; +inp[23071] = 0; +inp[23072] = 1052459755; +inp[23073] = 0; +inp[23074] = 1052202838; +inp[23075] = 0; +inp[23076] = 1051945984; +inp[23077] = 0; +inp[23078] = 1051689192; +inp[23079] = 0; +inp[23080] = 1051432464; +inp[23081] = 0; +inp[23082] = 1051175798; +inp[23083] = 0; +inp[23084] = 1050919194; +inp[23085] = 0; +inp[23086] = 1050662654; +inp[23087] = 0; +inp[23088] = 1050406175; +inp[23089] = 0; +inp[23090] = 1050149760; +inp[23091] = 0; +inp[23092] = 1049893407; +inp[23093] = 0; +inp[23094] = 1049637117; +inp[23095] = 0; +inp[23096] = 1049380889; +inp[23097] = 0; +inp[23098] = 1049124724; +inp[23099] = 0; +inp[23100] = 1048868621; +inp[23101] = 0; +inp[23102] = 1048612581; +inp[23103] = 0; +inp[23104] = 1048356603; +inp[23105] = 0; +inp[23106] = 1048100688; +inp[23107] = 0; +inp[23108] = 1047844835; +inp[23109] = 0; +inp[23110] = 1047589045; +inp[23111] = 0; +inp[23112] = 1047333317; +inp[23113] = 0; +inp[23114] = 1047077652; +inp[23115] = 0; +inp[23116] = 1046822049; +inp[23117] = 0; +inp[23118] = 1046566508; +inp[23119] = 0; +inp[23120] = 1046311030; +inp[23121] = 0; +inp[23122] = 1046055614; +inp[23123] = 0; +inp[23124] = 1045800261; +inp[23125] = 0; +inp[23126] = 1045544969; +inp[23127] = 0; +inp[23128] = 1045289741; +inp[23129] = 0; +inp[23130] = 1045034574; +inp[23131] = 0; +inp[23132] = 1044779470; +inp[23133] = 0; +inp[23134] = 1044524428; +inp[23135] = 0; +inp[23136] = 1044269448; +inp[23137] = 0; +inp[23138] = 1044014531; +inp[23139] = 0; +inp[23140] = 1043759675; +inp[23141] = 0; +inp[23142] = 1043504882; +inp[23143] = 0; +inp[23144] = 1043250151; +inp[23145] = 0; +inp[23146] = 1042995483; +inp[23147] = 0; +inp[23148] = 1042740876; +inp[23149] = 0; +inp[23150] = 1042486332; +inp[23151] = 0; +inp[23152] = 1042231850; +inp[23153] = 0; +inp[23154] = 1041977430; +inp[23155] = 0; +inp[23156] = 1041723072; +inp[23157] = 0; +inp[23158] = 1041468776; +inp[23159] = 0; +inp[23160] = 1041214542; +inp[23161] = 0; +inp[23162] = 1040960370; +inp[23163] = 0; +inp[23164] = 1040706261; +inp[23165] = 0; +inp[23166] = 1040452213; +inp[23167] = 0; +inp[23168] = 1040198227; +inp[23169] = 0; +inp[23170] = 1039944304; +inp[23171] = 0; +inp[23172] = 1039690442; +inp[23173] = 0; +inp[23174] = 1039436642; +inp[23175] = 0; +inp[23176] = 1039182905; +inp[23177] = 0; +inp[23178] = 1038929229; +inp[23179] = 0; +inp[23180] = 1038675615; +inp[23181] = 0; +inp[23182] = 1038422063; +inp[23183] = 0; +inp[23184] = 1038168573; +inp[23185] = 0; +inp[23186] = 1037915145; +inp[23187] = 0; +inp[23188] = 1037661778; +inp[23189] = 0; +inp[23190] = 1037408474; +inp[23191] = 0; +inp[23192] = 1037155231; +inp[23193] = 0; +inp[23194] = 1036902050; +inp[23195] = 0; +inp[23196] = 1036648931; +inp[23197] = 0; +inp[23198] = 1036395874; +inp[23199] = 0; +inp[23200] = 1036142879; +inp[23201] = 0; +inp[23202] = 1035889945; +inp[23203] = 0; +inp[23204] = 1035637073; +inp[23205] = 0; +inp[23206] = 1035384263; +inp[23207] = 0; +inp[23208] = 1035131514; +inp[23209] = 0; +inp[23210] = 1034878828; +inp[23211] = 0; +inp[23212] = 1034626202; +inp[23213] = 0; +inp[23214] = 1034373639; +inp[23215] = 0; +inp[23216] = 1034121137; +inp[23217] = 0; +inp[23218] = 1033868697; +inp[23219] = 0; +inp[23220] = 1033616318; +inp[23221] = 0; +inp[23222] = 1033364001; +inp[23223] = 0; +inp[23224] = 1033111746; +inp[23225] = 0; +inp[23226] = 1032859552; +inp[23227] = 0; +inp[23228] = 1032607420; +inp[23229] = 0; +inp[23230] = 1032355350; +inp[23231] = 0; +inp[23232] = 1032103340; +inp[23233] = 0; +inp[23234] = 1031851393; +inp[23235] = 0; +inp[23236] = 1031599507; +inp[23237] = 0; +inp[23238] = 1031347682; +inp[23239] = 0; +inp[23240] = 1031095919; +inp[23241] = 0; +inp[23242] = 1030844217; +inp[23243] = 0; +inp[23244] = 1030592577; +inp[23245] = 0; +inp[23246] = 1030340998; +inp[23247] = 0; +inp[23248] = 1030089481; +inp[23249] = 0; +inp[23250] = 1029838025; +inp[23251] = 0; +inp[23252] = 1029586630; +inp[23253] = 0; +inp[23254] = 1029335297; +inp[23255] = 0; +inp[23256] = 1029084025; +inp[23257] = 0; +inp[23258] = 1028832815; +inp[23259] = 0; +inp[23260] = 1028581665; +inp[23261] = 0; +inp[23262] = 1028330577; +inp[23263] = 0; +inp[23264] = 1028079551; +inp[23265] = 0; +inp[23266] = 1027828585; +inp[23267] = 0; +inp[23268] = 1027577681; +inp[23269] = 0; +inp[23270] = 1027326839; +inp[23271] = 0; +inp[23272] = 1027076057; +inp[23273] = 0; +inp[23274] = 1026825337; +inp[23275] = 0; +inp[23276] = 1026574677; +inp[23277] = 0; +inp[23278] = 1026324079; +inp[23279] = 0; +inp[23280] = 1026073543; +inp[23281] = 0; +inp[23282] = 1025823067; +inp[23283] = 0; +inp[23284] = 1025572652; +inp[23285] = 0; +inp[23286] = 1025322299; +inp[23287] = 0; +inp[23288] = 1025072007; +inp[23289] = 0; +inp[23290] = 1024821776; +inp[23291] = 0; +inp[23292] = 1024571605; +inp[23293] = 0; +inp[23294] = 1024321496; +inp[23295] = 0; +inp[23296] = 1024071449; +inp[23297] = 0; +inp[23298] = 1023821462; +inp[23299] = 0; +inp[23300] = 1023571536; +inp[23301] = 0; +inp[23302] = 1023321671; +inp[23303] = 0; +inp[23304] = 1023071867; +inp[23305] = 0; +inp[23306] = 1022822124; +inp[23307] = 0; +inp[23308] = 1022572442; +inp[23309] = 0; +inp[23310] = 1022322821; +inp[23311] = 0; +inp[23312] = 1022073261; +inp[23313] = 0; +inp[23314] = 1021823762; +inp[23315] = 0; +inp[23316] = 1021574324; +inp[23317] = 0; +inp[23318] = 1021324946; +inp[23319] = 0; +inp[23320] = 1021075630; +inp[23321] = 0; +inp[23322] = 1020826374; +inp[23323] = 0; +inp[23324] = 1020577179; +inp[23325] = 0; +inp[23326] = 1020328045; +inp[23327] = 0; +inp[23328] = 1020078972; +inp[23329] = 0; +inp[23330] = 1019829960; +inp[23331] = 0; +inp[23332] = 1019581008; +inp[23333] = 0; +inp[23334] = 1019332118; +inp[23335] = 0; +inp[23336] = 1019083288; +inp[23337] = 0; +inp[23338] = 1018834518; +inp[23339] = 0; +inp[23340] = 1018585810; +inp[23341] = 0; +inp[23342] = 1018337162; +inp[23343] = 0; +inp[23344] = 1018088575; +inp[23345] = 0; +inp[23346] = 1017840048; +inp[23347] = 0; +inp[23348] = 1017591583; +inp[23349] = 0; +inp[23350] = 1017343178; +inp[23351] = 0; +inp[23352] = 1017094833; +inp[23353] = 0; +inp[23354] = 1016846549; +inp[23355] = 0; +inp[23356] = 1016598326; +inp[23357] = 0; +inp[23358] = 1016350163; +inp[23359] = 0; +inp[23360] = 1016102061; +inp[23361] = 0; +inp[23362] = 1015854020; +inp[23363] = 0; +inp[23364] = 1015606039; +inp[23365] = 0; +inp[23366] = 1015358118; +inp[23367] = 0; +inp[23368] = 1015110258; +inp[23369] = 0; +inp[23370] = 1014862459; +inp[23371] = 0; +inp[23372] = 1014614720; +inp[23373] = 0; +inp[23374] = 1014367042; +inp[23375] = 0; +inp[23376] = 1014119424; +inp[23377] = 0; +inp[23378] = 1013871866; +inp[23379] = 0; +inp[23380] = 1013624369; +inp[23381] = 0; +inp[23382] = 1013376932; +inp[23383] = 0; +inp[23384] = 1013129556; +inp[23385] = 0; +inp[23386] = 1012882240; +inp[23387] = 0; +inp[23388] = 1012634985; +inp[23389] = 0; +inp[23390] = 1012387790; +inp[23391] = 0; +inp[23392] = 1012140655; +inp[23393] = 0; +inp[23394] = 1011893580; +inp[23395] = 0; +inp[23396] = 1011646566; +inp[23397] = 0; +inp[23398] = 1011399612; +inp[23399] = 0; +inp[23400] = 1011152719; +inp[23401] = 0; +inp[23402] = 1010905885; +inp[23403] = 0; +inp[23404] = 1010659112; +inp[23405] = 0; +inp[23406] = 1010412399; +inp[23407] = 0; +inp[23408] = 1010165747; +inp[23409] = 0; +inp[23410] = 1009919154; +inp[23411] = 0; +inp[23412] = 1009672622; +inp[23413] = 0; +inp[23414] = 1009426150; +inp[23415] = 0; +inp[23416] = 1009179738; +inp[23417] = 0; +inp[23418] = 1008933387; +inp[23419] = 0; +inp[23420] = 1073741824; +inp[23421] = 1073741824; +inp[23422] = 1073610759; +inp[23423] = 0; +inp[23424] = 1073479711; +inp[23425] = 0; +inp[23426] = 1073348679; +inp[23427] = 0; +inp[23428] = 1073217663; +inp[23429] = 0; +inp[23430] = 1073086663; +inp[23431] = 0; +inp[23432] = 1072955679; +inp[23433] = 0; +inp[23434] = 1072824711; +inp[23435] = 0; +inp[23436] = 1072693759; +inp[23437] = 0; +inp[23438] = 1072562823; +inp[23439] = 0; +inp[23440] = 1072431903; +inp[23441] = 0; +inp[23442] = 1072300999; +inp[23443] = 0; +inp[23444] = 1072170111; +inp[23445] = 0; +inp[23446] = 1072039239; +inp[23447] = 0; +inp[23448] = 1071908383; +inp[23449] = 0; +inp[23450] = 1071777542; +inp[23451] = 0; +inp[23452] = 1071646718; +inp[23453] = 0; +inp[23454] = 1071515910; +inp[23455] = 0; +inp[23456] = 1071385118; +inp[23457] = 0; +inp[23458] = 1071254341; +inp[23459] = 0; +inp[23460] = 1071123581; +inp[23461] = 0; +inp[23462] = 1070992836; +inp[23463] = 0; +inp[23464] = 1070862108; +inp[23465] = 0; +inp[23466] = 1070731396; +inp[23467] = 0; +inp[23468] = 1070600699; +inp[23469] = 0; +inp[23470] = 1070470018; +inp[23471] = 0; +inp[23472] = 1070339354; +inp[23473] = 0; +inp[23474] = 1070208705; +inp[23475] = 0; +inp[23476] = 1070078072; +inp[23477] = 0; +inp[23478] = 1069947456; +inp[23479] = 0; +inp[23480] = 1069816855; +inp[23481] = 0; +inp[23482] = 1069686270; +inp[23483] = 0; +inp[23484] = 1069555701; +inp[23485] = 0; +inp[23486] = 1069425148; +inp[23487] = 0; +inp[23488] = 1069294611; +inp[23489] = 0; +inp[23490] = 1069164090; +inp[23491] = 0; +inp[23492] = 1069033584; +inp[23493] = 0; +inp[23494] = 1068903095; +inp[23495] = 0; +inp[23496] = 1068772622; +inp[23497] = 0; +inp[23498] = 1068642164; +inp[23499] = 0; +inp[23500] = 1068511723; +inp[23501] = 0; +inp[23502] = 1068381297; +inp[23503] = 0; +inp[23504] = 1068250887; +inp[23505] = 0; +inp[23506] = 1068120494; +inp[23507] = 0; +inp[23508] = 1067990116; +inp[23509] = 0; +inp[23510] = 1067859754; +inp[23511] = 0; +inp[23512] = 1067729408; +inp[23513] = 0; +inp[23514] = 1067599078; +inp[23515] = 0; +inp[23516] = 1067468764; +inp[23517] = 0; +inp[23518] = 1067338465; +inp[23519] = 0; +inp[23520] = 1067208183; +inp[23521] = 0; +inp[23522] = 1067077916; +inp[23523] = 0; +inp[23524] = 1066947666; +inp[23525] = 0; +inp[23526] = 1066817431; +inp[23527] = 0; +inp[23528] = 1066687212; +inp[23529] = 0; +inp[23530] = 1066557009; +inp[23531] = 0; +inp[23532] = 1066426822; +inp[23533] = 0; +inp[23534] = 1066296651; +inp[23535] = 0; +inp[23536] = 1066166496; +inp[23537] = 0; +inp[23538] = 1066036357; +inp[23539] = 0; +inp[23540] = 1065906233; +inp[23541] = 0; +inp[23542] = 1065776126; +inp[23543] = 0; +inp[23544] = 1065646034; +inp[23545] = 0; +inp[23546] = 1065515958; +inp[23547] = 0; +inp[23548] = 1065385898; +inp[23549] = 0; +inp[23550] = 1065255854; +inp[23551] = 0; +inp[23552] = 1065125826; +inp[23553] = 0; +inp[23554] = 1064995814; +inp[23555] = 0; +inp[23556] = 1064865817; +inp[23557] = 0; +inp[23558] = 1064735837; +inp[23559] = 0; +inp[23560] = 1064605872; +inp[23561] = 0; +inp[23562] = 1064475923; +inp[23563] = 0; +inp[23564] = 1064345990; +inp[23565] = 0; +inp[23566] = 1064216073; +inp[23567] = 0; +inp[23568] = 1064086172; +inp[23569] = 0; +inp[23570] = 1063956286; +inp[23571] = 0; +inp[23572] = 1063826417; +inp[23573] = 0; +inp[23574] = 1063696563; +inp[23575] = 0; +inp[23576] = 1063566725; +inp[23577] = 0; +inp[23578] = 1063436903; +inp[23579] = 0; +inp[23580] = 1063307097; +inp[23581] = 0; +inp[23582] = 1063177307; +inp[23583] = 0; +inp[23584] = 1063047532; +inp[23585] = 0; +inp[23586] = 1062917774; +inp[23587] = 0; +inp[23588] = 1062788031; +inp[23589] = 0; +inp[23590] = 1062658304; +inp[23591] = 0; +inp[23592] = 1062528593; +inp[23593] = 0; +inp[23594] = 1062398898; +inp[23595] = 0; +inp[23596] = 1062269218; +inp[23597] = 0; +inp[23598] = 1062139555; +inp[23599] = 0; +inp[23600] = 1062009907; +inp[23601] = 0; +inp[23602] = 1061880275; +inp[23603] = 0; +inp[23604] = 1061750659; +inp[23605] = 0; +inp[23606] = 1061621058; +inp[23607] = 0; +inp[23608] = 1061491474; +inp[23609] = 0; +inp[23610] = 1061361905; +inp[23611] = 0; +inp[23612] = 1061232352; +inp[23613] = 0; +inp[23614] = 1061102815; +inp[23615] = 0; +inp[23616] = 1060973294; +inp[23617] = 0; +inp[23618] = 1060843789; +inp[23619] = 0; +inp[23620] = 1060714299; +inp[23621] = 0; +inp[23622] = 1060584825; +inp[23623] = 0; +inp[23624] = 1060455367; +inp[23625] = 0; +inp[23626] = 1060325925; +inp[23627] = 0; +inp[23628] = 1060196498; +inp[23629] = 0; +inp[23630] = 1060067088; +inp[23631] = 0; +inp[23632] = 1059937693; +inp[23633] = 0; +inp[23634] = 1059808314; +inp[23635] = 0; +inp[23636] = 1059678951; +inp[23637] = 0; +inp[23638] = 1059549603; +inp[23639] = 0; +inp[23640] = 1059420272; +inp[23641] = 0; +inp[23642] = 1059290956; +inp[23643] = 0; +inp[23644] = 1059161656; +inp[23645] = 0; +inp[23646] = 1059032371; +inp[23647] = 0; +inp[23648] = 1058903103; +inp[23649] = 0; +inp[23650] = 1058773850; +inp[23651] = 0; +inp[23652] = 1058644613; +inp[23653] = 0; +inp[23654] = 1058515392; +inp[23655] = 0; +inp[23656] = 1058386187; +inp[23657] = 0; +inp[23658] = 1058256997; +inp[23659] = 0; +inp[23660] = 1058127823; +inp[23661] = 0; +inp[23662] = 1057998665; +inp[23663] = 0; +inp[23664] = 1057869523; +inp[23665] = 0; +inp[23666] = 1057740396; +inp[23667] = 0; +inp[23668] = 1057611285; +inp[23669] = 0; +inp[23670] = 1057482190; +inp[23671] = 0; +inp[23672] = 1057353111; +inp[23673] = 0; +inp[23674] = 1057224047; +inp[23675] = 0; +inp[23676] = 1057094999; +inp[23677] = 0; +inp[23678] = 1056965967; +inp[23679] = 0; +inp[23680] = 1056836951; +inp[23681] = 0; +inp[23682] = 1056707951; +inp[23683] = 0; +inp[23684] = 1056578966; +inp[23685] = 0; +inp[23686] = 1056449997; +inp[23687] = 0; +inp[23688] = 1056321043; +inp[23689] = 0; +inp[23690] = 1056192106; +inp[23691] = 0; +inp[23692] = 1056063184; +inp[23693] = 0; +inp[23694] = 1055934278; +inp[23695] = 0; +inp[23696] = 1055805388; +inp[23697] = 0; +inp[23698] = 1055676513; +inp[23699] = 0; +inp[23700] = 1055547654; +inp[23701] = 0; +inp[23702] = 1055418811; +inp[23703] = 0; +inp[23704] = 1055289983; +inp[23705] = 0; +inp[23706] = 1055161172; +inp[23707] = 0; +inp[23708] = 1055032376; +inp[23709] = 0; +inp[23710] = 1054903595; +inp[23711] = 0; +inp[23712] = 1054774831; +inp[23713] = 0; +inp[23714] = 1054646082; +inp[23715] = 0; +inp[23716] = 1054517349; +inp[23717] = 0; +inp[23718] = 1054388632; +inp[23719] = 0; +inp[23720] = 1054259930; +inp[23721] = 0; +inp[23722] = 1054131244; +inp[23723] = 0; +inp[23724] = 1054002574; +inp[23725] = 0; +inp[23726] = 1053873919; +inp[23727] = 0; +inp[23728] = 1053745280; +inp[23729] = 0; +inp[23730] = 1053616657; +inp[23731] = 0; +inp[23732] = 1053488050; +inp[23733] = 0; +inp[23734] = 1053359458; +inp[23735] = 0; +inp[23736] = 1053230882; +inp[23737] = 0; +inp[23738] = 1053102321; +inp[23739] = 0; +inp[23740] = 1052973777; +inp[23741] = 0; +inp[23742] = 1052845248; +inp[23743] = 0; +inp[23744] = 1052716734; +inp[23745] = 0; +inp[23746] = 1052588237; +inp[23747] = 0; +inp[23748] = 1052459755; +inp[23749] = 0; +inp[23750] = 1052331289; +inp[23751] = 0; +inp[23752] = 1052202838; +inp[23753] = 0; +inp[23754] = 1052074403; +inp[23755] = 0; +inp[23756] = 1051945984; +inp[23757] = 0; +inp[23758] = 1051817580; +inp[23759] = 0; +inp[23760] = 1051689192; +inp[23761] = 0; +inp[23762] = 1051560820; +inp[23763] = 0; +inp[23764] = 1051432464; +inp[23765] = 0; +inp[23766] = 1051304123; +inp[23767] = 0; +inp[23768] = 1051175798; +inp[23769] = 0; +inp[23770] = 1051047488; +inp[23771] = 0; +inp[23772] = 1050919194; +inp[23773] = 0; +inp[23774] = 1050790916; +inp[23775] = 0; +inp[23776] = 1050662654; +inp[23777] = 0; +inp[23778] = 1050534407; +inp[23779] = 0; +inp[23780] = 1050406175; +inp[23781] = 0; +inp[23782] = 1050277960; +inp[23783] = 0; +inp[23784] = 1050149760; +inp[23785] = 0; +inp[23786] = 1050021576; +inp[23787] = 0; +inp[23788] = 1049893407; +inp[23789] = 0; +inp[23790] = 1049765254; +inp[23791] = 0; +inp[23792] = 1049637117; +inp[23793] = 0; +inp[23794] = 1049508995; +inp[23795] = 0; +inp[23796] = 1049380889; +inp[23797] = 0; +inp[23798] = 1049252798; +inp[23799] = 0; +inp[23800] = 1049124724; +inp[23801] = 0; +inp[23802] = 1048996664; +inp[23803] = 0; +inp[23804] = 1048868621; +inp[23805] = 0; +inp[23806] = 1048740593; +inp[23807] = 0; +inp[23808] = 1048612581; +inp[23809] = 0; +inp[23810] = 1048484584; +inp[23811] = 0; +inp[23812] = 1048356603; +inp[23813] = 0; +inp[23814] = 1048228638; +inp[23815] = 0; +inp[23816] = 1048100688; +inp[23817] = 0; +inp[23818] = 1047972754; +inp[23819] = 0; +inp[23820] = 1047844835; +inp[23821] = 0; +inp[23822] = 1047716932; +inp[23823] = 0; +inp[23824] = 1047589045; +inp[23825] = 0; +inp[23826] = 1047461173; +inp[23827] = 0; +inp[23828] = 1047333317; +inp[23829] = 0; +inp[23830] = 1047205477; +inp[23831] = 0; +inp[23832] = 1047077652; +inp[23833] = 0; +inp[23834] = 1046949842; +inp[23835] = 0; +inp[23836] = 1046822049; +inp[23837] = 0; +inp[23838] = 1046694271; +inp[23839] = 0; +inp[23840] = 1046566508; +inp[23841] = 0; +inp[23842] = 1046438761; +inp[23843] = 0; +inp[23844] = 1046311030; +inp[23845] = 0; +inp[23846] = 1046183314; +inp[23847] = 0; +inp[23848] = 1046055614; +inp[23849] = 0; +inp[23850] = 1045927929; +inp[23851] = 0; +inp[23852] = 1045800261; +inp[23853] = 0; +inp[23854] = 1045672607; +inp[23855] = 0; +inp[23856] = 1045544969; +inp[23857] = 0; +inp[23858] = 1045417347; +inp[23859] = 0; +inp[23860] = 1045289741; +inp[23861] = 0; +inp[23862] = 1045162149; +inp[23863] = 0; +inp[23864] = 1045034574; +inp[23865] = 0; +inp[23866] = 1044907014; +inp[23867] = 0; +inp[23868] = 1044779470; +inp[23869] = 0; +inp[23870] = 1044651941; +inp[23871] = 0; +inp[23872] = 1044524428; +inp[23873] = 0; +inp[23874] = 1044396930; +inp[23875] = 0; +inp[23876] = 1044269448; +inp[23877] = 0; +inp[23878] = 1044141981; +inp[23879] = 0; +inp[23880] = 1044014531; +inp[23881] = 0; +inp[23882] = 1043887095; +inp[23883] = 0; +inp[23884] = 1043759675; +inp[23885] = 0; +inp[23886] = 1043632271; +inp[23887] = 0; +inp[23888] = 1043504882; +inp[23889] = 0; +inp[23890] = 1043377509; +inp[23891] = 0; +inp[23892] = 1043250151; +inp[23893] = 0; +inp[23894] = 1043122809; +inp[23895] = 0; +inp[23896] = 1042995483; +inp[23897] = 0; +inp[23898] = 1042868172; +inp[23899] = 0; +inp[23900] = 1042740876; +inp[23901] = 0; +inp[23902] = 1042613596; +inp[23903] = 0; +inp[23904] = 1042486332; +inp[23905] = 0; +inp[23906] = 1042359083; +inp[23907] = 0; +inp[23908] = 1042231850; +inp[23909] = 0; +inp[23910] = 1042104632; +inp[23911] = 0; +inp[23912] = 1041977430; +inp[23913] = 0; +inp[23914] = 1041850243; +inp[23915] = 0; +inp[23916] = 1041723072; +inp[23917] = 0; +inp[23918] = 1041595916; +inp[23919] = 0; +inp[23920] = 1041468776; +inp[23921] = 0; +inp[23922] = 1041341651; +inp[23923] = 0; +inp[23924] = 1041214542; +inp[23925] = 0; +inp[23926] = 1041087448; +inp[23927] = 0; +inp[23928] = 1040960370; +inp[23929] = 0; +inp[23930] = 1040833308; +inp[23931] = 0; +inp[23932] = 1073741824; +inp[23933] = 1073741824; +inp[23934] = 1073676289; +inp[23935] = 0; +inp[23936] = 1073610759; +inp[23937] = 0; +inp[23938] = 1073545233; +inp[23939] = 0; +inp[23940] = 1073479711; +inp[23941] = 0; +inp[23942] = 1073414193; +inp[23943] = 0; +inp[23944] = 1073348679; +inp[23945] = 0; +inp[23946] = 1073283169; +inp[23947] = 0; +inp[23948] = 1073217663; +inp[23949] = 0; +inp[23950] = 1073152161; +inp[23951] = 0; +inp[23952] = 1073086663; +inp[23953] = 0; +inp[23954] = 1073021169; +inp[23955] = 0; +inp[23956] = 1072955679; +inp[23957] = 0; +inp[23958] = 1072890193; +inp[23959] = 0; +inp[23960] = 1072824711; +inp[23961] = 0; +inp[23962] = 1072759233; +inp[23963] = 0; +inp[23964] = 1072693759; +inp[23965] = 0; +inp[23966] = 1072628289; +inp[23967] = 0; +inp[23968] = 1072562823; +inp[23969] = 0; +inp[23970] = 1072497361; +inp[23971] = 0; +inp[23972] = 1072431903; +inp[23973] = 0; +inp[23974] = 1072366449; +inp[23975] = 0; +inp[23976] = 1072300999; +inp[23977] = 0; +inp[23978] = 1072235553; +inp[23979] = 0; +inp[23980] = 1072170111; +inp[23981] = 0; +inp[23982] = 1072104673; +inp[23983] = 0; +inp[23984] = 1072039239; +inp[23985] = 0; +inp[23986] = 1071973809; +inp[23987] = 0; +inp[23988] = 1071908383; +inp[23989] = 0; +inp[23990] = 1071842961; +inp[23991] = 0; +inp[23992] = 1071777542; +inp[23993] = 0; +inp[23994] = 1071712128; +inp[23995] = 0; +inp[23996] = 1071646718; +inp[23997] = 0; +inp[23998] = 1071581312; +inp[23999] = 0; +inp[24000] = 1071515910; +inp[24001] = 0; +inp[24002] = 1071450512; +inp[24003] = 0; +inp[24004] = 1071385118; +inp[24005] = 0; +inp[24006] = 1071319727; +inp[24007] = 0; +inp[24008] = 1071254341; +inp[24009] = 0; +inp[24010] = 1071188959; +inp[24011] = 0; +inp[24012] = 1071123581; +inp[24013] = 0; +inp[24014] = 1071058207; +inp[24015] = 0; +inp[24016] = 1070992836; +inp[24017] = 0; +inp[24018] = 1070927470; +inp[24019] = 0; +inp[24020] = 1070862108; +inp[24021] = 0; +inp[24022] = 1070796750; +inp[24023] = 0; +inp[24024] = 1070731396; +inp[24025] = 0; +inp[24026] = 1070666045; +inp[24027] = 0; +inp[24028] = 1070600699; +inp[24029] = 0; +inp[24030] = 1070535357; +inp[24031] = 0; +inp[24032] = 1070470018; +inp[24033] = 0; +inp[24034] = 1070404684; +inp[24035] = 0; +inp[24036] = 1070339354; +inp[24037] = 0; +inp[24038] = 1070274027; +inp[24039] = 0; +inp[24040] = 1070208705; +inp[24041] = 0; +inp[24042] = 1070143387; +inp[24043] = 0; +inp[24044] = 1070078072; +inp[24045] = 0; +inp[24046] = 1070012762; +inp[24047] = 0; +inp[24048] = 1069947456; +inp[24049] = 0; +inp[24050] = 1069882153; +inp[24051] = 0; +inp[24052] = 1069816855; +inp[24053] = 0; +inp[24054] = 1069751560; +inp[24055] = 0; +inp[24056] = 1069686270; +inp[24057] = 0; +inp[24058] = 1069620983; +inp[24059] = 0; +inp[24060] = 1069555701; +inp[24061] = 0; +inp[24062] = 1069490422; +inp[24063] = 0; +inp[24064] = 1069425148; +inp[24065] = 0; +inp[24066] = 1069359877; +inp[24067] = 0; +inp[24068] = 1069294611; +inp[24069] = 0; +inp[24070] = 1069229348; +inp[24071] = 0; +inp[24072] = 1069164090; +inp[24073] = 0; +inp[24074] = 1069098835; +inp[24075] = 0; +inp[24076] = 1069033584; +inp[24077] = 0; +inp[24078] = 1068968338; +inp[24079] = 0; +inp[24080] = 1068903095; +inp[24081] = 0; +inp[24082] = 1068837856; +inp[24083] = 0; +inp[24084] = 1068772622; +inp[24085] = 0; +inp[24086] = 1068707391; +inp[24087] = 0; +inp[24088] = 1068642164; +inp[24089] = 0; +inp[24090] = 1068576941; +inp[24091] = 0; +inp[24092] = 1068511723; +inp[24093] = 0; +inp[24094] = 1068446508; +inp[24095] = 0; +inp[24096] = 1068381297; +inp[24097] = 0; +inp[24098] = 1068316090; +inp[24099] = 0; +inp[24100] = 1068250887; +inp[24101] = 0; +inp[24102] = 1068185689; +inp[24103] = 0; +inp[24104] = 1068120494; +inp[24105] = 0; +inp[24106] = 1068055303; +inp[24107] = 0; +inp[24108] = 1067990116; +inp[24109] = 0; +inp[24110] = 1067924933; +inp[24111] = 0; +inp[24112] = 1067859754; +inp[24113] = 0; +inp[24114] = 1067794579; +inp[24115] = 0; +inp[24116] = 1067729408; +inp[24117] = 0; +inp[24118] = 1067664241; +inp[24119] = 0; +inp[24120] = 1067599078; +inp[24121] = 0; +inp[24122] = 1067533919; +inp[24123] = 0; +inp[24124] = 1067468764; +inp[24125] = 0; +inp[24126] = 1067403612; +inp[24127] = 0; +inp[24128] = 1067338465; +inp[24129] = 0; +inp[24130] = 1067273322; +inp[24131] = 0; +inp[24132] = 1067208183; +inp[24133] = 0; +inp[24134] = 1067143048; +inp[24135] = 0; +inp[24136] = 1067077916; +inp[24137] = 0; +inp[24138] = 1067012789; +inp[24139] = 0; +inp[24140] = 1066947666; +inp[24141] = 0; +inp[24142] = 1066882546; +inp[24143] = 0; +inp[24144] = 1066817431; +inp[24145] = 0; +inp[24146] = 1066752320; +inp[24147] = 0; +inp[24148] = 1066687212; +inp[24149] = 0; +inp[24150] = 1066622109; +inp[24151] = 0; +inp[24152] = 1066557009; +inp[24153] = 0; +inp[24154] = 1066491914; +inp[24155] = 0; +inp[24156] = 1066426822; +inp[24157] = 0; +inp[24158] = 1066361735; +inp[24159] = 0; +inp[24160] = 1066296651; +inp[24161] = 0; +inp[24162] = 1066231572; +inp[24163] = 0; +inp[24164] = 1066166496; +inp[24165] = 0; +inp[24166] = 1066101424; +inp[24167] = 0; +inp[24168] = 1066036357; +inp[24169] = 0; +inp[24170] = 1065971293; +inp[24171] = 0; +inp[24172] = 1065906233; +inp[24173] = 0; +inp[24174] = 1065841178; +inp[24175] = 0; +inp[24176] = 1065776126; +inp[24177] = 0; +inp[24178] = 1065711078; +inp[24179] = 0; +inp[24180] = 1065646034; +inp[24181] = 0; +inp[24182] = 1065580994; +inp[24183] = 0; +inp[24184] = 1065515958; +inp[24185] = 0; +inp[24186] = 1065450926; +inp[24187] = 0; +inp[24188] = 1065385898; +inp[24189] = 0; +inp[24190] = 1065320874; +inp[24191] = 0; +inp[24192] = 1065255854; +inp[24193] = 0; +inp[24194] = 1065190838; +inp[24195] = 0; +inp[24196] = 1065125826; +inp[24197] = 0; +inp[24198] = 1065060818; +inp[24199] = 0; +inp[24200] = 1064995814; +inp[24201] = 0; +inp[24202] = 1064930814; +inp[24203] = 0; +inp[24204] = 1064865817; +inp[24205] = 0; +inp[24206] = 1064800825; +inp[24207] = 0; +inp[24208] = 1064735837; +inp[24209] = 0; +inp[24210] = 1064670852; +inp[24211] = 0; +inp[24212] = 1064605872; +inp[24213] = 0; +inp[24214] = 1064540896; +inp[24215] = 0; +inp[24216] = 1064475923; +inp[24217] = 0; +inp[24218] = 1064410955; +inp[24219] = 0; +inp[24220] = 1064345990; +inp[24221] = 0; +inp[24222] = 1064281030; +inp[24223] = 0; +inp[24224] = 1064216073; +inp[24225] = 0; +inp[24226] = 1064151121; +inp[24227] = 0; +inp[24228] = 1064086172; +inp[24229] = 0; +inp[24230] = 1064021227; +inp[24231] = 0; +inp[24232] = 1063956286; +inp[24233] = 0; +inp[24234] = 1063891350; +inp[24235] = 0; +inp[24236] = 1063826417; +inp[24237] = 0; +inp[24238] = 1063761488; +inp[24239] = 0; +inp[24240] = 1063696563; +inp[24241] = 0; +inp[24242] = 1063631642; +inp[24243] = 0; +inp[24244] = 1063566725; +inp[24245] = 0; +inp[24246] = 1063501812; +inp[24247] = 0; +inp[24248] = 1063436903; +inp[24249] = 0; +inp[24250] = 1063371998; +inp[24251] = 0; +inp[24252] = 1063307097; +inp[24253] = 0; +inp[24254] = 1063242200; +inp[24255] = 0; +inp[24256] = 1063177307; +inp[24257] = 0; +inp[24258] = 1063112418; +inp[24259] = 0; +inp[24260] = 1063047532; +inp[24261] = 0; +inp[24262] = 1062982651; +inp[24263] = 0; +inp[24264] = 1062917774; +inp[24265] = 0; +inp[24266] = 1062852900; +inp[24267] = 0; +inp[24268] = 1062788031; +inp[24269] = 0; +inp[24270] = 1062723166; +inp[24271] = 0; +inp[24272] = 1062658304; +inp[24273] = 0; +inp[24274] = 1062593447; +inp[24275] = 0; +inp[24276] = 1062528593; +inp[24277] = 0; +inp[24278] = 1062463743; +inp[24279] = 0; +inp[24280] = 1062398898; +inp[24281] = 0; +inp[24282] = 1062334056; +inp[24283] = 0; +inp[24284] = 1062269218; +inp[24285] = 0; +inp[24286] = 1062204384; +inp[24287] = 0; +inp[24288] = 1062139555; +inp[24289] = 0; +inp[24290] = 1062074729; +inp[24291] = 0; +inp[24292] = 1062009907; +inp[24293] = 0; +inp[24294] = 1061945089; +inp[24295] = 0; +inp[24296] = 1061880275; +inp[24297] = 0; +inp[24298] = 1061815465; +inp[24299] = 0; +inp[24300] = 1061750659; +inp[24301] = 0; +inp[24302] = 1061685857; +inp[24303] = 0; +inp[24304] = 1061621058; +inp[24305] = 0; +inp[24306] = 1061556264; +inp[24307] = 0; +inp[24308] = 1061491474; +inp[24309] = 0; +inp[24310] = 1061426688; +inp[24311] = 0; +inp[24312] = 1061361905; +inp[24313] = 0; +inp[24314] = 1061297127; +inp[24315] = 0; +inp[24316] = 1061232352; +inp[24317] = 0; +inp[24318] = 1061167582; +inp[24319] = 0; +inp[24320] = 1061102815; +inp[24321] = 0; +inp[24322] = 1061038053; +inp[24323] = 0; +inp[24324] = 1060973294; +inp[24325] = 0; +inp[24326] = 1060908539; +inp[24327] = 0; +inp[24328] = 1060843789; +inp[24329] = 0; +inp[24330] = 1060779042; +inp[24331] = 0; +inp[24332] = 1060714299; +inp[24333] = 0; +inp[24334] = 1060649560; +inp[24335] = 0; +inp[24336] = 1060584825; +inp[24337] = 0; +inp[24338] = 1060520094; +inp[24339] = 0; +inp[24340] = 1060455367; +inp[24341] = 0; +inp[24342] = 1060390644; +inp[24343] = 0; +inp[24344] = 1060325925; +inp[24345] = 0; +inp[24346] = 1060261210; +inp[24347] = 0; +inp[24348] = 1060196498; +inp[24349] = 0; +inp[24350] = 1060131791; +inp[24351] = 0; +inp[24352] = 1060067088; +inp[24353] = 0; +inp[24354] = 1060002388; +inp[24355] = 0; +inp[24356] = 1059937693; +inp[24357] = 0; +inp[24358] = 1059873002; +inp[24359] = 0; +inp[24360] = 1059808314; +inp[24361] = 0; +inp[24362] = 1059743630; +inp[24363] = 0; +inp[24364] = 1059678951; +inp[24365] = 0; +inp[24366] = 1059614275; +inp[24367] = 0; +inp[24368] = 1059549603; +inp[24369] = 0; +inp[24370] = 1059484936; +inp[24371] = 0; +inp[24372] = 1059420272; +inp[24373] = 0; +inp[24374] = 1059355612; +inp[24375] = 0; +inp[24376] = 1059290956; +inp[24377] = 0; +inp[24378] = 1059226304; +inp[24379] = 0; +inp[24380] = 1059161656; +inp[24381] = 0; +inp[24382] = 1059097012; +inp[24383] = 0; +inp[24384] = 1059032371; +inp[24385] = 0; +inp[24386] = 1058967735; +inp[24387] = 0; +inp[24388] = 1058903103; +inp[24389] = 0; +inp[24390] = 1058838475; +inp[24391] = 0; +inp[24392] = 1058773850; +inp[24393] = 0; +inp[24394] = 1058709230; +inp[24395] = 0; +inp[24396] = 1058644613; +inp[24397] = 0; +inp[24398] = 1058580001; +inp[24399] = 0; +inp[24400] = 1058515392; +inp[24401] = 0; +inp[24402] = 1058450787; +inp[24403] = 0; +inp[24404] = 1058386187; +inp[24405] = 0; +inp[24406] = 1058321590; +inp[24407] = 0; +inp[24408] = 1058256997; +inp[24409] = 0; +inp[24410] = 1058192408; +inp[24411] = 0; +inp[24412] = 1058127823; +inp[24413] = 0; +inp[24414] = 1058063242; +inp[24415] = 0; +inp[24416] = 1057998665; +inp[24417] = 0; +inp[24418] = 1057934092; +inp[24419] = 0; +inp[24420] = 1057869523; +inp[24421] = 0; +inp[24422] = 1057804957; +inp[24423] = 0; +inp[24424] = 1057740396; +inp[24425] = 0; +inp[24426] = 1057675839; +inp[24427] = 0; +inp[24428] = 1057611285; +inp[24429] = 0; +inp[24430] = 1057546736; +inp[24431] = 0; +inp[24432] = 1057482190; +inp[24433] = 0; +inp[24434] = 1057417649; +inp[24435] = 0; +inp[24436] = 1057353111; +inp[24437] = 0; +inp[24438] = 1057288577; +inp[24439] = 0; +inp[24440] = 1057224047; +inp[24441] = 0; +inp[24442] = 1057159521; +inp[24443] = 0; +inp[24444] = 1073741824; +inp[24445] = 1073741824; +inp[24446] = 1073709056; +inp[24447] = 0; +inp[24448] = 1073676289; +inp[24449] = 0; +inp[24450] = 1073643524; +inp[24451] = 0; +inp[24452] = 1073610759; +inp[24453] = 0; +inp[24454] = 1073577996; +inp[24455] = 0; +inp[24456] = 1073545233; +inp[24457] = 0; +inp[24458] = 1073512472; +inp[24459] = 0; +inp[24460] = 1073479711; +inp[24461] = 0; +inp[24462] = 1073446952; +inp[24463] = 0; +inp[24464] = 1073414193; +inp[24465] = 0; +inp[24466] = 1073381436; +inp[24467] = 0; +inp[24468] = 1073348679; +inp[24469] = 0; +inp[24470] = 1073315924; +inp[24471] = 0; +inp[24472] = 1073283169; +inp[24473] = 0; +inp[24474] = 1073250416; +inp[24475] = 0; +inp[24476] = 1073217663; +inp[24477] = 0; +inp[24478] = 1073184912; +inp[24479] = 0; +inp[24480] = 1073152161; +inp[24481] = 0; +inp[24482] = 1073119412; +inp[24483] = 0; +inp[24484] = 1073086663; +inp[24485] = 0; +inp[24486] = 1073053916; +inp[24487] = 0; +inp[24488] = 1073021169; +inp[24489] = 0; +inp[24490] = 1072988424; +inp[24491] = 0; +inp[24492] = 1072955679; +inp[24493] = 0; +inp[24494] = 1072922936; +inp[24495] = 0; +inp[24496] = 1072890193; +inp[24497] = 0; +inp[24498] = 1072857452; +inp[24499] = 0; +inp[24500] = 1072824711; +inp[24501] = 0; +inp[24502] = 1072791972; +inp[24503] = 0; +inp[24504] = 1072759233; +inp[24505] = 0; +inp[24506] = 1072726496; +inp[24507] = 0; +inp[24508] = 1072693759; +inp[24509] = 0; +inp[24510] = 1072661024; +inp[24511] = 0; +inp[24512] = 1072628289; +inp[24513] = 0; +inp[24514] = 1072595556; +inp[24515] = 0; +inp[24516] = 1072562823; +inp[24517] = 0; +inp[24518] = 1072530092; +inp[24519] = 0; +inp[24520] = 1072497361; +inp[24521] = 0; +inp[24522] = 1072464632; +inp[24523] = 0; +inp[24524] = 1072431903; +inp[24525] = 0; +inp[24526] = 1072399176; +inp[24527] = 0; +inp[24528] = 1072366449; +inp[24529] = 0; +inp[24530] = 1072333724; +inp[24531] = 0; +inp[24532] = 1072300999; +inp[24533] = 0; +inp[24534] = 1072268276; +inp[24535] = 0; +inp[24536] = 1072235553; +inp[24537] = 0; +inp[24538] = 1072202831; +inp[24539] = 0; +inp[24540] = 1072170111; +inp[24541] = 0; +inp[24542] = 1072137391; +inp[24543] = 0; +inp[24544] = 1072104673; +inp[24545] = 0; +inp[24546] = 1072071955; +inp[24547] = 0; +inp[24548] = 1072039239; +inp[24549] = 0; +inp[24550] = 1072006523; +inp[24551] = 0; +inp[24552] = 1071973809; +inp[24553] = 0; +inp[24554] = 1071941095; +inp[24555] = 0; +inp[24556] = 1071908383; +inp[24557] = 0; +inp[24558] = 1071875671; +inp[24559] = 0; +inp[24560] = 1071842961; +inp[24561] = 0; +inp[24562] = 1071810251; +inp[24563] = 0; +inp[24564] = 1071777542; +inp[24565] = 0; +inp[24566] = 1071744835; +inp[24567] = 0; +inp[24568] = 1071712128; +inp[24569] = 0; +inp[24570] = 1071679423; +inp[24571] = 0; +inp[24572] = 1071646718; +inp[24573] = 0; +inp[24574] = 1071614015; +inp[24575] = 0; +inp[24576] = 1071581312; +inp[24577] = 0; +inp[24578] = 1071548610; +inp[24579] = 0; +inp[24580] = 1071515910; +inp[24581] = 0; +inp[24582] = 1071483210; +inp[24583] = 0; +inp[24584] = 1071450512; +inp[24585] = 0; +inp[24586] = 1071417814; +inp[24587] = 0; +inp[24588] = 1071385118; +inp[24589] = 0; +inp[24590] = 1071352422; +inp[24591] = 0; +inp[24592] = 1071319727; +inp[24593] = 0; +inp[24594] = 1071287034; +inp[24595] = 0; +inp[24596] = 1071254341; +inp[24597] = 0; +inp[24598] = 1071221650; +inp[24599] = 0; +inp[24600] = 1071188959; +inp[24601] = 0; +inp[24602] = 1071156269; +inp[24603] = 0; +inp[24604] = 1071123581; +inp[24605] = 0; +inp[24606] = 1071090893; +inp[24607] = 0; +inp[24608] = 1071058207; +inp[24609] = 0; +inp[24610] = 1071025521; +inp[24611] = 0; +inp[24612] = 1070992836; +inp[24613] = 0; +inp[24614] = 1070960153; +inp[24615] = 0; +inp[24616] = 1070927470; +inp[24617] = 0; +inp[24618] = 1070894789; +inp[24619] = 0; +inp[24620] = 1070862108; +inp[24621] = 0; +inp[24622] = 1070829428; +inp[24623] = 0; +inp[24624] = 1070796750; +inp[24625] = 0; +inp[24626] = 1070764072; +inp[24627] = 0; +inp[24628] = 1070731396; +inp[24629] = 0; +inp[24630] = 1070698720; +inp[24631] = 0; +inp[24632] = 1070666045; +inp[24633] = 0; +inp[24634] = 1070633372; +inp[24635] = 0; +inp[24636] = 1070600699; +inp[24637] = 0; +inp[24638] = 1070568027; +inp[24639] = 0; +inp[24640] = 1070535357; +inp[24641] = 0; +inp[24642] = 1070502687; +inp[24643] = 0; +inp[24644] = 1070470018; +inp[24645] = 0; +inp[24646] = 1070437351; +inp[24647] = 0; +inp[24648] = 1070404684; +inp[24649] = 0; +inp[24650] = 1070372018; +inp[24651] = 0; +inp[24652] = 1070339354; +inp[24653] = 0; +inp[24654] = 1070306690; +inp[24655] = 0; +inp[24656] = 1070274027; +inp[24657] = 0; +inp[24658] = 1070241366; +inp[24659] = 0; +inp[24660] = 1070208705; +inp[24661] = 0; +inp[24662] = 1070176045; +inp[24663] = 0; +inp[24664] = 1070143387; +inp[24665] = 0; +inp[24666] = 1070110729; +inp[24667] = 0; +inp[24668] = 1070078072; +inp[24669] = 0; +inp[24670] = 1070045417; +inp[24671] = 0; +inp[24672] = 1070012762; +inp[24673] = 0; +inp[24674] = 1069980108; +inp[24675] = 0; +inp[24676] = 1069947456; +inp[24677] = 0; +inp[24678] = 1069914804; +inp[24679] = 0; +inp[24680] = 1069882153; +inp[24681] = 0; +inp[24682] = 1069849503; +inp[24683] = 0; +inp[24684] = 1069816855; +inp[24685] = 0; +inp[24686] = 1069784207; +inp[24687] = 0; +inp[24688] = 1069751560; +inp[24689] = 0; +inp[24690] = 1069718915; +inp[24691] = 0; +inp[24692] = 1069686270; +inp[24693] = 0; +inp[24694] = 1069653626; +inp[24695] = 0; +inp[24696] = 1069620983; +inp[24697] = 0; +inp[24698] = 1069588342; +inp[24699] = 0; +inp[24700] = 1069555701; +inp[24701] = 0; +inp[24702] = 1069523061; +inp[24703] = 0; +inp[24704] = 1069490422; +inp[24705] = 0; +inp[24706] = 1069457785; +inp[24707] = 0; +inp[24708] = 1069425148; +inp[24709] = 0; +inp[24710] = 1069392512; +inp[24711] = 0; +inp[24712] = 1069359877; +inp[24713] = 0; +inp[24714] = 1069327243; +inp[24715] = 0; +inp[24716] = 1069294611; +inp[24717] = 0; +inp[24718] = 1069261979; +inp[24719] = 0; +inp[24720] = 1069229348; +inp[24721] = 0; +inp[24722] = 1069196718; +inp[24723] = 0; +inp[24724] = 1069164090; +inp[24725] = 0; +inp[24726] = 1069131462; +inp[24727] = 0; +inp[24728] = 1069098835; +inp[24729] = 0; +inp[24730] = 1069066209; +inp[24731] = 0; +inp[24732] = 1069033584; +inp[24733] = 0; +inp[24734] = 1069000961; +inp[24735] = 0; +inp[24736] = 1068968338; +inp[24737] = 0; +inp[24738] = 1068935716; +inp[24739] = 0; +inp[24740] = 1068903095; +inp[24741] = 0; +inp[24742] = 1068870475; +inp[24743] = 0; +inp[24744] = 1068837856; +inp[24745] = 0; +inp[24746] = 1068805239; +inp[24747] = 0; +inp[24748] = 1068772622; +inp[24749] = 0; +inp[24750] = 1068740006; +inp[24751] = 0; +inp[24752] = 1068707391; +inp[24753] = 0; +inp[24754] = 1068674777; +inp[24755] = 0; +inp[24756] = 1068642164; +inp[24757] = 0; +inp[24758] = 1068609552; +inp[24759] = 0; +inp[24760] = 1068576941; +inp[24761] = 0; +inp[24762] = 1068544332; +inp[24763] = 0; +inp[24764] = 1068511723; +inp[24765] = 0; +inp[24766] = 1068479115; +inp[24767] = 0; +inp[24768] = 1068446508; +inp[24769] = 0; +inp[24770] = 1068413902; +inp[24771] = 0; +inp[24772] = 1068381297; +inp[24773] = 0; +inp[24774] = 1068348693; +inp[24775] = 0; +inp[24776] = 1068316090; +inp[24777] = 0; +inp[24778] = 1068283488; +inp[24779] = 0; +inp[24780] = 1068250887; +inp[24781] = 0; +inp[24782] = 1068218287; +inp[24783] = 0; +inp[24784] = 1068185689; +inp[24785] = 0; +inp[24786] = 1068153091; +inp[24787] = 0; +inp[24788] = 1068120494; +inp[24789] = 0; +inp[24790] = 1068087898; +inp[24791] = 0; +inp[24792] = 1068055303; +inp[24793] = 0; +inp[24794] = 1068022709; +inp[24795] = 0; +inp[24796] = 1067990116; +inp[24797] = 0; +inp[24798] = 1067957524; +inp[24799] = 0; +inp[24800] = 1067924933; +inp[24801] = 0; +inp[24802] = 1067892343; +inp[24803] = 0; +inp[24804] = 1067859754; +inp[24805] = 0; +inp[24806] = 1067827166; +inp[24807] = 0; +inp[24808] = 1067794579; +inp[24809] = 0; +inp[24810] = 1067761993; +inp[24811] = 0; +inp[24812] = 1067729408; +inp[24813] = 0; +inp[24814] = 1067696824; +inp[24815] = 0; +inp[24816] = 1067664241; +inp[24817] = 0; +inp[24818] = 1067631659; +inp[24819] = 0; +inp[24820] = 1067599078; +inp[24821] = 0; +inp[24822] = 1067566498; +inp[24823] = 0; +inp[24824] = 1067533919; +inp[24825] = 0; +inp[24826] = 1067501341; +inp[24827] = 0; +inp[24828] = 1067468764; +inp[24829] = 0; +inp[24830] = 1067436187; +inp[24831] = 0; +inp[24832] = 1067403612; +inp[24833] = 0; +inp[24834] = 1067371038; +inp[24835] = 0; +inp[24836] = 1067338465; +inp[24837] = 0; +inp[24838] = 1067305893; +inp[24839] = 0; +inp[24840] = 1067273322; +inp[24841] = 0; +inp[24842] = 1067240752; +inp[24843] = 0; +inp[24844] = 1067208183; +inp[24845] = 0; +inp[24846] = 1067175615; +inp[24847] = 0; +inp[24848] = 1067143048; +inp[24849] = 0; +inp[24850] = 1067110482; +inp[24851] = 0; +inp[24852] = 1067077916; +inp[24853] = 0; +inp[24854] = 1067045352; +inp[24855] = 0; +inp[24856] = 1067012789; +inp[24857] = 0; +inp[24858] = 1066980227; +inp[24859] = 0; +inp[24860] = 1066947666; +inp[24861] = 0; +inp[24862] = 1066915106; +inp[24863] = 0; +inp[24864] = 1066882546; +inp[24865] = 0; +inp[24866] = 1066849988; +inp[24867] = 0; +inp[24868] = 1066817431; +inp[24869] = 0; +inp[24870] = 1066784875; +inp[24871] = 0; +inp[24872] = 1066752320; +inp[24873] = 0; +inp[24874] = 1066719766; +inp[24875] = 0; +inp[24876] = 1066687212; +inp[24877] = 0; +inp[24878] = 1066654660; +inp[24879] = 0; +inp[24880] = 1066622109; +inp[24881] = 0; +inp[24882] = 1066589559; +inp[24883] = 0; +inp[24884] = 1066557009; +inp[24885] = 0; +inp[24886] = 1066524461; +inp[24887] = 0; +inp[24888] = 1066491914; +inp[24889] = 0; +inp[24890] = 1066459368; +inp[24891] = 0; +inp[24892] = 1066426822; +inp[24893] = 0; +inp[24894] = 1066394278; +inp[24895] = 0; +inp[24896] = 1066361735; +inp[24897] = 0; +inp[24898] = 1066329193; +inp[24899] = 0; +inp[24900] = 1066296651; +inp[24901] = 0; +inp[24902] = 1066264111; +inp[24903] = 0; +inp[24904] = 1066231572; +inp[24905] = 0; +inp[24906] = 1066199033; +inp[24907] = 0; +inp[24908] = 1066166496; +inp[24909] = 0; +inp[24910] = 1066133960; +inp[24911] = 0; +inp[24912] = 1066101424; +inp[24913] = 0; +inp[24914] = 1066068890; +inp[24915] = 0; +inp[24916] = 1066036357; +inp[24917] = 0; +inp[24918] = 1066003824; +inp[24919] = 0; +inp[24920] = 1065971293; +inp[24921] = 0; +inp[24922] = 1065938763; +inp[24923] = 0; +inp[24924] = 1065906233; +inp[24925] = 0; +inp[24926] = 1065873705; +inp[24927] = 0; +inp[24928] = 1065841178; +inp[24929] = 0; +inp[24930] = 1065808651; +inp[24931] = 0; +inp[24932] = 1065776126; +inp[24933] = 0; +inp[24934] = 1065743601; +inp[24935] = 0; +inp[24936] = 1065711078; +inp[24937] = 0; +inp[24938] = 1065678555; +inp[24939] = 0; +inp[24940] = 1065646034; +inp[24941] = 0; +inp[24942] = 1065613514; +inp[24943] = 0; +inp[24944] = 1065580994; +inp[24945] = 0; +inp[24946] = 1065548476; +inp[24947] = 0; +inp[24948] = 1065515958; +inp[24949] = 0; +inp[24950] = 1065483442; +inp[24951] = 0; +inp[24952] = 1065450926; +inp[24953] = 0; +inp[24954] = 1065418412; +inp[24955] = 0; +inp[24956] = 1073741824; +inp[24957] = 1073741824; +inp[24958] = 1073725440; +inp[24959] = 0; +inp[24960] = 1073709056; +inp[24961] = 0; +inp[24962] = 1073692673; +inp[24963] = 0; +inp[24964] = 1073676289; +inp[24965] = 0; +inp[24966] = 1073659907; +inp[24967] = 0; +inp[24968] = 1073643524; +inp[24969] = 0; +inp[24970] = 1073627142; +inp[24971] = 0; +inp[24972] = 1073610759; +inp[24973] = 0; +inp[24974] = 1073594378; +inp[24975] = 0; +inp[24976] = 1073577996; +inp[24977] = 0; +inp[24978] = 1073561615; +inp[24979] = 0; +inp[24980] = 1073545233; +inp[24981] = 0; +inp[24982] = 1073528853; +inp[24983] = 0; +inp[24984] = 1073512472; +inp[24985] = 0; +inp[24986] = 1073496092; +inp[24987] = 0; +inp[24988] = 1073479711; +inp[24989] = 0; +inp[24990] = 1073463332; +inp[24991] = 0; +inp[24992] = 1073446952; +inp[24993] = 0; +inp[24994] = 1073430573; +inp[24995] = 0; +inp[24996] = 1073414193; +inp[24997] = 0; +inp[24998] = 1073397815; +inp[24999] = 0; +inp[25000] = 1073381436; +inp[25001] = 0; +inp[25002] = 1073365058; +inp[25003] = 0; +inp[25004] = 1073348679; +inp[25005] = 0; +inp[25006] = 1073332302; +inp[25007] = 0; +inp[25008] = 1073315924; +inp[25009] = 0; +inp[25010] = 1073299547; +inp[25011] = 0; +inp[25012] = 1073283169; +inp[25013] = 0; +inp[25014] = 1073266793; +inp[25015] = 0; +inp[25016] = 1073250416; +inp[25017] = 0; +inp[25018] = 1073234040; +inp[25019] = 0; +inp[25020] = 1073217663; +inp[25021] = 0; +inp[25022] = 1073201288; +inp[25023] = 0; +inp[25024] = 1073184912; +inp[25025] = 0; +inp[25026] = 1073168537; +inp[25027] = 0; +inp[25028] = 1073152161; +inp[25029] = 0; +inp[25030] = 1073135787; +inp[25031] = 0; +inp[25032] = 1073119412; +inp[25033] = 0; +inp[25034] = 1073103038; +inp[25035] = 0; +inp[25036] = 1073086663; +inp[25037] = 0; +inp[25038] = 1073070290; +inp[25039] = 0; +inp[25040] = 1073053916; +inp[25041] = 0; +inp[25042] = 1073037543; +inp[25043] = 0; +inp[25044] = 1073021169; +inp[25045] = 0; +inp[25046] = 1073004797; +inp[25047] = 0; +inp[25048] = 1072988424; +inp[25049] = 0; +inp[25050] = 1072972052; +inp[25051] = 0; +inp[25052] = 1072955679; +inp[25053] = 0; +inp[25054] = 1072939308; +inp[25055] = 0; +inp[25056] = 1072922936; +inp[25057] = 0; +inp[25058] = 1072906565; +inp[25059] = 0; +inp[25060] = 1072890193; +inp[25061] = 0; +inp[25062] = 1072873823; +inp[25063] = 0; +inp[25064] = 1072857452; +inp[25065] = 0; +inp[25066] = 1072841082; +inp[25067] = 0; +inp[25068] = 1072824711; +inp[25069] = 0; +inp[25070] = 1072808342; +inp[25071] = 0; +inp[25072] = 1072791972; +inp[25073] = 0; +inp[25074] = 1072775602; +inp[25075] = 0; +inp[25076] = 1072759233; +inp[25077] = 0; +inp[25078] = 1072742864; +inp[25079] = 0; +inp[25080] = 1072726496; +inp[25081] = 0; +inp[25082] = 1072710127; +inp[25083] = 0; +inp[25084] = 1072693759; +inp[25085] = 0; +inp[25086] = 1072677391; +inp[25087] = 0; +inp[25088] = 1072661024; +inp[25089] = 0; +inp[25090] = 1072644656; +inp[25091] = 0; +inp[25092] = 1072628289; +inp[25093] = 0; +inp[25094] = 1072611922; +inp[25095] = 0; +inp[25096] = 1072595556; +inp[25097] = 0; +inp[25098] = 1072579189; +inp[25099] = 0; +inp[25100] = 1072562823; +inp[25101] = 0; +inp[25102] = 1072546457; +inp[25103] = 0; +inp[25104] = 1072530092; +inp[25105] = 0; +inp[25106] = 1072513726; +inp[25107] = 0; +inp[25108] = 1072497361; +inp[25109] = 0; +inp[25110] = 1072480996; +inp[25111] = 0; +inp[25112] = 1072464632; +inp[25113] = 0; +inp[25114] = 1072448267; +inp[25115] = 0; +inp[25116] = 1072431903; +inp[25117] = 0; +inp[25118] = 1072415539; +inp[25119] = 0; +inp[25120] = 1072399176; +inp[25121] = 0; +inp[25122] = 1072382812; +inp[25123] = 0; +inp[25124] = 1072366449; +inp[25125] = 0; +inp[25126] = 1072350086; +inp[25127] = 0; +inp[25128] = 1072333724; +inp[25129] = 0; +inp[25130] = 1072317361; +inp[25131] = 0; +inp[25132] = 1072300999; +inp[25133] = 0; +inp[25134] = 1072284637; +inp[25135] = 0; +inp[25136] = 1072268276; +inp[25137] = 0; +inp[25138] = 1072251914; +inp[25139] = 0; +inp[25140] = 1072235553; +inp[25141] = 0; +inp[25142] = 1072219192; +inp[25143] = 0; +inp[25144] = 1072202831; +inp[25145] = 0; +inp[25146] = 1072186471; +inp[25147] = 0; +inp[25148] = 1072170111; +inp[25149] = 0; +inp[25150] = 1072153751; +inp[25151] = 0; +inp[25152] = 1072137391; +inp[25153] = 0; +inp[25154] = 1072121032; +inp[25155] = 0; +inp[25156] = 1072104673; +inp[25157] = 0; +inp[25158] = 1072088314; +inp[25159] = 0; +inp[25160] = 1072071955; +inp[25161] = 0; +inp[25162] = 1072055597; +inp[25163] = 0; +inp[25164] = 1072039239; +inp[25165] = 0; +inp[25166] = 1072022881; +inp[25167] = 0; +inp[25168] = 1072006523; +inp[25169] = 0; +inp[25170] = 1071990166; +inp[25171] = 0; +inp[25172] = 1071973809; +inp[25173] = 0; +inp[25174] = 1071957452; +inp[25175] = 0; +inp[25176] = 1071941095; +inp[25177] = 0; +inp[25178] = 1071924739; +inp[25179] = 0; +inp[25180] = 1071908383; +inp[25181] = 0; +inp[25182] = 1071892027; +inp[25183] = 0; +inp[25184] = 1071875671; +inp[25185] = 0; +inp[25186] = 1071859316; +inp[25187] = 0; +inp[25188] = 1071842961; +inp[25189] = 0; +inp[25190] = 1071826606; +inp[25191] = 0; +inp[25192] = 1071810251; +inp[25193] = 0; +inp[25194] = 1071793897; +inp[25195] = 0; +inp[25196] = 1071777542; +inp[25197] = 0; +inp[25198] = 1071761188; +inp[25199] = 0; +inp[25200] = 1071744835; +inp[25201] = 0; +inp[25202] = 1071728481; +inp[25203] = 0; +inp[25204] = 1071712128; +inp[25205] = 0; +inp[25206] = 1071695775; +inp[25207] = 0; +inp[25208] = 1071679423; +inp[25209] = 0; +inp[25210] = 1071663070; +inp[25211] = 0; +inp[25212] = 1071646718; +inp[25213] = 0; +inp[25214] = 1071630366; +inp[25215] = 0; +inp[25216] = 1071614015; +inp[25217] = 0; +inp[25218] = 1071597663; +inp[25219] = 0; +inp[25220] = 1071581312; +inp[25221] = 0; +inp[25222] = 1071564961; +inp[25223] = 0; +inp[25224] = 1071548610; +inp[25225] = 0; +inp[25226] = 1071532260; +inp[25227] = 0; +inp[25228] = 1071515910; +inp[25229] = 0; +inp[25230] = 1071499560; +inp[25231] = 0; +inp[25232] = 1071483210; +inp[25233] = 0; +inp[25234] = 1071466861; +inp[25235] = 0; +inp[25236] = 1071450512; +inp[25237] = 0; +inp[25238] = 1071434163; +inp[25239] = 0; +inp[25240] = 1071417814; +inp[25241] = 0; +inp[25242] = 1071401466; +inp[25243] = 0; +inp[25244] = 1071385118; +inp[25245] = 0; +inp[25246] = 1071368770; +inp[25247] = 0; +inp[25248] = 1071352422; +inp[25249] = 0; +inp[25250] = 1071336075; +inp[25251] = 0; +inp[25252] = 1071319727; +inp[25253] = 0; +inp[25254] = 1071303381; +inp[25255] = 0; +inp[25256] = 1071287034; +inp[25257] = 0; +inp[25258] = 1071270687; +inp[25259] = 0; +inp[25260] = 1071254341; +inp[25261] = 0; +inp[25262] = 1071237995; +inp[25263] = 0; +inp[25264] = 1071221650; +inp[25265] = 0; +inp[25266] = 1071205304; +inp[25267] = 0; +inp[25268] = 1071188959; +inp[25269] = 0; +inp[25270] = 1071172614; +inp[25271] = 0; +inp[25272] = 1071156269; +inp[25273] = 0; +inp[25274] = 1071139925; +inp[25275] = 0; +inp[25276] = 1071123581; +inp[25277] = 0; +inp[25278] = 1071107237; +inp[25279] = 0; +inp[25280] = 1071090893; +inp[25281] = 0; +inp[25282] = 1071074550; +inp[25283] = 0; +inp[25284] = 1071058207; +inp[25285] = 0; +inp[25286] = 1071041864; +inp[25287] = 0; +inp[25288] = 1071025521; +inp[25289] = 0; +inp[25290] = 1071009179; +inp[25291] = 0; +inp[25292] = 1070992836; +inp[25293] = 0; +inp[25294] = 1070976495; +inp[25295] = 0; +inp[25296] = 1070960153; +inp[25297] = 0; +inp[25298] = 1070943811; +inp[25299] = 0; +inp[25300] = 1070927470; +inp[25301] = 0; +inp[25302] = 1070911129; +inp[25303] = 0; +inp[25304] = 1070894789; +inp[25305] = 0; +inp[25306] = 1070878448; +inp[25307] = 0; +inp[25308] = 1070862108; +inp[25309] = 0; +inp[25310] = 1070845768; +inp[25311] = 0; +inp[25312] = 1070829428; +inp[25313] = 0; +inp[25314] = 1070813089; +inp[25315] = 0; +inp[25316] = 1070796750; +inp[25317] = 0; +inp[25318] = 1070780411; +inp[25319] = 0; +inp[25320] = 1070764072; +inp[25321] = 0; +inp[25322] = 1070747734; +inp[25323] = 0; +inp[25324] = 1070731396; +inp[25325] = 0; +inp[25326] = 1070715058; +inp[25327] = 0; +inp[25328] = 1070698720; +inp[25329] = 0; +inp[25330] = 1070682382; +inp[25331] = 0; +inp[25332] = 1070666045; +inp[25333] = 0; +inp[25334] = 1070649708; +inp[25335] = 0; +inp[25336] = 1070633372; +inp[25337] = 0; +inp[25338] = 1070617035; +inp[25339] = 0; +inp[25340] = 1070600699; +inp[25341] = 0; +inp[25342] = 1070584363; +inp[25343] = 0; +inp[25344] = 1070568027; +inp[25345] = 0; +inp[25346] = 1070551692; +inp[25347] = 0; +inp[25348] = 1070535357; +inp[25349] = 0; +inp[25350] = 1070519022; +inp[25351] = 0; +inp[25352] = 1070502687; +inp[25353] = 0; +inp[25354] = 1070486353; +inp[25355] = 0; +inp[25356] = 1070470018; +inp[25357] = 0; +inp[25358] = 1070453684; +inp[25359] = 0; +inp[25360] = 1070437351; +inp[25361] = 0; +inp[25362] = 1070421017; +inp[25363] = 0; +inp[25364] = 1070404684; +inp[25365] = 0; +inp[25366] = 1070388351; +inp[25367] = 0; +inp[25368] = 1070372018; +inp[25369] = 0; +inp[25370] = 1070355686; +inp[25371] = 0; +inp[25372] = 1070339354; +inp[25373] = 0; +inp[25374] = 1070323022; +inp[25375] = 0; +inp[25376] = 1070306690; +inp[25377] = 0; +inp[25378] = 1070290359; +inp[25379] = 0; +inp[25380] = 1070274027; +inp[25381] = 0; +inp[25382] = 1070257696; +inp[25383] = 0; +inp[25384] = 1070241366; +inp[25385] = 0; +inp[25386] = 1070225035; +inp[25387] = 0; +inp[25388] = 1070208705; +inp[25389] = 0; +inp[25390] = 1070192375; +inp[25391] = 0; +inp[25392] = 1070176045; +inp[25393] = 0; +inp[25394] = 1070159716; +inp[25395] = 0; +inp[25396] = 1070143387; +inp[25397] = 0; +inp[25398] = 1070127058; +inp[25399] = 0; +inp[25400] = 1070110729; +inp[25401] = 0; +inp[25402] = 1070094401; +inp[25403] = 0; +inp[25404] = 1070078072; +inp[25405] = 0; +inp[25406] = 1070061744; +inp[25407] = 0; +inp[25408] = 1070045417; +inp[25409] = 0; +inp[25410] = 1070029089; +inp[25411] = 0; +inp[25412] = 1070012762; +inp[25413] = 0; +inp[25414] = 1069996435; +inp[25415] = 0; +inp[25416] = 1069980108; +inp[25417] = 0; +inp[25418] = 1069963782; +inp[25419] = 0; +inp[25420] = 1069947456; +inp[25421] = 0; +inp[25422] = 1069931130; +inp[25423] = 0; +inp[25424] = 1069914804; +inp[25425] = 0; +inp[25426] = 1069898478; +inp[25427] = 0; +inp[25428] = 1069882153; +inp[25429] = 0; +inp[25430] = 1069865828; +inp[25431] = 0; +inp[25432] = 1069849503; +inp[25433] = 0; +inp[25434] = 1069833179; +inp[25435] = 0; +inp[25436] = 1069816855; +inp[25437] = 0; +inp[25438] = 1069800531; +inp[25439] = 0; +inp[25440] = 1069784207; +inp[25441] = 0; +inp[25442] = 1069767884; +inp[25443] = 0; +inp[25444] = 1069751560; +inp[25445] = 0; +inp[25446] = 1069735237; +inp[25447] = 0; +inp[25448] = 1069718915; +inp[25449] = 0; +inp[25450] = 1069702592; +inp[25451] = 0; +inp[25452] = 1069686270; +inp[25453] = 0; +inp[25454] = 1069669948; +inp[25455] = 0; +inp[25456] = 1069653626; +inp[25457] = 0; +inp[25458] = 1069637305; +inp[25459] = 0; +inp[25460] = 1069620983; +inp[25461] = 0; +inp[25462] = 1069604662; +inp[25463] = 0; +inp[25464] = 1069588342; +inp[25465] = 0; +inp[25466] = 1069572021; +inp[25467] = 0; +inp[25468] = 1073741824; +inp[25469] = 1073741824; +inp[25470] = 1073733632; +inp[25471] = 0; +inp[25472] = 1073725440; +inp[25473] = 0; +inp[25474] = 1073717248; +inp[25475] = 0; +inp[25476] = 1073709056; +inp[25477] = 0; +inp[25478] = 1073700864; +inp[25479] = 0; +inp[25480] = 1073692673; +inp[25481] = 0; +inp[25482] = 1073684481; +inp[25483] = 0; +inp[25484] = 1073676289; +inp[25485] = 0; +inp[25486] = 1073668098; +inp[25487] = 0; +inp[25488] = 1073659907; +inp[25489] = 0; +inp[25490] = 1073651715; +inp[25491] = 0; +inp[25492] = 1073643524; +inp[25493] = 0; +inp[25494] = 1073635333; +inp[25495] = 0; +inp[25496] = 1073627142; +inp[25497] = 0; +inp[25498] = 1073618951; +inp[25499] = 0; +inp[25500] = 1073610759; +inp[25501] = 0; +inp[25502] = 1073602569; +inp[25503] = 0; +inp[25504] = 1073594378; +inp[25505] = 0; +inp[25506] = 1073586187; +inp[25507] = 0; +inp[25508] = 1073577996; +inp[25509] = 0; +inp[25510] = 1073569805; +inp[25511] = 0; +inp[25512] = 1073561615; +inp[25513] = 0; +inp[25514] = 1073553424; +inp[25515] = 0; +inp[25516] = 1073545233; +inp[25517] = 0; +inp[25518] = 1073537043; +inp[25519] = 0; +inp[25520] = 1073528853; +inp[25521] = 0; +inp[25522] = 1073520662; +inp[25523] = 0; +inp[25524] = 1073512472; +inp[25525] = 0; +inp[25526] = 1073504282; +inp[25527] = 0; +inp[25528] = 1073496092; +inp[25529] = 0; +inp[25530] = 1073487902; +inp[25531] = 0; +inp[25532] = 1073479711; +inp[25533] = 0; +inp[25534] = 1073471522; +inp[25535] = 0; +inp[25536] = 1073463332; +inp[25537] = 0; +inp[25538] = 1073455142; +inp[25539] = 0; +inp[25540] = 1073446952; +inp[25541] = 0; +inp[25542] = 1073438762; +inp[25543] = 0; +inp[25544] = 1073430573; +inp[25545] = 0; +inp[25546] = 1073422383; +inp[25547] = 0; +inp[25548] = 1073414193; +inp[25549] = 0; +inp[25550] = 1073406004; +inp[25551] = 0; +inp[25552] = 1073397815; +inp[25553] = 0; +inp[25554] = 1073389625; +inp[25555] = 0; +inp[25556] = 1073381436; +inp[25557] = 0; +inp[25558] = 1073373247; +inp[25559] = 0; +inp[25560] = 1073365058; +inp[25561] = 0; +inp[25562] = 1073356869; +inp[25563] = 0; +inp[25564] = 1073348679; +inp[25565] = 0; +inp[25566] = 1073340491; +inp[25567] = 0; +inp[25568] = 1073332302; +inp[25569] = 0; +inp[25570] = 1073324113; +inp[25571] = 0; +inp[25572] = 1073315924; +inp[25573] = 0; +inp[25574] = 1073307735; +inp[25575] = 0; +inp[25576] = 1073299547; +inp[25577] = 0; +inp[25578] = 1073291358; +inp[25579] = 0; +inp[25580] = 1073283169; +inp[25581] = 0; +inp[25582] = 1073274981; +inp[25583] = 0; +inp[25584] = 1073266793; +inp[25585] = 0; +inp[25586] = 1073258604; +inp[25587] = 0; +inp[25588] = 1073250416; +inp[25589] = 0; +inp[25590] = 1073242228; +inp[25591] = 0; +inp[25592] = 1073234040; +inp[25593] = 0; +inp[25594] = 1073225852; +inp[25595] = 0; +inp[25596] = 1073217663; +inp[25597] = 0; +inp[25598] = 1073209476; +inp[25599] = 0; +inp[25600] = 1073201288; +inp[25601] = 0; +inp[25602] = 1073193100; +inp[25603] = 0; +inp[25604] = 1073184912; +inp[25605] = 0; +inp[25606] = 1073176724; +inp[25607] = 0; +inp[25608] = 1073168537; +inp[25609] = 0; +inp[25610] = 1073160349; +inp[25611] = 0; +inp[25612] = 1073152161; +inp[25613] = 0; +inp[25614] = 1073143974; +inp[25615] = 0; +inp[25616] = 1073135787; +inp[25617] = 0; +inp[25618] = 1073127599; +inp[25619] = 0; +inp[25620] = 1073119412; +inp[25621] = 0; +inp[25622] = 1073111225; +inp[25623] = 0; +inp[25624] = 1073103038; +inp[25625] = 0; +inp[25626] = 1073094850; +inp[25627] = 0; +inp[25628] = 1073086663; +inp[25629] = 0; +inp[25630] = 1073078476; +inp[25631] = 0; +inp[25632] = 1073070290; +inp[25633] = 0; +inp[25634] = 1073062103; +inp[25635] = 0; +inp[25636] = 1073053916; +inp[25637] = 0; +inp[25638] = 1073045729; +inp[25639] = 0; +inp[25640] = 1073037543; +inp[25641] = 0; +inp[25642] = 1073029356; +inp[25643] = 0; +inp[25644] = 1073021169; +inp[25645] = 0; +inp[25646] = 1073012983; +inp[25647] = 0; +inp[25648] = 1073004797; +inp[25649] = 0; +inp[25650] = 1072996610; +inp[25651] = 0; +inp[25652] = 1072988424; +inp[25653] = 0; +inp[25654] = 1072980238; +inp[25655] = 0; +inp[25656] = 1072972052; +inp[25657] = 0; +inp[25658] = 1072963865; +inp[25659] = 0; +inp[25660] = 1072955679; +inp[25661] = 0; +inp[25662] = 1072947493; +inp[25663] = 0; +inp[25664] = 1072939308; +inp[25665] = 0; +inp[25666] = 1072931122; +inp[25667] = 0; +inp[25668] = 1072922936; +inp[25669] = 0; +inp[25670] = 1072914750; +inp[25671] = 0; +inp[25672] = 1072906565; +inp[25673] = 0; +inp[25674] = 1072898379; +inp[25675] = 0; +inp[25676] = 1072890193; +inp[25677] = 0; +inp[25678] = 1072882008; +inp[25679] = 0; +inp[25680] = 1072873823; +inp[25681] = 0; +inp[25682] = 1072865637; +inp[25683] = 0; +inp[25684] = 1072857452; +inp[25685] = 0; +inp[25686] = 1072849267; +inp[25687] = 0; +inp[25688] = 1072841082; +inp[25689] = 0; +inp[25690] = 1072832896; +inp[25691] = 0; +inp[25692] = 1072824711; +inp[25693] = 0; +inp[25694] = 1072816526; +inp[25695] = 0; +inp[25696] = 1072808342; +inp[25697] = 0; +inp[25698] = 1072800157; +inp[25699] = 0; +inp[25700] = 1072791972; +inp[25701] = 0; +inp[25702] = 1072783787; +inp[25703] = 0; +inp[25704] = 1072775602; +inp[25705] = 0; +inp[25706] = 1072767418; +inp[25707] = 0; +inp[25708] = 1072759233; +inp[25709] = 0; +inp[25710] = 1072751049; +inp[25711] = 0; +inp[25712] = 1072742864; +inp[25713] = 0; +inp[25714] = 1072734680; +inp[25715] = 0; +inp[25716] = 1072726496; +inp[25717] = 0; +inp[25718] = 1072718312; +inp[25719] = 0; +inp[25720] = 1072710127; +inp[25721] = 0; +inp[25722] = 1072701943; +inp[25723] = 0; +inp[25724] = 1072693759; +inp[25725] = 0; +inp[25726] = 1072685575; +inp[25727] = 0; +inp[25728] = 1072677391; +inp[25729] = 0; +inp[25730] = 1072669208; +inp[25731] = 0; +inp[25732] = 1072661024; +inp[25733] = 0; +inp[25734] = 1072652840; +inp[25735] = 0; +inp[25736] = 1072644656; +inp[25737] = 0; +inp[25738] = 1072636473; +inp[25739] = 0; +inp[25740] = 1072628289; +inp[25741] = 0; +inp[25742] = 1072620106; +inp[25743] = 0; +inp[25744] = 1072611922; +inp[25745] = 0; +inp[25746] = 1072603739; +inp[25747] = 0; +inp[25748] = 1072595556; +inp[25749] = 0; +inp[25750] = 1072587373; +inp[25751] = 0; +inp[25752] = 1072579189; +inp[25753] = 0; +inp[25754] = 1072571006; +inp[25755] = 0; +inp[25756] = 1072562823; +inp[25757] = 0; +inp[25758] = 1072554640; +inp[25759] = 0; +inp[25760] = 1072546457; +inp[25761] = 0; +inp[25762] = 1072538275; +inp[25763] = 0; +inp[25764] = 1072530092; +inp[25765] = 0; +inp[25766] = 1072521909; +inp[25767] = 0; +inp[25768] = 1072513726; +inp[25769] = 0; +inp[25770] = 1072505544; +inp[25771] = 0; +inp[25772] = 1072497361; +inp[25773] = 0; +inp[25774] = 1072489179; +inp[25775] = 0; +inp[25776] = 1072480996; +inp[25777] = 0; +inp[25778] = 1072472814; +inp[25779] = 0; +inp[25780] = 1072464632; +inp[25781] = 0; +inp[25782] = 1072456449; +inp[25783] = 0; +inp[25784] = 1072448267; +inp[25785] = 0; +inp[25786] = 1072440085; +inp[25787] = 0; +inp[25788] = 1072431903; +inp[25789] = 0; +inp[25790] = 1072423721; +inp[25791] = 0; +inp[25792] = 1072415539; +inp[25793] = 0; +inp[25794] = 1072407357; +inp[25795] = 0; +inp[25796] = 1072399176; +inp[25797] = 0; +inp[25798] = 1072390994; +inp[25799] = 0; +inp[25800] = 1072382812; +inp[25801] = 0; +inp[25802] = 1072374631; +inp[25803] = 0; +inp[25804] = 1072366449; +inp[25805] = 0; +inp[25806] = 1072358268; +inp[25807] = 0; +inp[25808] = 1072350086; +inp[25809] = 0; +inp[25810] = 1072341905; +inp[25811] = 0; +inp[25812] = 1072333724; +inp[25813] = 0; +inp[25814] = 1072325542; +inp[25815] = 0; +inp[25816] = 1072317361; +inp[25817] = 0; +inp[25818] = 1072309180; +inp[25819] = 0; +inp[25820] = 1072300999; +inp[25821] = 0; +inp[25822] = 1072292818; +inp[25823] = 0; +inp[25824] = 1072284637; +inp[25825] = 0; +inp[25826] = 1072276456; +inp[25827] = 0; +inp[25828] = 1072268276; +inp[25829] = 0; +inp[25830] = 1072260095; +inp[25831] = 0; +inp[25832] = 1072251914; +inp[25833] = 0; +inp[25834] = 1072243734; +inp[25835] = 0; +inp[25836] = 1072235553; +inp[25837] = 0; +inp[25838] = 1072227373; +inp[25839] = 0; +inp[25840] = 1072219192; +inp[25841] = 0; +inp[25842] = 1072211012; +inp[25843] = 0; +inp[25844] = 1072202831; +inp[25845] = 0; +inp[25846] = 1072194651; +inp[25847] = 0; +inp[25848] = 1072186471; +inp[25849] = 0; +inp[25850] = 1072178291; +inp[25851] = 0; +inp[25852] = 1072170111; +inp[25853] = 0; +inp[25854] = 1072161931; +inp[25855] = 0; +inp[25856] = 1072153751; +inp[25857] = 0; +inp[25858] = 1072145571; +inp[25859] = 0; +inp[25860] = 1072137391; +inp[25861] = 0; +inp[25862] = 1072129212; +inp[25863] = 0; +inp[25864] = 1072121032; +inp[25865] = 0; +inp[25866] = 1072112852; +inp[25867] = 0; +inp[25868] = 1072104673; +inp[25869] = 0; +inp[25870] = 1072096493; +inp[25871] = 0; +inp[25872] = 1072088314; +inp[25873] = 0; +inp[25874] = 1072080135; +inp[25875] = 0; +inp[25876] = 1072071955; +inp[25877] = 0; +inp[25878] = 1072063776; +inp[25879] = 0; +inp[25880] = 1072055597; +inp[25881] = 0; +inp[25882] = 1072047418; +inp[25883] = 0; +inp[25884] = 1072039239; +inp[25885] = 0; +inp[25886] = 1072031060; +inp[25887] = 0; +inp[25888] = 1072022881; +inp[25889] = 0; +inp[25890] = 1072014702; +inp[25891] = 0; +inp[25892] = 1072006523; +inp[25893] = 0; +inp[25894] = 1071998345; +inp[25895] = 0; +inp[25896] = 1071990166; +inp[25897] = 0; +inp[25898] = 1071981987; +inp[25899] = 0; +inp[25900] = 1071973809; +inp[25901] = 0; +inp[25902] = 1071965630; +inp[25903] = 0; +inp[25904] = 1071957452; +inp[25905] = 0; +inp[25906] = 1071949273; +inp[25907] = 0; +inp[25908] = 1071941095; +inp[25909] = 0; +inp[25910] = 1071932917; +inp[25911] = 0; +inp[25912] = 1071924739; +inp[25913] = 0; +inp[25914] = 1071916561; +inp[25915] = 0; +inp[25916] = 1071908383; +inp[25917] = 0; +inp[25918] = 1071900205; +inp[25919] = 0; +inp[25920] = 1071892027; +inp[25921] = 0; +inp[25922] = 1071883849; +inp[25923] = 0; +inp[25924] = 1071875671; +inp[25925] = 0; +inp[25926] = 1071867493; +inp[25927] = 0; +inp[25928] = 1071859316; +inp[25929] = 0; +inp[25930] = 1071851138; +inp[25931] = 0; +inp[25932] = 1071842961; +inp[25933] = 0; +inp[25934] = 1071834783; +inp[25935] = 0; +inp[25936] = 1071826606; +inp[25937] = 0; +inp[25938] = 1071818428; +inp[25939] = 0; +inp[25940] = 1071810251; +inp[25941] = 0; +inp[25942] = 1071802074; +inp[25943] = 0; +inp[25944] = 1071793897; +inp[25945] = 0; +inp[25946] = 1071785719; +inp[25947] = 0; +inp[25948] = 1071777542; +inp[25949] = 0; +inp[25950] = 1071769365; +inp[25951] = 0; +inp[25952] = 1071761188; +inp[25953] = 0; +inp[25954] = 1071753012; +inp[25955] = 0; +inp[25956] = 1071744835; +inp[25957] = 0; +inp[25958] = 1071736658; +inp[25959] = 0; +inp[25960] = 1071728481; +inp[25961] = 0; +inp[25962] = 1071720305; +inp[25963] = 0; +inp[25964] = 1071712128; +inp[25965] = 0; +inp[25966] = 1071703952; +inp[25967] = 0; +inp[25968] = 1071695775; +inp[25969] = 0; +inp[25970] = 1071687599; +inp[25971] = 0; +inp[25972] = 1071679423; +inp[25973] = 0; +inp[25974] = 1071671246; +inp[25975] = 0; +inp[25976] = 1071663070; +inp[25977] = 0; +inp[25978] = 1071654894; +inp[25979] = 0; +inp[25980] = 1073741824; +inp[25981] = 1073741824; +inp[25982] = 1073737728; +inp[25983] = 0; +inp[25984] = 1073733632; +inp[25985] = 0; +inp[25986] = 1073729536; +inp[25987] = 0; +inp[25988] = 1073725440; +inp[25989] = 0; +inp[25990] = 1073721344; +inp[25991] = 0; +inp[25992] = 1073717248; +inp[25993] = 0; +inp[25994] = 1073713152; +inp[25995] = 0; +inp[25996] = 1073709056; +inp[25997] = 0; +inp[25998] = 1073704960; +inp[25999] = 0; +inp[26000] = 1073700864; +inp[26001] = 0; +inp[26002] = 1073696768; +inp[26003] = 0; +inp[26004] = 1073692673; +inp[26005] = 0; +inp[26006] = 1073688577; +inp[26007] = 0; +inp[26008] = 1073684481; +inp[26009] = 0; +inp[26010] = 1073680385; +inp[26011] = 0; +inp[26012] = 1073676289; +inp[26013] = 0; +inp[26014] = 1073672194; +inp[26015] = 0; +inp[26016] = 1073668098; +inp[26017] = 0; +inp[26018] = 1073664002; +inp[26019] = 0; +inp[26020] = 1073659907; +inp[26021] = 0; +inp[26022] = 1073655811; +inp[26023] = 0; +inp[26024] = 1073651715; +inp[26025] = 0; +inp[26026] = 1073647620; +inp[26027] = 0; +inp[26028] = 1073643524; +inp[26029] = 0; +inp[26030] = 1073639428; +inp[26031] = 0; +inp[26032] = 1073635333; +inp[26033] = 0; +inp[26034] = 1073631237; +inp[26035] = 0; +inp[26036] = 1073627142; +inp[26037] = 0; +inp[26038] = 1073623046; +inp[26039] = 0; +inp[26040] = 1073618951; +inp[26041] = 0; +inp[26042] = 1073614855; +inp[26043] = 0; +inp[26044] = 1073610759; +inp[26045] = 0; +inp[26046] = 1073606664; +inp[26047] = 0; +inp[26048] = 1073602569; +inp[26049] = 0; +inp[26050] = 1073598473; +inp[26051] = 0; +inp[26052] = 1073594378; +inp[26053] = 0; +inp[26054] = 1073590282; +inp[26055] = 0; +inp[26056] = 1073586187; +inp[26057] = 0; +inp[26058] = 1073582091; +inp[26059] = 0; +inp[26060] = 1073577996; +inp[26061] = 0; +inp[26062] = 1073573901; +inp[26063] = 0; +inp[26064] = 1073569805; +inp[26065] = 0; +inp[26066] = 1073565710; +inp[26067] = 0; +inp[26068] = 1073561615; +inp[26069] = 0; +inp[26070] = 1073557519; +inp[26071] = 0; +inp[26072] = 1073553424; +inp[26073] = 0; +inp[26074] = 1073549329; +inp[26075] = 0; +inp[26076] = 1073545233; +inp[26077] = 0; +inp[26078] = 1073541138; +inp[26079] = 0; +inp[26080] = 1073537043; +inp[26081] = 0; +inp[26082] = 1073532948; +inp[26083] = 0; +inp[26084] = 1073528853; +inp[26085] = 0; +inp[26086] = 1073524757; +inp[26087] = 0; +inp[26088] = 1073520662; +inp[26089] = 0; +inp[26090] = 1073516567; +inp[26091] = 0; +inp[26092] = 1073512472; +inp[26093] = 0; +inp[26094] = 1073508377; +inp[26095] = 0; +inp[26096] = 1073504282; +inp[26097] = 0; +inp[26098] = 1073500187; +inp[26099] = 0; +inp[26100] = 1073496092; +inp[26101] = 0; +inp[26102] = 1073491997; +inp[26103] = 0; +inp[26104] = 1073487902; +inp[26105] = 0; +inp[26106] = 1073483807; +inp[26107] = 0; +inp[26108] = 1073479711; +inp[26109] = 0; +inp[26110] = 1073475617; +inp[26111] = 0; +inp[26112] = 1073471522; +inp[26113] = 0; +inp[26114] = 1073467427; +inp[26115] = 0; +inp[26116] = 1073463332; +inp[26117] = 0; +inp[26118] = 1073459237; +inp[26119] = 0; +inp[26120] = 1073455142; +inp[26121] = 0; +inp[26122] = 1073451047; +inp[26123] = 0; +inp[26124] = 1073446952; +inp[26125] = 0; +inp[26126] = 1073442857; +inp[26127] = 0; +inp[26128] = 1073438762; +inp[26129] = 0; +inp[26130] = 1073434667; +inp[26131] = 0; +inp[26132] = 1073430573; +inp[26133] = 0; +inp[26134] = 1073426478; +inp[26135] = 0; +inp[26136] = 1073422383; +inp[26137] = 0; +inp[26138] = 1073418288; +inp[26139] = 0; +inp[26140] = 1073414193; +inp[26141] = 0; +inp[26142] = 1073410099; +inp[26143] = 0; +inp[26144] = 1073406004; +inp[26145] = 0; +inp[26146] = 1073401909; +inp[26147] = 0; +inp[26148] = 1073397815; +inp[26149] = 0; +inp[26150] = 1073393720; +inp[26151] = 0; +inp[26152] = 1073389625; +inp[26153] = 0; +inp[26154] = 1073385531; +inp[26155] = 0; +inp[26156] = 1073381436; +inp[26157] = 0; +inp[26158] = 1073377341; +inp[26159] = 0; +inp[26160] = 1073373247; +inp[26161] = 0; +inp[26162] = 1073369152; +inp[26163] = 0; +inp[26164] = 1073365058; +inp[26165] = 0; +inp[26166] = 1073360963; +inp[26167] = 0; +inp[26168] = 1073356869; +inp[26169] = 0; +inp[26170] = 1073352774; +inp[26171] = 0; +inp[26172] = 1073348679; +inp[26173] = 0; +inp[26174] = 1073344585; +inp[26175] = 0; +inp[26176] = 1073340491; +inp[26177] = 0; +inp[26178] = 1073336396; +inp[26179] = 0; +inp[26180] = 1073332302; +inp[26181] = 0; +inp[26182] = 1073328207; +inp[26183] = 0; +inp[26184] = 1073324113; +inp[26185] = 0; +inp[26186] = 1073320018; +inp[26187] = 0; +inp[26188] = 1073315924; +inp[26189] = 0; +inp[26190] = 1073311830; +inp[26191] = 0; +inp[26192] = 1073307735; +inp[26193] = 0; +inp[26194] = 1073303641; +inp[26195] = 0; +inp[26196] = 1073299547; +inp[26197] = 0; +inp[26198] = 1073295452; +inp[26199] = 0; +inp[26200] = 1073291358; +inp[26201] = 0; +inp[26202] = 1073287264; +inp[26203] = 0; +inp[26204] = 1073283169; +inp[26205] = 0; +inp[26206] = 1073279075; +inp[26207] = 0; +inp[26208] = 1073274981; +inp[26209] = 0; +inp[26210] = 1073270887; +inp[26211] = 0; +inp[26212] = 1073266793; +inp[26213] = 0; +inp[26214] = 1073262698; +inp[26215] = 0; +inp[26216] = 1073258604; +inp[26217] = 0; +inp[26218] = 1073254510; +inp[26219] = 0; +inp[26220] = 1073250416; +inp[26221] = 0; +inp[26222] = 1073246322; +inp[26223] = 0; +inp[26224] = 1073242228; +inp[26225] = 0; +inp[26226] = 1073238134; +inp[26227] = 0; +inp[26228] = 1073234040; +inp[26229] = 0; +inp[26230] = 1073229946; +inp[26231] = 0; +inp[26232] = 1073225852; +inp[26233] = 0; +inp[26234] = 1073221757; +inp[26235] = 0; +inp[26236] = 1073217663; +inp[26237] = 0; +inp[26238] = 1073213569; +inp[26239] = 0; +inp[26240] = 1073209476; +inp[26241] = 0; +inp[26242] = 1073205382; +inp[26243] = 0; +inp[26244] = 1073201288; +inp[26245] = 0; +inp[26246] = 1073197194; +inp[26247] = 0; +inp[26248] = 1073193100; +inp[26249] = 0; +inp[26250] = 1073189006; +inp[26251] = 0; +inp[26252] = 1073184912; +inp[26253] = 0; +inp[26254] = 1073180818; +inp[26255] = 0; +inp[26256] = 1073176724; +inp[26257] = 0; +inp[26258] = 1073172630; +inp[26259] = 0; +inp[26260] = 1073168537; +inp[26261] = 0; +inp[26262] = 1073164443; +inp[26263] = 0; +inp[26264] = 1073160349; +inp[26265] = 0; +inp[26266] = 1073156255; +inp[26267] = 0; +inp[26268] = 1073152161; +inp[26269] = 0; +inp[26270] = 1073148068; +inp[26271] = 0; +inp[26272] = 1073143974; +inp[26273] = 0; +inp[26274] = 1073139880; +inp[26275] = 0; +inp[26276] = 1073135787; +inp[26277] = 0; +inp[26278] = 1073131693; +inp[26279] = 0; +inp[26280] = 1073127599; +inp[26281] = 0; +inp[26282] = 1073123506; +inp[26283] = 0; +inp[26284] = 1073119412; +inp[26285] = 0; +inp[26286] = 1073115318; +inp[26287] = 0; +inp[26288] = 1073111225; +inp[26289] = 0; +inp[26290] = 1073107131; +inp[26291] = 0; +inp[26292] = 1073103038; +inp[26293] = 0; +inp[26294] = 1073098944; +inp[26295] = 0; +inp[26296] = 1073094850; +inp[26297] = 0; +inp[26298] = 1073090757; +inp[26299] = 0; +inp[26300] = 1073086663; +inp[26301] = 0; +inp[26302] = 1073082570; +inp[26303] = 0; +inp[26304] = 1073078476; +inp[26305] = 0; +inp[26306] = 1073074383; +inp[26307] = 0; +inp[26308] = 1073070290; +inp[26309] = 0; +inp[26310] = 1073066196; +inp[26311] = 0; +inp[26312] = 1073062103; +inp[26313] = 0; +inp[26314] = 1073058009; +inp[26315] = 0; +inp[26316] = 1073053916; +inp[26317] = 0; +inp[26318] = 1073049823; +inp[26319] = 0; +inp[26320] = 1073045729; +inp[26321] = 0; +inp[26322] = 1073041636; +inp[26323] = 0; +inp[26324] = 1073037543; +inp[26325] = 0; +inp[26326] = 1073033449; +inp[26327] = 0; +inp[26328] = 1073029356; +inp[26329] = 0; +inp[26330] = 1073025263; +inp[26331] = 0; +inp[26332] = 1073021169; +inp[26333] = 0; +inp[26334] = 1073017076; +inp[26335] = 0; +inp[26336] = 1073012983; +inp[26337] = 0; +inp[26338] = 1073008890; +inp[26339] = 0; +inp[26340] = 1073004797; +inp[26341] = 0; +inp[26342] = 1073000703; +inp[26343] = 0; +inp[26344] = 1072996610; +inp[26345] = 0; +inp[26346] = 1072992517; +inp[26347] = 0; +inp[26348] = 1072988424; +inp[26349] = 0; +inp[26350] = 1072984331; +inp[26351] = 0; +inp[26352] = 1072980238; +inp[26353] = 0; +inp[26354] = 1072976145; +inp[26355] = 0; +inp[26356] = 1072972052; +inp[26357] = 0; +inp[26358] = 1072967959; +inp[26359] = 0; +inp[26360] = 1072963865; +inp[26361] = 0; +inp[26362] = 1072959772; +inp[26363] = 0; +inp[26364] = 1072955679; +inp[26365] = 0; +inp[26366] = 1072951586; +inp[26367] = 0; +inp[26368] = 1072947493; +inp[26369] = 0; +inp[26370] = 1072943400; +inp[26371] = 0; +inp[26372] = 1072939308; +inp[26373] = 0; +inp[26374] = 1072935215; +inp[26375] = 0; +inp[26376] = 1072931122; +inp[26377] = 0; +inp[26378] = 1072927029; +inp[26379] = 0; +inp[26380] = 1072922936; +inp[26381] = 0; +inp[26382] = 1072918843; +inp[26383] = 0; +inp[26384] = 1072914750; +inp[26385] = 0; +inp[26386] = 1072910657; +inp[26387] = 0; +inp[26388] = 1072906565; +inp[26389] = 0; +inp[26390] = 1072902472; +inp[26391] = 0; +inp[26392] = 1072898379; +inp[26393] = 0; +inp[26394] = 1072894286; +inp[26395] = 0; +inp[26396] = 1072890193; +inp[26397] = 0; +inp[26398] = 1072886101; +inp[26399] = 0; +inp[26400] = 1072882008; +inp[26401] = 0; +inp[26402] = 1072877915; +inp[26403] = 0; +inp[26404] = 1072873823; +inp[26405] = 0; +inp[26406] = 1072869730; +inp[26407] = 0; +inp[26408] = 1072865637; +inp[26409] = 0; +inp[26410] = 1072861545; +inp[26411] = 0; +inp[26412] = 1072857452; +inp[26413] = 0; +inp[26414] = 1072853359; +inp[26415] = 0; +inp[26416] = 1072849267; +inp[26417] = 0; +inp[26418] = 1072845174; +inp[26419] = 0; +inp[26420] = 1072841082; +inp[26421] = 0; +inp[26422] = 1072836989; +inp[26423] = 0; +inp[26424] = 1072832896; +inp[26425] = 0; +inp[26426] = 1072828804; +inp[26427] = 0; +inp[26428] = 1072824711; +inp[26429] = 0; +inp[26430] = 1072820619; +inp[26431] = 0; +inp[26432] = 1072816526; +inp[26433] = 0; +inp[26434] = 1072812434; +inp[26435] = 0; +inp[26436] = 1072808342; +inp[26437] = 0; +inp[26438] = 1072804249; +inp[26439] = 0; +inp[26440] = 1072800157; +inp[26441] = 0; +inp[26442] = 1072796064; +inp[26443] = 0; +inp[26444] = 1072791972; +inp[26445] = 0; +inp[26446] = 1072787880; +inp[26447] = 0; +inp[26448] = 1072783787; +inp[26449] = 0; +inp[26450] = 1072779695; +inp[26451] = 0; +inp[26452] = 1072775602; +inp[26453] = 0; +inp[26454] = 1072771510; +inp[26455] = 0; +inp[26456] = 1072767418; +inp[26457] = 0; +inp[26458] = 1072763326; +inp[26459] = 0; +inp[26460] = 1072759233; +inp[26461] = 0; +inp[26462] = 1072755141; +inp[26463] = 0; +inp[26464] = 1072751049; +inp[26465] = 0; +inp[26466] = 1072746957; +inp[26467] = 0; +inp[26468] = 1072742864; +inp[26469] = 0; +inp[26470] = 1072738772; +inp[26471] = 0; +inp[26472] = 1072734680; +inp[26473] = 0; +inp[26474] = 1072730588; +inp[26475] = 0; +inp[26476] = 1072726496; +inp[26477] = 0; +inp[26478] = 1072722404; +inp[26479] = 0; +inp[26480] = 1072718312; +inp[26481] = 0; +inp[26482] = 1072714220; +inp[26483] = 0; +inp[26484] = 1072710127; +inp[26485] = 0; +inp[26486] = 1072706035; +inp[26487] = 0; +inp[26488] = 1072701943; +inp[26489] = 0; +inp[26490] = 1072697851; +inp[26491] = 0; +inp[26492] = 1073741824; +inp[26493] = 1073741824; +inp[26494] = 1073739776; +inp[26495] = 0; +inp[26496] = 1073737728; +inp[26497] = 0; +inp[26498] = 1073735680; +inp[26499] = 0; +inp[26500] = 1073733632; +inp[26501] = 0; +inp[26502] = 1073731584; +inp[26503] = 0; +inp[26504] = 1073729536; +inp[26505] = 0; +inp[26506] = 1073727488; +inp[26507] = 0; +inp[26508] = 1073725440; +inp[26509] = 0; +inp[26510] = 1073723392; +inp[26511] = 0; +inp[26512] = 1073721344; +inp[26513] = 0; +inp[26514] = 1073719296; +inp[26515] = 0; +inp[26516] = 1073717248; +inp[26517] = 0; +inp[26518] = 1073715200; +inp[26519] = 0; +inp[26520] = 1073713152; +inp[26521] = 0; +inp[26522] = 1073711104; +inp[26523] = 0; +inp[26524] = 1073709056; +inp[26525] = 0; +inp[26526] = 1073707008; +inp[26527] = 0; +inp[26528] = 1073704960; +inp[26529] = 0; +inp[26530] = 1073702912; +inp[26531] = 0; +inp[26532] = 1073700864; +inp[26533] = 0; +inp[26534] = 1073698816; +inp[26535] = 0; +inp[26536] = 1073696768; +inp[26537] = 0; +inp[26538] = 1073694721; +inp[26539] = 0; +inp[26540] = 1073692673; +inp[26541] = 0; +inp[26542] = 1073690625; +inp[26543] = 0; +inp[26544] = 1073688577; +inp[26545] = 0; +inp[26546] = 1073686529; +inp[26547] = 0; +inp[26548] = 1073684481; +inp[26549] = 0; +inp[26550] = 1073682433; +inp[26551] = 0; +inp[26552] = 1073680385; +inp[26553] = 0; +inp[26554] = 1073678337; +inp[26555] = 0; +inp[26556] = 1073676289; +inp[26557] = 0; +inp[26558] = 1073674242; +inp[26559] = 0; +inp[26560] = 1073672194; +inp[26561] = 0; +inp[26562] = 1073670146; +inp[26563] = 0; +inp[26564] = 1073668098; +inp[26565] = 0; +inp[26566] = 1073666050; +inp[26567] = 0; +inp[26568] = 1073664002; +inp[26569] = 0; +inp[26570] = 1073661954; +inp[26571] = 0; +inp[26572] = 1073659907; +inp[26573] = 0; +inp[26574] = 1073657859; +inp[26575] = 0; +inp[26576] = 1073655811; +inp[26577] = 0; +inp[26578] = 1073653763; +inp[26579] = 0; +inp[26580] = 1073651715; +inp[26581] = 0; +inp[26582] = 1073649667; +inp[26583] = 0; +inp[26584] = 1073647620; +inp[26585] = 0; +inp[26586] = 1073645572; +inp[26587] = 0; +inp[26588] = 1073643524; +inp[26589] = 0; +inp[26590] = 1073641476; +inp[26591] = 0; +inp[26592] = 1073639428; +inp[26593] = 0; +inp[26594] = 1073637381; +inp[26595] = 0; +inp[26596] = 1073635333; +inp[26597] = 0; +inp[26598] = 1073633285; +inp[26599] = 0; +inp[26600] = 1073631237; +inp[26601] = 0; +inp[26602] = 1073629189; +inp[26603] = 0; +inp[26604] = 1073627142; +inp[26605] = 0; +inp[26606] = 1073625094; +inp[26607] = 0; +inp[26608] = 1073623046; +inp[26609] = 0; +inp[26610] = 1073620998; +inp[26611] = 0; +inp[26612] = 1073618951; +inp[26613] = 0; +inp[26614] = 1073616903; +inp[26615] = 0; +inp[26616] = 1073614855; +inp[26617] = 0; +inp[26618] = 1073612807; +inp[26619] = 0; +inp[26620] = 1073610759; +inp[26621] = 0; +inp[26622] = 1073608712; +inp[26623] = 0; +inp[26624] = 1073606664; +inp[26625] = 0; +inp[26626] = 1073604616; +inp[26627] = 0; +inp[26628] = 1073602569; +inp[26629] = 0; +inp[26630] = 1073600521; +inp[26631] = 0; +inp[26632] = 1073598473; +inp[26633] = 0; +inp[26634] = 1073596425; +inp[26635] = 0; +inp[26636] = 1073594378; +inp[26637] = 0; +inp[26638] = 1073592330; +inp[26639] = 0; +inp[26640] = 1073590282; +inp[26641] = 0; +inp[26642] = 1073588234; +inp[26643] = 0; +inp[26644] = 1073586187; +inp[26645] = 0; +inp[26646] = 1073584139; +inp[26647] = 0; +inp[26648] = 1073582091; +inp[26649] = 0; +inp[26650] = 1073580044; +inp[26651] = 0; +inp[26652] = 1073577996; +inp[26653] = 0; +inp[26654] = 1073575948; +inp[26655] = 0; +inp[26656] = 1073573901; +inp[26657] = 0; +inp[26658] = 1073571853; +inp[26659] = 0; +inp[26660] = 1073569805; +inp[26661] = 0; +inp[26662] = 1073567758; +inp[26663] = 0; +inp[26664] = 1073565710; +inp[26665] = 0; +inp[26666] = 1073563662; +inp[26667] = 0; +inp[26668] = 1073561615; +inp[26669] = 0; +inp[26670] = 1073559567; +inp[26671] = 0; +inp[26672] = 1073557519; +inp[26673] = 0; +inp[26674] = 1073555472; +inp[26675] = 0; +inp[26676] = 1073553424; +inp[26677] = 0; +inp[26678] = 1073551376; +inp[26679] = 0; +inp[26680] = 1073549329; +inp[26681] = 0; +inp[26682] = 1073547281; +inp[26683] = 0; +inp[26684] = 1073545233; +inp[26685] = 0; +inp[26686] = 1073543186; +inp[26687] = 0; +inp[26688] = 1073541138; +inp[26689] = 0; +inp[26690] = 1073539091; +inp[26691] = 0; +inp[26692] = 1073537043; +inp[26693] = 0; +inp[26694] = 1073534995; +inp[26695] = 0; +inp[26696] = 1073532948; +inp[26697] = 0; +inp[26698] = 1073530900; +inp[26699] = 0; +inp[26700] = 1073528853; +inp[26701] = 0; +inp[26702] = 1073526805; +inp[26703] = 0; +inp[26704] = 1073524757; +inp[26705] = 0; +inp[26706] = 1073522710; +inp[26707] = 0; +inp[26708] = 1073520662; +inp[26709] = 0; +inp[26710] = 1073518615; +inp[26711] = 0; +inp[26712] = 1073516567; +inp[26713] = 0; +inp[26714] = 1073514520; +inp[26715] = 0; +inp[26716] = 1073512472; +inp[26717] = 0; +inp[26718] = 1073510424; +inp[26719] = 0; +inp[26720] = 1073508377; +inp[26721] = 0; +inp[26722] = 1073506329; +inp[26723] = 0; +inp[26724] = 1073504282; +inp[26725] = 0; +inp[26726] = 1073502234; +inp[26727] = 0; +inp[26728] = 1073500187; +inp[26729] = 0; +inp[26730] = 1073498139; +inp[26731] = 0; +inp[26732] = 1073496092; +inp[26733] = 0; +inp[26734] = 1073494044; +inp[26735] = 0; +inp[26736] = 1073491997; +inp[26737] = 0; +inp[26738] = 1073489949; +inp[26739] = 0; +inp[26740] = 1073487902; +inp[26741] = 0; +inp[26742] = 1073485854; +inp[26743] = 0; +inp[26744] = 1073483807; +inp[26745] = 0; +inp[26746] = 1073481759; +inp[26747] = 0; +inp[26748] = 1073479711; +inp[26749] = 0; +inp[26750] = 1073477664; +inp[26751] = 0; +inp[26752] = 1073475617; +inp[26753] = 0; +inp[26754] = 1073473569; +inp[26755] = 0; +inp[26756] = 1073471522; +inp[26757] = 0; +inp[26758] = 1073469474; +inp[26759] = 0; +inp[26760] = 1073467427; +inp[26761] = 0; +inp[26762] = 1073465379; +inp[26763] = 0; +inp[26764] = 1073463332; +inp[26765] = 0; +inp[26766] = 1073461284; +inp[26767] = 0; +inp[26768] = 1073459237; +inp[26769] = 0; +inp[26770] = 1073457189; +inp[26771] = 0; +inp[26772] = 1073455142; +inp[26773] = 0; +inp[26774] = 1073453094; +inp[26775] = 0; +inp[26776] = 1073451047; +inp[26777] = 0; +inp[26778] = 1073448999; +inp[26779] = 0; +inp[26780] = 1073446952; +inp[26781] = 0; +inp[26782] = 1073444905; +inp[26783] = 0; +inp[26784] = 1073442857; +inp[26785] = 0; +inp[26786] = 1073440810; +inp[26787] = 0; +inp[26788] = 1073438762; +inp[26789] = 0; +inp[26790] = 1073436715; +inp[26791] = 0; +inp[26792] = 1073434667; +inp[26793] = 0; +inp[26794] = 1073432620; +inp[26795] = 0; +inp[26796] = 1073430573; +inp[26797] = 0; +inp[26798] = 1073428525; +inp[26799] = 0; +inp[26800] = 1073426478; +inp[26801] = 0; +inp[26802] = 1073424430; +inp[26803] = 0; +inp[26804] = 1073422383; +inp[26805] = 0; +inp[26806] = 1073420336; +inp[26807] = 0; +inp[26808] = 1073418288; +inp[26809] = 0; +inp[26810] = 1073416241; +inp[26811] = 0; +inp[26812] = 1073414193; +inp[26813] = 0; +inp[26814] = 1073412146; +inp[26815] = 0; +inp[26816] = 1073410099; +inp[26817] = 0; +inp[26818] = 1073408051; +inp[26819] = 0; +inp[26820] = 1073406004; +inp[26821] = 0; +inp[26822] = 1073403957; +inp[26823] = 0; +inp[26824] = 1073401909; +inp[26825] = 0; +inp[26826] = 1073399862; +inp[26827] = 0; +inp[26828] = 1073397815; +inp[26829] = 0; +inp[26830] = 1073395767; +inp[26831] = 0; +inp[26832] = 1073393720; +inp[26833] = 0; +inp[26834] = 1073391673; +inp[26835] = 0; +inp[26836] = 1073389625; +inp[26837] = 0; +inp[26838] = 1073387578; +inp[26839] = 0; +inp[26840] = 1073385531; +inp[26841] = 0; +inp[26842] = 1073383483; +inp[26843] = 0; +inp[26844] = 1073381436; +inp[26845] = 0; +inp[26846] = 1073379389; +inp[26847] = 0; +inp[26848] = 1073377341; +inp[26849] = 0; +inp[26850] = 1073375294; +inp[26851] = 0; +inp[26852] = 1073373247; +inp[26853] = 0; +inp[26854] = 1073371199; +inp[26855] = 0; +inp[26856] = 1073369152; +inp[26857] = 0; +inp[26858] = 1073367105; +inp[26859] = 0; +inp[26860] = 1073365058; +inp[26861] = 0; +inp[26862] = 1073363010; +inp[26863] = 0; +inp[26864] = 1073360963; +inp[26865] = 0; +inp[26866] = 1073358916; +inp[26867] = 0; +inp[26868] = 1073356869; +inp[26869] = 0; +inp[26870] = 1073354821; +inp[26871] = 0; +inp[26872] = 1073352774; +inp[26873] = 0; +inp[26874] = 1073350727; +inp[26875] = 0; +inp[26876] = 1073348679; +inp[26877] = 0; +inp[26878] = 1073346632; +inp[26879] = 0; +inp[26880] = 1073344585; +inp[26881] = 0; +inp[26882] = 1073342538; +inp[26883] = 0; +inp[26884] = 1073340491; +inp[26885] = 0; +inp[26886] = 1073338443; +inp[26887] = 0; +inp[26888] = 1073336396; +inp[26889] = 0; +inp[26890] = 1073334349; +inp[26891] = 0; +inp[26892] = 1073332302; +inp[26893] = 0; +inp[26894] = 1073330254; +inp[26895] = 0; +inp[26896] = 1073328207; +inp[26897] = 0; +inp[26898] = 1073326160; +inp[26899] = 0; +inp[26900] = 1073324113; +inp[26901] = 0; +inp[26902] = 1073322066; +inp[26903] = 0; +inp[26904] = 1073320018; +inp[26905] = 0; +inp[26906] = 1073317971; +inp[26907] = 0; +inp[26908] = 1073315924; +inp[26909] = 0; +inp[26910] = 1073313877; +inp[26911] = 0; +inp[26912] = 1073311830; +inp[26913] = 0; +inp[26914] = 1073309782; +inp[26915] = 0; +inp[26916] = 1073307735; +inp[26917] = 0; +inp[26918] = 1073305688; +inp[26919] = 0; +inp[26920] = 1073303641; +inp[26921] = 0; +inp[26922] = 1073301594; +inp[26923] = 0; +inp[26924] = 1073299547; +inp[26925] = 0; +inp[26926] = 1073297499; +inp[26927] = 0; +inp[26928] = 1073295452; +inp[26929] = 0; +inp[26930] = 1073293405; +inp[26931] = 0; +inp[26932] = 1073291358; +inp[26933] = 0; +inp[26934] = 1073289311; +inp[26935] = 0; +inp[26936] = 1073287264; +inp[26937] = 0; +inp[26938] = 1073285217; +inp[26939] = 0; +inp[26940] = 1073283169; +inp[26941] = 0; +inp[26942] = 1073281122; +inp[26943] = 0; +inp[26944] = 1073279075; +inp[26945] = 0; +inp[26946] = 1073277028; +inp[26947] = 0; +inp[26948] = 1073274981; +inp[26949] = 0; +inp[26950] = 1073272934; +inp[26951] = 0; +inp[26952] = 1073270887; +inp[26953] = 0; +inp[26954] = 1073268840; +inp[26955] = 0; +inp[26956] = 1073266793; +inp[26957] = 0; +inp[26958] = 1073264746; +inp[26959] = 0; +inp[26960] = 1073262698; +inp[26961] = 0; +inp[26962] = 1073260651; +inp[26963] = 0; +inp[26964] = 1073258604; +inp[26965] = 0; +inp[26966] = 1073256557; +inp[26967] = 0; +inp[26968] = 1073254510; +inp[26969] = 0; +inp[26970] = 1073252463; +inp[26971] = 0; +inp[26972] = 1073250416; +inp[26973] = 0; +inp[26974] = 1073248369; +inp[26975] = 0; +inp[26976] = 1073246322; +inp[26977] = 0; +inp[26978] = 1073244275; +inp[26979] = 0; +inp[26980] = 1073242228; +inp[26981] = 0; +inp[26982] = 1073240181; +inp[26983] = 0; +inp[26984] = 1073238134; +inp[26985] = 0; +inp[26986] = 1073236087; +inp[26987] = 0; +inp[26988] = 1073234040; +inp[26989] = 0; +inp[26990] = 1073231993; +inp[26991] = 0; +inp[26992] = 1073229946; +inp[26993] = 0; +inp[26994] = 1073227899; +inp[26995] = 0; +inp[26996] = 1073225852; +inp[26997] = 0; +inp[26998] = 1073223804; +inp[26999] = 0; +inp[27000] = 1073221757; +inp[27001] = 0; +inp[27002] = 1073219710; +inp[27003] = 0; +inp[27004] = 1073741824; +inp[27005] = 1073741824; +inp[27006] = 1073740800; +inp[27007] = 0; +inp[27008] = 1073739776; +inp[27009] = 0; +inp[27010] = 1073738752; +inp[27011] = 0; +inp[27012] = 1073737728; +inp[27013] = 0; +inp[27014] = 1073736704; +inp[27015] = 0; +inp[27016] = 1073735680; +inp[27017] = 0; +inp[27018] = 1073734656; +inp[27019] = 0; +inp[27020] = 1073733632; +inp[27021] = 0; +inp[27022] = 1073732608; +inp[27023] = 0; +inp[27024] = 1073731584; +inp[27025] = 0; +inp[27026] = 1073730560; +inp[27027] = 0; +inp[27028] = 1073729536; +inp[27029] = 0; +inp[27030] = 1073728512; +inp[27031] = 0; +inp[27032] = 1073727488; +inp[27033] = 0; +inp[27034] = 1073726464; +inp[27035] = 0; +inp[27036] = 1073725440; +inp[27037] = 0; +inp[27038] = 1073724416; +inp[27039] = 0; +inp[27040] = 1073723392; +inp[27041] = 0; +inp[27042] = 1073722368; +inp[27043] = 0; +inp[27044] = 1073721344; +inp[27045] = 0; +inp[27046] = 1073720320; +inp[27047] = 0; +inp[27048] = 1073719296; +inp[27049] = 0; +inp[27050] = 1073718272; +inp[27051] = 0; +inp[27052] = 1073717248; +inp[27053] = 0; +inp[27054] = 1073716224; +inp[27055] = 0; +inp[27056] = 1073715200; +inp[27057] = 0; +inp[27058] = 1073714176; +inp[27059] = 0; +inp[27060] = 1073713152; +inp[27061] = 0; +inp[27062] = 1073712128; +inp[27063] = 0; +inp[27064] = 1073711104; +inp[27065] = 0; +inp[27066] = 1073710080; +inp[27067] = 0; +inp[27068] = 1073709056; +inp[27069] = 0; +inp[27070] = 1073708032; +inp[27071] = 0; +inp[27072] = 1073707008; +inp[27073] = 0; +inp[27074] = 1073705984; +inp[27075] = 0; +inp[27076] = 1073704960; +inp[27077] = 0; +inp[27078] = 1073703936; +inp[27079] = 0; +inp[27080] = 1073702912; +inp[27081] = 0; +inp[27082] = 1073701888; +inp[27083] = 0; +inp[27084] = 1073700864; +inp[27085] = 0; +inp[27086] = 1073699840; +inp[27087] = 0; +inp[27088] = 1073698816; +inp[27089] = 0; +inp[27090] = 1073697792; +inp[27091] = 0; +inp[27092] = 1073696768; +inp[27093] = 0; +inp[27094] = 1073695744; +inp[27095] = 0; +inp[27096] = 1073694721; +inp[27097] = 0; +inp[27098] = 1073693697; +inp[27099] = 0; +inp[27100] = 1073692673; +inp[27101] = 0; +inp[27102] = 1073691649; +inp[27103] = 0; +inp[27104] = 1073690625; +inp[27105] = 0; +inp[27106] = 1073689601; +inp[27107] = 0; +inp[27108] = 1073688577; +inp[27109] = 0; +inp[27110] = 1073687553; +inp[27111] = 0; +inp[27112] = 1073686529; +inp[27113] = 0; +inp[27114] = 1073685505; +inp[27115] = 0; +inp[27116] = 1073684481; +inp[27117] = 0; +inp[27118] = 1073683457; +inp[27119] = 0; +inp[27120] = 1073682433; +inp[27121] = 0; +inp[27122] = 1073681409; +inp[27123] = 0; +inp[27124] = 1073680385; +inp[27125] = 0; +inp[27126] = 1073679361; +inp[27127] = 0; +inp[27128] = 1073678337; +inp[27129] = 0; +inp[27130] = 1073677313; +inp[27131] = 0; +inp[27132] = 1073676289; +inp[27133] = 0; +inp[27134] = 1073675266; +inp[27135] = 0; +inp[27136] = 1073674242; +inp[27137] = 0; +inp[27138] = 1073673218; +inp[27139] = 0; +inp[27140] = 1073672194; +inp[27141] = 0; +inp[27142] = 1073671170; +inp[27143] = 0; +inp[27144] = 1073670146; +inp[27145] = 0; +inp[27146] = 1073669122; +inp[27147] = 0; +inp[27148] = 1073668098; +inp[27149] = 0; +inp[27150] = 1073667074; +inp[27151] = 0; +inp[27152] = 1073666050; +inp[27153] = 0; +inp[27154] = 1073665026; +inp[27155] = 0; +inp[27156] = 1073664002; +inp[27157] = 0; +inp[27158] = 1073662978; +inp[27159] = 0; +inp[27160] = 1073661954; +inp[27161] = 0; +inp[27162] = 1073660931; +inp[27163] = 0; +inp[27164] = 1073659907; +inp[27165] = 0; +inp[27166] = 1073658883; +inp[27167] = 0; +inp[27168] = 1073657859; +inp[27169] = 0; +inp[27170] = 1073656835; +inp[27171] = 0; +inp[27172] = 1073655811; +inp[27173] = 0; +inp[27174] = 1073654787; +inp[27175] = 0; +inp[27176] = 1073653763; +inp[27177] = 0; +inp[27178] = 1073652739; +inp[27179] = 0; +inp[27180] = 1073651715; +inp[27181] = 0; +inp[27182] = 1073650691; +inp[27183] = 0; +inp[27184] = 1073649667; +inp[27185] = 0; +inp[27186] = 1073648644; +inp[27187] = 0; +inp[27188] = 1073647620; +inp[27189] = 0; +inp[27190] = 1073646596; +inp[27191] = 0; +inp[27192] = 1073645572; +inp[27193] = 0; +inp[27194] = 1073644548; +inp[27195] = 0; +inp[27196] = 1073643524; +inp[27197] = 0; +inp[27198] = 1073642500; +inp[27199] = 0; +inp[27200] = 1073641476; +inp[27201] = 0; +inp[27202] = 1073640452; +inp[27203] = 0; +inp[27204] = 1073639428; +inp[27205] = 0; +inp[27206] = 1073638404; +inp[27207] = 0; +inp[27208] = 1073637381; +inp[27209] = 0; +inp[27210] = 1073636357; +inp[27211] = 0; +inp[27212] = 1073635333; +inp[27213] = 0; +inp[27214] = 1073634309; +inp[27215] = 0; +inp[27216] = 1073633285; +inp[27217] = 0; +inp[27218] = 1073632261; +inp[27219] = 0; +inp[27220] = 1073631237; +inp[27221] = 0; +inp[27222] = 1073630213; +inp[27223] = 0; +inp[27224] = 1073629189; +inp[27225] = 0; +inp[27226] = 1073628166; +inp[27227] = 0; +inp[27228] = 1073627142; +inp[27229] = 0; +inp[27230] = 1073626118; +inp[27231] = 0; +inp[27232] = 1073625094; +inp[27233] = 0; +inp[27234] = 1073624070; +inp[27235] = 0; +inp[27236] = 1073623046; +inp[27237] = 0; +inp[27238] = 1073622022; +inp[27239] = 0; +inp[27240] = 1073620998; +inp[27241] = 0; +inp[27242] = 1073619974; +inp[27243] = 0; +inp[27244] = 1073618951; +inp[27245] = 0; +inp[27246] = 1073617927; +inp[27247] = 0; +inp[27248] = 1073616903; +inp[27249] = 0; +inp[27250] = 1073615879; +inp[27251] = 0; +inp[27252] = 1073614855; +inp[27253] = 0; +inp[27254] = 1073613831; +inp[27255] = 0; +inp[27256] = 1073612807; +inp[27257] = 0; +inp[27258] = 1073611783; +inp[27259] = 0; +inp[27260] = 1073610759; +inp[27261] = 0; +inp[27262] = 1073609736; +inp[27263] = 0; +inp[27264] = 1073608712; +inp[27265] = 0; +inp[27266] = 1073607688; +inp[27267] = 0; +inp[27268] = 1073606664; +inp[27269] = 0; +inp[27270] = 1073605640; +inp[27271] = 0; +inp[27272] = 1073604616; +inp[27273] = 0; +inp[27274] = 1073603592; +inp[27275] = 0; +inp[27276] = 1073602569; +inp[27277] = 0; +inp[27278] = 1073601545; +inp[27279] = 0; +inp[27280] = 1073600521; +inp[27281] = 0; +inp[27282] = 1073599497; +inp[27283] = 0; +inp[27284] = 1073598473; +inp[27285] = 0; +inp[27286] = 1073597449; +inp[27287] = 0; +inp[27288] = 1073596425; +inp[27289] = 0; +inp[27290] = 1073595401; +inp[27291] = 0; +inp[27292] = 1073594378; +inp[27293] = 0; +inp[27294] = 1073593354; +inp[27295] = 0; +inp[27296] = 1073592330; +inp[27297] = 0; +inp[27298] = 1073591306; +inp[27299] = 0; +inp[27300] = 1073590282; +inp[27301] = 0; +inp[27302] = 1073589258; +inp[27303] = 0; +inp[27304] = 1073588234; +inp[27305] = 0; +inp[27306] = 1073587211; +inp[27307] = 0; +inp[27308] = 1073586187; +inp[27309] = 0; +inp[27310] = 1073585163; +inp[27311] = 0; +inp[27312] = 1073584139; +inp[27313] = 0; +inp[27314] = 1073583115; +inp[27315] = 0; +inp[27316] = 1073582091; +inp[27317] = 0; +inp[27318] = 1073581068; +inp[27319] = 0; +inp[27320] = 1073580044; +inp[27321] = 0; +inp[27322] = 1073579020; +inp[27323] = 0; +inp[27324] = 1073577996; +inp[27325] = 0; +inp[27326] = 1073576972; +inp[27327] = 0; +inp[27328] = 1073575948; +inp[27329] = 0; +inp[27330] = 1073574924; +inp[27331] = 0; +inp[27332] = 1073573901; +inp[27333] = 0; +inp[27334] = 1073572877; +inp[27335] = 0; +inp[27336] = 1073571853; +inp[27337] = 0; +inp[27338] = 1073570829; +inp[27339] = 0; +inp[27340] = 1073569805; +inp[27341] = 0; +inp[27342] = 1073568781; +inp[27343] = 0; +inp[27344] = 1073567758; +inp[27345] = 0; +inp[27346] = 1073566734; +inp[27347] = 0; +inp[27348] = 1073565710; +inp[27349] = 0; +inp[27350] = 1073564686; +inp[27351] = 0; +inp[27352] = 1073563662; +inp[27353] = 0; +inp[27354] = 1073562638; +inp[27355] = 0; +inp[27356] = 1073561615; +inp[27357] = 0; +inp[27358] = 1073560591; +inp[27359] = 0; +inp[27360] = 1073559567; +inp[27361] = 0; +inp[27362] = 1073558543; +inp[27363] = 0; +inp[27364] = 1073557519; +inp[27365] = 0; +inp[27366] = 1073556495; +inp[27367] = 0; +inp[27368] = 1073555472; +inp[27369] = 0; +inp[27370] = 1073554448; +inp[27371] = 0; +inp[27372] = 1073553424; +inp[27373] = 0; +inp[27374] = 1073552400; +inp[27375] = 0; +inp[27376] = 1073551376; +inp[27377] = 0; +inp[27378] = 1073550353; +inp[27379] = 0; +inp[27380] = 1073549329; +inp[27381] = 0; +inp[27382] = 1073548305; +inp[27383] = 0; +inp[27384] = 1073547281; +inp[27385] = 0; +inp[27386] = 1073546257; +inp[27387] = 0; +inp[27388] = 1073545233; +inp[27389] = 0; +inp[27390] = 1073544210; +inp[27391] = 0; +inp[27392] = 1073543186; +inp[27393] = 0; +inp[27394] = 1073542162; +inp[27395] = 0; +inp[27396] = 1073541138; +inp[27397] = 0; +inp[27398] = 1073540114; +inp[27399] = 0; +inp[27400] = 1073539091; +inp[27401] = 0; +inp[27402] = 1073538067; +inp[27403] = 0; +inp[27404] = 1073537043; +inp[27405] = 0; +inp[27406] = 1073536019; +inp[27407] = 0; +inp[27408] = 1073534995; +inp[27409] = 0; +inp[27410] = 1073533972; +inp[27411] = 0; +inp[27412] = 1073532948; +inp[27413] = 0; +inp[27414] = 1073531924; +inp[27415] = 0; +inp[27416] = 1073530900; +inp[27417] = 0; +inp[27418] = 1073529876; +inp[27419] = 0; +inp[27420] = 1073528853; +inp[27421] = 0; +inp[27422] = 1073527829; +inp[27423] = 0; +inp[27424] = 1073526805; +inp[27425] = 0; +inp[27426] = 1073525781; +inp[27427] = 0; +inp[27428] = 1073524757; +inp[27429] = 0; +inp[27430] = 1073523734; +inp[27431] = 0; +inp[27432] = 1073522710; +inp[27433] = 0; +inp[27434] = 1073521686; +inp[27435] = 0; +inp[27436] = 1073520662; +inp[27437] = 0; +inp[27438] = 1073519638; +inp[27439] = 0; +inp[27440] = 1073518615; +inp[27441] = 0; +inp[27442] = 1073517591; +inp[27443] = 0; +inp[27444] = 1073516567; +inp[27445] = 0; +inp[27446] = 1073515543; +inp[27447] = 0; +inp[27448] = 1073514520; +inp[27449] = 0; +inp[27450] = 1073513496; +inp[27451] = 0; +inp[27452] = 1073512472; +inp[27453] = 0; +inp[27454] = 1073511448; +inp[27455] = 0; +inp[27456] = 1073510424; +inp[27457] = 0; +inp[27458] = 1073509401; +inp[27459] = 0; +inp[27460] = 1073508377; +inp[27461] = 0; +inp[27462] = 1073507353; +inp[27463] = 0; +inp[27464] = 1073506329; +inp[27465] = 0; +inp[27466] = 1073505306; +inp[27467] = 0; +inp[27468] = 1073504282; +inp[27469] = 0; +inp[27470] = 1073503258; +inp[27471] = 0; +inp[27472] = 1073502234; +inp[27473] = 0; +inp[27474] = 1073501210; +inp[27475] = 0; +inp[27476] = 1073500187; +inp[27477] = 0; +inp[27478] = 1073499163; +inp[27479] = 0; +inp[27480] = 1073498139; +inp[27481] = 0; +inp[27482] = 1073497115; +inp[27483] = 0; +inp[27484] = 1073496092; +inp[27485] = 0; +inp[27486] = 1073495068; +inp[27487] = 0; +inp[27488] = 1073494044; +inp[27489] = 0; +inp[27490] = 1073493020; +inp[27491] = 0; +inp[27492] = 1073491997; +inp[27493] = 0; +inp[27494] = 1073490973; +inp[27495] = 0; +inp[27496] = 1073489949; +inp[27497] = 0; +inp[27498] = 1073488925; +inp[27499] = 0; +inp[27500] = 1073487902; +inp[27501] = 0; +inp[27502] = 1073486878; +inp[27503] = 0; +inp[27504] = 1073485854; +inp[27505] = 0; +inp[27506] = 1073484830; +inp[27507] = 0; +inp[27508] = 1073483807; +inp[27509] = 0; +inp[27510] = 1073482783; +inp[27511] = 0; +inp[27512] = 1073481759; +inp[27513] = 0; +inp[27514] = 1073480735; +inp[27515] = 0; +inp[27516] = 1073741824; +inp[27517] = 1073741824; +inp[27518] = 1073741312; +inp[27519] = 0; +inp[27520] = 1073740800; +inp[27521] = 0; +inp[27522] = 1073740288; +inp[27523] = 0; +inp[27524] = 1073739776; +inp[27525] = 0; +inp[27526] = 1073739264; +inp[27527] = 0; +inp[27528] = 1073738752; +inp[27529] = 0; +inp[27530] = 1073738240; +inp[27531] = 0; +inp[27532] = 1073737728; +inp[27533] = 0; +inp[27534] = 1073737216; +inp[27535] = 0; +inp[27536] = 1073736704; +inp[27537] = 0; +inp[27538] = 1073736192; +inp[27539] = 0; +inp[27540] = 1073735680; +inp[27541] = 0; +inp[27542] = 1073735168; +inp[27543] = 0; +inp[27544] = 1073734656; +inp[27545] = 0; +inp[27546] = 1073734144; +inp[27547] = 0; +inp[27548] = 1073733632; +inp[27549] = 0; +inp[27550] = 1073733120; +inp[27551] = 0; +inp[27552] = 1073732608; +inp[27553] = 0; +inp[27554] = 1073732096; +inp[27555] = 0; +inp[27556] = 1073731584; +inp[27557] = 0; +inp[27558] = 1073731072; +inp[27559] = 0; +inp[27560] = 1073730560; +inp[27561] = 0; +inp[27562] = 1073730048; +inp[27563] = 0; +inp[27564] = 1073729536; +inp[27565] = 0; +inp[27566] = 1073729024; +inp[27567] = 0; +inp[27568] = 1073728512; +inp[27569] = 0; +inp[27570] = 1073728000; +inp[27571] = 0; +inp[27572] = 1073727488; +inp[27573] = 0; +inp[27574] = 1073726976; +inp[27575] = 0; +inp[27576] = 1073726464; +inp[27577] = 0; +inp[27578] = 1073725952; +inp[27579] = 0; +inp[27580] = 1073725440; +inp[27581] = 0; +inp[27582] = 1073724928; +inp[27583] = 0; +inp[27584] = 1073724416; +inp[27585] = 0; +inp[27586] = 1073723904; +inp[27587] = 0; +inp[27588] = 1073723392; +inp[27589] = 0; +inp[27590] = 1073722880; +inp[27591] = 0; +inp[27592] = 1073722368; +inp[27593] = 0; +inp[27594] = 1073721856; +inp[27595] = 0; +inp[27596] = 1073721344; +inp[27597] = 0; +inp[27598] = 1073720832; +inp[27599] = 0; +inp[27600] = 1073720320; +inp[27601] = 0; +inp[27602] = 1073719808; +inp[27603] = 0; +inp[27604] = 1073719296; +inp[27605] = 0; +inp[27606] = 1073718784; +inp[27607] = 0; +inp[27608] = 1073718272; +inp[27609] = 0; +inp[27610] = 1073717760; +inp[27611] = 0; +inp[27612] = 1073717248; +inp[27613] = 0; +inp[27614] = 1073716736; +inp[27615] = 0; +inp[27616] = 1073716224; +inp[27617] = 0; +inp[27618] = 1073715712; +inp[27619] = 0; +inp[27620] = 1073715200; +inp[27621] = 0; +inp[27622] = 1073714688; +inp[27623] = 0; +inp[27624] = 1073714176; +inp[27625] = 0; +inp[27626] = 1073713664; +inp[27627] = 0; +inp[27628] = 1073713152; +inp[27629] = 0; +inp[27630] = 1073712640; +inp[27631] = 0; +inp[27632] = 1073712128; +inp[27633] = 0; +inp[27634] = 1073711616; +inp[27635] = 0; +inp[27636] = 1073711104; +inp[27637] = 0; +inp[27638] = 1073710592; +inp[27639] = 0; +inp[27640] = 1073710080; +inp[27641] = 0; +inp[27642] = 1073709568; +inp[27643] = 0; +inp[27644] = 1073709056; +inp[27645] = 0; +inp[27646] = 1073708544; +inp[27647] = 0; +inp[27648] = 1073708032; +inp[27649] = 0; +inp[27650] = 1073707520; +inp[27651] = 0; +inp[27652] = 1073707008; +inp[27653] = 0; +inp[27654] = 1073706496; +inp[27655] = 0; +inp[27656] = 1073705984; +inp[27657] = 0; +inp[27658] = 1073705472; +inp[27659] = 0; +inp[27660] = 1073704960; +inp[27661] = 0; +inp[27662] = 1073704448; +inp[27663] = 0; +inp[27664] = 1073703936; +inp[27665] = 0; +inp[27666] = 1073703424; +inp[27667] = 0; +inp[27668] = 1073702912; +inp[27669] = 0; +inp[27670] = 1073702400; +inp[27671] = 0; +inp[27672] = 1073701888; +inp[27673] = 0; +inp[27674] = 1073701376; +inp[27675] = 0; +inp[27676] = 1073700864; +inp[27677] = 0; +inp[27678] = 1073700352; +inp[27679] = 0; +inp[27680] = 1073699840; +inp[27681] = 0; +inp[27682] = 1073699328; +inp[27683] = 0; +inp[27684] = 1073698816; +inp[27685] = 0; +inp[27686] = 1073698304; +inp[27687] = 0; +inp[27688] = 1073697792; +inp[27689] = 0; +inp[27690] = 1073697280; +inp[27691] = 0; +inp[27692] = 1073696768; +inp[27693] = 0; +inp[27694] = 1073696256; +inp[27695] = 0; +inp[27696] = 1073695744; +inp[27697] = 0; +inp[27698] = 1073695233; +inp[27699] = 0; +inp[27700] = 1073694721; +inp[27701] = 0; +inp[27702] = 1073694209; +inp[27703] = 0; +inp[27704] = 1073693697; +inp[27705] = 0; +inp[27706] = 1073693185; +inp[27707] = 0; +inp[27708] = 1073692673; +inp[27709] = 0; +inp[27710] = 1073692161; +inp[27711] = 0; +inp[27712] = 1073691649; +inp[27713] = 0; +inp[27714] = 1073691137; +inp[27715] = 0; +inp[27716] = 1073690625; +inp[27717] = 0; +inp[27718] = 1073690113; +inp[27719] = 0; +inp[27720] = 1073689601; +inp[27721] = 0; +inp[27722] = 1073689089; +inp[27723] = 0; +inp[27724] = 1073688577; +inp[27725] = 0; +inp[27726] = 1073688065; +inp[27727] = 0; +inp[27728] = 1073687553; +inp[27729] = 0; +inp[27730] = 1073687041; +inp[27731] = 0; +inp[27732] = 1073686529; +inp[27733] = 0; +inp[27734] = 1073686017; +inp[27735] = 0; +inp[27736] = 1073685505; +inp[27737] = 0; +inp[27738] = 1073684993; +inp[27739] = 0; +inp[27740] = 1073684481; +inp[27741] = 0; +inp[27742] = 1073683969; +inp[27743] = 0; +inp[27744] = 1073683457; +inp[27745] = 0; +inp[27746] = 1073682945; +inp[27747] = 0; +inp[27748] = 1073682433; +inp[27749] = 0; +inp[27750] = 1073681921; +inp[27751] = 0; +inp[27752] = 1073681409; +inp[27753] = 0; +inp[27754] = 1073680897; +inp[27755] = 0; +inp[27756] = 1073680385; +inp[27757] = 0; +inp[27758] = 1073679873; +inp[27759] = 0; +inp[27760] = 1073679361; +inp[27761] = 0; +inp[27762] = 1073678849; +inp[27763] = 0; +inp[27764] = 1073678337; +inp[27765] = 0; +inp[27766] = 1073677825; +inp[27767] = 0; +inp[27768] = 1073677313; +inp[27769] = 0; +inp[27770] = 1073676801; +inp[27771] = 0; +inp[27772] = 1073676289; +inp[27773] = 0; +inp[27774] = 1073675778; +inp[27775] = 0; +inp[27776] = 1073675266; +inp[27777] = 0; +inp[27778] = 1073674754; +inp[27779] = 0; +inp[27780] = 1073674242; +inp[27781] = 0; +inp[27782] = 1073673730; +inp[27783] = 0; +inp[27784] = 1073673218; +inp[27785] = 0; +inp[27786] = 1073672706; +inp[27787] = 0; +inp[27788] = 1073672194; +inp[27789] = 0; +inp[27790] = 1073671682; +inp[27791] = 0; +inp[27792] = 1073671170; +inp[27793] = 0; +inp[27794] = 1073670658; +inp[27795] = 0; +inp[27796] = 1073670146; +inp[27797] = 0; +inp[27798] = 1073669634; +inp[27799] = 0; +inp[27800] = 1073669122; +inp[27801] = 0; +inp[27802] = 1073668610; +inp[27803] = 0; +inp[27804] = 1073668098; +inp[27805] = 0; +inp[27806] = 1073667586; +inp[27807] = 0; +inp[27808] = 1073667074; +inp[27809] = 0; +inp[27810] = 1073666562; +inp[27811] = 0; +inp[27812] = 1073666050; +inp[27813] = 0; +inp[27814] = 1073665538; +inp[27815] = 0; +inp[27816] = 1073665026; +inp[27817] = 0; +inp[27818] = 1073664514; +inp[27819] = 0; +inp[27820] = 1073664002; +inp[27821] = 0; +inp[27822] = 1073663490; +inp[27823] = 0; +inp[27824] = 1073662978; +inp[27825] = 0; +inp[27826] = 1073662466; +inp[27827] = 0; +inp[27828] = 1073661954; +inp[27829] = 0; +inp[27830] = 1073661443; +inp[27831] = 0; +inp[27832] = 1073660931; +inp[27833] = 0; +inp[27834] = 1073660419; +inp[27835] = 0; +inp[27836] = 1073659907; +inp[27837] = 0; +inp[27838] = 1073659395; +inp[27839] = 0; +inp[27840] = 1073658883; +inp[27841] = 0; +inp[27842] = 1073658371; +inp[27843] = 0; +inp[27844] = 1073657859; +inp[27845] = 0; +inp[27846] = 1073657347; +inp[27847] = 0; +inp[27848] = 1073656835; +inp[27849] = 0; +inp[27850] = 1073656323; +inp[27851] = 0; +inp[27852] = 1073655811; +inp[27853] = 0; +inp[27854] = 1073655299; +inp[27855] = 0; +inp[27856] = 1073654787; +inp[27857] = 0; +inp[27858] = 1073654275; +inp[27859] = 0; +inp[27860] = 1073653763; +inp[27861] = 0; +inp[27862] = 1073653251; +inp[27863] = 0; +inp[27864] = 1073652739; +inp[27865] = 0; +inp[27866] = 1073652227; +inp[27867] = 0; +inp[27868] = 1073651715; +inp[27869] = 0; +inp[27870] = 1073651203; +inp[27871] = 0; +inp[27872] = 1073650691; +inp[27873] = 0; +inp[27874] = 1073650179; +inp[27875] = 0; +inp[27876] = 1073649667; +inp[27877] = 0; +inp[27878] = 1073649155; +inp[27879] = 0; +inp[27880] = 1073648644; +inp[27881] = 0; +inp[27882] = 1073648132; +inp[27883] = 0; +inp[27884] = 1073647620; +inp[27885] = 0; +inp[27886] = 1073647108; +inp[27887] = 0; +inp[27888] = 1073646596; +inp[27889] = 0; +inp[27890] = 1073646084; +inp[27891] = 0; +inp[27892] = 1073645572; +inp[27893] = 0; +inp[27894] = 1073645060; +inp[27895] = 0; +inp[27896] = 1073644548; +inp[27897] = 0; +inp[27898] = 1073644036; +inp[27899] = 0; +inp[27900] = 1073643524; +inp[27901] = 0; +inp[27902] = 1073643012; +inp[27903] = 0; +inp[27904] = 1073642500; +inp[27905] = 0; +inp[27906] = 1073641988; +inp[27907] = 0; +inp[27908] = 1073641476; +inp[27909] = 0; +inp[27910] = 1073640964; +inp[27911] = 0; +inp[27912] = 1073640452; +inp[27913] = 0; +inp[27914] = 1073639940; +inp[27915] = 0; +inp[27916] = 1073639428; +inp[27917] = 0; +inp[27918] = 1073638916; +inp[27919] = 0; +inp[27920] = 1073638404; +inp[27921] = 0; +inp[27922] = 1073637893; +inp[27923] = 0; +inp[27924] = 1073637381; +inp[27925] = 0; +inp[27926] = 1073636869; +inp[27927] = 0; +inp[27928] = 1073636357; +inp[27929] = 0; +inp[27930] = 1073635845; +inp[27931] = 0; +inp[27932] = 1073635333; +inp[27933] = 0; +inp[27934] = 1073634821; +inp[27935] = 0; +inp[27936] = 1073634309; +inp[27937] = 0; +inp[27938] = 1073633797; +inp[27939] = 0; +inp[27940] = 1073633285; +inp[27941] = 0; +inp[27942] = 1073632773; +inp[27943] = 0; +inp[27944] = 1073632261; +inp[27945] = 0; +inp[27946] = 1073631749; +inp[27947] = 0; +inp[27948] = 1073631237; +inp[27949] = 0; +inp[27950] = 1073630725; +inp[27951] = 0; +inp[27952] = 1073630213; +inp[27953] = 0; +inp[27954] = 1073629701; +inp[27955] = 0; +inp[27956] = 1073629189; +inp[27957] = 0; +inp[27958] = 1073628677; +inp[27959] = 0; +inp[27960] = 1073628166; +inp[27961] = 0; +inp[27962] = 1073627654; +inp[27963] = 0; +inp[27964] = 1073627142; +inp[27965] = 0; +inp[27966] = 1073626630; +inp[27967] = 0; +inp[27968] = 1073626118; +inp[27969] = 0; +inp[27970] = 1073625606; +inp[27971] = 0; +inp[27972] = 1073625094; +inp[27973] = 0; +inp[27974] = 1073624582; +inp[27975] = 0; +inp[27976] = 1073624070; +inp[27977] = 0; +inp[27978] = 1073623558; +inp[27979] = 0; +inp[27980] = 1073623046; +inp[27981] = 0; +inp[27982] = 1073622534; +inp[27983] = 0; +inp[27984] = 1073622022; +inp[27985] = 0; +inp[27986] = 1073621510; +inp[27987] = 0; +inp[27988] = 1073620998; +inp[27989] = 0; +inp[27990] = 1073620486; +inp[27991] = 0; +inp[27992] = 1073619974; +inp[27993] = 0; +inp[27994] = 1073619462; +inp[27995] = 0; +inp[27996] = 1073618951; +inp[27997] = 0; +inp[27998] = 1073618439; +inp[27999] = 0; +inp[28000] = 1073617927; +inp[28001] = 0; +inp[28002] = 1073617415; +inp[28003] = 0; +inp[28004] = 1073616903; +inp[28005] = 0; +inp[28006] = 1073616391; +inp[28007] = 0; +inp[28008] = 1073615879; +inp[28009] = 0; +inp[28010] = 1073615367; +inp[28011] = 0; +inp[28012] = 1073614855; +inp[28013] = 0; +inp[28014] = 1073614343; +inp[28015] = 0; +inp[28016] = 1073613831; +inp[28017] = 0; +inp[28018] = 1073613319; +inp[28019] = 0; +inp[28020] = 1073612807; +inp[28021] = 0; +inp[28022] = 1073612295; +inp[28023] = 0; +inp[28024] = 1073611783; +inp[28025] = 0; +inp[28026] = 1073611271; +inp[28027] = 0; +inp[28028] = 1073741824; +inp[28029] = 1073741824; +inp[28030] = 1073741568; +inp[28031] = 0; +inp[28032] = 1073741312; +inp[28033] = 0; +inp[28034] = 1073741056; +inp[28035] = 0; +inp[28036] = 1073740800; +inp[28037] = 0; +inp[28038] = 1073740544; +inp[28039] = 0; +inp[28040] = 1073740288; +inp[28041] = 0; +inp[28042] = 1073740032; +inp[28043] = 0; +inp[28044] = 1073739776; +inp[28045] = 0; +inp[28046] = 1073739520; +inp[28047] = 0; +inp[28048] = 1073739264; +inp[28049] = 0; +inp[28050] = 1073739008; +inp[28051] = 0; +inp[28052] = 1073738752; +inp[28053] = 0; +inp[28054] = 1073738496; +inp[28055] = 0; +inp[28056] = 1073738240; +inp[28057] = 0; +inp[28058] = 1073737984; +inp[28059] = 0; +inp[28060] = 1073737728; +inp[28061] = 0; +inp[28062] = 1073737472; +inp[28063] = 0; +inp[28064] = 1073737216; +inp[28065] = 0; +inp[28066] = 1073736960; +inp[28067] = 0; +inp[28068] = 1073736704; +inp[28069] = 0; +inp[28070] = 1073736448; +inp[28071] = 0; +inp[28072] = 1073736192; +inp[28073] = 0; +inp[28074] = 1073735936; +inp[28075] = 0; +inp[28076] = 1073735680; +inp[28077] = 0; +inp[28078] = 1073735424; +inp[28079] = 0; +inp[28080] = 1073735168; +inp[28081] = 0; +inp[28082] = 1073734912; +inp[28083] = 0; +inp[28084] = 1073734656; +inp[28085] = 0; +inp[28086] = 1073734400; +inp[28087] = 0; +inp[28088] = 1073734144; +inp[28089] = 0; +inp[28090] = 1073733888; +inp[28091] = 0; +inp[28092] = 1073733632; +inp[28093] = 0; +inp[28094] = 1073733376; +inp[28095] = 0; +inp[28096] = 1073733120; +inp[28097] = 0; +inp[28098] = 1073732864; +inp[28099] = 0; +inp[28100] = 1073732608; +inp[28101] = 0; +inp[28102] = 1073732352; +inp[28103] = 0; +inp[28104] = 1073732096; +inp[28105] = 0; +inp[28106] = 1073731840; +inp[28107] = 0; +inp[28108] = 1073731584; +inp[28109] = 0; +inp[28110] = 1073731328; +inp[28111] = 0; +inp[28112] = 1073731072; +inp[28113] = 0; +inp[28114] = 1073730816; +inp[28115] = 0; +inp[28116] = 1073730560; +inp[28117] = 0; +inp[28118] = 1073730304; +inp[28119] = 0; +inp[28120] = 1073730048; +inp[28121] = 0; +inp[28122] = 1073729792; +inp[28123] = 0; +inp[28124] = 1073729536; +inp[28125] = 0; +inp[28126] = 1073729280; +inp[28127] = 0; +inp[28128] = 1073729024; +inp[28129] = 0; +inp[28130] = 1073728768; +inp[28131] = 0; +inp[28132] = 1073728512; +inp[28133] = 0; +inp[28134] = 1073728256; +inp[28135] = 0; +inp[28136] = 1073728000; +inp[28137] = 0; +inp[28138] = 1073727744; +inp[28139] = 0; +inp[28140] = 1073727488; +inp[28141] = 0; +inp[28142] = 1073727232; +inp[28143] = 0; +inp[28144] = 1073726976; +inp[28145] = 0; +inp[28146] = 1073726720; +inp[28147] = 0; +inp[28148] = 1073726464; +inp[28149] = 0; +inp[28150] = 1073726208; +inp[28151] = 0; +inp[28152] = 1073725952; +inp[28153] = 0; +inp[28154] = 1073725696; +inp[28155] = 0; +inp[28156] = 1073725440; +inp[28157] = 0; +inp[28158] = 1073725184; +inp[28159] = 0; +inp[28160] = 1073724928; +inp[28161] = 0; +inp[28162] = 1073724672; +inp[28163] = 0; +inp[28164] = 1073724416; +inp[28165] = 0; +inp[28166] = 1073724160; +inp[28167] = 0; +inp[28168] = 1073723904; +inp[28169] = 0; +inp[28170] = 1073723648; +inp[28171] = 0; +inp[28172] = 1073723392; +inp[28173] = 0; +inp[28174] = 1073723136; +inp[28175] = 0; +inp[28176] = 1073722880; +inp[28177] = 0; +inp[28178] = 1073722624; +inp[28179] = 0; +inp[28180] = 1073722368; +inp[28181] = 0; +inp[28182] = 1073722112; +inp[28183] = 0; +inp[28184] = 1073721856; +inp[28185] = 0; +inp[28186] = 1073721600; +inp[28187] = 0; +inp[28188] = 1073721344; +inp[28189] = 0; +inp[28190] = 1073721088; +inp[28191] = 0; +inp[28192] = 1073720832; +inp[28193] = 0; +inp[28194] = 1073720576; +inp[28195] = 0; +inp[28196] = 1073720320; +inp[28197] = 0; +inp[28198] = 1073720064; +inp[28199] = 0; +inp[28200] = 1073719808; +inp[28201] = 0; +inp[28202] = 1073719552; +inp[28203] = 0; +inp[28204] = 1073719296; +inp[28205] = 0; +inp[28206] = 1073719040; +inp[28207] = 0; +inp[28208] = 1073718784; +inp[28209] = 0; +inp[28210] = 1073718528; +inp[28211] = 0; +inp[28212] = 1073718272; +inp[28213] = 0; +inp[28214] = 1073718016; +inp[28215] = 0; +inp[28216] = 1073717760; +inp[28217] = 0; +inp[28218] = 1073717504; +inp[28219] = 0; +inp[28220] = 1073717248; +inp[28221] = 0; +inp[28222] = 1073716992; +inp[28223] = 0; +inp[28224] = 1073716736; +inp[28225] = 0; +inp[28226] = 1073716480; +inp[28227] = 0; +inp[28228] = 1073716224; +inp[28229] = 0; +inp[28230] = 1073715968; +inp[28231] = 0; +inp[28232] = 1073715712; +inp[28233] = 0; +inp[28234] = 1073715456; +inp[28235] = 0; +inp[28236] = 1073715200; +inp[28237] = 0; +inp[28238] = 1073714944; +inp[28239] = 0; +inp[28240] = 1073714688; +inp[28241] = 0; +inp[28242] = 1073714432; +inp[28243] = 0; +inp[28244] = 1073714176; +inp[28245] = 0; +inp[28246] = 1073713920; +inp[28247] = 0; +inp[28248] = 1073713664; +inp[28249] = 0; +inp[28250] = 1073713408; +inp[28251] = 0; +inp[28252] = 1073713152; +inp[28253] = 0; +inp[28254] = 1073712896; +inp[28255] = 0; +inp[28256] = 1073712640; +inp[28257] = 0; +inp[28258] = 1073712384; +inp[28259] = 0; +inp[28260] = 1073712128; +inp[28261] = 0; +inp[28262] = 1073711872; +inp[28263] = 0; +inp[28264] = 1073711616; +inp[28265] = 0; +inp[28266] = 1073711360; +inp[28267] = 0; +inp[28268] = 1073711104; +inp[28269] = 0; +inp[28270] = 1073710848; +inp[28271] = 0; +inp[28272] = 1073710592; +inp[28273] = 0; +inp[28274] = 1073710336; +inp[28275] = 0; +inp[28276] = 1073710080; +inp[28277] = 0; +inp[28278] = 1073709824; +inp[28279] = 0; +inp[28280] = 1073709568; +inp[28281] = 0; +inp[28282] = 1073709312; +inp[28283] = 0; +inp[28284] = 1073709056; +inp[28285] = 0; +inp[28286] = 1073708800; +inp[28287] = 0; +inp[28288] = 1073708544; +inp[28289] = 0; +inp[28290] = 1073708288; +inp[28291] = 0; +inp[28292] = 1073708032; +inp[28293] = 0; +inp[28294] = 1073707776; +inp[28295] = 0; +inp[28296] = 1073707520; +inp[28297] = 0; +inp[28298] = 1073707264; +inp[28299] = 0; +inp[28300] = 1073707008; +inp[28301] = 0; +inp[28302] = 1073706752; +inp[28303] = 0; +inp[28304] = 1073706496; +inp[28305] = 0; +inp[28306] = 1073706240; +inp[28307] = 0; +inp[28308] = 1073705984; +inp[28309] = 0; +inp[28310] = 1073705728; +inp[28311] = 0; +inp[28312] = 1073705472; +inp[28313] = 0; +inp[28314] = 1073705216; +inp[28315] = 0; +inp[28316] = 1073704960; +inp[28317] = 0; +inp[28318] = 1073704704; +inp[28319] = 0; +inp[28320] = 1073704448; +inp[28321] = 0; +inp[28322] = 1073704192; +inp[28323] = 0; +inp[28324] = 1073703936; +inp[28325] = 0; +inp[28326] = 1073703680; +inp[28327] = 0; +inp[28328] = 1073703424; +inp[28329] = 0; +inp[28330] = 1073703168; +inp[28331] = 0; +inp[28332] = 1073702912; +inp[28333] = 0; +inp[28334] = 1073702656; +inp[28335] = 0; +inp[28336] = 1073702400; +inp[28337] = 0; +inp[28338] = 1073702144; +inp[28339] = 0; +inp[28340] = 1073701888; +inp[28341] = 0; +inp[28342] = 1073701632; +inp[28343] = 0; +inp[28344] = 1073701376; +inp[28345] = 0; +inp[28346] = 1073701120; +inp[28347] = 0; +inp[28348] = 1073700864; +inp[28349] = 0; +inp[28350] = 1073700608; +inp[28351] = 0; +inp[28352] = 1073700352; +inp[28353] = 0; +inp[28354] = 1073700096; +inp[28355] = 0; +inp[28356] = 1073699840; +inp[28357] = 0; +inp[28358] = 1073699584; +inp[28359] = 0; +inp[28360] = 1073699328; +inp[28361] = 0; +inp[28362] = 1073699072; +inp[28363] = 0; +inp[28364] = 1073698816; +inp[28365] = 0; +inp[28366] = 1073698560; +inp[28367] = 0; +inp[28368] = 1073698304; +inp[28369] = 0; +inp[28370] = 1073698048; +inp[28371] = 0; +inp[28372] = 1073697792; +inp[28373] = 0; +inp[28374] = 1073697536; +inp[28375] = 0; +inp[28376] = 1073697280; +inp[28377] = 0; +inp[28378] = 1073697024; +inp[28379] = 0; +inp[28380] = 1073696768; +inp[28381] = 0; +inp[28382] = 1073696512; +inp[28383] = 0; +inp[28384] = 1073696256; +inp[28385] = 0; +inp[28386] = 1073696000; +inp[28387] = 0; +inp[28388] = 1073695744; +inp[28389] = 0; +inp[28390] = 1073695488; +inp[28391] = 0; +inp[28392] = 1073695233; +inp[28393] = 0; +inp[28394] = 1073694977; +inp[28395] = 0; +inp[28396] = 1073694721; +inp[28397] = 0; +inp[28398] = 1073694465; +inp[28399] = 0; +inp[28400] = 1073694209; +inp[28401] = 0; +inp[28402] = 1073693953; +inp[28403] = 0; +inp[28404] = 1073693697; +inp[28405] = 0; +inp[28406] = 1073693441; +inp[28407] = 0; +inp[28408] = 1073693185; +inp[28409] = 0; +inp[28410] = 1073692929; +inp[28411] = 0; +inp[28412] = 1073692673; +inp[28413] = 0; +inp[28414] = 1073692417; +inp[28415] = 0; +inp[28416] = 1073692161; +inp[28417] = 0; +inp[28418] = 1073691905; +inp[28419] = 0; +inp[28420] = 1073691649; +inp[28421] = 0; +inp[28422] = 1073691393; +inp[28423] = 0; +inp[28424] = 1073691137; +inp[28425] = 0; +inp[28426] = 1073690881; +inp[28427] = 0; +inp[28428] = 1073690625; +inp[28429] = 0; +inp[28430] = 1073690369; +inp[28431] = 0; +inp[28432] = 1073690113; +inp[28433] = 0; +inp[28434] = 1073689857; +inp[28435] = 0; +inp[28436] = 1073689601; +inp[28437] = 0; +inp[28438] = 1073689345; +inp[28439] = 0; +inp[28440] = 1073689089; +inp[28441] = 0; +inp[28442] = 1073688833; +inp[28443] = 0; +inp[28444] = 1073688577; +inp[28445] = 0; +inp[28446] = 1073688321; +inp[28447] = 0; +inp[28448] = 1073688065; +inp[28449] = 0; +inp[28450] = 1073687809; +inp[28451] = 0; +inp[28452] = 1073687553; +inp[28453] = 0; +inp[28454] = 1073687297; +inp[28455] = 0; +inp[28456] = 1073687041; +inp[28457] = 0; +inp[28458] = 1073686785; +inp[28459] = 0; +inp[28460] = 1073686529; +inp[28461] = 0; +inp[28462] = 1073686273; +inp[28463] = 0; +inp[28464] = 1073686017; +inp[28465] = 0; +inp[28466] = 1073685761; +inp[28467] = 0; +inp[28468] = 1073685505; +inp[28469] = 0; +inp[28470] = 1073685249; +inp[28471] = 0; +inp[28472] = 1073684993; +inp[28473] = 0; +inp[28474] = 1073684737; +inp[28475] = 0; +inp[28476] = 1073684481; +inp[28477] = 0; +inp[28478] = 1073684225; +inp[28479] = 0; +inp[28480] = 1073683969; +inp[28481] = 0; +inp[28482] = 1073683713; +inp[28483] = 0; +inp[28484] = 1073683457; +inp[28485] = 0; +inp[28486] = 1073683201; +inp[28487] = 0; +inp[28488] = 1073682945; +inp[28489] = 0; +inp[28490] = 1073682689; +inp[28491] = 0; +inp[28492] = 1073682433; +inp[28493] = 0; +inp[28494] = 1073682177; +inp[28495] = 0; +inp[28496] = 1073681921; +inp[28497] = 0; +inp[28498] = 1073681665; +inp[28499] = 0; +inp[28500] = 1073681409; +inp[28501] = 0; +inp[28502] = 1073681153; +inp[28503] = 0; +inp[28504] = 1073680897; +inp[28505] = 0; +inp[28506] = 1073680641; +inp[28507] = 0; +inp[28508] = 1073680385; +inp[28509] = 0; +inp[28510] = 1073680129; +inp[28511] = 0; +inp[28512] = 1073679873; +inp[28513] = 0; +inp[28514] = 1073679617; +inp[28515] = 0; +inp[28516] = 1073679361; +inp[28517] = 0; +inp[28518] = 1073679105; +inp[28519] = 0; +inp[28520] = 1073678849; +inp[28521] = 0; +inp[28522] = 1073678593; +inp[28523] = 0; +inp[28524] = 1073678337; +inp[28525] = 0; +inp[28526] = 1073678081; +inp[28527] = 0; +inp[28528] = 1073677825; +inp[28529] = 0; +inp[28530] = 1073677569; +inp[28531] = 0; +inp[28532] = 1073677313; +inp[28533] = 0; +inp[28534] = 1073677057; +inp[28535] = 0; +inp[28536] = 1073676801; +inp[28537] = 0; +inp[28538] = 1073676545; +inp[28539] = 0; +inp[28540] = 1073741824; +inp[28541] = 1073741824; +inp[28542] = 1073741696; +inp[28543] = 0; +inp[28544] = 1073741568; +inp[28545] = 0; +inp[28546] = 1073741440; +inp[28547] = 0; +inp[28548] = 1073741312; +inp[28549] = 0; +inp[28550] = 1073741184; +inp[28551] = 0; +inp[28552] = 1073741056; +inp[28553] = 0; +inp[28554] = 1073740928; +inp[28555] = 0; +inp[28556] = 1073740800; +inp[28557] = 0; +inp[28558] = 1073740672; +inp[28559] = 0; +inp[28560] = 1073740544; +inp[28561] = 0; +inp[28562] = 1073740416; +inp[28563] = 0; +inp[28564] = 1073740288; +inp[28565] = 0; +inp[28566] = 1073740160; +inp[28567] = 0; +inp[28568] = 1073740032; +inp[28569] = 0; +inp[28570] = 1073739904; +inp[28571] = 0; +inp[28572] = 1073739776; +inp[28573] = 0; +inp[28574] = 1073739648; +inp[28575] = 0; +inp[28576] = 1073739520; +inp[28577] = 0; +inp[28578] = 1073739392; +inp[28579] = 0; +inp[28580] = 1073739264; +inp[28581] = 0; +inp[28582] = 1073739136; +inp[28583] = 0; +inp[28584] = 1073739008; +inp[28585] = 0; +inp[28586] = 1073738880; +inp[28587] = 0; +inp[28588] = 1073738752; +inp[28589] = 0; +inp[28590] = 1073738624; +inp[28591] = 0; +inp[28592] = 1073738496; +inp[28593] = 0; +inp[28594] = 1073738368; +inp[28595] = 0; +inp[28596] = 1073738240; +inp[28597] = 0; +inp[28598] = 1073738112; +inp[28599] = 0; +inp[28600] = 1073737984; +inp[28601] = 0; +inp[28602] = 1073737856; +inp[28603] = 0; +inp[28604] = 1073737728; +inp[28605] = 0; +inp[28606] = 1073737600; +inp[28607] = 0; +inp[28608] = 1073737472; +inp[28609] = 0; +inp[28610] = 1073737344; +inp[28611] = 0; +inp[28612] = 1073737216; +inp[28613] = 0; +inp[28614] = 1073737088; +inp[28615] = 0; +inp[28616] = 1073736960; +inp[28617] = 0; +inp[28618] = 1073736832; +inp[28619] = 0; +inp[28620] = 1073736704; +inp[28621] = 0; +inp[28622] = 1073736576; +inp[28623] = 0; +inp[28624] = 1073736448; +inp[28625] = 0; +inp[28626] = 1073736320; +inp[28627] = 0; +inp[28628] = 1073736192; +inp[28629] = 0; +inp[28630] = 1073736064; +inp[28631] = 0; +inp[28632] = 1073735936; +inp[28633] = 0; +inp[28634] = 1073735808; +inp[28635] = 0; +inp[28636] = 1073735680; +inp[28637] = 0; +inp[28638] = 1073735552; +inp[28639] = 0; +inp[28640] = 1073735424; +inp[28641] = 0; +inp[28642] = 1073735296; +inp[28643] = 0; +inp[28644] = 1073735168; +inp[28645] = 0; +inp[28646] = 1073735040; +inp[28647] = 0; +inp[28648] = 1073734912; +inp[28649] = 0; +inp[28650] = 1073734784; +inp[28651] = 0; +inp[28652] = 1073734656; +inp[28653] = 0; +inp[28654] = 1073734528; +inp[28655] = 0; +inp[28656] = 1073734400; +inp[28657] = 0; +inp[28658] = 1073734272; +inp[28659] = 0; +inp[28660] = 1073734144; +inp[28661] = 0; +inp[28662] = 1073734016; +inp[28663] = 0; +inp[28664] = 1073733888; +inp[28665] = 0; +inp[28666] = 1073733760; +inp[28667] = 0; +inp[28668] = 1073733632; +inp[28669] = 0; +inp[28670] = 1073733504; +inp[28671] = 0; +inp[28672] = 1073733376; +inp[28673] = 0; +inp[28674] = 1073733248; +inp[28675] = 0; +inp[28676] = 1073733120; +inp[28677] = 0; +inp[28678] = 1073732992; +inp[28679] = 0; +inp[28680] = 1073732864; +inp[28681] = 0; +inp[28682] = 1073732736; +inp[28683] = 0; +inp[28684] = 1073732608; +inp[28685] = 0; +inp[28686] = 1073732480; +inp[28687] = 0; +inp[28688] = 1073732352; +inp[28689] = 0; +inp[28690] = 1073732224; +inp[28691] = 0; +inp[28692] = 1073732096; +inp[28693] = 0; +inp[28694] = 1073731968; +inp[28695] = 0; +inp[28696] = 1073731840; +inp[28697] = 0; +inp[28698] = 1073731712; +inp[28699] = 0; +inp[28700] = 1073731584; +inp[28701] = 0; +inp[28702] = 1073731456; +inp[28703] = 0; +inp[28704] = 1073731328; +inp[28705] = 0; +inp[28706] = 1073731200; +inp[28707] = 0; +inp[28708] = 1073731072; +inp[28709] = 0; +inp[28710] = 1073730944; +inp[28711] = 0; +inp[28712] = 1073730816; +inp[28713] = 0; +inp[28714] = 1073730688; +inp[28715] = 0; +inp[28716] = 1073730560; +inp[28717] = 0; +inp[28718] = 1073730432; +inp[28719] = 0; +inp[28720] = 1073730304; +inp[28721] = 0; +inp[28722] = 1073730176; +inp[28723] = 0; +inp[28724] = 1073730048; +inp[28725] = 0; +inp[28726] = 1073729920; +inp[28727] = 0; +inp[28728] = 1073729792; +inp[28729] = 0; +inp[28730] = 1073729664; +inp[28731] = 0; +inp[28732] = 1073729536; +inp[28733] = 0; +inp[28734] = 1073729408; +inp[28735] = 0; +inp[28736] = 1073729280; +inp[28737] = 0; +inp[28738] = 1073729152; +inp[28739] = 0; +inp[28740] = 1073729024; +inp[28741] = 0; +inp[28742] = 1073728896; +inp[28743] = 0; +inp[28744] = 1073728768; +inp[28745] = 0; +inp[28746] = 1073728640; +inp[28747] = 0; +inp[28748] = 1073728512; +inp[28749] = 0; +inp[28750] = 1073728384; +inp[28751] = 0; +inp[28752] = 1073728256; +inp[28753] = 0; +inp[28754] = 1073728128; +inp[28755] = 0; +inp[28756] = 1073728000; +inp[28757] = 0; +inp[28758] = 1073727872; +inp[28759] = 0; +inp[28760] = 1073727744; +inp[28761] = 0; +inp[28762] = 1073727616; +inp[28763] = 0; +inp[28764] = 1073727488; +inp[28765] = 0; +inp[28766] = 1073727360; +inp[28767] = 0; +inp[28768] = 1073727232; +inp[28769] = 0; +inp[28770] = 1073727104; +inp[28771] = 0; +inp[28772] = 1073726976; +inp[28773] = 0; +inp[28774] = 1073726848; +inp[28775] = 0; +inp[28776] = 1073726720; +inp[28777] = 0; +inp[28778] = 1073726592; +inp[28779] = 0; +inp[28780] = 1073726464; +inp[28781] = 0; +inp[28782] = 1073726336; +inp[28783] = 0; +inp[28784] = 1073726208; +inp[28785] = 0; +inp[28786] = 1073726080; +inp[28787] = 0; +inp[28788] = 1073725952; +inp[28789] = 0; +inp[28790] = 1073725824; +inp[28791] = 0; +inp[28792] = 1073725696; +inp[28793] = 0; +inp[28794] = 1073725568; +inp[28795] = 0; +inp[28796] = 1073725440; +inp[28797] = 0; +inp[28798] = 1073725312; +inp[28799] = 0; +inp[28800] = 1073725184; +inp[28801] = 0; +inp[28802] = 1073725056; +inp[28803] = 0; +inp[28804] = 1073724928; +inp[28805] = 0; +inp[28806] = 1073724800; +inp[28807] = 0; +inp[28808] = 1073724672; +inp[28809] = 0; +inp[28810] = 1073724544; +inp[28811] = 0; +inp[28812] = 1073724416; +inp[28813] = 0; +inp[28814] = 1073724288; +inp[28815] = 0; +inp[28816] = 1073724160; +inp[28817] = 0; +inp[28818] = 1073724032; +inp[28819] = 0; +inp[28820] = 1073723904; +inp[28821] = 0; +inp[28822] = 1073723776; +inp[28823] = 0; +inp[28824] = 1073723648; +inp[28825] = 0; +inp[28826] = 1073723520; +inp[28827] = 0; +inp[28828] = 1073723392; +inp[28829] = 0; +inp[28830] = 1073723264; +inp[28831] = 0; +inp[28832] = 1073723136; +inp[28833] = 0; +inp[28834] = 1073723008; +inp[28835] = 0; +inp[28836] = 1073722880; +inp[28837] = 0; +inp[28838] = 1073722752; +inp[28839] = 0; +inp[28840] = 1073722624; +inp[28841] = 0; +inp[28842] = 1073722496; +inp[28843] = 0; +inp[28844] = 1073722368; +inp[28845] = 0; +inp[28846] = 1073722240; +inp[28847] = 0; +inp[28848] = 1073722112; +inp[28849] = 0; +inp[28850] = 1073721984; +inp[28851] = 0; +inp[28852] = 1073721856; +inp[28853] = 0; +inp[28854] = 1073721728; +inp[28855] = 0; +inp[28856] = 1073721600; +inp[28857] = 0; +inp[28858] = 1073721472; +inp[28859] = 0; +inp[28860] = 1073721344; +inp[28861] = 0; +inp[28862] = 1073721216; +inp[28863] = 0; +inp[28864] = 1073721088; +inp[28865] = 0; +inp[28866] = 1073720960; +inp[28867] = 0; +inp[28868] = 1073720832; +inp[28869] = 0; +inp[28870] = 1073720704; +inp[28871] = 0; +inp[28872] = 1073720576; +inp[28873] = 0; +inp[28874] = 1073720448; +inp[28875] = 0; +inp[28876] = 1073720320; +inp[28877] = 0; +inp[28878] = 1073720192; +inp[28879] = 0; +inp[28880] = 1073720064; +inp[28881] = 0; +inp[28882] = 1073719936; +inp[28883] = 0; +inp[28884] = 1073719808; +inp[28885] = 0; +inp[28886] = 1073719680; +inp[28887] = 0; +inp[28888] = 1073719552; +inp[28889] = 0; +inp[28890] = 1073719424; +inp[28891] = 0; +inp[28892] = 1073719296; +inp[28893] = 0; +inp[28894] = 1073719168; +inp[28895] = 0; +inp[28896] = 1073719040; +inp[28897] = 0; +inp[28898] = 1073718912; +inp[28899] = 0; +inp[28900] = 1073718784; +inp[28901] = 0; +inp[28902] = 1073718656; +inp[28903] = 0; +inp[28904] = 1073718528; +inp[28905] = 0; +inp[28906] = 1073718400; +inp[28907] = 0; +inp[28908] = 1073718272; +inp[28909] = 0; +inp[28910] = 1073718144; +inp[28911] = 0; +inp[28912] = 1073718016; +inp[28913] = 0; +inp[28914] = 1073717888; +inp[28915] = 0; +inp[28916] = 1073717760; +inp[28917] = 0; +inp[28918] = 1073717632; +inp[28919] = 0; +inp[28920] = 1073717504; +inp[28921] = 0; +inp[28922] = 1073717376; +inp[28923] = 0; +inp[28924] = 1073717248; +inp[28925] = 0; +inp[28926] = 1073717120; +inp[28927] = 0; +inp[28928] = 1073716992; +inp[28929] = 0; +inp[28930] = 1073716864; +inp[28931] = 0; +inp[28932] = 1073716736; +inp[28933] = 0; +inp[28934] = 1073716608; +inp[28935] = 0; +inp[28936] = 1073716480; +inp[28937] = 0; +inp[28938] = 1073716352; +inp[28939] = 0; +inp[28940] = 1073716224; +inp[28941] = 0; +inp[28942] = 1073716096; +inp[28943] = 0; +inp[28944] = 1073715968; +inp[28945] = 0; +inp[28946] = 1073715840; +inp[28947] = 0; +inp[28948] = 1073715712; +inp[28949] = 0; +inp[28950] = 1073715584; +inp[28951] = 0; +inp[28952] = 1073715456; +inp[28953] = 0; +inp[28954] = 1073715328; +inp[28955] = 0; +inp[28956] = 1073715200; +inp[28957] = 0; +inp[28958] = 1073715072; +inp[28959] = 0; +inp[28960] = 1073714944; +inp[28961] = 0; +inp[28962] = 1073714816; +inp[28963] = 0; +inp[28964] = 1073714688; +inp[28965] = 0; +inp[28966] = 1073714560; +inp[28967] = 0; +inp[28968] = 1073714432; +inp[28969] = 0; +inp[28970] = 1073714304; +inp[28971] = 0; +inp[28972] = 1073714176; +inp[28973] = 0; +inp[28974] = 1073714048; +inp[28975] = 0; +inp[28976] = 1073713920; +inp[28977] = 0; +inp[28978] = 1073713792; +inp[28979] = 0; +inp[28980] = 1073713664; +inp[28981] = 0; +inp[28982] = 1073713536; +inp[28983] = 0; +inp[28984] = 1073713408; +inp[28985] = 0; +inp[28986] = 1073713280; +inp[28987] = 0; +inp[28988] = 1073713152; +inp[28989] = 0; +inp[28990] = 1073713024; +inp[28991] = 0; +inp[28992] = 1073712896; +inp[28993] = 0; +inp[28994] = 1073712768; +inp[28995] = 0; +inp[28996] = 1073712640; +inp[28997] = 0; +inp[28998] = 1073712512; +inp[28999] = 0; +inp[29000] = 1073712384; +inp[29001] = 0; +inp[29002] = 1073712256; +inp[29003] = 0; +inp[29004] = 1073712128; +inp[29005] = 0; +inp[29006] = 1073712000; +inp[29007] = 0; +inp[29008] = 1073711872; +inp[29009] = 0; +inp[29010] = 1073711744; +inp[29011] = 0; +inp[29012] = 1073711616; +inp[29013] = 0; +inp[29014] = 1073711488; +inp[29015] = 0; +inp[29016] = 1073711360; +inp[29017] = 0; +inp[29018] = 1073711232; +inp[29019] = 0; +inp[29020] = 1073711104; +inp[29021] = 0; +inp[29022] = 1073710976; +inp[29023] = 0; +inp[29024] = 1073710848; +inp[29025] = 0; +inp[29026] = 1073710720; +inp[29027] = 0; +inp[29028] = 1073710592; +inp[29029] = 0; +inp[29030] = 1073710464; +inp[29031] = 0; +inp[29032] = 1073710336; +inp[29033] = 0; +inp[29034] = 1073710208; +inp[29035] = 0; +inp[29036] = 1073710080; +inp[29037] = 0; +inp[29038] = 1073709952; +inp[29039] = 0; +inp[29040] = 1073709824; +inp[29041] = 0; +inp[29042] = 1073709696; +inp[29043] = 0; +inp[29044] = 1073709568; +inp[29045] = 0; +inp[29046] = 1073709440; +inp[29047] = 0; +inp[29048] = 1073709312; +inp[29049] = 0; +inp[29050] = 1073709184; +inp[29051] = 0; +inp[29052] = 1073741824; +inp[29053] = 1073741824; +inp[29054] = 1073741760; +inp[29055] = 0; +inp[29056] = 1073741696; +inp[29057] = 0; +inp[29058] = 1073741632; +inp[29059] = 0; +inp[29060] = 1073741568; +inp[29061] = 0; +inp[29062] = 1073741504; +inp[29063] = 0; +inp[29064] = 1073741440; +inp[29065] = 0; +inp[29066] = 1073741376; +inp[29067] = 0; +inp[29068] = 1073741312; +inp[29069] = 0; +inp[29070] = 1073741248; +inp[29071] = 0; +inp[29072] = 1073741184; +inp[29073] = 0; +inp[29074] = 1073741120; +inp[29075] = 0; +inp[29076] = 1073741056; +inp[29077] = 0; +inp[29078] = 1073740992; +inp[29079] = 0; +inp[29080] = 1073740928; +inp[29081] = 0; +inp[29082] = 1073740864; +inp[29083] = 0; +inp[29084] = 1073740800; +inp[29085] = 0; +inp[29086] = 1073740736; +inp[29087] = 0; +inp[29088] = 1073740672; +inp[29089] = 0; +inp[29090] = 1073740608; +inp[29091] = 0; +inp[29092] = 1073740544; +inp[29093] = 0; +inp[29094] = 1073740480; +inp[29095] = 0; +inp[29096] = 1073740416; +inp[29097] = 0; +inp[29098] = 1073740352; +inp[29099] = 0; +inp[29100] = 1073740288; +inp[29101] = 0; +inp[29102] = 1073740224; +inp[29103] = 0; +inp[29104] = 1073740160; +inp[29105] = 0; +inp[29106] = 1073740096; +inp[29107] = 0; +inp[29108] = 1073740032; +inp[29109] = 0; +inp[29110] = 1073739968; +inp[29111] = 0; +inp[29112] = 1073739904; +inp[29113] = 0; +inp[29114] = 1073739840; +inp[29115] = 0; +inp[29116] = 1073739776; +inp[29117] = 0; +inp[29118] = 1073739712; +inp[29119] = 0; +inp[29120] = 1073739648; +inp[29121] = 0; +inp[29122] = 1073739584; +inp[29123] = 0; +inp[29124] = 1073739520; +inp[29125] = 0; +inp[29126] = 1073739456; +inp[29127] = 0; +inp[29128] = 1073739392; +inp[29129] = 0; +inp[29130] = 1073739328; +inp[29131] = 0; +inp[29132] = 1073739264; +inp[29133] = 0; +inp[29134] = 1073739200; +inp[29135] = 0; +inp[29136] = 1073739136; +inp[29137] = 0; +inp[29138] = 1073739072; +inp[29139] = 0; +inp[29140] = 1073739008; +inp[29141] = 0; +inp[29142] = 1073738944; +inp[29143] = 0; +inp[29144] = 1073738880; +inp[29145] = 0; +inp[29146] = 1073738816; +inp[29147] = 0; +inp[29148] = 1073738752; +inp[29149] = 0; +inp[29150] = 1073738688; +inp[29151] = 0; +inp[29152] = 1073738624; +inp[29153] = 0; +inp[29154] = 1073738560; +inp[29155] = 0; +inp[29156] = 1073738496; +inp[29157] = 0; +inp[29158] = 1073738432; +inp[29159] = 0; +inp[29160] = 1073738368; +inp[29161] = 0; +inp[29162] = 1073738304; +inp[29163] = 0; +inp[29164] = 1073738240; +inp[29165] = 0; +inp[29166] = 1073738176; +inp[29167] = 0; +inp[29168] = 1073738112; +inp[29169] = 0; +inp[29170] = 1073738048; +inp[29171] = 0; +inp[29172] = 1073737984; +inp[29173] = 0; +inp[29174] = 1073737920; +inp[29175] = 0; +inp[29176] = 1073737856; +inp[29177] = 0; +inp[29178] = 1073737792; +inp[29179] = 0; +inp[29180] = 1073737728; +inp[29181] = 0; +inp[29182] = 1073737664; +inp[29183] = 0; +inp[29184] = 1073737600; +inp[29185] = 0; +inp[29186] = 1073737536; +inp[29187] = 0; +inp[29188] = 1073737472; +inp[29189] = 0; +inp[29190] = 1073737408; +inp[29191] = 0; +inp[29192] = 1073737344; +inp[29193] = 0; +inp[29194] = 1073737280; +inp[29195] = 0; +inp[29196] = 1073737216; +inp[29197] = 0; +inp[29198] = 1073737152; +inp[29199] = 0; +inp[29200] = 1073737088; +inp[29201] = 0; +inp[29202] = 1073737024; +inp[29203] = 0; +inp[29204] = 1073736960; +inp[29205] = 0; +inp[29206] = 1073736896; +inp[29207] = 0; +inp[29208] = 1073736832; +inp[29209] = 0; +inp[29210] = 1073736768; +inp[29211] = 0; +inp[29212] = 1073736704; +inp[29213] = 0; +inp[29214] = 1073736640; +inp[29215] = 0; +inp[29216] = 1073736576; +inp[29217] = 0; +inp[29218] = 1073736512; +inp[29219] = 0; +inp[29220] = 1073736448; +inp[29221] = 0; +inp[29222] = 1073736384; +inp[29223] = 0; +inp[29224] = 1073736320; +inp[29225] = 0; +inp[29226] = 1073736256; +inp[29227] = 0; +inp[29228] = 1073736192; +inp[29229] = 0; +inp[29230] = 1073736128; +inp[29231] = 0; +inp[29232] = 1073736064; +inp[29233] = 0; +inp[29234] = 1073736000; +inp[29235] = 0; +inp[29236] = 1073735936; +inp[29237] = 0; +inp[29238] = 1073735872; +inp[29239] = 0; +inp[29240] = 1073735808; +inp[29241] = 0; +inp[29242] = 1073735744; +inp[29243] = 0; +inp[29244] = 1073735680; +inp[29245] = 0; +inp[29246] = 1073735616; +inp[29247] = 0; +inp[29248] = 1073735552; +inp[29249] = 0; +inp[29250] = 1073735488; +inp[29251] = 0; +inp[29252] = 1073735424; +inp[29253] = 0; +inp[29254] = 1073735360; +inp[29255] = 0; +inp[29256] = 1073735296; +inp[29257] = 0; +inp[29258] = 1073735232; +inp[29259] = 0; +inp[29260] = 1073735168; +inp[29261] = 0; +inp[29262] = 1073735104; +inp[29263] = 0; +inp[29264] = 1073735040; +inp[29265] = 0; +inp[29266] = 1073734976; +inp[29267] = 0; +inp[29268] = 1073734912; +inp[29269] = 0; +inp[29270] = 1073734848; +inp[29271] = 0; +inp[29272] = 1073734784; +inp[29273] = 0; +inp[29274] = 1073734720; +inp[29275] = 0; +inp[29276] = 1073734656; +inp[29277] = 0; +inp[29278] = 1073734592; +inp[29279] = 0; +inp[29280] = 1073734528; +inp[29281] = 0; +inp[29282] = 1073734464; +inp[29283] = 0; +inp[29284] = 1073734400; +inp[29285] = 0; +inp[29286] = 1073734336; +inp[29287] = 0; +inp[29288] = 1073734272; +inp[29289] = 0; +inp[29290] = 1073734208; +inp[29291] = 0; +inp[29292] = 1073734144; +inp[29293] = 0; +inp[29294] = 1073734080; +inp[29295] = 0; +inp[29296] = 1073734016; +inp[29297] = 0; +inp[29298] = 1073733952; +inp[29299] = 0; +inp[29300] = 1073733888; +inp[29301] = 0; +inp[29302] = 1073733824; +inp[29303] = 0; +inp[29304] = 1073733760; +inp[29305] = 0; +inp[29306] = 1073733696; +inp[29307] = 0; +inp[29308] = 1073733632; +inp[29309] = 0; +inp[29310] = 1073733568; +inp[29311] = 0; +inp[29312] = 1073733504; +inp[29313] = 0; +inp[29314] = 1073733440; +inp[29315] = 0; +inp[29316] = 1073733376; +inp[29317] = 0; +inp[29318] = 1073733312; +inp[29319] = 0; +inp[29320] = 1073733248; +inp[29321] = 0; +inp[29322] = 1073733184; +inp[29323] = 0; +inp[29324] = 1073733120; +inp[29325] = 0; +inp[29326] = 1073733056; +inp[29327] = 0; +inp[29328] = 1073732992; +inp[29329] = 0; +inp[29330] = 1073732928; +inp[29331] = 0; +inp[29332] = 1073732864; +inp[29333] = 0; +inp[29334] = 1073732800; +inp[29335] = 0; +inp[29336] = 1073732736; +inp[29337] = 0; +inp[29338] = 1073732672; +inp[29339] = 0; +inp[29340] = 1073732608; +inp[29341] = 0; +inp[29342] = 1073732544; +inp[29343] = 0; +inp[29344] = 1073732480; +inp[29345] = 0; +inp[29346] = 1073732416; +inp[29347] = 0; +inp[29348] = 1073732352; +inp[29349] = 0; +inp[29350] = 1073732288; +inp[29351] = 0; +inp[29352] = 1073732224; +inp[29353] = 0; +inp[29354] = 1073732160; +inp[29355] = 0; +inp[29356] = 1073732096; +inp[29357] = 0; +inp[29358] = 1073732032; +inp[29359] = 0; +inp[29360] = 1073731968; +inp[29361] = 0; +inp[29362] = 1073731904; +inp[29363] = 0; +inp[29364] = 1073731840; +inp[29365] = 0; +inp[29366] = 1073731776; +inp[29367] = 0; +inp[29368] = 1073731712; +inp[29369] = 0; +inp[29370] = 1073731648; +inp[29371] = 0; +inp[29372] = 1073731584; +inp[29373] = 0; +inp[29374] = 1073731520; +inp[29375] = 0; +inp[29376] = 1073731456; +inp[29377] = 0; +inp[29378] = 1073731392; +inp[29379] = 0; +inp[29380] = 1073731328; +inp[29381] = 0; +inp[29382] = 1073731264; +inp[29383] = 0; +inp[29384] = 1073731200; +inp[29385] = 0; +inp[29386] = 1073731136; +inp[29387] = 0; +inp[29388] = 1073731072; +inp[29389] = 0; +inp[29390] = 1073731008; +inp[29391] = 0; +inp[29392] = 1073730944; +inp[29393] = 0; +inp[29394] = 1073730880; +inp[29395] = 0; +inp[29396] = 1073730816; +inp[29397] = 0; +inp[29398] = 1073730752; +inp[29399] = 0; +inp[29400] = 1073730688; +inp[29401] = 0; +inp[29402] = 1073730624; +inp[29403] = 0; +inp[29404] = 1073730560; +inp[29405] = 0; +inp[29406] = 1073730496; +inp[29407] = 0; +inp[29408] = 1073730432; +inp[29409] = 0; +inp[29410] = 1073730368; +inp[29411] = 0; +inp[29412] = 1073730304; +inp[29413] = 0; +inp[29414] = 1073730240; +inp[29415] = 0; +inp[29416] = 1073730176; +inp[29417] = 0; +inp[29418] = 1073730112; +inp[29419] = 0; +inp[29420] = 1073730048; +inp[29421] = 0; +inp[29422] = 1073729984; +inp[29423] = 0; +inp[29424] = 1073729920; +inp[29425] = 0; +inp[29426] = 1073729856; +inp[29427] = 0; +inp[29428] = 1073729792; +inp[29429] = 0; +inp[29430] = 1073729728; +inp[29431] = 0; +inp[29432] = 1073729664; +inp[29433] = 0; +inp[29434] = 1073729600; +inp[29435] = 0; +inp[29436] = 1073729536; +inp[29437] = 0; +inp[29438] = 1073729472; +inp[29439] = 0; +inp[29440] = 1073729408; +inp[29441] = 0; +inp[29442] = 1073729344; +inp[29443] = 0; +inp[29444] = 1073729280; +inp[29445] = 0; +inp[29446] = 1073729216; +inp[29447] = 0; +inp[29448] = 1073729152; +inp[29449] = 0; +inp[29450] = 1073729088; +inp[29451] = 0; +inp[29452] = 1073729024; +inp[29453] = 0; +inp[29454] = 1073728960; +inp[29455] = 0; +inp[29456] = 1073728896; +inp[29457] = 0; +inp[29458] = 1073728832; +inp[29459] = 0; +inp[29460] = 1073728768; +inp[29461] = 0; +inp[29462] = 1073728704; +inp[29463] = 0; +inp[29464] = 1073728640; +inp[29465] = 0; +inp[29466] = 1073728576; +inp[29467] = 0; +inp[29468] = 1073728512; +inp[29469] = 0; +inp[29470] = 1073728448; +inp[29471] = 0; +inp[29472] = 1073728384; +inp[29473] = 0; +inp[29474] = 1073728320; +inp[29475] = 0; +inp[29476] = 1073728256; +inp[29477] = 0; +inp[29478] = 1073728192; +inp[29479] = 0; +inp[29480] = 1073728128; +inp[29481] = 0; +inp[29482] = 1073728064; +inp[29483] = 0; +inp[29484] = 1073728000; +inp[29485] = 0; +inp[29486] = 1073727936; +inp[29487] = 0; +inp[29488] = 1073727872; +inp[29489] = 0; +inp[29490] = 1073727808; +inp[29491] = 0; +inp[29492] = 1073727744; +inp[29493] = 0; +inp[29494] = 1073727680; +inp[29495] = 0; +inp[29496] = 1073727616; +inp[29497] = 0; +inp[29498] = 1073727552; +inp[29499] = 0; +inp[29500] = 1073727488; +inp[29501] = 0; +inp[29502] = 1073727424; +inp[29503] = 0; +inp[29504] = 1073727360; +inp[29505] = 0; +inp[29506] = 1073727296; +inp[29507] = 0; +inp[29508] = 1073727232; +inp[29509] = 0; +inp[29510] = 1073727168; +inp[29511] = 0; +inp[29512] = 1073727104; +inp[29513] = 0; +inp[29514] = 1073727040; +inp[29515] = 0; +inp[29516] = 1073726976; +inp[29517] = 0; +inp[29518] = 1073726912; +inp[29519] = 0; +inp[29520] = 1073726848; +inp[29521] = 0; +inp[29522] = 1073726784; +inp[29523] = 0; +inp[29524] = 1073726720; +inp[29525] = 0; +inp[29526] = 1073726656; +inp[29527] = 0; +inp[29528] = 1073726592; +inp[29529] = 0; +inp[29530] = 1073726528; +inp[29531] = 0; +inp[29532] = 1073726464; +inp[29533] = 0; +inp[29534] = 1073726400; +inp[29535] = 0; +inp[29536] = 1073726336; +inp[29537] = 0; +inp[29538] = 1073726272; +inp[29539] = 0; +inp[29540] = 1073726208; +inp[29541] = 0; +inp[29542] = 1073726144; +inp[29543] = 0; +inp[29544] = 1073726080; +inp[29545] = 0; +inp[29546] = 1073726016; +inp[29547] = 0; +inp[29548] = 1073725952; +inp[29549] = 0; +inp[29550] = 1073725888; +inp[29551] = 0; +inp[29552] = 1073725824; +inp[29553] = 0; +inp[29554] = 1073725760; +inp[29555] = 0; +inp[29556] = 1073725696; +inp[29557] = 0; +inp[29558] = 1073725632; +inp[29559] = 0; +inp[29560] = 1073725568; +inp[29561] = 0; +inp[29562] = 1073725504; +inp[29563] = 0; +inp[29564] = 1073741824; +inp[29565] = 1073741824; +inp[29566] = 1073741792; +inp[29567] = 0; +inp[29568] = 1073741760; +inp[29569] = 0; +inp[29570] = 1073741728; +inp[29571] = 0; +inp[29572] = 1073741696; +inp[29573] = 0; +inp[29574] = 1073741664; +inp[29575] = 0; +inp[29576] = 1073741632; +inp[29577] = 0; +inp[29578] = 1073741600; +inp[29579] = 0; +inp[29580] = 1073741568; +inp[29581] = 0; +inp[29582] = 1073741536; +inp[29583] = 0; +inp[29584] = 1073741504; +inp[29585] = 0; +inp[29586] = 1073741472; +inp[29587] = 0; +inp[29588] = 1073741440; +inp[29589] = 0; +inp[29590] = 1073741408; +inp[29591] = 0; +inp[29592] = 1073741376; +inp[29593] = 0; +inp[29594] = 1073741344; +inp[29595] = 0; +inp[29596] = 1073741312; +inp[29597] = 0; +inp[29598] = 1073741280; +inp[29599] = 0; +inp[29600] = 1073741248; +inp[29601] = 0; +inp[29602] = 1073741216; +inp[29603] = 0; +inp[29604] = 1073741184; +inp[29605] = 0; +inp[29606] = 1073741152; +inp[29607] = 0; +inp[29608] = 1073741120; +inp[29609] = 0; +inp[29610] = 1073741088; +inp[29611] = 0; +inp[29612] = 1073741056; +inp[29613] = 0; +inp[29614] = 1073741024; +inp[29615] = 0; +inp[29616] = 1073740992; +inp[29617] = 0; +inp[29618] = 1073740960; +inp[29619] = 0; +inp[29620] = 1073740928; +inp[29621] = 0; +inp[29622] = 1073740896; +inp[29623] = 0; +inp[29624] = 1073740864; +inp[29625] = 0; +inp[29626] = 1073740832; +inp[29627] = 0; +inp[29628] = 1073740800; +inp[29629] = 0; +inp[29630] = 1073740768; +inp[29631] = 0; +inp[29632] = 1073740736; +inp[29633] = 0; +inp[29634] = 1073740704; +inp[29635] = 0; +inp[29636] = 1073740672; +inp[29637] = 0; +inp[29638] = 1073740640; +inp[29639] = 0; +inp[29640] = 1073740608; +inp[29641] = 0; +inp[29642] = 1073740576; +inp[29643] = 0; +inp[29644] = 1073740544; +inp[29645] = 0; +inp[29646] = 1073740512; +inp[29647] = 0; +inp[29648] = 1073740480; +inp[29649] = 0; +inp[29650] = 1073740448; +inp[29651] = 0; +inp[29652] = 1073740416; +inp[29653] = 0; +inp[29654] = 1073740384; +inp[29655] = 0; +inp[29656] = 1073740352; +inp[29657] = 0; +inp[29658] = 1073740320; +inp[29659] = 0; +inp[29660] = 1073740288; +inp[29661] = 0; +inp[29662] = 1073740256; +inp[29663] = 0; +inp[29664] = 1073740224; +inp[29665] = 0; +inp[29666] = 1073740192; +inp[29667] = 0; +inp[29668] = 1073740160; +inp[29669] = 0; +inp[29670] = 1073740128; +inp[29671] = 0; +inp[29672] = 1073740096; +inp[29673] = 0; +inp[29674] = 1073740064; +inp[29675] = 0; +inp[29676] = 1073740032; +inp[29677] = 0; +inp[29678] = 1073740000; +inp[29679] = 0; +inp[29680] = 1073739968; +inp[29681] = 0; +inp[29682] = 1073739936; +inp[29683] = 0; +inp[29684] = 1073739904; +inp[29685] = 0; +inp[29686] = 1073739872; +inp[29687] = 0; +inp[29688] = 1073739840; +inp[29689] = 0; +inp[29690] = 1073739808; +inp[29691] = 0; +inp[29692] = 1073739776; +inp[29693] = 0; +inp[29694] = 1073739744; +inp[29695] = 0; +inp[29696] = 1073739712; +inp[29697] = 0; +inp[29698] = 1073739680; +inp[29699] = 0; +inp[29700] = 1073739648; +inp[29701] = 0; +inp[29702] = 1073739616; +inp[29703] = 0; +inp[29704] = 1073739584; +inp[29705] = 0; +inp[29706] = 1073739552; +inp[29707] = 0; +inp[29708] = 1073739520; +inp[29709] = 0; +inp[29710] = 1073739488; +inp[29711] = 0; +inp[29712] = 1073739456; +inp[29713] = 0; +inp[29714] = 1073739424; +inp[29715] = 0; +inp[29716] = 1073739392; +inp[29717] = 0; +inp[29718] = 1073739360; +inp[29719] = 0; +inp[29720] = 1073739328; +inp[29721] = 0; +inp[29722] = 1073739296; +inp[29723] = 0; +inp[29724] = 1073739264; +inp[29725] = 0; +inp[29726] = 1073739232; +inp[29727] = 0; +inp[29728] = 1073739200; +inp[29729] = 0; +inp[29730] = 1073739168; +inp[29731] = 0; +inp[29732] = 1073739136; +inp[29733] = 0; +inp[29734] = 1073739104; +inp[29735] = 0; +inp[29736] = 1073739072; +inp[29737] = 0; +inp[29738] = 1073739040; +inp[29739] = 0; +inp[29740] = 1073739008; +inp[29741] = 0; +inp[29742] = 1073738976; +inp[29743] = 0; +inp[29744] = 1073738944; +inp[29745] = 0; +inp[29746] = 1073738912; +inp[29747] = 0; +inp[29748] = 1073738880; +inp[29749] = 0; +inp[29750] = 1073738848; +inp[29751] = 0; +inp[29752] = 1073738816; +inp[29753] = 0; +inp[29754] = 1073738784; +inp[29755] = 0; +inp[29756] = 1073738752; +inp[29757] = 0; +inp[29758] = 1073738720; +inp[29759] = 0; +inp[29760] = 1073738688; +inp[29761] = 0; +inp[29762] = 1073738656; +inp[29763] = 0; +inp[29764] = 1073738624; +inp[29765] = 0; +inp[29766] = 1073738592; +inp[29767] = 0; +inp[29768] = 1073738560; +inp[29769] = 0; +inp[29770] = 1073738528; +inp[29771] = 0; +inp[29772] = 1073738496; +inp[29773] = 0; +inp[29774] = 1073738464; +inp[29775] = 0; +inp[29776] = 1073738432; +inp[29777] = 0; +inp[29778] = 1073738400; +inp[29779] = 0; +inp[29780] = 1073738368; +inp[29781] = 0; +inp[29782] = 1073738336; +inp[29783] = 0; +inp[29784] = 1073738304; +inp[29785] = 0; +inp[29786] = 1073738272; +inp[29787] = 0; +inp[29788] = 1073738240; +inp[29789] = 0; +inp[29790] = 1073738208; +inp[29791] = 0; +inp[29792] = 1073738176; +inp[29793] = 0; +inp[29794] = 1073738144; +inp[29795] = 0; +inp[29796] = 1073738112; +inp[29797] = 0; +inp[29798] = 1073738080; +inp[29799] = 0; +inp[29800] = 1073738048; +inp[29801] = 0; +inp[29802] = 1073738016; +inp[29803] = 0; +inp[29804] = 1073737984; +inp[29805] = 0; +inp[29806] = 1073737952; +inp[29807] = 0; +inp[29808] = 1073737920; +inp[29809] = 0; +inp[29810] = 1073737888; +inp[29811] = 0; +inp[29812] = 1073737856; +inp[29813] = 0; +inp[29814] = 1073737824; +inp[29815] = 0; +inp[29816] = 1073737792; +inp[29817] = 0; +inp[29818] = 1073737760; +inp[29819] = 0; +inp[29820] = 1073737728; +inp[29821] = 0; +inp[29822] = 1073737696; +inp[29823] = 0; +inp[29824] = 1073737664; +inp[29825] = 0; +inp[29826] = 1073737632; +inp[29827] = 0; +inp[29828] = 1073737600; +inp[29829] = 0; +inp[29830] = 1073737568; +inp[29831] = 0; +inp[29832] = 1073737536; +inp[29833] = 0; +inp[29834] = 1073737504; +inp[29835] = 0; +inp[29836] = 1073737472; +inp[29837] = 0; +inp[29838] = 1073737440; +inp[29839] = 0; +inp[29840] = 1073737408; +inp[29841] = 0; +inp[29842] = 1073737376; +inp[29843] = 0; +inp[29844] = 1073737344; +inp[29845] = 0; +inp[29846] = 1073737312; +inp[29847] = 0; +inp[29848] = 1073737280; +inp[29849] = 0; +inp[29850] = 1073737248; +inp[29851] = 0; +inp[29852] = 1073737216; +inp[29853] = 0; +inp[29854] = 1073737184; +inp[29855] = 0; +inp[29856] = 1073737152; +inp[29857] = 0; +inp[29858] = 1073737120; +inp[29859] = 0; +inp[29860] = 1073737088; +inp[29861] = 0; +inp[29862] = 1073737056; +inp[29863] = 0; +inp[29864] = 1073737024; +inp[29865] = 0; +inp[29866] = 1073736992; +inp[29867] = 0; +inp[29868] = 1073736960; +inp[29869] = 0; +inp[29870] = 1073736928; +inp[29871] = 0; +inp[29872] = 1073736896; +inp[29873] = 0; +inp[29874] = 1073736864; +inp[29875] = 0; +inp[29876] = 1073736832; +inp[29877] = 0; +inp[29878] = 1073736800; +inp[29879] = 0; +inp[29880] = 1073736768; +inp[29881] = 0; +inp[29882] = 1073736736; +inp[29883] = 0; +inp[29884] = 1073736704; +inp[29885] = 0; +inp[29886] = 1073736672; +inp[29887] = 0; +inp[29888] = 1073736640; +inp[29889] = 0; +inp[29890] = 1073736608; +inp[29891] = 0; +inp[29892] = 1073736576; +inp[29893] = 0; +inp[29894] = 1073736544; +inp[29895] = 0; +inp[29896] = 1073736512; +inp[29897] = 0; +inp[29898] = 1073736480; +inp[29899] = 0; +inp[29900] = 1073736448; +inp[29901] = 0; +inp[29902] = 1073736416; +inp[29903] = 0; +inp[29904] = 1073736384; +inp[29905] = 0; +inp[29906] = 1073736352; +inp[29907] = 0; +inp[29908] = 1073736320; +inp[29909] = 0; +inp[29910] = 1073736288; +inp[29911] = 0; +inp[29912] = 1073736256; +inp[29913] = 0; +inp[29914] = 1073736224; +inp[29915] = 0; +inp[29916] = 1073736192; +inp[29917] = 0; +inp[29918] = 1073736160; +inp[29919] = 0; +inp[29920] = 1073736128; +inp[29921] = 0; +inp[29922] = 1073736096; +inp[29923] = 0; +inp[29924] = 1073736064; +inp[29925] = 0; +inp[29926] = 1073736032; +inp[29927] = 0; +inp[29928] = 1073736000; +inp[29929] = 0; +inp[29930] = 1073735968; +inp[29931] = 0; +inp[29932] = 1073735936; +inp[29933] = 0; +inp[29934] = 1073735904; +inp[29935] = 0; +inp[29936] = 1073735872; +inp[29937] = 0; +inp[29938] = 1073735840; +inp[29939] = 0; +inp[29940] = 1073735808; +inp[29941] = 0; +inp[29942] = 1073735776; +inp[29943] = 0; +inp[29944] = 1073735744; +inp[29945] = 0; +inp[29946] = 1073735712; +inp[29947] = 0; +inp[29948] = 1073735680; +inp[29949] = 0; +inp[29950] = 1073735648; +inp[29951] = 0; +inp[29952] = 1073735616; +inp[29953] = 0; +inp[29954] = 1073735584; +inp[29955] = 0; +inp[29956] = 1073735552; +inp[29957] = 0; +inp[29958] = 1073735520; +inp[29959] = 0; +inp[29960] = 1073735488; +inp[29961] = 0; +inp[29962] = 1073735456; +inp[29963] = 0; +inp[29964] = 1073735424; +inp[29965] = 0; +inp[29966] = 1073735392; +inp[29967] = 0; +inp[29968] = 1073735360; +inp[29969] = 0; +inp[29970] = 1073735328; +inp[29971] = 0; +inp[29972] = 1073735296; +inp[29973] = 0; +inp[29974] = 1073735264; +inp[29975] = 0; +inp[29976] = 1073735232; +inp[29977] = 0; +inp[29978] = 1073735200; +inp[29979] = 0; +inp[29980] = 1073735168; +inp[29981] = 0; +inp[29982] = 1073735136; +inp[29983] = 0; +inp[29984] = 1073735104; +inp[29985] = 0; +inp[29986] = 1073735072; +inp[29987] = 0; +inp[29988] = 1073735040; +inp[29989] = 0; +inp[29990] = 1073735008; +inp[29991] = 0; +inp[29992] = 1073734976; +inp[29993] = 0; +inp[29994] = 1073734944; +inp[29995] = 0; +inp[29996] = 1073734912; +inp[29997] = 0; +inp[29998] = 1073734880; +inp[29999] = 0; +inp[30000] = 1073734848; +inp[30001] = 0; +inp[30002] = 1073734816; +inp[30003] = 0; +inp[30004] = 1073734784; +inp[30005] = 0; +inp[30006] = 1073734752; +inp[30007] = 0; +inp[30008] = 1073734720; +inp[30009] = 0; +inp[30010] = 1073734688; +inp[30011] = 0; +inp[30012] = 1073734656; +inp[30013] = 0; +inp[30014] = 1073734624; +inp[30015] = 0; +inp[30016] = 1073734592; +inp[30017] = 0; +inp[30018] = 1073734560; +inp[30019] = 0; +inp[30020] = 1073734528; +inp[30021] = 0; +inp[30022] = 1073734496; +inp[30023] = 0; +inp[30024] = 1073734464; +inp[30025] = 0; +inp[30026] = 1073734432; +inp[30027] = 0; +inp[30028] = 1073734400; +inp[30029] = 0; +inp[30030] = 1073734368; +inp[30031] = 0; +inp[30032] = 1073734336; +inp[30033] = 0; +inp[30034] = 1073734304; +inp[30035] = 0; +inp[30036] = 1073734272; +inp[30037] = 0; +inp[30038] = 1073734240; +inp[30039] = 0; +inp[30040] = 1073734208; +inp[30041] = 0; +inp[30042] = 1073734176; +inp[30043] = 0; +inp[30044] = 1073734144; +inp[30045] = 0; +inp[30046] = 1073734112; +inp[30047] = 0; +inp[30048] = 1073734080; +inp[30049] = 0; +inp[30050] = 1073734048; +inp[30051] = 0; +inp[30052] = 1073734016; +inp[30053] = 0; +inp[30054] = 1073733984; +inp[30055] = 0; +inp[30056] = 1073733952; +inp[30057] = 0; +inp[30058] = 1073733920; +inp[30059] = 0; +inp[30060] = 1073733888; +inp[30061] = 0; +inp[30062] = 1073733856; +inp[30063] = 0; +inp[30064] = 1073733824; +inp[30065] = 0; +inp[30066] = 1073733792; +inp[30067] = 0; +inp[30068] = 1073733760; +inp[30069] = 0; +inp[30070] = 1073733728; +inp[30071] = 0; +inp[30072] = 1073733696; +inp[30073] = 0; +inp[30074] = 1073733664; +inp[30075] = 0; +inp[30076] = 1073741824; +inp[30077] = 1073741824; +inp[30078] = 1073741808; +inp[30079] = 0; +inp[30080] = 1073741792; +inp[30081] = 0; +inp[30082] = 1073741776; +inp[30083] = 0; +inp[30084] = 1073741760; +inp[30085] = 0; +inp[30086] = 1073741744; +inp[30087] = 0; +inp[30088] = 1073741728; +inp[30089] = 0; +inp[30090] = 1073741712; +inp[30091] = 0; +inp[30092] = 1073741696; +inp[30093] = 0; +inp[30094] = 1073741680; +inp[30095] = 0; +inp[30096] = 1073741664; +inp[30097] = 0; +inp[30098] = 1073741648; +inp[30099] = 0; +inp[30100] = 1073741632; +inp[30101] = 0; +inp[30102] = 1073741616; +inp[30103] = 0; +inp[30104] = 1073741600; +inp[30105] = 0; +inp[30106] = 1073741584; +inp[30107] = 0; +inp[30108] = 1073741568; +inp[30109] = 0; +inp[30110] = 1073741552; +inp[30111] = 0; +inp[30112] = 1073741536; +inp[30113] = 0; +inp[30114] = 1073741520; +inp[30115] = 0; +inp[30116] = 1073741504; +inp[30117] = 0; +inp[30118] = 1073741488; +inp[30119] = 0; +inp[30120] = 1073741472; +inp[30121] = 0; +inp[30122] = 1073741456; +inp[30123] = 0; +inp[30124] = 1073741440; +inp[30125] = 0; +inp[30126] = 1073741424; +inp[30127] = 0; +inp[30128] = 1073741408; +inp[30129] = 0; +inp[30130] = 1073741392; +inp[30131] = 0; +inp[30132] = 1073741376; +inp[30133] = 0; +inp[30134] = 1073741360; +inp[30135] = 0; +inp[30136] = 1073741344; +inp[30137] = 0; +inp[30138] = 1073741328; +inp[30139] = 0; +inp[30140] = 1073741312; +inp[30141] = 0; +inp[30142] = 1073741296; +inp[30143] = 0; +inp[30144] = 1073741280; +inp[30145] = 0; +inp[30146] = 1073741264; +inp[30147] = 0; +inp[30148] = 1073741248; +inp[30149] = 0; +inp[30150] = 1073741232; +inp[30151] = 0; +inp[30152] = 1073741216; +inp[30153] = 0; +inp[30154] = 1073741200; +inp[30155] = 0; +inp[30156] = 1073741184; +inp[30157] = 0; +inp[30158] = 1073741168; +inp[30159] = 0; +inp[30160] = 1073741152; +inp[30161] = 0; +inp[30162] = 1073741136; +inp[30163] = 0; +inp[30164] = 1073741120; +inp[30165] = 0; +inp[30166] = 1073741104; +inp[30167] = 0; +inp[30168] = 1073741088; +inp[30169] = 0; +inp[30170] = 1073741072; +inp[30171] = 0; +inp[30172] = 1073741056; +inp[30173] = 0; +inp[30174] = 1073741040; +inp[30175] = 0; +inp[30176] = 1073741024; +inp[30177] = 0; +inp[30178] = 1073741008; +inp[30179] = 0; +inp[30180] = 1073740992; +inp[30181] = 0; +inp[30182] = 1073740976; +inp[30183] = 0; +inp[30184] = 1073740960; +inp[30185] = 0; +inp[30186] = 1073740944; +inp[30187] = 0; +inp[30188] = 1073740928; +inp[30189] = 0; +inp[30190] = 1073740912; +inp[30191] = 0; +inp[30192] = 1073740896; +inp[30193] = 0; +inp[30194] = 1073740880; +inp[30195] = 0; +inp[30196] = 1073740864; +inp[30197] = 0; +inp[30198] = 1073740848; +inp[30199] = 0; +inp[30200] = 1073740832; +inp[30201] = 0; +inp[30202] = 1073740816; +inp[30203] = 0; +inp[30204] = 1073740800; +inp[30205] = 0; +inp[30206] = 1073740784; +inp[30207] = 0; +inp[30208] = 1073740768; +inp[30209] = 0; +inp[30210] = 1073740752; +inp[30211] = 0; +inp[30212] = 1073740736; +inp[30213] = 0; +inp[30214] = 1073740720; +inp[30215] = 0; +inp[30216] = 1073740704; +inp[30217] = 0; +inp[30218] = 1073740688; +inp[30219] = 0; +inp[30220] = 1073740672; +inp[30221] = 0; +inp[30222] = 1073740656; +inp[30223] = 0; +inp[30224] = 1073740640; +inp[30225] = 0; +inp[30226] = 1073740624; +inp[30227] = 0; +inp[30228] = 1073740608; +inp[30229] = 0; +inp[30230] = 1073740592; +inp[30231] = 0; +inp[30232] = 1073740576; +inp[30233] = 0; +inp[30234] = 1073740560; +inp[30235] = 0; +inp[30236] = 1073740544; +inp[30237] = 0; +inp[30238] = 1073740528; +inp[30239] = 0; +inp[30240] = 1073740512; +inp[30241] = 0; +inp[30242] = 1073740496; +inp[30243] = 0; +inp[30244] = 1073740480; +inp[30245] = 0; +inp[30246] = 1073740464; +inp[30247] = 0; +inp[30248] = 1073740448; +inp[30249] = 0; +inp[30250] = 1073740432; +inp[30251] = 0; +inp[30252] = 1073740416; +inp[30253] = 0; +inp[30254] = 1073740400; +inp[30255] = 0; +inp[30256] = 1073740384; +inp[30257] = 0; +inp[30258] = 1073740368; +inp[30259] = 0; +inp[30260] = 1073740352; +inp[30261] = 0; +inp[30262] = 1073740336; +inp[30263] = 0; +inp[30264] = 1073740320; +inp[30265] = 0; +inp[30266] = 1073740304; +inp[30267] = 0; +inp[30268] = 1073740288; +inp[30269] = 0; +inp[30270] = 1073740272; +inp[30271] = 0; +inp[30272] = 1073740256; +inp[30273] = 0; +inp[30274] = 1073740240; +inp[30275] = 0; +inp[30276] = 1073740224; +inp[30277] = 0; +inp[30278] = 1073740208; +inp[30279] = 0; +inp[30280] = 1073740192; +inp[30281] = 0; +inp[30282] = 1073740176; +inp[30283] = 0; +inp[30284] = 1073740160; +inp[30285] = 0; +inp[30286] = 1073740144; +inp[30287] = 0; +inp[30288] = 1073740128; +inp[30289] = 0; +inp[30290] = 1073740112; +inp[30291] = 0; +inp[30292] = 1073740096; +inp[30293] = 0; +inp[30294] = 1073740080; +inp[30295] = 0; +inp[30296] = 1073740064; +inp[30297] = 0; +inp[30298] = 1073740048; +inp[30299] = 0; +inp[30300] = 1073740032; +inp[30301] = 0; +inp[30302] = 1073740016; +inp[30303] = 0; +inp[30304] = 1073740000; +inp[30305] = 0; +inp[30306] = 1073739984; +inp[30307] = 0; +inp[30308] = 1073739968; +inp[30309] = 0; +inp[30310] = 1073739952; +inp[30311] = 0; +inp[30312] = 1073739936; +inp[30313] = 0; +inp[30314] = 1073739920; +inp[30315] = 0; +inp[30316] = 1073739904; +inp[30317] = 0; +inp[30318] = 1073739888; +inp[30319] = 0; +inp[30320] = 1073739872; +inp[30321] = 0; +inp[30322] = 1073739856; +inp[30323] = 0; +inp[30324] = 1073739840; +inp[30325] = 0; +inp[30326] = 1073739824; +inp[30327] = 0; +inp[30328] = 1073739808; +inp[30329] = 0; +inp[30330] = 1073739792; +inp[30331] = 0; +inp[30332] = 1073739776; +inp[30333] = 0; +inp[30334] = 1073739760; +inp[30335] = 0; +inp[30336] = 1073739744; +inp[30337] = 0; +inp[30338] = 1073739728; +inp[30339] = 0; +inp[30340] = 1073739712; +inp[30341] = 0; +inp[30342] = 1073739696; +inp[30343] = 0; +inp[30344] = 1073739680; +inp[30345] = 0; +inp[30346] = 1073739664; +inp[30347] = 0; +inp[30348] = 1073739648; +inp[30349] = 0; +inp[30350] = 1073739632; +inp[30351] = 0; +inp[30352] = 1073739616; +inp[30353] = 0; +inp[30354] = 1073739600; +inp[30355] = 0; +inp[30356] = 1073739584; +inp[30357] = 0; +inp[30358] = 1073739568; +inp[30359] = 0; +inp[30360] = 1073739552; +inp[30361] = 0; +inp[30362] = 1073739536; +inp[30363] = 0; +inp[30364] = 1073739520; +inp[30365] = 0; +inp[30366] = 1073739504; +inp[30367] = 0; +inp[30368] = 1073739488; +inp[30369] = 0; +inp[30370] = 1073739472; +inp[30371] = 0; +inp[30372] = 1073739456; +inp[30373] = 0; +inp[30374] = 1073739440; +inp[30375] = 0; +inp[30376] = 1073739424; +inp[30377] = 0; +inp[30378] = 1073739408; +inp[30379] = 0; +inp[30380] = 1073739392; +inp[30381] = 0; +inp[30382] = 1073739376; +inp[30383] = 0; +inp[30384] = 1073739360; +inp[30385] = 0; +inp[30386] = 1073739344; +inp[30387] = 0; +inp[30388] = 1073739328; +inp[30389] = 0; +inp[30390] = 1073739312; +inp[30391] = 0; +inp[30392] = 1073739296; +inp[30393] = 0; +inp[30394] = 1073739280; +inp[30395] = 0; +inp[30396] = 1073739264; +inp[30397] = 0; +inp[30398] = 1073739248; +inp[30399] = 0; +inp[30400] = 1073739232; +inp[30401] = 0; +inp[30402] = 1073739216; +inp[30403] = 0; +inp[30404] = 1073739200; +inp[30405] = 0; +inp[30406] = 1073739184; +inp[30407] = 0; +inp[30408] = 1073739168; +inp[30409] = 0; +inp[30410] = 1073739152; +inp[30411] = 0; +inp[30412] = 1073739136; +inp[30413] = 0; +inp[30414] = 1073739120; +inp[30415] = 0; +inp[30416] = 1073739104; +inp[30417] = 0; +inp[30418] = 1073739088; +inp[30419] = 0; +inp[30420] = 1073739072; +inp[30421] = 0; +inp[30422] = 1073739056; +inp[30423] = 0; +inp[30424] = 1073739040; +inp[30425] = 0; +inp[30426] = 1073739024; +inp[30427] = 0; +inp[30428] = 1073739008; +inp[30429] = 0; +inp[30430] = 1073738992; +inp[30431] = 0; +inp[30432] = 1073738976; +inp[30433] = 0; +inp[30434] = 1073738960; +inp[30435] = 0; +inp[30436] = 1073738944; +inp[30437] = 0; +inp[30438] = 1073738928; +inp[30439] = 0; +inp[30440] = 1073738912; +inp[30441] = 0; +inp[30442] = 1073738896; +inp[30443] = 0; +inp[30444] = 1073738880; +inp[30445] = 0; +inp[30446] = 1073738864; +inp[30447] = 0; +inp[30448] = 1073738848; +inp[30449] = 0; +inp[30450] = 1073738832; +inp[30451] = 0; +inp[30452] = 1073738816; +inp[30453] = 0; +inp[30454] = 1073738800; +inp[30455] = 0; +inp[30456] = 1073738784; +inp[30457] = 0; +inp[30458] = 1073738768; +inp[30459] = 0; +inp[30460] = 1073738752; +inp[30461] = 0; +inp[30462] = 1073738736; +inp[30463] = 0; +inp[30464] = 1073738720; +inp[30465] = 0; +inp[30466] = 1073738704; +inp[30467] = 0; +inp[30468] = 1073738688; +inp[30469] = 0; +inp[30470] = 1073738672; +inp[30471] = 0; +inp[30472] = 1073738656; +inp[30473] = 0; +inp[30474] = 1073738640; +inp[30475] = 0; +inp[30476] = 1073738624; +inp[30477] = 0; +inp[30478] = 1073738608; +inp[30479] = 0; +inp[30480] = 1073738592; +inp[30481] = 0; +inp[30482] = 1073738576; +inp[30483] = 0; +inp[30484] = 1073738560; +inp[30485] = 0; +inp[30486] = 1073738544; +inp[30487] = 0; +inp[30488] = 1073738528; +inp[30489] = 0; +inp[30490] = 1073738512; +inp[30491] = 0; +inp[30492] = 1073738496; +inp[30493] = 0; +inp[30494] = 1073738480; +inp[30495] = 0; +inp[30496] = 1073738464; +inp[30497] = 0; +inp[30498] = 1073738448; +inp[30499] = 0; +inp[30500] = 1073738432; +inp[30501] = 0; +inp[30502] = 1073738416; +inp[30503] = 0; +inp[30504] = 1073738400; +inp[30505] = 0; +inp[30506] = 1073738384; +inp[30507] = 0; +inp[30508] = 1073738368; +inp[30509] = 0; +inp[30510] = 1073738352; +inp[30511] = 0; +inp[30512] = 1073738336; +inp[30513] = 0; +inp[30514] = 1073738320; +inp[30515] = 0; +inp[30516] = 1073738304; +inp[30517] = 0; +inp[30518] = 1073738288; +inp[30519] = 0; +inp[30520] = 1073738272; +inp[30521] = 0; +inp[30522] = 1073738256; +inp[30523] = 0; +inp[30524] = 1073738240; +inp[30525] = 0; +inp[30526] = 1073738224; +inp[30527] = 0; +inp[30528] = 1073738208; +inp[30529] = 0; +inp[30530] = 1073738192; +inp[30531] = 0; +inp[30532] = 1073738176; +inp[30533] = 0; +inp[30534] = 1073738160; +inp[30535] = 0; +inp[30536] = 1073738144; +inp[30537] = 0; +inp[30538] = 1073738128; +inp[30539] = 0; +inp[30540] = 1073738112; +inp[30541] = 0; +inp[30542] = 1073738096; +inp[30543] = 0; +inp[30544] = 1073738080; +inp[30545] = 0; +inp[30546] = 1073738064; +inp[30547] = 0; +inp[30548] = 1073738048; +inp[30549] = 0; +inp[30550] = 1073738032; +inp[30551] = 0; +inp[30552] = 1073738016; +inp[30553] = 0; +inp[30554] = 1073738000; +inp[30555] = 0; +inp[30556] = 1073737984; +inp[30557] = 0; +inp[30558] = 1073737968; +inp[30559] = 0; +inp[30560] = 1073737952; +inp[30561] = 0; +inp[30562] = 1073737936; +inp[30563] = 0; +inp[30564] = 1073737920; +inp[30565] = 0; +inp[30566] = 1073737904; +inp[30567] = 0; +inp[30568] = 1073737888; +inp[30569] = 0; +inp[30570] = 1073737872; +inp[30571] = 0; +inp[30572] = 1073737856; +inp[30573] = 0; +inp[30574] = 1073737840; +inp[30575] = 0; +inp[30576] = 1073737824; +inp[30577] = 0; +inp[30578] = 1073737808; +inp[30579] = 0; +inp[30580] = 1073737792; +inp[30581] = 0; +inp[30582] = 1073737776; +inp[30583] = 0; +inp[30584] = 1073737760; +inp[30585] = 0; +inp[30586] = 1073737744; +inp[30587] = 0; +inp[30588] = 1073741824; +inp[30589] = 1073741824; +inp[30590] = 1073741816; +inp[30591] = 0; +inp[30592] = 1073741808; +inp[30593] = 0; +inp[30594] = 1073741800; +inp[30595] = 0; +inp[30596] = 1073741792; +inp[30597] = 0; +inp[30598] = 1073741784; +inp[30599] = 0; +inp[30600] = 1073741776; +inp[30601] = 0; +inp[30602] = 1073741768; +inp[30603] = 0; +inp[30604] = 1073741760; +inp[30605] = 0; +inp[30606] = 1073741752; +inp[30607] = 0; +inp[30608] = 1073741744; +inp[30609] = 0; +inp[30610] = 1073741736; +inp[30611] = 0; +inp[30612] = 1073741728; +inp[30613] = 0; +inp[30614] = 1073741720; +inp[30615] = 0; +inp[30616] = 1073741712; +inp[30617] = 0; +inp[30618] = 1073741704; +inp[30619] = 0; +inp[30620] = 1073741696; +inp[30621] = 0; +inp[30622] = 1073741688; +inp[30623] = 0; +inp[30624] = 1073741680; +inp[30625] = 0; +inp[30626] = 1073741672; +inp[30627] = 0; +inp[30628] = 1073741664; +inp[30629] = 0; +inp[30630] = 1073741656; +inp[30631] = 0; +inp[30632] = 1073741648; +inp[30633] = 0; +inp[30634] = 1073741640; +inp[30635] = 0; +inp[30636] = 1073741632; +inp[30637] = 0; +inp[30638] = 1073741624; +inp[30639] = 0; +inp[30640] = 1073741616; +inp[30641] = 0; +inp[30642] = 1073741608; +inp[30643] = 0; +inp[30644] = 1073741600; +inp[30645] = 0; +inp[30646] = 1073741592; +inp[30647] = 0; +inp[30648] = 1073741584; +inp[30649] = 0; +inp[30650] = 1073741576; +inp[30651] = 0; +inp[30652] = 1073741568; +inp[30653] = 0; +inp[30654] = 1073741560; +inp[30655] = 0; +inp[30656] = 1073741552; +inp[30657] = 0; +inp[30658] = 1073741544; +inp[30659] = 0; +inp[30660] = 1073741536; +inp[30661] = 0; +inp[30662] = 1073741528; +inp[30663] = 0; +inp[30664] = 1073741520; +inp[30665] = 0; +inp[30666] = 1073741512; +inp[30667] = 0; +inp[30668] = 1073741504; +inp[30669] = 0; +inp[30670] = 1073741496; +inp[30671] = 0; +inp[30672] = 1073741488; +inp[30673] = 0; +inp[30674] = 1073741480; +inp[30675] = 0; +inp[30676] = 1073741472; +inp[30677] = 0; +inp[30678] = 1073741464; +inp[30679] = 0; +inp[30680] = 1073741456; +inp[30681] = 0; +inp[30682] = 1073741448; +inp[30683] = 0; +inp[30684] = 1073741440; +inp[30685] = 0; +inp[30686] = 1073741432; +inp[30687] = 0; +inp[30688] = 1073741424; +inp[30689] = 0; +inp[30690] = 1073741416; +inp[30691] = 0; +inp[30692] = 1073741408; +inp[30693] = 0; +inp[30694] = 1073741400; +inp[30695] = 0; +inp[30696] = 1073741392; +inp[30697] = 0; +inp[30698] = 1073741384; +inp[30699] = 0; +inp[30700] = 1073741376; +inp[30701] = 0; +inp[30702] = 1073741368; +inp[30703] = 0; +inp[30704] = 1073741360; +inp[30705] = 0; +inp[30706] = 1073741352; +inp[30707] = 0; +inp[30708] = 1073741344; +inp[30709] = 0; +inp[30710] = 1073741336; +inp[30711] = 0; +inp[30712] = 1073741328; +inp[30713] = 0; +inp[30714] = 1073741320; +inp[30715] = 0; +inp[30716] = 1073741312; +inp[30717] = 0; +inp[30718] = 1073741304; +inp[30719] = 0; +inp[30720] = 1073741296; +inp[30721] = 0; +inp[30722] = 1073741288; +inp[30723] = 0; +inp[30724] = 1073741280; +inp[30725] = 0; +inp[30726] = 1073741272; +inp[30727] = 0; +inp[30728] = 1073741264; +inp[30729] = 0; +inp[30730] = 1073741256; +inp[30731] = 0; +inp[30732] = 1073741248; +inp[30733] = 0; +inp[30734] = 1073741240; +inp[30735] = 0; +inp[30736] = 1073741232; +inp[30737] = 0; +inp[30738] = 1073741224; +inp[30739] = 0; +inp[30740] = 1073741216; +inp[30741] = 0; +inp[30742] = 1073741208; +inp[30743] = 0; +inp[30744] = 1073741200; +inp[30745] = 0; +inp[30746] = 1073741192; +inp[30747] = 0; +inp[30748] = 1073741184; +inp[30749] = 0; +inp[30750] = 1073741176; +inp[30751] = 0; +inp[30752] = 1073741168; +inp[30753] = 0; +inp[30754] = 1073741160; +inp[30755] = 0; +inp[30756] = 1073741152; +inp[30757] = 0; +inp[30758] = 1073741144; +inp[30759] = 0; +inp[30760] = 1073741136; +inp[30761] = 0; +inp[30762] = 1073741128; +inp[30763] = 0; +inp[30764] = 1073741120; +inp[30765] = 0; +inp[30766] = 1073741112; +inp[30767] = 0; +inp[30768] = 1073741104; +inp[30769] = 0; +inp[30770] = 1073741096; +inp[30771] = 0; +inp[30772] = 1073741088; +inp[30773] = 0; +inp[30774] = 1073741080; +inp[30775] = 0; +inp[30776] = 1073741072; +inp[30777] = 0; +inp[30778] = 1073741064; +inp[30779] = 0; +inp[30780] = 1073741056; +inp[30781] = 0; +inp[30782] = 1073741048; +inp[30783] = 0; +inp[30784] = 1073741040; +inp[30785] = 0; +inp[30786] = 1073741032; +inp[30787] = 0; +inp[30788] = 1073741024; +inp[30789] = 0; +inp[30790] = 1073741016; +inp[30791] = 0; +inp[30792] = 1073741008; +inp[30793] = 0; +inp[30794] = 1073741000; +inp[30795] = 0; +inp[30796] = 1073740992; +inp[30797] = 0; +inp[30798] = 1073740984; +inp[30799] = 0; +inp[30800] = 1073740976; +inp[30801] = 0; +inp[30802] = 1073740968; +inp[30803] = 0; +inp[30804] = 1073740960; +inp[30805] = 0; +inp[30806] = 1073740952; +inp[30807] = 0; +inp[30808] = 1073740944; +inp[30809] = 0; +inp[30810] = 1073740936; +inp[30811] = 0; +inp[30812] = 1073740928; +inp[30813] = 0; +inp[30814] = 1073740920; +inp[30815] = 0; +inp[30816] = 1073740912; +inp[30817] = 0; +inp[30818] = 1073740904; +inp[30819] = 0; +inp[30820] = 1073740896; +inp[30821] = 0; +inp[30822] = 1073740888; +inp[30823] = 0; +inp[30824] = 1073740880; +inp[30825] = 0; +inp[30826] = 1073740872; +inp[30827] = 0; +inp[30828] = 1073740864; +inp[30829] = 0; +inp[30830] = 1073740856; +inp[30831] = 0; +inp[30832] = 1073740848; +inp[30833] = 0; +inp[30834] = 1073740840; +inp[30835] = 0; +inp[30836] = 1073740832; +inp[30837] = 0; +inp[30838] = 1073740824; +inp[30839] = 0; +inp[30840] = 1073740816; +inp[30841] = 0; +inp[30842] = 1073740808; +inp[30843] = 0; +inp[30844] = 1073740800; +inp[30845] = 0; +inp[30846] = 1073740792; +inp[30847] = 0; +inp[30848] = 1073740784; +inp[30849] = 0; +inp[30850] = 1073740776; +inp[30851] = 0; +inp[30852] = 1073740768; +inp[30853] = 0; +inp[30854] = 1073740760; +inp[30855] = 0; +inp[30856] = 1073740752; +inp[30857] = 0; +inp[30858] = 1073740744; +inp[30859] = 0; +inp[30860] = 1073740736; +inp[30861] = 0; +inp[30862] = 1073740728; +inp[30863] = 0; +inp[30864] = 1073740720; +inp[30865] = 0; +inp[30866] = 1073740712; +inp[30867] = 0; +inp[30868] = 1073740704; +inp[30869] = 0; +inp[30870] = 1073740696; +inp[30871] = 0; +inp[30872] = 1073740688; +inp[30873] = 0; +inp[30874] = 1073740680; +inp[30875] = 0; +inp[30876] = 1073740672; +inp[30877] = 0; +inp[30878] = 1073740664; +inp[30879] = 0; +inp[30880] = 1073740656; +inp[30881] = 0; +inp[30882] = 1073740648; +inp[30883] = 0; +inp[30884] = 1073740640; +inp[30885] = 0; +inp[30886] = 1073740632; +inp[30887] = 0; +inp[30888] = 1073740624; +inp[30889] = 0; +inp[30890] = 1073740616; +inp[30891] = 0; +inp[30892] = 1073740608; +inp[30893] = 0; +inp[30894] = 1073740600; +inp[30895] = 0; +inp[30896] = 1073740592; +inp[30897] = 0; +inp[30898] = 1073740584; +inp[30899] = 0; +inp[30900] = 1073740576; +inp[30901] = 0; +inp[30902] = 1073740568; +inp[30903] = 0; +inp[30904] = 1073740560; +inp[30905] = 0; +inp[30906] = 1073740552; +inp[30907] = 0; +inp[30908] = 1073740544; +inp[30909] = 0; +inp[30910] = 1073740536; +inp[30911] = 0; +inp[30912] = 1073740528; +inp[30913] = 0; +inp[30914] = 1073740520; +inp[30915] = 0; +inp[30916] = 1073740512; +inp[30917] = 0; +inp[30918] = 1073740504; +inp[30919] = 0; +inp[30920] = 1073740496; +inp[30921] = 0; +inp[30922] = 1073740488; +inp[30923] = 0; +inp[30924] = 1073740480; +inp[30925] = 0; +inp[30926] = 1073740472; +inp[30927] = 0; +inp[30928] = 1073740464; +inp[30929] = 0; +inp[30930] = 1073740456; +inp[30931] = 0; +inp[30932] = 1073740448; +inp[30933] = 0; +inp[30934] = 1073740440; +inp[30935] = 0; +inp[30936] = 1073740432; +inp[30937] = 0; +inp[30938] = 1073740424; +inp[30939] = 0; +inp[30940] = 1073740416; +inp[30941] = 0; +inp[30942] = 1073740408; +inp[30943] = 0; +inp[30944] = 1073740400; +inp[30945] = 0; +inp[30946] = 1073740392; +inp[30947] = 0; +inp[30948] = 1073740384; +inp[30949] = 0; +inp[30950] = 1073740376; +inp[30951] = 0; +inp[30952] = 1073740368; +inp[30953] = 0; +inp[30954] = 1073740360; +inp[30955] = 0; +inp[30956] = 1073740352; +inp[30957] = 0; +inp[30958] = 1073740344; +inp[30959] = 0; +inp[30960] = 1073740336; +inp[30961] = 0; +inp[30962] = 1073740328; +inp[30963] = 0; +inp[30964] = 1073740320; +inp[30965] = 0; +inp[30966] = 1073740312; +inp[30967] = 0; +inp[30968] = 1073740304; +inp[30969] = 0; +inp[30970] = 1073740296; +inp[30971] = 0; +inp[30972] = 1073740288; +inp[30973] = 0; +inp[30974] = 1073740280; +inp[30975] = 0; +inp[30976] = 1073740272; +inp[30977] = 0; +inp[30978] = 1073740264; +inp[30979] = 0; +inp[30980] = 1073740256; +inp[30981] = 0; +inp[30982] = 1073740248; +inp[30983] = 0; +inp[30984] = 1073740240; +inp[30985] = 0; +inp[30986] = 1073740232; +inp[30987] = 0; +inp[30988] = 1073740224; +inp[30989] = 0; +inp[30990] = 1073740216; +inp[30991] = 0; +inp[30992] = 1073740208; +inp[30993] = 0; +inp[30994] = 1073740200; +inp[30995] = 0; +inp[30996] = 1073740192; +inp[30997] = 0; +inp[30998] = 1073740184; +inp[30999] = 0; +inp[31000] = 1073740176; +inp[31001] = 0; +inp[31002] = 1073740168; +inp[31003] = 0; +inp[31004] = 1073740160; +inp[31005] = 0; +inp[31006] = 1073740152; +inp[31007] = 0; +inp[31008] = 1073740144; +inp[31009] = 0; +inp[31010] = 1073740136; +inp[31011] = 0; +inp[31012] = 1073740128; +inp[31013] = 0; +inp[31014] = 1073740120; +inp[31015] = 0; +inp[31016] = 1073740112; +inp[31017] = 0; +inp[31018] = 1073740104; +inp[31019] = 0; +inp[31020] = 1073740096; +inp[31021] = 0; +inp[31022] = 1073740088; +inp[31023] = 0; +inp[31024] = 1073740080; +inp[31025] = 0; +inp[31026] = 1073740072; +inp[31027] = 0; +inp[31028] = 1073740064; +inp[31029] = 0; +inp[31030] = 1073740056; +inp[31031] = 0; +inp[31032] = 1073740048; +inp[31033] = 0; +inp[31034] = 1073740040; +inp[31035] = 0; +inp[31036] = 1073740032; +inp[31037] = 0; +inp[31038] = 1073740024; +inp[31039] = 0; +inp[31040] = 1073740016; +inp[31041] = 0; +inp[31042] = 1073740008; +inp[31043] = 0; +inp[31044] = 1073740000; +inp[31045] = 0; +inp[31046] = 1073739992; +inp[31047] = 0; +inp[31048] = 1073739984; +inp[31049] = 0; +inp[31050] = 1073739976; +inp[31051] = 0; +inp[31052] = 1073739968; +inp[31053] = 0; +inp[31054] = 1073739960; +inp[31055] = 0; +inp[31056] = 1073739952; +inp[31057] = 0; +inp[31058] = 1073739944; +inp[31059] = 0; +inp[31060] = 1073739936; +inp[31061] = 0; +inp[31062] = 1073739928; +inp[31063] = 0; +inp[31064] = 1073739920; +inp[31065] = 0; +inp[31066] = 1073739912; +inp[31067] = 0; +inp[31068] = 1073739904; +inp[31069] = 0; +inp[31070] = 1073739896; +inp[31071] = 0; +inp[31072] = 1073739888; +inp[31073] = 0; +inp[31074] = 1073739880; +inp[31075] = 0; +inp[31076] = 1073739872; +inp[31077] = 0; +inp[31078] = 1073739864; +inp[31079] = 0; +inp[31080] = 1073739856; +inp[31081] = 0; +inp[31082] = 1073739848; +inp[31083] = 0; +inp[31084] = 1073739840; +inp[31085] = 0; +inp[31086] = 1073739832; +inp[31087] = 0; +inp[31088] = 1073739824; +inp[31089] = 0; +inp[31090] = 1073739816; +inp[31091] = 0; +inp[31092] = 1073739808; +inp[31093] = 0; +inp[31094] = 1073739800; +inp[31095] = 0; +inp[31096] = 1073739792; +inp[31097] = 0; +inp[31098] = 1073739784; +inp[31099] = 0; +inp[31100] = 1073741824; +inp[31101] = 1073741824; +inp[31102] = 1073741820; +inp[31103] = 0; +inp[31104] = 1073741816; +inp[31105] = 0; +inp[31106] = 1073741812; +inp[31107] = 0; +inp[31108] = 1073741808; +inp[31109] = 0; +inp[31110] = 1073741804; +inp[31111] = 0; +inp[31112] = 1073741800; +inp[31113] = 0; +inp[31114] = 1073741796; +inp[31115] = 0; +inp[31116] = 1073741792; +inp[31117] = 0; +inp[31118] = 1073741788; +inp[31119] = 0; +inp[31120] = 1073741784; +inp[31121] = 0; +inp[31122] = 1073741780; +inp[31123] = 0; +inp[31124] = 1073741776; +inp[31125] = 0; +inp[31126] = 1073741772; +inp[31127] = 0; +inp[31128] = 1073741768; +inp[31129] = 0; +inp[31130] = 1073741764; +inp[31131] = 0; +inp[31132] = 1073741760; +inp[31133] = 0; +inp[31134] = 1073741756; +inp[31135] = 0; +inp[31136] = 1073741752; +inp[31137] = 0; +inp[31138] = 1073741748; +inp[31139] = 0; +inp[31140] = 1073741744; +inp[31141] = 0; +inp[31142] = 1073741740; +inp[31143] = 0; +inp[31144] = 1073741736; +inp[31145] = 0; +inp[31146] = 1073741732; +inp[31147] = 0; +inp[31148] = 1073741728; +inp[31149] = 0; +inp[31150] = 1073741724; +inp[31151] = 0; +inp[31152] = 1073741720; +inp[31153] = 0; +inp[31154] = 1073741716; +inp[31155] = 0; +inp[31156] = 1073741712; +inp[31157] = 0; +inp[31158] = 1073741708; +inp[31159] = 0; +inp[31160] = 1073741704; +inp[31161] = 0; +inp[31162] = 1073741700; +inp[31163] = 0; +inp[31164] = 1073741696; +inp[31165] = 0; +inp[31166] = 1073741692; +inp[31167] = 0; +inp[31168] = 1073741688; +inp[31169] = 0; +inp[31170] = 1073741684; +inp[31171] = 0; +inp[31172] = 1073741680; +inp[31173] = 0; +inp[31174] = 1073741676; +inp[31175] = 0; +inp[31176] = 1073741672; +inp[31177] = 0; +inp[31178] = 1073741668; +inp[31179] = 0; +inp[31180] = 1073741664; +inp[31181] = 0; +inp[31182] = 1073741660; +inp[31183] = 0; +inp[31184] = 1073741656; +inp[31185] = 0; +inp[31186] = 1073741652; +inp[31187] = 0; +inp[31188] = 1073741648; +inp[31189] = 0; +inp[31190] = 1073741644; +inp[31191] = 0; +inp[31192] = 1073741640; +inp[31193] = 0; +inp[31194] = 1073741636; +inp[31195] = 0; +inp[31196] = 1073741632; +inp[31197] = 0; +inp[31198] = 1073741628; +inp[31199] = 0; +inp[31200] = 1073741624; +inp[31201] = 0; +inp[31202] = 1073741620; +inp[31203] = 0; +inp[31204] = 1073741616; +inp[31205] = 0; +inp[31206] = 1073741612; +inp[31207] = 0; +inp[31208] = 1073741608; +inp[31209] = 0; +inp[31210] = 1073741604; +inp[31211] = 0; +inp[31212] = 1073741600; +inp[31213] = 0; +inp[31214] = 1073741596; +inp[31215] = 0; +inp[31216] = 1073741592; +inp[31217] = 0; +inp[31218] = 1073741588; +inp[31219] = 0; +inp[31220] = 1073741584; +inp[31221] = 0; +inp[31222] = 1073741580; +inp[31223] = 0; +inp[31224] = 1073741576; +inp[31225] = 0; +inp[31226] = 1073741572; +inp[31227] = 0; +inp[31228] = 1073741568; +inp[31229] = 0; +inp[31230] = 1073741564; +inp[31231] = 0; +inp[31232] = 1073741560; +inp[31233] = 0; +inp[31234] = 1073741556; +inp[31235] = 0; +inp[31236] = 1073741552; +inp[31237] = 0; +inp[31238] = 1073741548; +inp[31239] = 0; +inp[31240] = 1073741544; +inp[31241] = 0; +inp[31242] = 1073741540; +inp[31243] = 0; +inp[31244] = 1073741536; +inp[31245] = 0; +inp[31246] = 1073741532; +inp[31247] = 0; +inp[31248] = 1073741528; +inp[31249] = 0; +inp[31250] = 1073741524; +inp[31251] = 0; +inp[31252] = 1073741520; +inp[31253] = 0; +inp[31254] = 1073741516; +inp[31255] = 0; +inp[31256] = 1073741512; +inp[31257] = 0; +inp[31258] = 1073741508; +inp[31259] = 0; +inp[31260] = 1073741504; +inp[31261] = 0; +inp[31262] = 1073741500; +inp[31263] = 0; +inp[31264] = 1073741496; +inp[31265] = 0; +inp[31266] = 1073741492; +inp[31267] = 0; +inp[31268] = 1073741488; +inp[31269] = 0; +inp[31270] = 1073741484; +inp[31271] = 0; +inp[31272] = 1073741480; +inp[31273] = 0; +inp[31274] = 1073741476; +inp[31275] = 0; +inp[31276] = 1073741472; +inp[31277] = 0; +inp[31278] = 1073741468; +inp[31279] = 0; +inp[31280] = 1073741464; +inp[31281] = 0; +inp[31282] = 1073741460; +inp[31283] = 0; +inp[31284] = 1073741456; +inp[31285] = 0; +inp[31286] = 1073741452; +inp[31287] = 0; +inp[31288] = 1073741448; +inp[31289] = 0; +inp[31290] = 1073741444; +inp[31291] = 0; +inp[31292] = 1073741440; +inp[31293] = 0; +inp[31294] = 1073741436; +inp[31295] = 0; +inp[31296] = 1073741432; +inp[31297] = 0; +inp[31298] = 1073741428; +inp[31299] = 0; +inp[31300] = 1073741424; +inp[31301] = 0; +inp[31302] = 1073741420; +inp[31303] = 0; +inp[31304] = 1073741416; +inp[31305] = 0; +inp[31306] = 1073741412; +inp[31307] = 0; +inp[31308] = 1073741408; +inp[31309] = 0; +inp[31310] = 1073741404; +inp[31311] = 0; +inp[31312] = 1073741400; +inp[31313] = 0; +inp[31314] = 1073741396; +inp[31315] = 0; +inp[31316] = 1073741392; +inp[31317] = 0; +inp[31318] = 1073741388; +inp[31319] = 0; +inp[31320] = 1073741384; +inp[31321] = 0; +inp[31322] = 1073741380; +inp[31323] = 0; +inp[31324] = 1073741376; +inp[31325] = 0; +inp[31326] = 1073741372; +inp[31327] = 0; +inp[31328] = 1073741368; +inp[31329] = 0; +inp[31330] = 1073741364; +inp[31331] = 0; +inp[31332] = 1073741360; +inp[31333] = 0; +inp[31334] = 1073741356; +inp[31335] = 0; +inp[31336] = 1073741352; +inp[31337] = 0; +inp[31338] = 1073741348; +inp[31339] = 0; +inp[31340] = 1073741344; +inp[31341] = 0; +inp[31342] = 1073741340; +inp[31343] = 0; +inp[31344] = 1073741336; +inp[31345] = 0; +inp[31346] = 1073741332; +inp[31347] = 0; +inp[31348] = 1073741328; +inp[31349] = 0; +inp[31350] = 1073741324; +inp[31351] = 0; +inp[31352] = 1073741320; +inp[31353] = 0; +inp[31354] = 1073741316; +inp[31355] = 0; +inp[31356] = 1073741312; +inp[31357] = 0; +inp[31358] = 1073741308; +inp[31359] = 0; +inp[31360] = 1073741304; +inp[31361] = 0; +inp[31362] = 1073741300; +inp[31363] = 0; +inp[31364] = 1073741296; +inp[31365] = 0; +inp[31366] = 1073741292; +inp[31367] = 0; +inp[31368] = 1073741288; +inp[31369] = 0; +inp[31370] = 1073741284; +inp[31371] = 0; +inp[31372] = 1073741280; +inp[31373] = 0; +inp[31374] = 1073741276; +inp[31375] = 0; +inp[31376] = 1073741272; +inp[31377] = 0; +inp[31378] = 1073741268; +inp[31379] = 0; +inp[31380] = 1073741264; +inp[31381] = 0; +inp[31382] = 1073741260; +inp[31383] = 0; +inp[31384] = 1073741256; +inp[31385] = 0; +inp[31386] = 1073741252; +inp[31387] = 0; +inp[31388] = 1073741248; +inp[31389] = 0; +inp[31390] = 1073741244; +inp[31391] = 0; +inp[31392] = 1073741240; +inp[31393] = 0; +inp[31394] = 1073741236; +inp[31395] = 0; +inp[31396] = 1073741232; +inp[31397] = 0; +inp[31398] = 1073741228; +inp[31399] = 0; +inp[31400] = 1073741224; +inp[31401] = 0; +inp[31402] = 1073741220; +inp[31403] = 0; +inp[31404] = 1073741216; +inp[31405] = 0; +inp[31406] = 1073741212; +inp[31407] = 0; +inp[31408] = 1073741208; +inp[31409] = 0; +inp[31410] = 1073741204; +inp[31411] = 0; +inp[31412] = 1073741200; +inp[31413] = 0; +inp[31414] = 1073741196; +inp[31415] = 0; +inp[31416] = 1073741192; +inp[31417] = 0; +inp[31418] = 1073741188; +inp[31419] = 0; +inp[31420] = 1073741184; +inp[31421] = 0; +inp[31422] = 1073741180; +inp[31423] = 0; +inp[31424] = 1073741176; +inp[31425] = 0; +inp[31426] = 1073741172; +inp[31427] = 0; +inp[31428] = 1073741168; +inp[31429] = 0; +inp[31430] = 1073741164; +inp[31431] = 0; +inp[31432] = 1073741160; +inp[31433] = 0; +inp[31434] = 1073741156; +inp[31435] = 0; +inp[31436] = 1073741152; +inp[31437] = 0; +inp[31438] = 1073741148; +inp[31439] = 0; +inp[31440] = 1073741144; +inp[31441] = 0; +inp[31442] = 1073741140; +inp[31443] = 0; +inp[31444] = 1073741136; +inp[31445] = 0; +inp[31446] = 1073741132; +inp[31447] = 0; +inp[31448] = 1073741128; +inp[31449] = 0; +inp[31450] = 1073741124; +inp[31451] = 0; +inp[31452] = 1073741120; +inp[31453] = 0; +inp[31454] = 1073741116; +inp[31455] = 0; +inp[31456] = 1073741112; +inp[31457] = 0; +inp[31458] = 1073741108; +inp[31459] = 0; +inp[31460] = 1073741104; +inp[31461] = 0; +inp[31462] = 1073741100; +inp[31463] = 0; +inp[31464] = 1073741096; +inp[31465] = 0; +inp[31466] = 1073741092; +inp[31467] = 0; +inp[31468] = 1073741088; +inp[31469] = 0; +inp[31470] = 1073741084; +inp[31471] = 0; +inp[31472] = 1073741080; +inp[31473] = 0; +inp[31474] = 1073741076; +inp[31475] = 0; +inp[31476] = 1073741072; +inp[31477] = 0; +inp[31478] = 1073741068; +inp[31479] = 0; +inp[31480] = 1073741064; +inp[31481] = 0; +inp[31482] = 1073741060; +inp[31483] = 0; +inp[31484] = 1073741056; +inp[31485] = 0; +inp[31486] = 1073741052; +inp[31487] = 0; +inp[31488] = 1073741048; +inp[31489] = 0; +inp[31490] = 1073741044; +inp[31491] = 0; +inp[31492] = 1073741040; +inp[31493] = 0; +inp[31494] = 1073741036; +inp[31495] = 0; +inp[31496] = 1073741032; +inp[31497] = 0; +inp[31498] = 1073741028; +inp[31499] = 0; +inp[31500] = 1073741024; +inp[31501] = 0; +inp[31502] = 1073741020; +inp[31503] = 0; +inp[31504] = 1073741016; +inp[31505] = 0; +inp[31506] = 1073741012; +inp[31507] = 0; +inp[31508] = 1073741008; +inp[31509] = 0; +inp[31510] = 1073741004; +inp[31511] = 0; +inp[31512] = 1073741000; +inp[31513] = 0; +inp[31514] = 1073740996; +inp[31515] = 0; +inp[31516] = 1073740992; +inp[31517] = 0; +inp[31518] = 1073740988; +inp[31519] = 0; +inp[31520] = 1073740984; +inp[31521] = 0; +inp[31522] = 1073740980; +inp[31523] = 0; +inp[31524] = 1073740976; +inp[31525] = 0; +inp[31526] = 1073740972; +inp[31527] = 0; +inp[31528] = 1073740968; +inp[31529] = 0; +inp[31530] = 1073740964; +inp[31531] = 0; +inp[31532] = 1073740960; +inp[31533] = 0; +inp[31534] = 1073740956; +inp[31535] = 0; +inp[31536] = 1073740952; +inp[31537] = 0; +inp[31538] = 1073740948; +inp[31539] = 0; +inp[31540] = 1073740944; +inp[31541] = 0; +inp[31542] = 1073740940; +inp[31543] = 0; +inp[31544] = 1073740936; +inp[31545] = 0; +inp[31546] = 1073740932; +inp[31547] = 0; +inp[31548] = 1073740928; +inp[31549] = 0; +inp[31550] = 1073740924; +inp[31551] = 0; +inp[31552] = 1073740920; +inp[31553] = 0; +inp[31554] = 1073740916; +inp[31555] = 0; +inp[31556] = 1073740912; +inp[31557] = 0; +inp[31558] = 1073740908; +inp[31559] = 0; +inp[31560] = 1073740904; +inp[31561] = 0; +inp[31562] = 1073740900; +inp[31563] = 0; +inp[31564] = 1073740896; +inp[31565] = 0; +inp[31566] = 1073740892; +inp[31567] = 0; +inp[31568] = 1073740888; +inp[31569] = 0; +inp[31570] = 1073740884; +inp[31571] = 0; +inp[31572] = 1073740880; +inp[31573] = 0; +inp[31574] = 1073740876; +inp[31575] = 0; +inp[31576] = 1073740872; +inp[31577] = 0; +inp[31578] = 1073740868; +inp[31579] = 0; +inp[31580] = 1073740864; +inp[31581] = 0; +inp[31582] = 1073740860; +inp[31583] = 0; +inp[31584] = 1073740856; +inp[31585] = 0; +inp[31586] = 1073740852; +inp[31587] = 0; +inp[31588] = 1073740848; +inp[31589] = 0; +inp[31590] = 1073740844; +inp[31591] = 0; +inp[31592] = 1073740840; +inp[31593] = 0; +inp[31594] = 1073740836; +inp[31595] = 0; +inp[31596] = 1073740832; +inp[31597] = 0; +inp[31598] = 1073740828; +inp[31599] = 0; +inp[31600] = 1073740824; +inp[31601] = 0; +inp[31602] = 1073740820; +inp[31603] = 0; +inp[31604] = 1073740816; +inp[31605] = 0; +inp[31606] = 1073740812; +inp[31607] = 0; +inp[31608] = 1073740808; +inp[31609] = 0; +inp[31610] = 1073740804; +inp[31611] = 0; +inp[31612] = 1073741824; +inp[31613] = 1073741824; +inp[31614] = 1073741822; +inp[31615] = 0; +inp[31616] = 1073741820; +inp[31617] = 0; +inp[31618] = 1073741818; +inp[31619] = 0; +inp[31620] = 1073741816; +inp[31621] = 0; +inp[31622] = 1073741814; +inp[31623] = 0; +inp[31624] = 1073741812; +inp[31625] = 0; +inp[31626] = 1073741810; +inp[31627] = 0; +inp[31628] = 1073741808; +inp[31629] = 0; +inp[31630] = 1073741806; +inp[31631] = 0; +inp[31632] = 1073741804; +inp[31633] = 0; +inp[31634] = 1073741802; +inp[31635] = 0; +inp[31636] = 1073741800; +inp[31637] = 0; +inp[31638] = 1073741798; +inp[31639] = 0; +inp[31640] = 1073741796; +inp[31641] = 0; +inp[31642] = 1073741794; +inp[31643] = 0; +inp[31644] = 1073741792; +inp[31645] = 0; +inp[31646] = 1073741790; +inp[31647] = 0; +inp[31648] = 1073741788; +inp[31649] = 0; +inp[31650] = 1073741786; +inp[31651] = 0; +inp[31652] = 1073741784; +inp[31653] = 0; +inp[31654] = 1073741782; +inp[31655] = 0; +inp[31656] = 1073741780; +inp[31657] = 0; +inp[31658] = 1073741778; +inp[31659] = 0; +inp[31660] = 1073741776; +inp[31661] = 0; +inp[31662] = 1073741774; +inp[31663] = 0; +inp[31664] = 1073741772; +inp[31665] = 0; +inp[31666] = 1073741770; +inp[31667] = 0; +inp[31668] = 1073741768; +inp[31669] = 0; +inp[31670] = 1073741766; +inp[31671] = 0; +inp[31672] = 1073741764; +inp[31673] = 0; +inp[31674] = 1073741762; +inp[31675] = 0; +inp[31676] = 1073741760; +inp[31677] = 0; +inp[31678] = 1073741758; +inp[31679] = 0; +inp[31680] = 1073741756; +inp[31681] = 0; +inp[31682] = 1073741754; +inp[31683] = 0; +inp[31684] = 1073741752; +inp[31685] = 0; +inp[31686] = 1073741750; +inp[31687] = 0; +inp[31688] = 1073741748; +inp[31689] = 0; +inp[31690] = 1073741746; +inp[31691] = 0; +inp[31692] = 1073741744; +inp[31693] = 0; +inp[31694] = 1073741742; +inp[31695] = 0; +inp[31696] = 1073741740; +inp[31697] = 0; +inp[31698] = 1073741738; +inp[31699] = 0; +inp[31700] = 1073741736; +inp[31701] = 0; +inp[31702] = 1073741734; +inp[31703] = 0; +inp[31704] = 1073741732; +inp[31705] = 0; +inp[31706] = 1073741730; +inp[31707] = 0; +inp[31708] = 1073741728; +inp[31709] = 0; +inp[31710] = 1073741726; +inp[31711] = 0; +inp[31712] = 1073741724; +inp[31713] = 0; +inp[31714] = 1073741722; +inp[31715] = 0; +inp[31716] = 1073741720; +inp[31717] = 0; +inp[31718] = 1073741718; +inp[31719] = 0; +inp[31720] = 1073741716; +inp[31721] = 0; +inp[31722] = 1073741714; +inp[31723] = 0; +inp[31724] = 1073741712; +inp[31725] = 0; +inp[31726] = 1073741710; +inp[31727] = 0; +inp[31728] = 1073741708; +inp[31729] = 0; +inp[31730] = 1073741706; +inp[31731] = 0; +inp[31732] = 1073741704; +inp[31733] = 0; +inp[31734] = 1073741702; +inp[31735] = 0; +inp[31736] = 1073741700; +inp[31737] = 0; +inp[31738] = 1073741698; +inp[31739] = 0; +inp[31740] = 1073741696; +inp[31741] = 0; +inp[31742] = 1073741694; +inp[31743] = 0; +inp[31744] = 1073741692; +inp[31745] = 0; +inp[31746] = 1073741690; +inp[31747] = 0; +inp[31748] = 1073741688; +inp[31749] = 0; +inp[31750] = 1073741686; +inp[31751] = 0; +inp[31752] = 1073741684; +inp[31753] = 0; +inp[31754] = 1073741682; +inp[31755] = 0; +inp[31756] = 1073741680; +inp[31757] = 0; +inp[31758] = 1073741678; +inp[31759] = 0; +inp[31760] = 1073741676; +inp[31761] = 0; +inp[31762] = 1073741674; +inp[31763] = 0; +inp[31764] = 1073741672; +inp[31765] = 0; +inp[31766] = 1073741670; +inp[31767] = 0; +inp[31768] = 1073741668; +inp[31769] = 0; +inp[31770] = 1073741666; +inp[31771] = 0; +inp[31772] = 1073741664; +inp[31773] = 0; +inp[31774] = 1073741662; +inp[31775] = 0; +inp[31776] = 1073741660; +inp[31777] = 0; +inp[31778] = 1073741658; +inp[31779] = 0; +inp[31780] = 1073741656; +inp[31781] = 0; +inp[31782] = 1073741654; +inp[31783] = 0; +inp[31784] = 1073741652; +inp[31785] = 0; +inp[31786] = 1073741650; +inp[31787] = 0; +inp[31788] = 1073741648; +inp[31789] = 0; +inp[31790] = 1073741646; +inp[31791] = 0; +inp[31792] = 1073741644; +inp[31793] = 0; +inp[31794] = 1073741642; +inp[31795] = 0; +inp[31796] = 1073741640; +inp[31797] = 0; +inp[31798] = 1073741638; +inp[31799] = 0; +inp[31800] = 1073741636; +inp[31801] = 0; +inp[31802] = 1073741634; +inp[31803] = 0; +inp[31804] = 1073741632; +inp[31805] = 0; +inp[31806] = 1073741630; +inp[31807] = 0; +inp[31808] = 1073741628; +inp[31809] = 0; +inp[31810] = 1073741626; +inp[31811] = 0; +inp[31812] = 1073741624; +inp[31813] = 0; +inp[31814] = 1073741622; +inp[31815] = 0; +inp[31816] = 1073741620; +inp[31817] = 0; +inp[31818] = 1073741618; +inp[31819] = 0; +inp[31820] = 1073741616; +inp[31821] = 0; +inp[31822] = 1073741614; +inp[31823] = 0; +inp[31824] = 1073741612; +inp[31825] = 0; +inp[31826] = 1073741610; +inp[31827] = 0; +inp[31828] = 1073741608; +inp[31829] = 0; +inp[31830] = 1073741606; +inp[31831] = 0; +inp[31832] = 1073741604; +inp[31833] = 0; +inp[31834] = 1073741602; +inp[31835] = 0; +inp[31836] = 1073741600; +inp[31837] = 0; +inp[31838] = 1073741598; +inp[31839] = 0; +inp[31840] = 1073741596; +inp[31841] = 0; +inp[31842] = 1073741594; +inp[31843] = 0; +inp[31844] = 1073741592; +inp[31845] = 0; +inp[31846] = 1073741590; +inp[31847] = 0; +inp[31848] = 1073741588; +inp[31849] = 0; +inp[31850] = 1073741586; +inp[31851] = 0; +inp[31852] = 1073741584; +inp[31853] = 0; +inp[31854] = 1073741582; +inp[31855] = 0; +inp[31856] = 1073741580; +inp[31857] = 0; +inp[31858] = 1073741578; +inp[31859] = 0; +inp[31860] = 1073741576; +inp[31861] = 0; +inp[31862] = 1073741574; +inp[31863] = 0; +inp[31864] = 1073741572; +inp[31865] = 0; +inp[31866] = 1073741570; +inp[31867] = 0; +inp[31868] = 1073741568; +inp[31869] = 0; +inp[31870] = 1073741566; +inp[31871] = 0; +inp[31872] = 1073741564; +inp[31873] = 0; +inp[31874] = 1073741562; +inp[31875] = 0; +inp[31876] = 1073741560; +inp[31877] = 0; +inp[31878] = 1073741558; +inp[31879] = 0; +inp[31880] = 1073741556; +inp[31881] = 0; +inp[31882] = 1073741554; +inp[31883] = 0; +inp[31884] = 1073741552; +inp[31885] = 0; +inp[31886] = 1073741550; +inp[31887] = 0; +inp[31888] = 1073741548; +inp[31889] = 0; +inp[31890] = 1073741546; +inp[31891] = 0; +inp[31892] = 1073741544; +inp[31893] = 0; +inp[31894] = 1073741542; +inp[31895] = 0; +inp[31896] = 1073741540; +inp[31897] = 0; +inp[31898] = 1073741538; +inp[31899] = 0; +inp[31900] = 1073741536; +inp[31901] = 0; +inp[31902] = 1073741534; +inp[31903] = 0; +inp[31904] = 1073741532; +inp[31905] = 0; +inp[31906] = 1073741530; +inp[31907] = 0; +inp[31908] = 1073741528; +inp[31909] = 0; +inp[31910] = 1073741526; +inp[31911] = 0; +inp[31912] = 1073741524; +inp[31913] = 0; +inp[31914] = 1073741522; +inp[31915] = 0; +inp[31916] = 1073741520; +inp[31917] = 0; +inp[31918] = 1073741518; +inp[31919] = 0; +inp[31920] = 1073741516; +inp[31921] = 0; +inp[31922] = 1073741514; +inp[31923] = 0; +inp[31924] = 1073741512; +inp[31925] = 0; +inp[31926] = 1073741510; +inp[31927] = 0; +inp[31928] = 1073741508; +inp[31929] = 0; +inp[31930] = 1073741506; +inp[31931] = 0; +inp[31932] = 1073741504; +inp[31933] = 0; +inp[31934] = 1073741502; +inp[31935] = 0; +inp[31936] = 1073741500; +inp[31937] = 0; +inp[31938] = 1073741498; +inp[31939] = 0; +inp[31940] = 1073741496; +inp[31941] = 0; +inp[31942] = 1073741494; +inp[31943] = 0; +inp[31944] = 1073741492; +inp[31945] = 0; +inp[31946] = 1073741490; +inp[31947] = 0; +inp[31948] = 1073741488; +inp[31949] = 0; +inp[31950] = 1073741486; +inp[31951] = 0; +inp[31952] = 1073741484; +inp[31953] = 0; +inp[31954] = 1073741482; +inp[31955] = 0; +inp[31956] = 1073741480; +inp[31957] = 0; +inp[31958] = 1073741478; +inp[31959] = 0; +inp[31960] = 1073741476; +inp[31961] = 0; +inp[31962] = 1073741474; +inp[31963] = 0; +inp[31964] = 1073741472; +inp[31965] = 0; +inp[31966] = 1073741470; +inp[31967] = 0; +inp[31968] = 1073741468; +inp[31969] = 0; +inp[31970] = 1073741466; +inp[31971] = 0; +inp[31972] = 1073741464; +inp[31973] = 0; +inp[31974] = 1073741462; +inp[31975] = 0; +inp[31976] = 1073741460; +inp[31977] = 0; +inp[31978] = 1073741458; +inp[31979] = 0; +inp[31980] = 1073741456; +inp[31981] = 0; +inp[31982] = 1073741454; +inp[31983] = 0; +inp[31984] = 1073741452; +inp[31985] = 0; +inp[31986] = 1073741450; +inp[31987] = 0; +inp[31988] = 1073741448; +inp[31989] = 0; +inp[31990] = 1073741446; +inp[31991] = 0; +inp[31992] = 1073741444; +inp[31993] = 0; +inp[31994] = 1073741442; +inp[31995] = 0; +inp[31996] = 1073741440; +inp[31997] = 0; +inp[31998] = 1073741438; +inp[31999] = 0; +inp[32000] = 1073741436; +inp[32001] = 0; +inp[32002] = 1073741434; +inp[32003] = 0; +inp[32004] = 1073741432; +inp[32005] = 0; +inp[32006] = 1073741430; +inp[32007] = 0; +inp[32008] = 1073741428; +inp[32009] = 0; +inp[32010] = 1073741426; +inp[32011] = 0; +inp[32012] = 1073741424; +inp[32013] = 0; +inp[32014] = 1073741422; +inp[32015] = 0; +inp[32016] = 1073741420; +inp[32017] = 0; +inp[32018] = 1073741418; +inp[32019] = 0; +inp[32020] = 1073741416; +inp[32021] = 0; +inp[32022] = 1073741414; +inp[32023] = 0; +inp[32024] = 1073741412; +inp[32025] = 0; +inp[32026] = 1073741410; +inp[32027] = 0; +inp[32028] = 1073741408; +inp[32029] = 0; +inp[32030] = 1073741406; +inp[32031] = 0; +inp[32032] = 1073741404; +inp[32033] = 0; +inp[32034] = 1073741402; +inp[32035] = 0; +inp[32036] = 1073741400; +inp[32037] = 0; +inp[32038] = 1073741398; +inp[32039] = 0; +inp[32040] = 1073741396; +inp[32041] = 0; +inp[32042] = 1073741394; +inp[32043] = 0; +inp[32044] = 1073741392; +inp[32045] = 0; +inp[32046] = 1073741390; +inp[32047] = 0; +inp[32048] = 1073741388; +inp[32049] = 0; +inp[32050] = 1073741386; +inp[32051] = 0; +inp[32052] = 1073741384; +inp[32053] = 0; +inp[32054] = 1073741382; +inp[32055] = 0; +inp[32056] = 1073741380; +inp[32057] = 0; +inp[32058] = 1073741378; +inp[32059] = 0; +inp[32060] = 1073741376; +inp[32061] = 0; +inp[32062] = 1073741374; +inp[32063] = 0; +inp[32064] = 1073741372; +inp[32065] = 0; +inp[32066] = 1073741370; +inp[32067] = 0; +inp[32068] = 1073741368; +inp[32069] = 0; +inp[32070] = 1073741366; +inp[32071] = 0; +inp[32072] = 1073741364; +inp[32073] = 0; +inp[32074] = 1073741362; +inp[32075] = 0; +inp[32076] = 1073741360; +inp[32077] = 0; +inp[32078] = 1073741358; +inp[32079] = 0; +inp[32080] = 1073741356; +inp[32081] = 0; +inp[32082] = 1073741354; +inp[32083] = 0; +inp[32084] = 1073741352; +inp[32085] = 0; +inp[32086] = 1073741350; +inp[32087] = 0; +inp[32088] = 1073741348; +inp[32089] = 0; +inp[32090] = 1073741346; +inp[32091] = 0; +inp[32092] = 1073741344; +inp[32093] = 0; +inp[32094] = 1073741342; +inp[32095] = 0; +inp[32096] = 1073741340; +inp[32097] = 0; +inp[32098] = 1073741338; +inp[32099] = 0; +inp[32100] = 1073741336; +inp[32101] = 0; +inp[32102] = 1073741334; +inp[32103] = 0; +inp[32104] = 1073741332; +inp[32105] = 0; +inp[32106] = 1073741330; +inp[32107] = 0; +inp[32108] = 1073741328; +inp[32109] = 0; +inp[32110] = 1073741326; +inp[32111] = 0; +inp[32112] = 1073741324; +inp[32113] = 0; +inp[32114] = 1073741322; +inp[32115] = 0; +inp[32116] = 1073741320; +inp[32117] = 0; +inp[32118] = 1073741318; +inp[32119] = 0; +inp[32120] = 1073741316; +inp[32121] = 0; +inp[32122] = 1073741314; +inp[32123] = 0; +inp[32124] = 1073741824; +inp[32125] = 1073741824; +inp[32126] = 1073741823; +inp[32127] = 0; +inp[32128] = 1073741822; +inp[32129] = 0; +inp[32130] = 1073741821; +inp[32131] = 0; +inp[32132] = 1073741820; +inp[32133] = 0; +inp[32134] = 1073741819; +inp[32135] = 0; +inp[32136] = 1073741818; +inp[32137] = 0; +inp[32138] = 1073741817; +inp[32139] = 0; +inp[32140] = 1073741816; +inp[32141] = 0; +inp[32142] = 1073741815; +inp[32143] = 0; +inp[32144] = 1073741814; +inp[32145] = 0; +inp[32146] = 1073741813; +inp[32147] = 0; +inp[32148] = 1073741812; +inp[32149] = 0; +inp[32150] = 1073741811; +inp[32151] = 0; +inp[32152] = 1073741810; +inp[32153] = 0; +inp[32154] = 1073741809; +inp[32155] = 0; +inp[32156] = 1073741808; +inp[32157] = 0; +inp[32158] = 1073741807; +inp[32159] = 0; +inp[32160] = 1073741806; +inp[32161] = 0; +inp[32162] = 1073741805; +inp[32163] = 0; +inp[32164] = 1073741804; +inp[32165] = 0; +inp[32166] = 1073741803; +inp[32167] = 0; +inp[32168] = 1073741802; +inp[32169] = 0; +inp[32170] = 1073741801; +inp[32171] = 0; +inp[32172] = 1073741800; +inp[32173] = 0; +inp[32174] = 1073741799; +inp[32175] = 0; +inp[32176] = 1073741798; +inp[32177] = 0; +inp[32178] = 1073741797; +inp[32179] = 0; +inp[32180] = 1073741796; +inp[32181] = 0; +inp[32182] = 1073741795; +inp[32183] = 0; +inp[32184] = 1073741794; +inp[32185] = 0; +inp[32186] = 1073741793; +inp[32187] = 0; +inp[32188] = 1073741792; +inp[32189] = 0; +inp[32190] = 1073741791; +inp[32191] = 0; +inp[32192] = 1073741790; +inp[32193] = 0; +inp[32194] = 1073741789; +inp[32195] = 0; +inp[32196] = 1073741788; +inp[32197] = 0; +inp[32198] = 1073741787; +inp[32199] = 0; +inp[32200] = 1073741786; +inp[32201] = 0; +inp[32202] = 1073741785; +inp[32203] = 0; +inp[32204] = 1073741784; +inp[32205] = 0; +inp[32206] = 1073741783; +inp[32207] = 0; +inp[32208] = 1073741782; +inp[32209] = 0; +inp[32210] = 1073741781; +inp[32211] = 0; +inp[32212] = 1073741780; +inp[32213] = 0; +inp[32214] = 1073741779; +inp[32215] = 0; +inp[32216] = 1073741778; +inp[32217] = 0; +inp[32218] = 1073741777; +inp[32219] = 0; +inp[32220] = 1073741776; +inp[32221] = 0; +inp[32222] = 1073741775; +inp[32223] = 0; +inp[32224] = 1073741774; +inp[32225] = 0; +inp[32226] = 1073741773; +inp[32227] = 0; +inp[32228] = 1073741772; +inp[32229] = 0; +inp[32230] = 1073741771; +inp[32231] = 0; +inp[32232] = 1073741770; +inp[32233] = 0; +inp[32234] = 1073741769; +inp[32235] = 0; +inp[32236] = 1073741768; +inp[32237] = 0; +inp[32238] = 1073741767; +inp[32239] = 0; +inp[32240] = 1073741766; +inp[32241] = 0; +inp[32242] = 1073741765; +inp[32243] = 0; +inp[32244] = 1073741764; +inp[32245] = 0; +inp[32246] = 1073741763; +inp[32247] = 0; +inp[32248] = 1073741762; +inp[32249] = 0; +inp[32250] = 1073741761; +inp[32251] = 0; +inp[32252] = 1073741760; +inp[32253] = 0; +inp[32254] = 1073741759; +inp[32255] = 0; +inp[32256] = 1073741758; +inp[32257] = 0; +inp[32258] = 1073741757; +inp[32259] = 0; +inp[32260] = 1073741756; +inp[32261] = 0; +inp[32262] = 1073741755; +inp[32263] = 0; +inp[32264] = 1073741754; +inp[32265] = 0; +inp[32266] = 1073741753; +inp[32267] = 0; +inp[32268] = 1073741752; +inp[32269] = 0; +inp[32270] = 1073741751; +inp[32271] = 0; +inp[32272] = 1073741750; +inp[32273] = 0; +inp[32274] = 1073741749; +inp[32275] = 0; +inp[32276] = 1073741748; +inp[32277] = 0; +inp[32278] = 1073741747; +inp[32279] = 0; +inp[32280] = 1073741746; +inp[32281] = 0; +inp[32282] = 1073741745; +inp[32283] = 0; +inp[32284] = 1073741744; +inp[32285] = 0; +inp[32286] = 1073741743; +inp[32287] = 0; +inp[32288] = 1073741742; +inp[32289] = 0; +inp[32290] = 1073741741; +inp[32291] = 0; +inp[32292] = 1073741740; +inp[32293] = 0; +inp[32294] = 1073741739; +inp[32295] = 0; +inp[32296] = 1073741738; +inp[32297] = 0; +inp[32298] = 1073741737; +inp[32299] = 0; +inp[32300] = 1073741736; +inp[32301] = 0; +inp[32302] = 1073741735; +inp[32303] = 0; +inp[32304] = 1073741734; +inp[32305] = 0; +inp[32306] = 1073741733; +inp[32307] = 0; +inp[32308] = 1073741732; +inp[32309] = 0; +inp[32310] = 1073741731; +inp[32311] = 0; +inp[32312] = 1073741730; +inp[32313] = 0; +inp[32314] = 1073741729; +inp[32315] = 0; +inp[32316] = 1073741728; +inp[32317] = 0; +inp[32318] = 1073741727; +inp[32319] = 0; +inp[32320] = 1073741726; +inp[32321] = 0; +inp[32322] = 1073741725; +inp[32323] = 0; +inp[32324] = 1073741724; +inp[32325] = 0; +inp[32326] = 1073741723; +inp[32327] = 0; +inp[32328] = 1073741722; +inp[32329] = 0; +inp[32330] = 1073741721; +inp[32331] = 0; +inp[32332] = 1073741720; +inp[32333] = 0; +inp[32334] = 1073741719; +inp[32335] = 0; +inp[32336] = 1073741718; +inp[32337] = 0; +inp[32338] = 1073741717; +inp[32339] = 0; +inp[32340] = 1073741716; +inp[32341] = 0; +inp[32342] = 1073741715; +inp[32343] = 0; +inp[32344] = 1073741714; +inp[32345] = 0; +inp[32346] = 1073741713; +inp[32347] = 0; +inp[32348] = 1073741712; +inp[32349] = 0; +inp[32350] = 1073741711; +inp[32351] = 0; +inp[32352] = 1073741710; +inp[32353] = 0; +inp[32354] = 1073741709; +inp[32355] = 0; +inp[32356] = 1073741708; +inp[32357] = 0; +inp[32358] = 1073741707; +inp[32359] = 0; +inp[32360] = 1073741706; +inp[32361] = 0; +inp[32362] = 1073741705; +inp[32363] = 0; +inp[32364] = 1073741704; +inp[32365] = 0; +inp[32366] = 1073741703; +inp[32367] = 0; +inp[32368] = 1073741702; +inp[32369] = 0; +inp[32370] = 1073741701; +inp[32371] = 0; +inp[32372] = 1073741700; +inp[32373] = 0; +inp[32374] = 1073741699; +inp[32375] = 0; +inp[32376] = 1073741698; +inp[32377] = 0; +inp[32378] = 1073741697; +inp[32379] = 0; +inp[32380] = 1073741696; +inp[32381] = 0; +inp[32382] = 1073741695; +inp[32383] = 0; +inp[32384] = 1073741694; +inp[32385] = 0; +inp[32386] = 1073741693; +inp[32387] = 0; +inp[32388] = 1073741692; +inp[32389] = 0; +inp[32390] = 1073741691; +inp[32391] = 0; +inp[32392] = 1073741690; +inp[32393] = 0; +inp[32394] = 1073741689; +inp[32395] = 0; +inp[32396] = 1073741688; +inp[32397] = 0; +inp[32398] = 1073741687; +inp[32399] = 0; +inp[32400] = 1073741686; +inp[32401] = 0; +inp[32402] = 1073741685; +inp[32403] = 0; +inp[32404] = 1073741684; +inp[32405] = 0; +inp[32406] = 1073741683; +inp[32407] = 0; +inp[32408] = 1073741682; +inp[32409] = 0; +inp[32410] = 1073741681; +inp[32411] = 0; +inp[32412] = 1073741680; +inp[32413] = 0; +inp[32414] = 1073741679; +inp[32415] = 0; +inp[32416] = 1073741678; +inp[32417] = 0; +inp[32418] = 1073741677; +inp[32419] = 0; +inp[32420] = 1073741676; +inp[32421] = 0; +inp[32422] = 1073741675; +inp[32423] = 0; +inp[32424] = 1073741674; +inp[32425] = 0; +inp[32426] = 1073741673; +inp[32427] = 0; +inp[32428] = 1073741672; +inp[32429] = 0; +inp[32430] = 1073741671; +inp[32431] = 0; +inp[32432] = 1073741670; +inp[32433] = 0; +inp[32434] = 1073741669; +inp[32435] = 0; +inp[32436] = 1073741668; +inp[32437] = 0; +inp[32438] = 1073741667; +inp[32439] = 0; +inp[32440] = 1073741666; +inp[32441] = 0; +inp[32442] = 1073741665; +inp[32443] = 0; +inp[32444] = 1073741664; +inp[32445] = 0; +inp[32446] = 1073741663; +inp[32447] = 0; +inp[32448] = 1073741662; +inp[32449] = 0; +inp[32450] = 1073741661; +inp[32451] = 0; +inp[32452] = 1073741660; +inp[32453] = 0; +inp[32454] = 1073741659; +inp[32455] = 0; +inp[32456] = 1073741658; +inp[32457] = 0; +inp[32458] = 1073741657; +inp[32459] = 0; +inp[32460] = 1073741656; +inp[32461] = 0; +inp[32462] = 1073741655; +inp[32463] = 0; +inp[32464] = 1073741654; +inp[32465] = 0; +inp[32466] = 1073741653; +inp[32467] = 0; +inp[32468] = 1073741652; +inp[32469] = 0; +inp[32470] = 1073741651; +inp[32471] = 0; +inp[32472] = 1073741650; +inp[32473] = 0; +inp[32474] = 1073741649; +inp[32475] = 0; +inp[32476] = 1073741648; +inp[32477] = 0; +inp[32478] = 1073741647; +inp[32479] = 0; +inp[32480] = 1073741646; +inp[32481] = 0; +inp[32482] = 1073741645; +inp[32483] = 0; +inp[32484] = 1073741644; +inp[32485] = 0; +inp[32486] = 1073741643; +inp[32487] = 0; +inp[32488] = 1073741642; +inp[32489] = 0; +inp[32490] = 1073741641; +inp[32491] = 0; +inp[32492] = 1073741640; +inp[32493] = 0; +inp[32494] = 1073741639; +inp[32495] = 0; +inp[32496] = 1073741638; +inp[32497] = 0; +inp[32498] = 1073741637; +inp[32499] = 0; +inp[32500] = 1073741636; +inp[32501] = 0; +inp[32502] = 1073741635; +inp[32503] = 0; +inp[32504] = 1073741634; +inp[32505] = 0; +inp[32506] = 1073741633; +inp[32507] = 0; +inp[32508] = 1073741632; +inp[32509] = 0; +inp[32510] = 1073741631; +inp[32511] = 0; +inp[32512] = 1073741630; +inp[32513] = 0; +inp[32514] = 1073741629; +inp[32515] = 0; +inp[32516] = 1073741628; +inp[32517] = 0; +inp[32518] = 1073741627; +inp[32519] = 0; +inp[32520] = 1073741626; +inp[32521] = 0; +inp[32522] = 1073741625; +inp[32523] = 0; +inp[32524] = 1073741624; +inp[32525] = 0; +inp[32526] = 1073741623; +inp[32527] = 0; +inp[32528] = 1073741622; +inp[32529] = 0; +inp[32530] = 1073741621; +inp[32531] = 0; +inp[32532] = 1073741620; +inp[32533] = 0; +inp[32534] = 1073741619; +inp[32535] = 0; +inp[32536] = 1073741618; +inp[32537] = 0; +inp[32538] = 1073741617; +inp[32539] = 0; +inp[32540] = 1073741616; +inp[32541] = 0; +inp[32542] = 1073741615; +inp[32543] = 0; +inp[32544] = 1073741614; +inp[32545] = 0; +inp[32546] = 1073741613; +inp[32547] = 0; +inp[32548] = 1073741612; +inp[32549] = 0; +inp[32550] = 1073741611; +inp[32551] = 0; +inp[32552] = 1073741610; +inp[32553] = 0; +inp[32554] = 1073741609; +inp[32555] = 0; +inp[32556] = 1073741608; +inp[32557] = 0; +inp[32558] = 1073741607; +inp[32559] = 0; +inp[32560] = 1073741606; +inp[32561] = 0; +inp[32562] = 1073741605; +inp[32563] = 0; +inp[32564] = 1073741604; +inp[32565] = 0; +inp[32566] = 1073741603; +inp[32567] = 0; +inp[32568] = 1073741602; +inp[32569] = 0; +inp[32570] = 1073741601; +inp[32571] = 0; +inp[32572] = 1073741600; +inp[32573] = 0; +inp[32574] = 1073741599; +inp[32575] = 0; +inp[32576] = 1073741598; +inp[32577] = 0; +inp[32578] = 1073741597; +inp[32579] = 0; +inp[32580] = 1073741596; +inp[32581] = 0; +inp[32582] = 1073741595; +inp[32583] = 0; +inp[32584] = 1073741594; +inp[32585] = 0; +inp[32586] = 1073741593; +inp[32587] = 0; +inp[32588] = 1073741592; +inp[32589] = 0; +inp[32590] = 1073741591; +inp[32591] = 0; +inp[32592] = 1073741590; +inp[32593] = 0; +inp[32594] = 1073741589; +inp[32595] = 0; +inp[32596] = 1073741588; +inp[32597] = 0; +inp[32598] = 1073741587; +inp[32599] = 0; +inp[32600] = 1073741586; +inp[32601] = 0; +inp[32602] = 1073741585; +inp[32603] = 0; +inp[32604] = 1073741584; +inp[32605] = 0; +inp[32606] = 1073741583; +inp[32607] = 0; +inp[32608] = 1073741582; +inp[32609] = 0; +inp[32610] = 1073741581; +inp[32611] = 0; +inp[32612] = 1073741580; +inp[32613] = 0; +inp[32614] = 1073741579; +inp[32615] = 0; +inp[32616] = 1073741578; +inp[32617] = 0; +inp[32618] = 1073741577; +inp[32619] = 0; +inp[32620] = 1073741576; +inp[32621] = 0; +inp[32622] = 1073741575; +inp[32623] = 0; +inp[32624] = 1073741574; +inp[32625] = 0; +inp[32626] = 1073741573; +inp[32627] = 0; +inp[32628] = 1073741572; +inp[32629] = 0; +inp[32630] = 1073741571; +inp[32631] = 0; +inp[32632] = 1073741570; +inp[32633] = 0; +inp[32634] = 1073741569; +inp[32635] = 0; +inp[32636] = 1073741824; +inp[32637] = 1073741824; +inp[32638] = 1073741823; +inp[32639] = 0; +inp[32640] = 1073741823; +inp[32641] = 0; +inp[32642] = 1073741822; +inp[32643] = 0; +inp[32644] = 1073741822; +inp[32645] = 0; +inp[32646] = 1073741821; +inp[32647] = 0; +inp[32648] = 1073741821; +inp[32649] = 0; +inp[32650] = 1073741820; +inp[32651] = 0; +inp[32652] = 1073741820; +inp[32653] = 0; +inp[32654] = 1073741819; +inp[32655] = 0; +inp[32656] = 1073741819; +inp[32657] = 0; +inp[32658] = 1073741818; +inp[32659] = 0; +inp[32660] = 1073741818; +inp[32661] = 0; +inp[32662] = 1073741817; +inp[32663] = 0; +inp[32664] = 1073741817; +inp[32665] = 0; +inp[32666] = 1073741816; +inp[32667] = 0; +inp[32668] = 1073741816; +inp[32669] = 0; +inp[32670] = 1073741815; +inp[32671] = 0; +inp[32672] = 1073741815; +inp[32673] = 0; +inp[32674] = 1073741814; +inp[32675] = 0; +inp[32676] = 1073741814; +inp[32677] = 0; +inp[32678] = 1073741813; +inp[32679] = 0; +inp[32680] = 1073741813; +inp[32681] = 0; +inp[32682] = 1073741812; +inp[32683] = 0; +inp[32684] = 1073741812; +inp[32685] = 0; +inp[32686] = 1073741811; +inp[32687] = 0; +inp[32688] = 1073741811; +inp[32689] = 0; +inp[32690] = 1073741810; +inp[32691] = 0; +inp[32692] = 1073741810; +inp[32693] = 0; +inp[32694] = 1073741809; +inp[32695] = 0; +inp[32696] = 1073741809; +inp[32697] = 0; +inp[32698] = 1073741808; +inp[32699] = 0; +inp[32700] = 1073741808; +inp[32701] = 0; +inp[32702] = 1073741807; +inp[32703] = 0; +inp[32704] = 1073741807; +inp[32705] = 0; +inp[32706] = 1073741806; +inp[32707] = 0; +inp[32708] = 1073741806; +inp[32709] = 0; +inp[32710] = 1073741805; +inp[32711] = 0; +inp[32712] = 1073741805; +inp[32713] = 0; +inp[32714] = 1073741804; +inp[32715] = 0; +inp[32716] = 1073741804; +inp[32717] = 0; +inp[32718] = 1073741803; +inp[32719] = 0; +inp[32720] = 1073741803; +inp[32721] = 0; +inp[32722] = 1073741802; +inp[32723] = 0; +inp[32724] = 1073741802; +inp[32725] = 0; +inp[32726] = 1073741801; +inp[32727] = 0; +inp[32728] = 1073741801; +inp[32729] = 0; +inp[32730] = 1073741800; +inp[32731] = 0; +inp[32732] = 1073741800; +inp[32733] = 0; +inp[32734] = 1073741799; +inp[32735] = 0; +inp[32736] = 1073741799; +inp[32737] = 0; +inp[32738] = 1073741798; +inp[32739] = 0; +inp[32740] = 1073741798; +inp[32741] = 0; +inp[32742] = 1073741797; +inp[32743] = 0; +inp[32744] = 1073741797; +inp[32745] = 0; +inp[32746] = 1073741796; +inp[32747] = 0; +inp[32748] = 1073741796; +inp[32749] = 0; +inp[32750] = 1073741795; +inp[32751] = 0; +inp[32752] = 1073741795; +inp[32753] = 0; +inp[32754] = 1073741794; +inp[32755] = 0; +inp[32756] = 1073741794; +inp[32757] = 0; +inp[32758] = 1073741793; +inp[32759] = 0; +inp[32760] = 1073741793; +inp[32761] = 0; +inp[32762] = 1073741792; +inp[32763] = 0; +inp[32764] = 1073741792; +inp[32765] = 0; +inp[32766] = 1073741791; +inp[32767] = 0; +inp[32768] = 1073741791; +inp[32769] = 0; +inp[32770] = 1073741790; +inp[32771] = 0; +inp[32772] = 1073741790; +inp[32773] = 0; +inp[32774] = 1073741789; +inp[32775] = 0; +inp[32776] = 1073741789; +inp[32777] = 0; +inp[32778] = 1073741788; +inp[32779] = 0; +inp[32780] = 1073741788; +inp[32781] = 0; +inp[32782] = 1073741787; +inp[32783] = 0; +inp[32784] = 1073741787; +inp[32785] = 0; +inp[32786] = 1073741786; +inp[32787] = 0; +inp[32788] = 1073741786; +inp[32789] = 0; +inp[32790] = 1073741785; +inp[32791] = 0; +inp[32792] = 1073741785; +inp[32793] = 0; +inp[32794] = 1073741784; +inp[32795] = 0; +inp[32796] = 1073741784; +inp[32797] = 0; +inp[32798] = 1073741783; +inp[32799] = 0; +inp[32800] = 1073741783; +inp[32801] = 0; +inp[32802] = 1073741782; +inp[32803] = 0; +inp[32804] = 1073741782; +inp[32805] = 0; +inp[32806] = 1073741781; +inp[32807] = 0; +inp[32808] = 1073741781; +inp[32809] = 0; +inp[32810] = 1073741780; +inp[32811] = 0; +inp[32812] = 1073741780; +inp[32813] = 0; +inp[32814] = 1073741779; +inp[32815] = 0; +inp[32816] = 1073741779; +inp[32817] = 0; +inp[32818] = 1073741778; +inp[32819] = 0; +inp[32820] = 1073741778; +inp[32821] = 0; +inp[32822] = 1073741777; +inp[32823] = 0; +inp[32824] = 1073741777; +inp[32825] = 0; +inp[32826] = 1073741776; +inp[32827] = 0; +inp[32828] = 1073741776; +inp[32829] = 0; +inp[32830] = 1073741775; +inp[32831] = 0; +inp[32832] = 1073741775; +inp[32833] = 0; +inp[32834] = 1073741774; +inp[32835] = 0; +inp[32836] = 1073741774; +inp[32837] = 0; +inp[32838] = 1073741773; +inp[32839] = 0; +inp[32840] = 1073741773; +inp[32841] = 0; +inp[32842] = 1073741772; +inp[32843] = 0; +inp[32844] = 1073741772; +inp[32845] = 0; +inp[32846] = 1073741771; +inp[32847] = 0; +inp[32848] = 1073741771; +inp[32849] = 0; +inp[32850] = 1073741770; +inp[32851] = 0; +inp[32852] = 1073741770; +inp[32853] = 0; +inp[32854] = 1073741769; +inp[32855] = 0; +inp[32856] = 1073741769; +inp[32857] = 0; +inp[32858] = 1073741768; +inp[32859] = 0; +inp[32860] = 1073741768; +inp[32861] = 0; +inp[32862] = 1073741767; +inp[32863] = 0; +inp[32864] = 1073741767; +inp[32865] = 0; +inp[32866] = 1073741766; +inp[32867] = 0; +inp[32868] = 1073741766; +inp[32869] = 0; +inp[32870] = 1073741765; +inp[32871] = 0; +inp[32872] = 1073741765; +inp[32873] = 0; +inp[32874] = 1073741764; +inp[32875] = 0; +inp[32876] = 1073741764; +inp[32877] = 0; +inp[32878] = 1073741763; +inp[32879] = 0; +inp[32880] = 1073741763; +inp[32881] = 0; +inp[32882] = 1073741762; +inp[32883] = 0; +inp[32884] = 1073741762; +inp[32885] = 0; +inp[32886] = 1073741761; +inp[32887] = 0; +inp[32888] = 1073741761; +inp[32889] = 0; +inp[32890] = 1073741760; +inp[32891] = 0; +inp[32892] = 1073741760; +inp[32893] = 0; +inp[32894] = 1073741759; +inp[32895] = 0; +inp[32896] = 1073741759; +inp[32897] = 0; +inp[32898] = 1073741758; +inp[32899] = 0; +inp[32900] = 1073741758; +inp[32901] = 0; +inp[32902] = 1073741757; +inp[32903] = 0; +inp[32904] = 1073741757; +inp[32905] = 0; +inp[32906] = 1073741756; +inp[32907] = 0; +inp[32908] = 1073741756; +inp[32909] = 0; +inp[32910] = 1073741755; +inp[32911] = 0; +inp[32912] = 1073741755; +inp[32913] = 0; +inp[32914] = 1073741754; +inp[32915] = 0; +inp[32916] = 1073741754; +inp[32917] = 0; +inp[32918] = 1073741753; +inp[32919] = 0; +inp[32920] = 1073741753; +inp[32921] = 0; +inp[32922] = 1073741752; +inp[32923] = 0; +inp[32924] = 1073741752; +inp[32925] = 0; +inp[32926] = 1073741751; +inp[32927] = 0; +inp[32928] = 1073741751; +inp[32929] = 0; +inp[32930] = 1073741750; +inp[32931] = 0; +inp[32932] = 1073741750; +inp[32933] = 0; +inp[32934] = 1073741749; +inp[32935] = 0; +inp[32936] = 1073741749; +inp[32937] = 0; +inp[32938] = 1073741748; +inp[32939] = 0; +inp[32940] = 1073741748; +inp[32941] = 0; +inp[32942] = 1073741747; +inp[32943] = 0; +inp[32944] = 1073741747; +inp[32945] = 0; +inp[32946] = 1073741746; +inp[32947] = 0; +inp[32948] = 1073741746; +inp[32949] = 0; +inp[32950] = 1073741745; +inp[32951] = 0; +inp[32952] = 1073741745; +inp[32953] = 0; +inp[32954] = 1073741744; +inp[32955] = 0; +inp[32956] = 1073741744; +inp[32957] = 0; +inp[32958] = 1073741743; +inp[32959] = 0; +inp[32960] = 1073741743; +inp[32961] = 0; +inp[32962] = 1073741742; +inp[32963] = 0; +inp[32964] = 1073741742; +inp[32965] = 0; +inp[32966] = 1073741741; +inp[32967] = 0; +inp[32968] = 1073741741; +inp[32969] = 0; +inp[32970] = 1073741740; +inp[32971] = 0; +inp[32972] = 1073741740; +inp[32973] = 0; +inp[32974] = 1073741739; +inp[32975] = 0; +inp[32976] = 1073741739; +inp[32977] = 0; +inp[32978] = 1073741738; +inp[32979] = 0; +inp[32980] = 1073741738; +inp[32981] = 0; +inp[32982] = 1073741737; +inp[32983] = 0; +inp[32984] = 1073741737; +inp[32985] = 0; +inp[32986] = 1073741736; +inp[32987] = 0; +inp[32988] = 1073741736; +inp[32989] = 0; +inp[32990] = 1073741735; +inp[32991] = 0; +inp[32992] = 1073741735; +inp[32993] = 0; +inp[32994] = 1073741734; +inp[32995] = 0; +inp[32996] = 1073741734; +inp[32997] = 0; +inp[32998] = 1073741733; +inp[32999] = 0; +inp[33000] = 1073741733; +inp[33001] = 0; +inp[33002] = 1073741732; +inp[33003] = 0; +inp[33004] = 1073741732; +inp[33005] = 0; +inp[33006] = 1073741731; +inp[33007] = 0; +inp[33008] = 1073741731; +inp[33009] = 0; +inp[33010] = 1073741730; +inp[33011] = 0; +inp[33012] = 1073741730; +inp[33013] = 0; +inp[33014] = 1073741729; +inp[33015] = 0; +inp[33016] = 1073741729; +inp[33017] = 0; +inp[33018] = 1073741728; +inp[33019] = 0; +inp[33020] = 1073741728; +inp[33021] = 0; +inp[33022] = 1073741727; +inp[33023] = 0; +inp[33024] = 1073741727; +inp[33025] = 0; +inp[33026] = 1073741726; +inp[33027] = 0; +inp[33028] = 1073741726; +inp[33029] = 0; +inp[33030] = 1073741725; +inp[33031] = 0; +inp[33032] = 1073741725; +inp[33033] = 0; +inp[33034] = 1073741724; +inp[33035] = 0; +inp[33036] = 1073741724; +inp[33037] = 0; +inp[33038] = 1073741723; +inp[33039] = 0; +inp[33040] = 1073741723; +inp[33041] = 0; +inp[33042] = 1073741722; +inp[33043] = 0; +inp[33044] = 1073741722; +inp[33045] = 0; +inp[33046] = 1073741721; +inp[33047] = 0; +inp[33048] = 1073741721; +inp[33049] = 0; +inp[33050] = 1073741720; +inp[33051] = 0; +inp[33052] = 1073741720; +inp[33053] = 0; +inp[33054] = 1073741719; +inp[33055] = 0; +inp[33056] = 1073741719; +inp[33057] = 0; +inp[33058] = 1073741718; +inp[33059] = 0; +inp[33060] = 1073741718; +inp[33061] = 0; +inp[33062] = 1073741717; +inp[33063] = 0; +inp[33064] = 1073741717; +inp[33065] = 0; +inp[33066] = 1073741716; +inp[33067] = 0; +inp[33068] = 1073741716; +inp[33069] = 0; +inp[33070] = 1073741715; +inp[33071] = 0; +inp[33072] = 1073741715; +inp[33073] = 0; +inp[33074] = 1073741714; +inp[33075] = 0; +inp[33076] = 1073741714; +inp[33077] = 0; +inp[33078] = 1073741713; +inp[33079] = 0; +inp[33080] = 1073741713; +inp[33081] = 0; +inp[33082] = 1073741712; +inp[33083] = 0; +inp[33084] = 1073741712; +inp[33085] = 0; +inp[33086] = 1073741711; +inp[33087] = 0; +inp[33088] = 1073741711; +inp[33089] = 0; +inp[33090] = 1073741710; +inp[33091] = 0; +inp[33092] = 1073741710; +inp[33093] = 0; +inp[33094] = 1073741709; +inp[33095] = 0; +inp[33096] = 1073741709; +inp[33097] = 0; +inp[33098] = 1073741708; +inp[33099] = 0; +inp[33100] = 1073741708; +inp[33101] = 0; +inp[33102] = 1073741707; +inp[33103] = 0; +inp[33104] = 1073741707; +inp[33105] = 0; +inp[33106] = 1073741706; +inp[33107] = 0; +inp[33108] = 1073741706; +inp[33109] = 0; +inp[33110] = 1073741705; +inp[33111] = 0; +inp[33112] = 1073741705; +inp[33113] = 0; +inp[33114] = 1073741704; +inp[33115] = 0; +inp[33116] = 1073741704; +inp[33117] = 0; +inp[33118] = 1073741703; +inp[33119] = 0; +inp[33120] = 1073741703; +inp[33121] = 0; +inp[33122] = 1073741702; +inp[33123] = 0; +inp[33124] = 1073741702; +inp[33125] = 0; +inp[33126] = 1073741701; +inp[33127] = 0; +inp[33128] = 1073741701; +inp[33129] = 0; +inp[33130] = 1073741700; +inp[33131] = 0; +inp[33132] = 1073741700; +inp[33133] = 0; +inp[33134] = 1073741699; +inp[33135] = 0; +inp[33136] = 1073741699; +inp[33137] = 0; +inp[33138] = 1073741698; +inp[33139] = 0; +inp[33140] = 1073741698; +inp[33141] = 0; +inp[33142] = 1073741697; +inp[33143] = 0; +inp[33144] = 1073741697; +inp[33145] = 0; +inp[33146] = 1073741696; +inp[33147] = 0; +inp[33148] = 1073741824; +inp[33149] = 1073741824; +inp[33150] = 1073741823; +inp[33151] = 0; +inp[33152] = 1073741823; +inp[33153] = 0; +inp[33154] = 1073741823; +inp[33155] = 0; +inp[33156] = 1073741823; +inp[33157] = 0; +inp[33158] = 1073741822; +inp[33159] = 0; +inp[33160] = 1073741822; +inp[33161] = 0; +inp[33162] = 1073741822; +inp[33163] = 0; +inp[33164] = 1073741822; +inp[33165] = 0; +inp[33166] = 1073741821; +inp[33167] = 0; +inp[33168] = 1073741821; +inp[33169] = 0; +inp[33170] = 1073741821; +inp[33171] = 0; +inp[33172] = 1073741821; +inp[33173] = 0; +inp[33174] = 1073741820; +inp[33175] = 0; +inp[33176] = 1073741820; +inp[33177] = 0; +inp[33178] = 1073741820; +inp[33179] = 0; +inp[33180] = 1073741820; +inp[33181] = 0; +inp[33182] = 1073741819; +inp[33183] = 0; +inp[33184] = 1073741819; +inp[33185] = 0; +inp[33186] = 1073741819; +inp[33187] = 0; +inp[33188] = 1073741819; +inp[33189] = 0; +inp[33190] = 1073741818; +inp[33191] = 0; +inp[33192] = 1073741818; +inp[33193] = 0; +inp[33194] = 1073741818; +inp[33195] = 0; +inp[33196] = 1073741818; +inp[33197] = 0; +inp[33198] = 1073741817; +inp[33199] = 0; +inp[33200] = 1073741817; +inp[33201] = 0; +inp[33202] = 1073741817; +inp[33203] = 0; +inp[33204] = 1073741817; +inp[33205] = 0; +inp[33206] = 1073741816; +inp[33207] = 0; +inp[33208] = 1073741816; +inp[33209] = 0; +inp[33210] = 1073741816; +inp[33211] = 0; +inp[33212] = 1073741816; +inp[33213] = 0; +inp[33214] = 1073741815; +inp[33215] = 0; +inp[33216] = 1073741815; +inp[33217] = 0; +inp[33218] = 1073741815; +inp[33219] = 0; +inp[33220] = 1073741815; +inp[33221] = 0; +inp[33222] = 1073741814; +inp[33223] = 0; +inp[33224] = 1073741814; +inp[33225] = 0; +inp[33226] = 1073741814; +inp[33227] = 0; +inp[33228] = 1073741814; +inp[33229] = 0; +inp[33230] = 1073741813; +inp[33231] = 0; +inp[33232] = 1073741813; +inp[33233] = 0; +inp[33234] = 1073741813; +inp[33235] = 0; +inp[33236] = 1073741813; +inp[33237] = 0; +inp[33238] = 1073741812; +inp[33239] = 0; +inp[33240] = 1073741812; +inp[33241] = 0; +inp[33242] = 1073741812; +inp[33243] = 0; +inp[33244] = 1073741812; +inp[33245] = 0; +inp[33246] = 1073741811; +inp[33247] = 0; +inp[33248] = 1073741811; +inp[33249] = 0; +inp[33250] = 1073741811; +inp[33251] = 0; +inp[33252] = 1073741811; +inp[33253] = 0; +inp[33254] = 1073741810; +inp[33255] = 0; +inp[33256] = 1073741810; +inp[33257] = 0; +inp[33258] = 1073741810; +inp[33259] = 0; +inp[33260] = 1073741810; +inp[33261] = 0; +inp[33262] = 1073741809; +inp[33263] = 0; +inp[33264] = 1073741809; +inp[33265] = 0; +inp[33266] = 1073741809; +inp[33267] = 0; +inp[33268] = 1073741809; +inp[33269] = 0; +inp[33270] = 1073741808; +inp[33271] = 0; +inp[33272] = 1073741808; +inp[33273] = 0; +inp[33274] = 1073741808; +inp[33275] = 0; +inp[33276] = 1073741808; +inp[33277] = 0; +inp[33278] = 1073741807; +inp[33279] = 0; +inp[33280] = 1073741807; +inp[33281] = 0; +inp[33282] = 1073741807; +inp[33283] = 0; +inp[33284] = 1073741807; +inp[33285] = 0; +inp[33286] = 1073741806; +inp[33287] = 0; +inp[33288] = 1073741806; +inp[33289] = 0; +inp[33290] = 1073741806; +inp[33291] = 0; +inp[33292] = 1073741806; +inp[33293] = 0; +inp[33294] = 1073741805; +inp[33295] = 0; +inp[33296] = 1073741805; +inp[33297] = 0; +inp[33298] = 1073741805; +inp[33299] = 0; +inp[33300] = 1073741805; +inp[33301] = 0; +inp[33302] = 1073741804; +inp[33303] = 0; +inp[33304] = 1073741804; +inp[33305] = 0; +inp[33306] = 1073741804; +inp[33307] = 0; +inp[33308] = 1073741804; +inp[33309] = 0; +inp[33310] = 1073741803; +inp[33311] = 0; +inp[33312] = 1073741803; +inp[33313] = 0; +inp[33314] = 1073741803; +inp[33315] = 0; +inp[33316] = 1073741803; +inp[33317] = 0; +inp[33318] = 1073741802; +inp[33319] = 0; +inp[33320] = 1073741802; +inp[33321] = 0; +inp[33322] = 1073741802; +inp[33323] = 0; +inp[33324] = 1073741802; +inp[33325] = 0; +inp[33326] = 1073741801; +inp[33327] = 0; +inp[33328] = 1073741801; +inp[33329] = 0; +inp[33330] = 1073741801; +inp[33331] = 0; +inp[33332] = 1073741801; +inp[33333] = 0; +inp[33334] = 1073741800; +inp[33335] = 0; +inp[33336] = 1073741800; +inp[33337] = 0; +inp[33338] = 1073741800; +inp[33339] = 0; +inp[33340] = 1073741800; +inp[33341] = 0; +inp[33342] = 1073741799; +inp[33343] = 0; +inp[33344] = 1073741799; +inp[33345] = 0; +inp[33346] = 1073741799; +inp[33347] = 0; +inp[33348] = 1073741799; +inp[33349] = 0; +inp[33350] = 1073741798; +inp[33351] = 0; +inp[33352] = 1073741798; +inp[33353] = 0; +inp[33354] = 1073741798; +inp[33355] = 0; +inp[33356] = 1073741798; +inp[33357] = 0; +inp[33358] = 1073741797; +inp[33359] = 0; +inp[33360] = 1073741797; +inp[33361] = 0; +inp[33362] = 1073741797; +inp[33363] = 0; +inp[33364] = 1073741797; +inp[33365] = 0; +inp[33366] = 1073741796; +inp[33367] = 0; +inp[33368] = 1073741796; +inp[33369] = 0; +inp[33370] = 1073741796; +inp[33371] = 0; +inp[33372] = 1073741796; +inp[33373] = 0; +inp[33374] = 1073741795; +inp[33375] = 0; +inp[33376] = 1073741795; +inp[33377] = 0; +inp[33378] = 1073741795; +inp[33379] = 0; +inp[33380] = 1073741795; +inp[33381] = 0; +inp[33382] = 1073741794; +inp[33383] = 0; +inp[33384] = 1073741794; +inp[33385] = 0; +inp[33386] = 1073741794; +inp[33387] = 0; +inp[33388] = 1073741794; +inp[33389] = 0; +inp[33390] = 1073741793; +inp[33391] = 0; +inp[33392] = 1073741793; +inp[33393] = 0; +inp[33394] = 1073741793; +inp[33395] = 0; +inp[33396] = 1073741793; +inp[33397] = 0; +inp[33398] = 1073741792; +inp[33399] = 0; +inp[33400] = 1073741792; +inp[33401] = 0; +inp[33402] = 1073741792; +inp[33403] = 0; +inp[33404] = 1073741792; +inp[33405] = 0; +inp[33406] = 1073741791; +inp[33407] = 0; +inp[33408] = 1073741791; +inp[33409] = 0; +inp[33410] = 1073741791; +inp[33411] = 0; +inp[33412] = 1073741791; +inp[33413] = 0; +inp[33414] = 1073741790; +inp[33415] = 0; +inp[33416] = 1073741790; +inp[33417] = 0; +inp[33418] = 1073741790; +inp[33419] = 0; +inp[33420] = 1073741790; +inp[33421] = 0; +inp[33422] = 1073741789; +inp[33423] = 0; +inp[33424] = 1073741789; +inp[33425] = 0; +inp[33426] = 1073741789; +inp[33427] = 0; +inp[33428] = 1073741789; +inp[33429] = 0; +inp[33430] = 1073741788; +inp[33431] = 0; +inp[33432] = 1073741788; +inp[33433] = 0; +inp[33434] = 1073741788; +inp[33435] = 0; +inp[33436] = 1073741788; +inp[33437] = 0; +inp[33438] = 1073741787; +inp[33439] = 0; +inp[33440] = 1073741787; +inp[33441] = 0; +inp[33442] = 1073741787; +inp[33443] = 0; +inp[33444] = 1073741787; +inp[33445] = 0; +inp[33446] = 1073741786; +inp[33447] = 0; +inp[33448] = 1073741786; +inp[33449] = 0; +inp[33450] = 1073741786; +inp[33451] = 0; +inp[33452] = 1073741786; +inp[33453] = 0; +inp[33454] = 1073741785; +inp[33455] = 0; +inp[33456] = 1073741785; +inp[33457] = 0; +inp[33458] = 1073741785; +inp[33459] = 0; +inp[33460] = 1073741785; +inp[33461] = 0; +inp[33462] = 1073741784; +inp[33463] = 0; +inp[33464] = 1073741784; +inp[33465] = 0; +inp[33466] = 1073741784; +inp[33467] = 0; +inp[33468] = 1073741784; +inp[33469] = 0; +inp[33470] = 1073741783; +inp[33471] = 0; +inp[33472] = 1073741783; +inp[33473] = 0; +inp[33474] = 1073741783; +inp[33475] = 0; +inp[33476] = 1073741783; +inp[33477] = 0; +inp[33478] = 1073741782; +inp[33479] = 0; +inp[33480] = 1073741782; +inp[33481] = 0; +inp[33482] = 1073741782; +inp[33483] = 0; +inp[33484] = 1073741782; +inp[33485] = 0; +inp[33486] = 1073741781; +inp[33487] = 0; +inp[33488] = 1073741781; +inp[33489] = 0; +inp[33490] = 1073741781; +inp[33491] = 0; +inp[33492] = 1073741781; +inp[33493] = 0; +inp[33494] = 1073741780; +inp[33495] = 0; +inp[33496] = 1073741780; +inp[33497] = 0; +inp[33498] = 1073741780; +inp[33499] = 0; +inp[33500] = 1073741780; +inp[33501] = 0; +inp[33502] = 1073741779; +inp[33503] = 0; +inp[33504] = 1073741779; +inp[33505] = 0; +inp[33506] = 1073741779; +inp[33507] = 0; +inp[33508] = 1073741779; +inp[33509] = 0; +inp[33510] = 1073741778; +inp[33511] = 0; +inp[33512] = 1073741778; +inp[33513] = 0; +inp[33514] = 1073741778; +inp[33515] = 0; +inp[33516] = 1073741778; +inp[33517] = 0; +inp[33518] = 1073741777; +inp[33519] = 0; +inp[33520] = 1073741777; +inp[33521] = 0; +inp[33522] = 1073741777; +inp[33523] = 0; +inp[33524] = 1073741777; +inp[33525] = 0; +inp[33526] = 1073741776; +inp[33527] = 0; +inp[33528] = 1073741776; +inp[33529] = 0; +inp[33530] = 1073741776; +inp[33531] = 0; +inp[33532] = 1073741776; +inp[33533] = 0; +inp[33534] = 1073741775; +inp[33535] = 0; +inp[33536] = 1073741775; +inp[33537] = 0; +inp[33538] = 1073741775; +inp[33539] = 0; +inp[33540] = 1073741775; +inp[33541] = 0; +inp[33542] = 1073741774; +inp[33543] = 0; +inp[33544] = 1073741774; +inp[33545] = 0; +inp[33546] = 1073741774; +inp[33547] = 0; +inp[33548] = 1073741774; +inp[33549] = 0; +inp[33550] = 1073741773; +inp[33551] = 0; +inp[33552] = 1073741773; +inp[33553] = 0; +inp[33554] = 1073741773; +inp[33555] = 0; +inp[33556] = 1073741773; +inp[33557] = 0; +inp[33558] = 1073741772; +inp[33559] = 0; +inp[33560] = 1073741772; +inp[33561] = 0; +inp[33562] = 1073741772; +inp[33563] = 0; +inp[33564] = 1073741772; +inp[33565] = 0; +inp[33566] = 1073741771; +inp[33567] = 0; +inp[33568] = 1073741771; +inp[33569] = 0; +inp[33570] = 1073741771; +inp[33571] = 0; +inp[33572] = 1073741771; +inp[33573] = 0; +inp[33574] = 1073741770; +inp[33575] = 0; +inp[33576] = 1073741770; +inp[33577] = 0; +inp[33578] = 1073741770; +inp[33579] = 0; +inp[33580] = 1073741770; +inp[33581] = 0; +inp[33582] = 1073741769; +inp[33583] = 0; +inp[33584] = 1073741769; +inp[33585] = 0; +inp[33586] = 1073741769; +inp[33587] = 0; +inp[33588] = 1073741769; +inp[33589] = 0; +inp[33590] = 1073741768; +inp[33591] = 0; +inp[33592] = 1073741768; +inp[33593] = 0; +inp[33594] = 1073741768; +inp[33595] = 0; +inp[33596] = 1073741768; +inp[33597] = 0; +inp[33598] = 1073741767; +inp[33599] = 0; +inp[33600] = 1073741767; +inp[33601] = 0; +inp[33602] = 1073741767; +inp[33603] = 0; +inp[33604] = 1073741767; +inp[33605] = 0; +inp[33606] = 1073741766; +inp[33607] = 0; +inp[33608] = 1073741766; +inp[33609] = 0; +inp[33610] = 1073741766; +inp[33611] = 0; +inp[33612] = 1073741766; +inp[33613] = 0; +inp[33614] = 1073741765; +inp[33615] = 0; +inp[33616] = 1073741765; +inp[33617] = 0; +inp[33618] = 1073741765; +inp[33619] = 0; +inp[33620] = 1073741765; +inp[33621] = 0; +inp[33622] = 1073741764; +inp[33623] = 0; +inp[33624] = 1073741764; +inp[33625] = 0; +inp[33626] = 1073741764; +inp[33627] = 0; +inp[33628] = 1073741764; +inp[33629] = 0; +inp[33630] = 1073741763; +inp[33631] = 0; +inp[33632] = 1073741763; +inp[33633] = 0; +inp[33634] = 1073741763; +inp[33635] = 0; +inp[33636] = 1073741763; +inp[33637] = 0; +inp[33638] = 1073741762; +inp[33639] = 0; +inp[33640] = 1073741762; +inp[33641] = 0; +inp[33642] = 1073741762; +inp[33643] = 0; +inp[33644] = 1073741762; +inp[33645] = 0; +inp[33646] = 1073741761; +inp[33647] = 0; +inp[33648] = 1073741761; +inp[33649] = 0; +inp[33650] = 1073741761; +inp[33651] = 0; +inp[33652] = 1073741761; +inp[33653] = 0; +inp[33654] = 1073741760; +inp[33655] = 0; +inp[33656] = 1073741760; +inp[33657] = 0; +inp[33658] = 1073741760; +inp[33659] = 0; +} + +(* <><><><><><> Auto-generated code end <><><><><><> *) + + + + + + + + + + + + + + + +(* size.R is the number of rows and size.C is the number of columns *) +int32 sizeXR = 2; +int32 sizeXC = 2; +int32 sizeYR = 2; +int32 sizeYC = 2; +int32 sizeZR = 2; +int32 sizeZC = 2; +int32 assymetry = 3; +int32 sizeVec = 10; + +(* <><><><><><><><>< *) +(* Library functions *) +(* <><><><><><><><>< *) + +(* All secret variables will have type int64_al and all public ones will be int32_pl. bwA will be bitwidth of variable A which is substitution *) +(* of TypeA and so on for B and C. bwTemp is the bitwidth of intermediate computation and is substitute for TypeTemp. *) + +(* x should be a power of 2 *) +def int32_pl log(int32_pl x) +{ + for i=[0:64] + { + if ((1L << i) == x) + { + return i; + }; + }; +} + +def int32_pl ceillog(int32_pl x) +{ + for i=[0:65] + { + if ((1L << i) >= x) + { + return i; + }; + }; +} + +def int32_pl ceildiv(int32_pl a, int32_pl b) +{ + int32_pl rem = a % b; + int32_pl ret = a / b; + if (((2*rem)/b) >= 1) + { + ret = ret + 1; + }; + return ret; +} + +(* If number from MSB to LSB is 00110001, then output can be 00100000 as a one-hot vector *) +def void msnzbgetvec(int32_pl NUMBITS, int32_pl batch, int64_al[batch] inp, int64_al[batch*NUMBITS] out) +{ + int64_al left; + int64_al right; + int64_al temp; + + for i=[0:batch] + { + out[i] = 0L; + for j=[0:NUMBITS] + { + left = (1L<<(NUMBITS-1-j)); + right = ((1L<<(NUMBITS-j)) - 1L); + temp = inp[i]; + out[i*NUMBITS + j] = ((temp >= left) && (temp <= right))?(1L):0L; + }; + }; +} + +(* If number from MSB to LSB is 00110001, then output is 5 *) +def void msnzb(int32_pl NUMBITS, int32_pl batch, int64_al[batch] inp, int64_al[batch] out) +{ + int64_al left; + int64_al right; + int64_al temp; + + for i=[0:batch] + { + out[i] = 0L; + for j=[0:NUMBITS] + { + left = (1L<<j); + right = ((1L<<(j+1)) - 1L); + temp = inp[i]; + out[i] = ((temp >= left) && (temp <= right))?(j+0L):(out[i]); + }; + }; +} + +def void MatAdd(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl shrC, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_pl bwTemp, int32_pl bwC, int64_al[I*J] A, int64_al[I*J] B, int64_al[I*J] C) +{ + int32_pl shiftA = log(shrA); + int32_pl shiftB = log(shrB); + int32_pl shiftC = log(shrC); + int32_pl shiftDemote = log(demote); + + int64_al a; + int64_al b; + int64_al c; + for i=[0:I] + { + for j=[0:J] + { + a = A[i*J + j]; + b = B[i*J + j]; + + a = a >> (shiftA + shiftC); + b = b >> (shiftB + shiftC); + c = a + b; + + C[i*J + j] = c >> shiftDemote; + }; + }; +} + +def void MatSub(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl shrC, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_pl bwTemp, int32_pl bwC, int64_al[I*J] A, int64_al[I*J] B, int64_al[I*J] C) +{ + int32_pl shiftA = log(shrA); + int32_pl shiftB = log(shrB); + int32_pl shiftC = log(shrC); + int32_pl shiftDemote = log(demote); + + int64_al a; + int64_al b; + int64_al c; + for i=[0:I] + { + for j=[0:J] + { + a = A[i*J + j]; + b = B[i*J + j]; + + a = a >> (shiftA + shiftC); + b = b >> (shiftB + shiftC); + c = a - b; + + C[i*J + j] = c >> shiftDemote; + }; + }; +} + +(* tmp should be allocated before the function call *) +def void MatMul(int32_pl I, int32_pl K, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl H1, int32_pl H2, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_pl bwTemp, int32_pl bwC, int64_al[I*K] A, int64_al[K*J] B, int64_al[I*J] C, int64_al[K] tmp) +{ + int32_pl shiftA = log(shrA); + int32_pl shiftB = log(shrB); + int32_pl shiftDemote = log(demote); + int32_pl depth = ceillog(K); + int32_pl shift = shiftA + shiftB + shiftDemote + H1 - depth; + + int64_al a; + int64_al b; + int64_al prod; + int64_al sum; + + for i=[0:I] + { + for j=[0:J] + { + for k=[0:K] + { + a = A[i*K + k]; + b = B[k*J + j]; + prod = a * b; + tmp[k] = prod; + }; + sum = 0L; + for k=[0:K] + { + sum = sum + tmp[k]; + }; + sum = sum >> depth; + if (shift >= 0) + { + C[i*J + j] = sum >> shift; + } + else + { + C[i*J + j] = sum * (1L << (-1*shift)); + }; + }; + }; +} + +def void MatAddBroadCastA(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl shrC, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_pl bwTemp, int32_pl bwC, int64_al A, int64_al[I*J] B, int64_al[I*J] C) +{ + int32_pl shiftA = log(shrA); + int32_pl shiftB = log(shrB); + int32_pl shiftC = log(shrC); + int32_pl shiftDemote = log(demote); + + int64_al a; + int64_al b; + int64_al c; + + a = A; + a = a >> (shiftA + shiftC); + + for i=[0:I] + { + for j=[0:J] + { + b = B[i*J + j]; + + b = b >> (shiftB + shiftC); + c = a + b; + + C[i*J + j] = c >> shiftDemote; + }; + }; +} + +def void MatAddBroadCastB(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl shrC, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_pl bwTemp, int32_pl bwC, int64_al[I*J] A, int64_al B, int64_al[I*J] C) +{ + int32_pl shiftA = log(shrA); + int32_pl shiftB = log(shrB); + int32_pl shiftC = log(shrC); + int32_pl shiftDemote = log(demote); + + int64_al a; + int64_al b; + int64_al c; + + b = B; + b = b >> (shiftB + shiftC); + + for i=[0:I] + { + for j=[0:J] + { + a = A[i*J + j]; + + a = a >> (shiftA + shiftC); + c = a + b; + + C[i*J + j] = c >> shiftDemote; + }; + }; +} + +def void MatSubBroadCastA(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl shrC, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_pl bwTemp, int32_pl bwC, int64_al A, int64_al[I*J] B, int64_al[I*J] C) +{ + int32_pl shiftA = log(shrA); + int32_pl shiftB = log(shrB); + int32_pl shiftC = log(shrC); + int32_pl shiftDemote = log(demote); + + int64_al a; + int64_al b; + int64_al c; + + a = A; + a = a >> (shiftA + shiftC); + + for i=[0:I] + { + for j=[0:J] + { + b = B[i*J + j]; + + b = (-1L*b) >> (shiftB + shiftC); + c = a + b; + + C[i*J + j] = c >> shiftDemote; + }; + }; +} + +def void MatSubBroadCastB(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl shrC, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_pl bwTemp, int32_pl bwC, int64_al[I*J] A, int64_al B, int64_al[I*J] C) +{ + int32_pl shiftA = log(shrA); + int32_pl shiftB = log(shrB); + int32_pl shiftC = log(shrC); + int32_pl shiftDemote = log(demote); + + int64_al a; + int64_al b; + int64_al c; + + b = B; + b = (-1L*b) >> (shiftB + shiftC); + + for i=[0:I] + { + for j=[0:J] + { + a = A[i*J + j]; + + a = a >> (shiftA + shiftC); + c = a + b; + + C[i*J + j] = c >> shiftDemote; + }; + }; +} + +def void ScalarMul(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_pl bwTemp, int32_pl bwC, int64_al A, int64_al[I*J] B, int64_al[I*J] C) +{ + int32_pl shiftA = log(shrA); + int32_pl shiftB = log(shrB); + int32_pl shiftDemote = log(demote); + + int64_al a; + int64_al b; + int64_al prod; + + a = A; + + for i=[0:I] + { + for j=[0:J] + { + b = B[i*J + j]; + + prod = a * b; + C[i*J + j] = prod >> (shiftA + shiftB + shiftDemote); + }; + }; +} + +def void MulCir(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl demote, int32_pl bwA, int32_pl bwB, int32_pl bwTemp, int32_pl bwC, int64_al[I*J] A, int64_al[I*J] B, int64_al[I*J] C) +{ + int32_pl shiftA = log(shrA); + int32_pl shiftB = log(shrB); + int32_pl shiftDemote = log(demote); + + int64_al a; + int64_al b; + int64_al prod; + + for i=[0:I] + { + for j=[0:J] + { + a = A[i*J + j]; + b = B[i*J + j]; + + prod = a * b; + C[i*J + j] = prod >> (shiftA + shiftB + shiftDemote); + }; + }; +} + +(* ArgMax assumes same scale *) +def void ArgMax(int32_pl I, int32_pl J, int32_pl bwA, int32_pl bwB, int64_al[I*J] A, int64_al[1] index) +{ + int64_al max = A[0]; + int64_al maxIndex = 0L; + int32_pl counter = 0; + bool_bl muxCondition; + + for i=[0:I] + { + for j=[0:J] + { + muxCondition = (max < A[i*J + j]); + maxIndex = (muxCondition)?(0L+counter):maxIndex; + max = (muxCondition)?A[i*J + j]:max; + + counter = counter + 1; + }; + }; + index[0] = maxIndex; +} + +(* MSB to LSB. MSB at index 0 *) +def void BitDecompose(int32_pl NUMBITS, int32_pl batch, int64_al[batch] inp, int64_al[batch*NUMBITS] outBits) +{ + bool_bl muxCondition; + for i=[0:batch] + { + for j=[0:NUMBITS] + { + muxCondition = ((inp[i] & (1L<<(NUMBITS-1-j))) == (1L<<(NUMBITS-1-j))); + outBits[i*NUMBITS + j] = (muxCondition)?1L:0L; + }; + }; +} + +(* Input a linear array of 2^LUTBITS elements *) +def void LookUpTableArithmeticMUX(int32_pl LUTBITS, int32_pl batch, int32_pl[1<<LUTBITS] LUT, int64_al[batch] inp, int64_al[batch] out) +{ + int64_al monomial; + int64_al[batch*LUTBITS] inpBits; + int32_pl[LUTBITS] iteratorBits; + + BitDecompose(LUTBITS, batch, inp, inpBits); + + for i=[0:batch] + { + out[i] = 0L; + for j=[0:(1<<LUTBITS)] + { + monomial = LUT[j]+0L; + for k=[0:LUTBITS] + { + (* MSB to LSB. MSB at index 0 *) + iteratorBits[k] = ((j & (1<<(LUTBITS-1-k))) == (1<<(LUTBITS-1-k)))?1:0; + }; + + for k=[0:LUTBITS] + { + (* monomial = monomial * (((1 - iteratorBits[k])*(1 - inpBits[i*LUTBITS + k])) + (iteratorBits[k] * inpBits[i*LUTBITS + k])); *) + monomial = monomial * (1L - ((iteratorBits[k]+0L) + inpBits[i*LUTBITS + k] - (2L*((iteratorBits[k]+0L) * inpBits[i*LUTBITS + k])))); + }; + out[i] = out[i] + monomial; + }; + }; +} + +def void sqrt(int32_pl LUTBITS, int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl bwA, int32_pl bwB, int64_al[I*J] A, int64_al[I*J] B) +{ + int32_pl sA = log(shrA); + int32_pl sB = log(shrB); + int32_pl temp; + int32_pl m; + int32_pl iter; + int64_al[I*J*bwA] msnzbvals; + int64_al msnzbcur; + + (* Get MSNZB values *) + msnzbgetvec(bwA, (I*J), A, msnzbvals); + + if (sB <= 14) + { + m = ceildiv(sB, 2); + iter = 1; + } + else + { + temp = ceildiv(sB, 2); + m = ceildiv(temp, 2); + iter = 2; + }; + + int64_pl mMask = (1L << m) - 1; + int64_pl bMask = (1L << bwB) - 1; + int64_al adjust; + (* To make the secret truncation at the end as multiplied followed by truncation by public value *) + int32_pl sqrtAdjustScale = ((sA + 1)/2); + int64_al sqrtAdjust; + int64_al expParity; + int64_al shiftedA; + int64_al[1] Am; + int64_al Y; + int64_al YCur; + int64_al YPrev; + int64_al YSquare; + int64_al[1] YPar0; + int64_al[1] YPar1; + int64_al X; + int64_al XPrev; + int64_al XCur; + int64_al BPrev; + int64_al BCur; + + bool_bl muxCondition; + + (* Assumption: LUTBITS >= m *) + int32_pl[1<<(LUTBITS+2)] LUT; + int32_pl[1<<m] LUTPar0; + int32_pl[1<<m] LUTPar1; + int32_pl LUTOffset = 2*((1<<m)-2); + fillLUTINVSQRT(LUT); + + for i=[0:(1<<m)] + { + LUTPar0[i] = LUT[LUTOffset+(2*i)]; + LUTPar1[i] = LUT[LUTOffset+((2*i)+1)]; + }; + + for i=[0:(I*J)] + { + adjust = 0L; + sqrtAdjust = 0L; + expParity = 0L; + (* Error prone part *) + for j=[0:bwA] + { + (* To make the input of the form sign||1||... and scale is now bwA-2 *) + adjust = adjust + ((1L<<(bwA-2-(bwA-1-j)))*msnzbvals[(i*bwA) + j]); + (* Multipy the result in the end with this value *) + sqrtAdjust = sqrtAdjust + ((1L<<((((bwA-1-j)-sA)/2) + sqrtAdjustScale))*msnzbvals[(i*bwA) + j]); + (* Take care of parity of the extra term being multiplied to x. If the extra term power is odd, then a root 2 is included with x itself. *) + expParity = expParity + ((((bwA-1-j)-sA) & 1L)*msnzbvals[(i*bwA) + j]); + }; + shiftedA = A[i] * adjust; + Am[0] = ((shiftedA >> (bwA - 2 - m)) & mMask); + (* TODO call the batched version instead *) + LookUpTableArithmeticMUX(m, 1, LUTPar0, Am, YPar0); + LookUpTableArithmeticMUX(m, 1, LUTPar1, Am, YPar1); + muxCondition = (expParity == 1L); + Y = muxCondition?YPar1[0]:YPar0[0]; + (* Ideally we wanted to multiply by 2 when parity is 1, but rather we divide by 2 when parity is 0 and decrease scale by 1 simultaneously. *) + X = muxCondition?shiftedA:(shiftedA >> 1); + (* Scale of XPrev is: (bwA - 3) + (m + 1) = bwA + m - 2 *) + + XPrev = (X * Y); + (* make scale = sB *) + if ((bwA + m - 2) > sB) + { + XPrev = XPrev >> (bwA + m - 2 - sB); + } + else + { + XPrev = XPrev << (-1*(bwA + m - 2 - sB)); + }; + + BPrev = X; + (* make scale = sB *) + if ((bwA - 3) > sB) + { + BPrev = BPrev >> (bwA - 3 - sB); + } + else + { + BPrev = BPrev << (-1*(bwA - 3 - sB)); + }; + + (* scale = m *) + YPrev = Y; + + (* Run iterations now *) + for j=[0:iter] + { + YSquare = YPrev * YPrev; + if (j == 0) + { + YSquare = YSquare << (sB - (2*(m+1))); + } + else + { + YSquare = YSquare >> (sB + 2); + }; + BCur = BPrev * YSquare; + BCur = BCur >> sB; + YCur = (((1L << (sB+1))*3)/2) - BCur; + XCur = XPrev * YCur; + XCur = XCur >> (sB+1); + XPrev = XCur; + BPrev = BCur; + YPrev = YCur; + }; + + B[i] = (XCur * sqrtAdjust); + B[i] = ((B[i]) >> sqrtAdjustScale) & bMask; + }; +} + +def void div(int32_pl LUTBITS, int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl shrC, int32_pl bwA, int32_pl bwB, int32_pl bwC, int64_al[I*J] A, int64_al[I*J] B, int64_al[I*J] C) +{ + int32_pl sA = log(shrA); + int32_pl sB = log(shrB); + int32_pl sC = log(shrC); + + int32_pl m; + int32_pl temp; + int32_pl iter; + + if (sC <= 18) + { + m = ceildiv((sC-2), 2); + iter = 1; + } + else + { + temp = ceildiv(sC, 2); + m = ceildiv((temp-2), 2); + iter = 2; + }; + + int64_pl mMask = (1L << m) - 1; + int64_pl cMask = (1L << bwC) - 1; + int64_pl sMinusmMask = (1L << (sB-m)) - 1; + + (* Assumption: LUTBITS >= m *) + int32_pl[1<<(LUTBITS+2)] LUT; + int32_pl[1<<m] LUTA0; + int32_pl[1<<m] LUTA1; + int32_pl LUTOffset = 2*((1<<m)-2); + fillLUTDIV(LUT); + + for i=[0:(1<<m)] + { + LUTA0[i] = LUT[LUTOffset+(2*i)]; + LUTA1[i] = LUT[LUTOffset+((2*i)+1)]; + }; + + int64_al[1] Bm; + int64_al[1] A0; + int64_al[1] A1; + int64_al Q; + int64_al A0Q; + int64_al Y; + int64_al e; + int64_al e0; + int64_al a0; + + for i=[0:(I*J)] + { + Bm[0] = (B[i] >> (sB - m)) & mMask; + + (* A0 scale = m+3 *) + (* A1 scale = 2m+2 *) + (* TODO call the batched version instead *) + LookUpTableArithmeticMUX(m, 1, LUTA0, Bm, A0); + LookUpTableArithmeticMUX(m, 1, LUTA1, Bm, A1); + + (* Q scale = sB *) + Q = B[i] & sMinusmMask; + + (* A0Q scale = m+3+sB *) + A0Q = (A0[0]) * Q; + + (* Reciprocal Approximation of B with precision sC *) + (* First make scale of A1 same as A0Q *) + Y = (((A1[0]) << (sB + 1 - m)) -_al A0Q) >> (sB + m + 3 - sC); + + e = (B[i] * Y) >> sB; + (* e0 = 2-e *) + e0 = (1L << (sC + 1)) - e; + a0 = (A[i] * Y) >> sA; + C[i] = (a0 * e0) >> sC; + C[i] = (C[i]) & cMask; + }; +} + +def void exp(int32_pl LUTBITS, int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl demote, int32_pl bwA, int32_pl bwB, int64_al[I*J] A, int64_al[I*J] B) +{ + int32_pl sA = log(shrA); + int32_pl sB = log(shrB); + int32_pl sDemote = log(demote); + int32_pl digitSize = LUTBITS; + int32_pl numDigits = ceildiv(bwA, digitSize); + int32_pl lastDigitSize = bwA % digitSize; + int64_pl digitMask; + int32_pl m = digitSize; + int32_pl maxScale = 32; + (* Assumption: LUTBITS >= m *) + int32_pl LUTOffset = 0; + for i=[1:m] + { + LUTOffset = LUTOffset + ((maxScale+1)*(1<<i)*2); + }; + int32_pl[LUTOffset + ((maxScale+1)*(1<<m)*2) + 10] LUT; + int32_pl[1<<m] LUTA; + + fillLUTNEGEXP(LUT); + + if (digitSize == 64){ + digitMask = -1; + } + else{ + digitMask = (1 << digitSize) -1; + }; + int64_pl bMask = (1L << bwB) - 1; + int64_al[numDigits] Adigits; + int64_al[1] Adigit; + int64_al[1] A0; + int64_al negA; + int32_pl curScale; + int32_pl negScale; + + for i=[0:(I*J)] + { + negA = -1L*A[i]; + + for j=[0:numDigits] + { + Adigits[j] = (negA >> (j*digitSize)) & digitMask; + Adigit[0] = Adigits[j]; + curScale = sA - (digitSize*j); + if (curScale < 0L){ + negScale = 1; + } + else{ + negScale = 0; + }; + for k=[0:(1<<m)] + { + (* Output Scale is 31 *) + LUTA[k] = LUT[LUTOffset + (curScale*(1<<(m+1))) + (2*k) + negScale]; + LUTA[k] = LUTA[k] >> (30-sB); + }; + + (* TODO call the batched version instead *) + LookUpTableArithmeticMUX(m, 1, LUTA, Adigit, A0); + Adigits[j] = A0[0]; + }; + + int32_pl jvar = 1; + int32_pl kvar = 0; + + for j=[1:numDigits] + { + if (jvar < numDigits) + { + kvar = 0; + for k=[0:numDigits] + { + if ((kvar+jvar) < numDigits) + { + if ((kvar) < numDigits) + { + Adigits[kvar] = (Adigits[kvar+jvar] * Adigits[kvar]) >> sB; + }; + }; + if ((kvar) < numDigits) + { + kvar = kvar + (2*jvar); + }; + }; + jvar = jvar*2; + }; + }; + B[i] = Adigits[0] >> sDemote; + B[i] = (B[i]) & bMask; + + }; + +} + + +def void Sigmoid(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl bwA, int32_pl bwB, int64_al[I*J] A, int64_al[I*J] B) +{ + int32_pl LUTBITS = 8; + int32_pl sA = log(shrA); + int32_pl sB = log(shrB); + int64_al[I*J] negA; + int64_al[I*J] expNegA; + int64_al[I*J] sigNegA; + int64_al[I*J] den; + int64_al[I*J] all1; + for i=[0:(I*J)] + { + negA[i] = ((A[i])<0L)?_bl(A[i]):((-1L)*(A[i])); + }; + + exp(LUTBITS, I, J, shrA, shrB, 1, bwA, 32, negA, expNegA); + + for i=[0:(I*J)] + { + den[i] = ((expNegA[i]) == (1L<<sB))?_bl((expNegA[i]) + (1L << sB) - 1L):((expNegA[i]) + (1L << sB)); + all1[i] = 1L; + }; + div(LUTBITS, I, J, 1, shrB, shrB, bwA, bwB, 32, all1, den, sigNegA); + for i=[0:(I*J)] + { + B[i] = ((A[i]) >= 0L)?_bl(sigNegA[i]):(((expNegA[i]) * (sigNegA[i])) >> sB); + }; +} + +def void TanH(int32_pl I, int32_pl J, int32_pl shrA, int32_pl shrB, int32_pl bwA, int32_pl bwB, int64_al[I*J] A, int64_al[I*J] B) +{ + int32_pl LUTBITS = 8; + int32_pl sA = log(shrA); + int32_pl sB = log(shrB); + int64_al[I*J] negA; + int64_al[I*J] expNeg2A; + int64_al[I*J] tanhNegA; + int64_al[I*J] den; + int64_al[I*J] num; + + for i=[0:(I*J)] + { + negA[i] = ((A[i])<0L)?_bl(A[i]):((-1L)*(A[i])); + }; + + exp(LUTBITS, I, J, shrA/2, shrB, 1, bwA, bwB, negA, expNeg2A); + + for i=[0:(I*J)] + { + den[i] = ((expNeg2A[i]) == (1L<<sB))?_bl((expNeg2A[i]) + (1L << sB) - 1L):((expNeg2A[i]) + (1L << sB)); + num[i] = (1L << sB) - expNeg2A[i]; + }; + + div(LUTBITS, I, J, shrB, shrB, shrB, bwA, bwB, 32, num, den, tanhNegA); + + for i=[0:(I*J)] + { + B[i] = ((A[i]) >= 0L)?_bl(tanhNegA[i]):((-1L) * (tanhNegA[i])); + }; +} + +def void AdjustScaleShl(int32_pl I, int32_pl J, int32_pl shr, int64_al[I*J] A) +{ + int64_al tmpA; + int64_pl shr64 = shr; + for i=[0:(I*J)] + { + tmpA = (A[i]) * shr64; + A[i] = tmpA; + }; +} + +def void initialize() +{ +} + +def void finalize() +{ + +} + +(* <><><><><><><><>< *) +(* Lib functions end *) +(* <><><><><><><><>< *) \ No newline at end of file diff --git a/SIRNN/README.md b/SIRNN/README.md new file mode 100644 index 00000000..cbd0571d --- /dev/null +++ b/SIRNN/README.md @@ -0,0 +1,164 @@ +# SIRNN: Secure Inference for Recurrent Neural Networks + +SIRNN is an application of the SCI MPC protocols for inference over RNNs. This README discusses the inference over [FastGRNN](https://github.com/microsoft/EdgeML/blob/master/docs/publications/FastGRNN.pdf) models. + +## Setup + +For setting up SIRNN, set-up: +1. [SCI](https://github.com/mpc-msri/EzPC/tree/master/SCI) +2. [EzPC](https://github.com/mpc-msri/EzPC/tree/master/EzPC) +3. [SeeDot](https://github.com/microsoft/EdgeML/tools/SeeDot) + +## Control Flow + +SIRNN performs inference on quantized machine learning models. +This quantization is carried out using the [SeeDot](https://www.microsoft.com/en-us/research/publication/shiftry-rnn-inference-in-2kb-of-ram/) framework. +**Seedot** generates an output that is in the [EzPC](https://www.microsoft.com/en-us/research/project/ezpc-easy-secure-multi-party-computation/) language. +The EzPC compiler is then used to translate the code into SIRNN. + +SIRNN code is essentially a sequence of function calls to the [SCI](https://www.microsoft.com/en-us/research/publication/cryptflow2-practical-2-party-secure-inference/) library. + +SIRNN Summary: SeeDot->EzPC->SCI. + +## Running Instructions + +This section provided a step-by-step runthrough of **SIRNN** using the **FastGRNN** model and the [*Google-30*](https://arxiv.org/abs/1804.03209) dataset. + +### Step 1: Training FastGRNN and Quantizing using SeeDot + +1. #### Clone EdgeML and checkout sirnn branch: + +``` +git clone https://github.com/microsoft/EdgeML.git +git checkout sirnn + +``` + +2. #### Follow the instructions in **SeeDot**'s [README](https://github.com/microsoft/EdgeML/blob/master/tools/SeeDot/README.md) to install SeeDot's dependencies. + + +3. #### Download [Google-30](http://download.tensorflow.org/data/speech_commands_v0.01.tar.gz) dataset. + +``` +cd EdgeML/examples/tf/FastCells/ +mkdir Google-30/ && cd Google-30/ +wget http://download.tensorflow.org/data/speech_commands_v0.01.tar.gz + +tar -xvf speech_commands_v0.01.tar.gz +cd ../ +``` + +4. #### Process the dataset: + +``` +python process_g30.py -d Google-30/ -s Google-30/ + +``` + +5. #### Train FastGRNN model: + +``` +python fastcell_example.py -id 32 -hd 100 -rW 16 -rU 35 -sU 0.2 -sW 0.2 -dir Google-30/ + +``` + +6. #### Quantize using SeeDot and generate input: + +``` +cd ../../../tools/SeeDot/ +mkdir -p model/fastgrnn/Google-30/ +mkdir -p datasets/fastgrnn/Google-30/ + +cp -r ../../examples/tf/FastCells/Google-30/FastGRNNResults/<timestamp>/* model/fastgrnn/Google-30/ + +cp -r ../../examples/tf/FastCells/Google-30/train.npy datasets/fastgrnn/Google-30/ +cp -r ../../examples/tf/FastCells/Google-30/test.npy datasets/fastgrnn/Google-30/ + +python fixSeeDotInput.py --seedot_file seedot/compiler/input/fastgrnn-g30.sd --model_dir model/fastgrnn/Google-30/ --dataset_dir datasets/fastgrnn/Google-30/ -n 1 --normalise_data + +python SeeDot-dev.py -a fastgrnn -e fixed -d Google-30 -m red_disagree -t EzPC -n 1 + +export SEEDOT_DIR=$(pwd) # For accessing the files in the following steps +``` +##### Warning: The above SeeDot run may fail in some devices due to a large number of threads being created. For resolution, reduce the number of rows in `datasets/fastgrnn/Google-30/train.npy`. + +### Step 2: Generating SIRNN code using EzPC + +1. #### Clone EzPC repo: + +``` +git clone https://github.com/mpc-msri/EzPC.git +``` + +2. #### Install **EzPC**'s dependencies and initialise OPAM environment. + +3. #### Set directory environment variable for EzPC: + +``` +cd EzPC/EzPC/EzPC/ + +# Build EzPC compiler, if not already done. +make + +# The directory from where EzPC can be run. +export EZPC_DIR=$(pwd) + +# Folder for storing EzPC's output when run on SeeDot generated EzPC code. + +# This can be any convenient location +mkdir -p sirnn/ + + + +``` + +4. #### Compile SeeDot generated EzPC code using the following steps: + +``` +cd ../../SIRNN/ +mkdir FastGRNN/ + +python preProcessSIRNN.py --seedot_dir ${SEEDOT_DIR} --results_dir FastGRNN/ --predict_dir ${EZPC_DIR}/sirnn --dataset Google-30 --sci_build_location FastGRNN/build +python secureCodegen.py --predict_dir ${EZPC_DIR}/sirnn --ezpc_dir ${EZPC_DIR} --results_dir FastGRNN/Google-30/ + +mkdir -p FastGRNN/build/ + +``` + +Explanation: + `preProcessSIRNN.py` script creates a folder with name 'dataset' in 'results_dir' folder. Then copies the SeeDot generated files to the 'dataset' folder. + It copies the predict.ezpc file to a location indicated by 'predict_dir'. + `sci_build_location` is the path that was specified for installing the SCI library. (If the location is not included within the `$PATH` environment variable.) + `securecppcodegne.py` script runs the EzPC compiler on predict.ezpc, specified by 'predict_dir', and stored the output in 'sirnn_fixed.cpp' at 'results_dir'. + +Note: The keywords in '' indicate the argument placeholders to the python scripts. + +### Step 3: Inference using SCI + +1. #### Install SCI using the instructions in [README](https://github.com/mpc-msri/EzPC/tree/master/SCI). + While installing SCI, the library should be installed to a location on the `$PATH` environment variable. + It is preferable to use `-DCMAKE_INSTALL_PREFIX` flag and install the libraries to the location indicated by 'sci_build_location' [above](https://github.com/mpc-msri/EzPC/blob/new-SCI/SIRNN/README.md#compile-seedot-generated-ezpc-code-using-the-following-steps). + + +2. #### Compile SIRNN code + +``` +cd FastGRNN/build/ +cmake .. # If compiling for the first time +make + +``` + +3. #### Running SIRNN: + +``` +# For SERVER +./bin/Google-30 r=1 addr=0.0.0.0 port=8000 nt=4 inputDir=../Google-30/input/ + +# For CLIENT +./bin/Google-30 r=2 addr=0.0.0.0 port=8000 nt=4 inputDir=../Google-30/input/ + +``` + + +Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license. diff --git a/SIRNN/preProcessSIRNN.py b/SIRNN/preProcessSIRNN.py new file mode 100644 index 00000000..1ab5cbce --- /dev/null +++ b/SIRNN/preProcessSIRNN.py @@ -0,0 +1,219 @@ +#! /usr/bin/env python + + +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT license. + + +import os +import argparse + + +def parseArgs(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "-sdir", + "--seedot_dir", + type=str, + metavar="", + help="Location to SeeDot home dir", + ) + parser.add_argument( + "-rdir", + "--results_dir", + type=str, + metavar="", + help="Location to store the sirnn inference files.", + ) + parser.add_argument( + "-tdir", + "--template_dir", + type=str, + metavar="", + default="templates/", + help="Location where the template file for running SIRNN inference are stored. \ + (Required only if running this file from different directory).", + ) + parser.add_argument( + "-pdir", + "--predict_dir", + type=str, + metavar="", + help="Location to store predict.ezpc file.", + ) + + parser.add_argument( + "-d", + "--dataset", + choices=["Google-30"], + default="Google-30", + metavar="", + help="The dataset to perform inference.", + ) + + parser.add_argument( + "-sci", + "--sci_build_location", + type=str, + default="", + metavar="", + help="The location where SCI is installed", + ) + + args = parser.parse_args() + return args + + +def copyFiles(args): + + os.popen( + "cp %s/EzPC/predict.ezpc %s/" + % (os.path.abspath(args.seedot_dir), os.path.abspath(args.predict_dir)) + ) + os.popen( + "cp -r %s/temp/Predictor/input/ %s/%s/" + % ( + os.path.abspath(args.seedot_dir), + os.path.abspath(args.results_dir), + args.dataset, + ) + ) + + os.popen( + "cp %s/temp/Predictor/model_fixed.h %s/%s/" + % ( + os.path.abspath(args.seedot_dir), + os.path.abspath(args.results_dir), + args.dataset, + ) + ) + os.popen( + "cp %s/temp/Predictor/vars_fixed.h %s/%s/" + % ( + os.path.abspath(args.seedot_dir), + os.path.abspath(args.results_dir), + args.dataset, + ) + ) + os.popen( + "cp %s/temp/Predictor/datatypes.h %s/%s/" + % ( + os.path.abspath(args.seedot_dir), + os.path.abspath(args.results_dir), + args.dataset, + ) + ) + + os.popen( + "cp %s/main.cpp %s/%s/" + % ( + os.path.abspath(args.template_dir), + os.path.abspath(args.results_dir), + args.dataset, + ) + ) + os.popen( + "cp %s/predictors.h %s/%s/" + % ( + os.path.abspath(args.template_dir), + os.path.abspath(args.results_dir), + args.dataset, + ) + ) + + os.popen( + "cp %s/CMakeLists.txt_Dataset %s/%s/CMakeLists.txt" + % ( + os.path.abspath(args.template_dir), + os.path.abspath(args.results_dir), + args.dataset, + ) + ) + + if not os.path.exists( + os.path.join(os.path.abspath(args.results_dir), "CMakeLists.txt") + ): + os.popen( + "cp %s/CMakeLists.txt %s/" + % (os.path.abspath(args.template_dir), os.path.abspath(args.results_dir)) + ) + + +def makeDatasetDir(args): + os.makedirs(os.path.join(args.results_dir, args.dataset), exist_ok=True) + + +def resetMYINT(args): + cur_dir = os.path.abspath(os.getcwd()) + os.chdir(os.path.join(args.results_dir, args.dataset)) + + file = open("datatypes.h").read().split("\n") + file[3] = file[3].replace("int16_t", "int32_t") + + f = open("datatypes.h", "w") + for line in file: + f.write(line + "\n") + f.close() + + os.chdir(cur_dir) + + +def fixModelFixed(args): + cur_dir = os.path.abspath(os.getcwd()) + os.chdir(os.path.join(args.results_dir, args.dataset)) + + file = open("model_fixed.h").read() + + file = file.replace("][", "*") + file = file.replace("seedot_fixed", "sirnn_fixed") + f = open("model_fixed.h", "w") + f.write(file) + f.close() + os.chdir(cur_dir) + + +def fixCMakeLists(args): + cur_dir = os.path.abspath(os.getcwd()) + + if args.sci_build_location == "": + sci_build_location = os.path.join(os.path.abspath(args.results_dir), "build/") + else: + sci_build_location = os.path.abspath(args.sci_build_location) + + os.chdir(os.path.join(args.results_dir, args.dataset)) + + file = open("CMakeLists.txt").read() + file = file.replace("EXECUTALBLE_NAME", args.dataset) + + f = open("CMakeLists.txt", "w") + f.write(file) + f.close + + os.chdir("..") + file = open("CMakeLists.txt").read() + + sub_dir_str = "add_subdirectory(%s)" % (args.dataset) + + file = file.replace("SCI_BUILD_LOCATION", '"%s"' % (sci_build_location)) + + if file.find(sub_dir_str) == -1: + file = file + "\n\n%s\n" % (sub_dir_str) + f = open("CMakeLists.txt", "w") + f.write(file) + f.close() + + os.chdir(cur_dir) + + +def run(args): + makeDatasetDir(args) + copyFiles(args) + resetMYINT(args) + fixModelFixed(args) + fixCMakeLists(args) + + +if __name__ == "__main__": + args = parseArgs() + run(args) diff --git a/SIRNN/secureCodegen.py b/SIRNN/secureCodegen.py new file mode 100644 index 00000000..8ea0b024 --- /dev/null +++ b/SIRNN/secureCodegen.py @@ -0,0 +1,404 @@ +#! /usr/bin/env python + + +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT license. + + +import os +from os import writev +import subprocess +import numpy +import argparse + +modelParams = [] +varSizeDict = {} +outputVar = "" +datasetname = "" + + +def readfile(dir, filename): + cur_dir = os.path.abspath(os.curdir) + os.chdir(os.path.join(cur_dir, dir)) + infile = open(filename).read().splitlines() + os.chdir(cur_dir) + return infile + + +def writefile(args, dir, filename, file): + cur_dir = os.getcwd() + os.chdir(dir) + outfile = open(filename, "w") + for i in range(len(file)): + outfile.write(file[i]) + outfile.write("\n") + outfile.close() + os.chdir(cur_dir) + + +def mainToFuncWithHeader(file): + header = [ + "#include <iostream>", + "#include <cstring>", + "#include <cmath>", + "", + '#include "defines.h"', + '#include "datatypes.h"', + '#include "predictors.h"', + '#include "library_fixed.h"', + '#include "model_fixed.h"', + '#include "vars_fixed.h"', + "", + "using namespace std;", + "using namespace sirnn_fixed;", + "", + "extern int party;", + "extern string address;", + "extern int port;", + "extern int num_threads;", + "void sirnnFixed(MYINT *Xtemp, int64_t* res) {", + ] + mainlineno = file.index("int main () {") + trimmedfile = file[mainlineno + 1 :] + header.extend(trimmedfile) + return header + + +def getLocStrings(args): + srcDir = args.predict_dir + dstDir = args.results_dir + infile = "predict0.cpp" + outfile = "sirnn_fixed.cpp" + return srcDir, dstDir, infile, outfile + + +def removeCinsCouts(file): + global varSizeDict + global outputVar + global modelParams + for i in range(len(file)): + spaceless = file[i].lstrip() + + if spaceless.find("make_vector") != -1: + if spaceless.find("temp") != -1: + keywords = spaceless.rstrip().split(" ") + for j in range(len(keywords)): + keyword = keywords[j] + if keyword.find("temp") != -1: + modelParams.append(keyword[:-4]) + file[i] = "" + else: + varname = spaceless.split(" ")[1] + lenStart = spaceless.find("(") + size = spaceless[lenStart:-1] + varSizeDict[varname] = size + pass + elif spaceless[0:3] == "cin": + file[i] = "" + elif spaceless[0:4] == "cout": + if spaceless.find("Value of") != -1: + start = spaceless.find("(") + end = spaceless.find(")") + varname = spaceless[start + 2 : end - 2].split(" ")[-1] + outputVar = varname + file[i] = "" + if spaceless.find("=") != -1: + splitline = spaceless.split("=") + if splitline[0].find("temp") != -1: + file[i] = "" + return file + + +def addPartyDistinction(file): + for i in range(len(file)): + spaceless = file[i].lstrip().rstrip() + if spaceless.find("=") != -1: + splitline = spaceless.split("=") + party = 1 + newline = "" + for j in range(len(modelParams)): + if splitline[0].find(modelParams[j]) != -1: + if splitline[1].find("make_vector") == -1: + if modelParams[j] == "X": + party = 2 + newline = splitline[0] + " = ( party == %d ? %s : 0);" % ( + party, + splitline[1].replace(";", ""), + ) + modelParams.pop(j) + file[i] = newline + break + return file + + +def correctTempName(file): + for i in range(len(file)): + file[i] = file[i].replace("temp", "_temp") + return file + + +def addReconstruct(file): + bwStart = outputVar.find("bw") + bw = 16 + if bwStart != -1: + bw = outputVar[bwStart + 2 :] + funccall = "reconstruct(%s, res, 1, %s, %s);" % ( + outputVar, + varSizeDict[outputVar], + bw, + ) + file.insert(-5, funccall) + return file + + +def addSuffix(file): + file[-3] = "return;" + suffix = [ + "const int switches = 0;", + "void sirnnFixedSwitch(int i, MYINT **X_temp, int32_t* res) {", + " switch(i) {", + " default: res[0] = -1; return;", + " }", + "}", + ] + file.extend(suffix) + return file + + +def deallocateModelAndVars(file): + for var in varSizeDict.keys(): + file.insert(-4, "delete[] %s;" % (var)) + return file + + +def removeComments(file): + for i in range(len(file)): + if file[i][0:2] == "/*" or file[i][0:2] == "//": + file[i] = "" + return file + + +def replaceMakeVector(file): + for i in range(len(file)): + line = file[i].rstrip() + if line.find("make_vector") != -1: + typeEnd = line.find(">") + line = line[:typeEnd] + "[" + line[typeEnd + 2 :] + line = line.replace("make_vector", "new ") + line = line.replace("<", "") + line = line.replace(">", "") + line = line[:-2] + "]" + ";" + file[i] = line + return file + + +def getLeftWhiteSpace(string): + return string.count(" ") + 2 * string.count("\t") + + +def createSpace(count): + string = "".join(" " for _ in range(count)) + return string + + +def replaceDivisions(file): + start = False + for i in range(len(file)): + spaceless = file[i] + if spaceless.find("main") != -1: + start = True + if start: + if (spaceless.find("/") != -1) and (spaceless.find("temp") == -1): + # print(i) + # input() + numFors = int(spaceless.count("+") / 2) + 1 + size = "" + for j in range(numFors): + forLine = (file[i - 2 * numFors + j]).lstrip().rstrip() + point = forLine.find(":") + length = forLine[point + 1 :] + length = length[: length.find("]")] + # print(length) + size = size + length + "*" + size = "(" + size[:-1] + ")" + + to, fro = spaceless.split("=") + to = to.rstrip() + numSpaces = getLeftWhiteSpace(to) + indentSpaces = createSpace(numSpaces) + fro = fro.lstrip().rstrip() + fro = fro[ + 2:-3 + ] # Removing parantheses and semicolon at the end of the line + froVar, shr = fro.split("/") + froVar = froVar.lstrip().rstrip() + varInd = froVar[froVar.find("[") :] + froVar = froVar[: froVar.find("[")] + shr = shr.lstrip().rstrip()[:-1] + adjustStr = "%sAdjustScaleShr(1L, %s, %s, %s, %s);" % ( + indentSpaces, + size, + shr, + froVar[froVar.find("bw") + 2 :], + froVar, + ) + file.insert(i - 2 * numFors, adjustStr) + file[i + 1] = "%s = %s%s;" % (to, froVar, varInd) + return file + + +def runEzPC(args, dir, file): + global datasetname + cur_dir = os.getcwd() + os.chdir(args.ezpc_dir) + # proc = subprocess.Popen("opam switch 4.05.0 && eval $(opam env)", stdout=subprocess.PIPE) + proc = subprocess.Popen( + "./ezpc.sh %s/%s --bitlen 64 --codegen CPP --disable-cse" % (dir, file), + shell=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + ) + out, err = proc.communicate() + # print(out.decode() + "\n\n" + err.decode()) + if out.decode().find("error") != -1: + assert ( + False + ), "Common solutions to error: Try building predict.ezpc file independently and Initialise the opam environment." + os.chdir(cur_dir) + + +def appendLibrary(file): + + lib = open("Library_SIRNN.ezpc").read().split("\n") + lib.extend(file) + return lib + + +def replaceDivisionsAndRunEzPC(args, srcDir): + global datasetname + filename = "predict.ezpc" + append_lib = True + + file = open(os.path.join(srcDir, filename)).read() + # Check if SIRNN library needs to be added to the file + if file.find("(* <><><><><><><> Auto-generated code <><><><><><><> *)") != -1: + append_lib = False + file = file.split("\n") + + noDivFile = replaceDivisions(file) + + if append_lib: + noDivFile = appendLibrary(noDivFile) + + writefile(args, srcDir, filename, noDivFile) + runEzPC(args, os.path.abspath(srcDir), filename) + + +def indentFile(file): + indent = 0 + for i in range(len(file)): + f = file[i] + if f.find("}") != -1 and f.find("{") != -1: + pass + elif f.find("}") != -1: + indent = indent - 1 + indentnow = "".join("\t" for j in range(indent)) + file[i] = indentnow + file[i] + if f.find("{") != -1: + indent = indent + 1 + return file + + +def run(args): + srcDir, dstDir, infile, outfile = getLocStrings(args) + replaceDivisionsAndRunEzPC(args, srcDir) + + file = readfile(srcDir, infile) + newfile = mainToFuncWithHeader(file) + + convfile = removeCinsCouts(newfile) + + partyfile = addPartyDistinction(convfile) + tempcorrect = correctTempName(partyfile) + reconstructFile = addReconstruct(tempcorrect) + deallocatedFile = deallocateModelAndVars(reconstructFile) + fullfile = addSuffix(deallocatedFile) + fullfile_with_new = replaceMakeVector(fullfile) + nocomment = removeComments(fullfile_with_new) + indentedFile = indentFile(nocomment) + writefile(args, dstDir, outfile, indentedFile) + + +def parseArgs(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "-pdir", + "--predict_dir", + type=str, + metavar="", + help="The location of the 'predict.ezpc' file to be converted to SIRNN C++ format.", + ) + parser.add_argument( + "-d", + "--datasets", + choices=["Google-30"], + default="Google-30", + metavar="", + help="Dataset to use ['Google-30'] \ + (Default: 'Google-30')", + ) + parser.add_argument( + "--ezpc_dir", + type=str, + metavar="", + default="../EzPC/EzPC/", + help="The path to location with 'ezpc.sh'", + ) + parser.add_argument( + "-rdir", + "--results_dir", + type=str, + metavar="", + help="Location to store the output 'seedot_fixed.cpp' file.", + ) + parser.add_argument( + "-ptype", + "--problem_type", + choices=["regression", "classification"], + metavar="", + default="classification", + help="Whether this is an instance of regression or classification problem.", + ) + + args = parser.parse_args() + return args + + +def main(): + global modelParams + global varSizeDict + global outputVar + global datasetname + + args = parseArgs() + # datasetnamelist = ["Google-12", "Google-30", "HAR-2", "HAR-6", "MNIST-10", "Wakeword-2", "spectakoms", "dsa", "usps10"] + # datasetnamelist = ["face-2"] + if not isinstance(args.datasets, list): + datasetnamelist = [args.datasets] + else: + datasetnamelist = args.datasets + + for dataset_name in datasetnamelist: + print("dataset: ", dataset_name) + modelParams = [] + varSizeDict = {} + outputVar = "" + datasetname = dataset_name + run(args) + + +if __name__ == "__main__": + main() + + # convertFunCall(["MatMul( (int64_t)1, (int64_t)8, (int64_t)64, (int64_t)1, (int64_t)1, (int64_t)0, (int64_t)3, (int64_t)64, (int32_t)8, (int32_t)8, (int32_t)16, (int32_t)8, tmp24, U2, tmp26, tmp25);"]) diff --git a/SIRNN/templates/CMakeLists.txt b/SIRNN/templates/CMakeLists.txt new file mode 100644 index 00000000..f2268b91 --- /dev/null +++ b/SIRNN/templates/CMakeLists.txt @@ -0,0 +1,21 @@ +cmake_minimum_required (VERSION 3.0) + +# Set paths to GNU gcc and g++ on Mac OS X +set(MAC_GCC "/usr/local/bin/gcc-9") +set(MAC_GPP "/usr/local/bin/g++-9") + +if(APPLE) + set(CMAKE_C_COMPILER ${MAC_GCC}) + set(CMAKE_CXX_COMPILER ${MAC_GPP}) +endif() + +project (FastGRNN-Inference) +set(NAME "FastGRNN-Inference") + +set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) +set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) + +set(CMAKE_CXX_FLAGS "-O3") + +find_package(SCI REQUIRED PATHS SCI_BUILD_LOCATION) diff --git a/SIRNN/templates/CMakeLists.txt_Dataset b/SIRNN/templates/CMakeLists.txt_Dataset new file mode 100644 index 00000000..6b8e897b --- /dev/null +++ b/SIRNN/templates/CMakeLists.txt_Dataset @@ -0,0 +1,3 @@ +add_executable(EXECUTALBLE_NAME main.cpp sirnn_fixed.cpp) +target_include_directories(EXECUTALBLE_NAME PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) +target_link_libraries(EXECUTALBLE_NAME SCI::SCI-OT) diff --git a/SIRNN/templates/main.cpp b/SIRNN/templates/main.cpp new file mode 100644 index 00000000..8a138435 --- /dev/null +++ b/SIRNN/templates/main.cpp @@ -0,0 +1,187 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT license. + +#include <iostream> +#include <fstream> +#include <sstream> +#include <vector> +#include <cstring> +#include <cmath> +#include <cstdlib> +#include <cassert> +#include <thread> +#include <algorithm> +#include "utils/ArgMapping/ArgMapping.h" +#include "defines.h" +#include "datatypes.h" +#include "predictors.h" + +using namespace std; + +int party = 1; +string address = "127.0.0.1"; +int port = 8000; +int num_threads = 2; +int32_t bitlength = 32; +string inputDir; + + +enum Version +{ + Fixed, + Float +}; +enum DatasetType +{ + Training, + Testing +}; +enum ProblemType +{ + Classification, + Regression +}; + +bool profilingEnabled = false; + +// Split the CSV row into multiple values +vector<string> readCSVLine(string line) +{ + vector<string> tokens; + + stringstream stream(line); + string str; + + while (getline(stream, str, ',')) + tokens.push_back(str); + + return tokens; +} + +vector<string> getFeatures(string line) +{ + static int featuresLength = -1; + + vector<string> features = readCSVLine(line); + + if (featuresLength == -1) + featuresLength = (int)features.size(); + + if ((int)features.size() != featuresLength) + throw "Number of row entries in X is inconsistent"; + + return features; +} + +vector<string> getLabel(string line) +{ + static int labelLength = -1; + + vector<string> labels = readCSVLine(line); + + if (labelLength == -1) + labelLength = (int)labels.size(); + + if ((int)labels.size() != labelLength) + throw "Number of row entries in Y is inconsistent"; + + return labels; +} + +void populateFixedVector(MYINT *features_int, vector<string> features, int scale) +{ + int features_size = (int)features.size(); + + for (int i = 0; i < features_size; i++) + { + double f = (double)(atof(features.at(i).c_str())); + double f_int = ldexp(f, -scale); + features_int[i] = (MYINT)(f_int); + } + + return; +} + +int main(int argc, char *argv[]) +{ + ArgMapping amap; + amap.arg("r", party, "Role of party: ALICE = 1; BOB = 2"); + amap.arg("addr", address, "Localhost Run?"); + amap.arg("port", port, "Port Number"); + amap.arg("nt", num_threads, "Number of threads"); + amap.arg("inputDir", inputDir, "The location of input CSV files"); + + amap.parse(argc, argv); + assert(party == 1 || party == 2); + + cout << "Party: " << party << endl; + + int numOutputs = 1; + + // Invoke the predictor function + + ifstream featuresFile(inputDir + "X.csv"); + ifstream lablesFile(inputDir + "Y.csv"); + + if (featuresFile.good() == false || lablesFile.good() == false) + throw "Input files doesn't exist"; + + #ifdef CLEARTEXT_ONLY + string line1, line2; + int correctCounter = 0; + int counter = 0; + while (getline(featuresFile, line1) && getline(lablesFile, line2)) + { + #endif + int64_t* fixed_res = new int64_t; + if (party == 1) { // SERVER + sirnnFixed(nullptr, fixed_res); + } else { // party == 2 (CLIENT) + // Reading the dataset + + int features_size = -1; + MYINT *features_int = NULL; + + vector<int32_t*> labelsInt; + + #ifndef CLEARTEXT_ONLY + string line1, line2; + + getline(featuresFile, line1); + getline(lablesFile, line2); + #endif + + vector<string> features = getFeatures(line1); + vector<string> labelString = getLabel(line2); + int32_t labelInt; + + labelInt = atoi(labelString[0].c_str()); + + // Allocate memory to store the feature vector as arrays + features_size = (int)features.size(); + + features_int = new MYINT[features_size]; + + cout << "[CLIENT] Input Parsed" << endl; + + // Populate the array using the feature vector + populateFixedVector(features_int, features, scaleForX); + + sirnnFixed(features_int, fixed_res); + #ifndef CLEARTEXT_ONLY + cout<<"Predicted Label:" << *fixed_res << ", Actual Label:" << labelInt << endl; + #else + if ((*fixed_res) == labelInt) + correctCounter++; + counter++; + #endif + // Deallocate memory + + delete[] features_int; + } + #ifdef CLEARTEXT_ONLY + } + cout<<float(correctCounter*100)/float(counter)<<endl; + #endif + return 0; +} diff --git a/SIRNN/templates/predictors.h b/SIRNN/templates/predictors.h new file mode 100644 index 00000000..6de3a2ec --- /dev/null +++ b/SIRNN/templates/predictors.h @@ -0,0 +1,10 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT license. + +#pragma once + +void sirnnFixed(MYINT *X, int64_t* res); +void sirnnFloat(float **X, float* res); +void sirnnFixedSwitch(int i, MYINT** X, int32_t* res); + +extern const int switches; diff --git a/setup_env_and_build.sh b/setup_env_and_build.sh index 79ca125b..525b42f2 100755 --- a/setup_env_and_build.sh +++ b/setup_env_and_build.sh @@ -100,5 +100,5 @@ make -j cd $ROOT/SCI mkdir -p build cd build -cmake -DBUILD_NETWORKS=ON ../ -make -j +cmake -DCMAKE_INSTALL_PREFIX=./install ../ +cmake --build . --target install --parallel