SPU Inside#

SPU is a virtual device backed by an MPC engine, which provides an arithmetic black box abstraction to front-end users. Just like other black boxes, it’s not easy to understand what happened inside it.

For this reason, SPU provides some features to show what happened inside it, this document demonstrates these features.

Simulation#

As the name suggests, multi-party computation is born to be distributed system with multiple participants, which makes it harder to setup, debug and inspect. So SPU provides a simulation module that uses threads to simulate multi-parties in a single process. All parties acts exactly the same as in production environment, so we can use it as a playground to inspect the internals of SPU.

To use the simulation module, we can simple do

[1]:

import spu
import jax.numpy as jnp
import numpy as np

# import spu simulation module
import spu.utils.simulation as pps

Now we can create SPU simulator and run program on it.

[2]:

# create a simulator with ABY3 x Ring64 protocol.
protocol = spu.ProtocolKind.ABY3
field = spu.FieldType.FM64
simulator = pps.Simulator.simple(3, protocol, field)

# decorate a jnp function to a simulated function
spu_add = pps.sim_jax(simulator, jnp.add)

# now we can call spu_fn like normal jnp fn.
x = np.array([[1., 2.], [3., 4.]])
y = np.array([[5., 6.], [7., 8.]])

# the function is simulated on SPU VM, which use 3 threads to simulate different parties.
# the actual progress is exactly the same as real distributed version.
z = spu_add(x, y)

print(z)

No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)

[[ 6.  8.]
 [10. 12.]]

In the above code. - First, we create an SPU simulator backed by ABY3 protocol with FM64 field. - Then we decorates a jax function jax.add to make it a SPU simulated function. - Then we can use the simulated function just like normal python functions.

As the result suggests, it behaves like a python function, we can also print the compiled pphlo program with

[3]:

print(spu_add.pphlo)

module @xla_computation_add attributes {mhlo.cross_program_prefetches = [], mhlo.dynamic_parameter_bindings = [], mhlo.is_dynamic = false, mhlo.use_auto_spmd_partitioning = false} {
  func.func @main(%arg0: tensor<2x2x!pphlo.sec<f32>>, %arg1: tensor<2x2x!pphlo.sec<f32>>) -> tensor<2x2x!pphlo.sec<f32>> {
    %0 = "pphlo.add"(%arg0, %arg1) : (tensor<2x2x!pphlo.sec<f32>>, tensor<2x2x!pphlo.sec<f32>>) -> tensor<2x2x!pphlo.sec<f32>>
    return %0 : tensor<2x2x!pphlo.sec<f32>>
  }
}

The above code is a pphlo dialect in MLIR format, which defines a main function that accepts two arguments and returns the sum as result.

Besides single jax.numpy op, we can simulate any jax function on SPU, i.e.

[4]:

def sigmoid(x):
    return 1 / (1 + jnp.exp(-x))

spu_sigmoid = pps.sim_jax(simulator, sigmoid)
spu_sigmoid(x)

print(spu_sigmoid.pphlo)

module @xla_computation_sigmoid attributes {mhlo.cross_program_prefetches = [], mhlo.dynamic_parameter_bindings = [], mhlo.is_dynamic = false, mhlo.use_auto_spmd_partitioning = false} {
  func.func @main(%arg0: tensor<2x2x!pphlo.sec<f32>>) -> tensor<2x2x!pphlo.sec<f32>> {
    %0 = "pphlo.constant"() {value = dense<1.000000e+00> : tensor<2x2xf32>} : () -> tensor<2x2x!pphlo.pub<f32>>
    %1 = "pphlo.negate"(%arg0) : (tensor<2x2x!pphlo.sec<f32>>) -> tensor<2x2x!pphlo.sec<f32>>
    %2 = "pphlo.exponential"(%1) : (tensor<2x2x!pphlo.sec<f32>>) -> tensor<2x2x!pphlo.sec<f32>>
    %3 = "pphlo.add"(%2, %0) : (tensor<2x2x!pphlo.sec<f32>>, tensor<2x2x!pphlo.pub<f32>>) -> tensor<2x2x!pphlo.sec<f32>>
    %4 = "pphlo.divide"(%0, %3) : (tensor<2x2x!pphlo.pub<f32>>, tensor<2x2x!pphlo.sec<f32>>) -> tensor<2x2x!pphlo.sec<f32>>
    return %4 : tensor<2x2x!pphlo.sec<f32>>
  }
}

The above code is spu function which is composed of spu builtin ops.

Note: since spu use JIT compilation, so we have to execute the function before printing the compiled bytecode.

Profling#

Besides simple simulation, we can profile the simulated program, although the profiling result could NOT be used as a reference of SPU perf, it still gives some information of what happened.

To use profiling, we have enabled some feature flags.

[5]:

config = spu.RuntimeConfig(protocol=protocol, field=field)
config.enable_pphlo_profile = True
simulator = pps.Simulator(3, config)

enable_pphlo_profile tells SPU runtime to print information about pphlo, now, let’s run the function on this new runtime.

[6]:

spu_sigmoid = pps.sim_jax(simulator, sigmoid)
z = spu_sigmoid(x)

[2023-02-25 08:28:41.147] [info] [api.cc:131] [Profiling] SPU execution sigmoid completed, input processing took 3.9e-07s, execution took 0.001579826s, output processing took 5.9e-07s, total time 0.001580806s.
[2023-02-25 08:28:41.147] [info] [api.cc:163] HLO profiling: total time 0.001053574
[2023-02-25 08:28:41.147] [info] [api.cc:166] - pphlo.add, executed 1 times, duration 4.35e-06s
[2023-02-25 08:28:41.147] [info] [api.cc:166] - pphlo.constant, executed 1 times, duration 1.0905e-05s
[2023-02-25 08:28:41.147] [info] [api.cc:166] - pphlo.divide, executed 1 times, duration 0.000771116s
[2023-02-25 08:28:41.147] [info] [api.cc:166] - pphlo.exponential, executed 1 times, duration 0.000243988s
[2023-02-25 08:28:41.147] [info] [api.cc:166] - pphlo.negate, executed 1 times, duration 2.3215e-05s
[2023-02-25 08:28:41.147] [info] [api.cc:175] Link details: total send bytes 3568, send actions 89

The above log tells the total execution time and the detailed statistics of each builtin function.

Besides the enable_pphlo_profile feature flag, SPU has other flags like enable_hal_profile to dump runtime information in different levels of instructions.

Tracing#

Profiling can only tell the statistics of SPU instructions, it’s still hard to understand what happened inside it. Tracing is a feature that used to print verbose call stack, which helps to understand/inspect what exactly happened.

To enable tracing features, just set enable_action_trace in the runtime config.

[7]:

config = spu.RuntimeConfig(protocol=protocol, field=field)
config.enable_action_trace = True
simulator = pps.Simulator(3, config)

Now, let’s run another function on this tracing enabled simulator.

[8]:

spu_mul = pps.sim_jax(simulator, jnp.multiply)
z = spu_mul(x, y)

[2023-02-25 08:28:45.293] [TR] [B] hlo.pphlo.multiply()
[2023-02-25 08:28:45.293] [TR] [B]   hal.mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:28:45.293] [TR] [B]     hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:28:45.293] [TR] [B]       hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:28:45.293] [TR] [B]         hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:28:45.293] [TR] [B]           mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:28:45.293] [TR] [B]             mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:28:45.293] [TR] [E]             mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:28:45.293] [TR] [E]           mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:28:45.293] [TR] [E]         hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:28:45.293] [TR] [E]       hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:28:45.293] [TR] [B]       hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:28:45.293] [TR] [B]         hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:28:45.293] [TR] [B]           mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:28:45.293] [TR] [B]             mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:28:45.293] [TR] [E]             mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:28:45.293] [TR] [E]           mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:28:45.293] [TR] [E]         hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:28:45.293] [TR] [E]       hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:28:45.293] [TR] [E]     hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:28:45.293] [TR] [E]   hal.mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:28:45.293] [TR] [E] hlo.pphlo.multiply()

At the first glance, the trace log is a bit of frustrating, so it worth a little while to explain it.

At the very begining, is the entry point of multiply function.

Each line follows the format as below:

[timestamp] [TR] [B/E] module.op(value_type...)

For example, the second line [timestamp] [TR] [B]   hal.mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>) means: - this is a tracing log indicated by [TR] - the function begins/ends [B/E] - the module is hal - the operator is mul - the two args are both Value<2x2xSFXP,s=2,1>

Note, hlo is short for High Level Operations, hal is short for Hardware Abstraction Layer, mpc is short for Multi-Party Computation.

The Value<2x2xSFXP,s=2,1> means it’s a Secret FiXed Pointed tensor with shape(2x2) and strides(2,1).

  1. the runtime dispatches the function according parameters datatype (in this case fxp), then calls the corresponding fixed point handle function hal.f_mul, the prefix f_ means its for fixed point.

  2. the runtime dispatches hal.f_mul to the untyped version hal._mul which operates on rings.

  3. the runtime dispatches hal._mul according to the visibility type, since both parameters are secret, so hal._mul_ss is called, the postfix _ss indicates that it operates on two secrets.

Then the function hal._mul_ss is dispatched to the MPC layer, the signature becomes more complicated.

mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>,ArrayRef<4xaby3.AShr<FM64>>)

The signature of this operation is the same as above, mpc.mul_ss indicates the module is mpc and the operation is mul_ss.

The type ArrayRef<4xaby3.AShr<FM64>> has two notable differences: 1. unlike hal ops, mpc ops operates on 1D-array instead of tensor, which makes it a more standard SIMD instruction. 2. the type aby3.AShr<FM64> is protocol-dependent, in this case, it’s an ABY3 arithmetic share in FM64.

Finally, it’s dispatched to mpc.mul_aa, the postfix _aa indicates both parameters are arithmetic shares, then the ABY3 share addition protocol is performed.

But f_mul could not be done with ring multiplication only, we have to truncate the result to make the fixed point legal, in the following lines, hal._trunc is called and finally dispatched to mpc.trunc_a protocol.

The above example is pretty straight forward, now let’s make it harder.

Fixed point reciprocal is done with Goldschmidt approximation algorithm, the algorithm itself is not that simple, and when it’s executed on MPC, things become more complicated.

It takes a lot of effort to understand how it works, let’s directly see the tracing result.

[9]:

spu_reciprocal = pps.sim_jax(simulator, jnp.reciprocal)
z = spu_reciprocal(x)

[2023-02-25 08:33:10.167] [TR] [B] hlo.pphlo.constant()
[2023-02-25 08:33:10.167] [TR] [B]   hal.constant(PtBufferView<0x7fd4b80acd10,xPT_F32,>, {})
[2023-02-25 08:33:10.167] [TR] [B]     hal.make_pub2k(PtBufferView<0x7fd4b80acd10,xPT_F32,>)
[2023-02-25 08:33:10.167] [TR] [E]     hal.make_pub2k(PtBufferView<0x7fd4b80acd10,xPT_F32,>)
[2023-02-25 08:33:10.167] [TR] [E]   hal.constant(PtBufferView<0x7fd4b80acd10,xPT_F32,>, {})
[2023-02-25 08:33:10.167] [TR] [B]   hal.broadcast_to(Value<xPFXP,s=>, {2,2})
[2023-02-25 08:33:10.167] [TR] [E]   hal.broadcast_to(Value<xPFXP,s=>, {2,2})
[2023-02-25 08:33:10.167] [TR] [E] hlo.pphlo.constant()
[2023-02-25 08:33:10.167] [TR] [B] hlo.pphlo.divide()
[2023-02-25 08:33:10.167] [TR] [B]   hal.div(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.167] [TR] [B]     hal.dtype_cast(Value<2x2xPFXP,s=0,0>, FXP)
[2023-02-25 08:33:10.167] [TR] [E]     hal.dtype_cast(Value<2x2xPFXP,s=0,0>, FXP)
[2023-02-25 08:33:10.167] [TR] [B]     hal.dtype_cast(Value<2x2xSFXP,s=2,1>, FXP)
[2023-02-25 08:33:10.167] [TR] [E]     hal.dtype_cast(Value<2x2xSFXP,s=2,1>, FXP)
[2023-02-25 08:33:10.167] [TR] [B]     hal.f_div(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.167] [TR] [B]       hal.div_goldschmidt(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.167] [TR] [B]         hal._msb(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.167] [TR] [B]           hal._msb_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.167] [TR] [B]             mpc.msb_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.167] [TR] [B]               mpc.msb_a2b(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U32,32>>, ArrayRef<8xaby3.BShr<PT_U32,32>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U32,32>>, ArrayRef<8xaby3.BShr<PT_U32,32>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U32,32>>, ArrayRef<4xaby3.BShr<PT_U32,32>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U32,32>>, ArrayRef<4xaby3.BShr<PT_U32,32>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U16,16>>, ArrayRef<8xaby3.BShr<PT_U16,16>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U16,16>>, ArrayRef<8xaby3.BShr<PT_U16,16>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U16,16>>, ArrayRef<4xaby3.BShr<PT_U16,16>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U16,16>>, ArrayRef<4xaby3.BShr<PT_U16,16>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U8,8>>, ArrayRef<8xaby3.BShr<PT_U8,8>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U8,8>>, ArrayRef<8xaby3.BShr<PT_U8,8>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,8>>, ArrayRef<4xaby3.BShr<PT_U8,8>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,8>>, ArrayRef<4xaby3.BShr<PT_U8,8>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U8,4>>, ArrayRef<8xaby3.BShr<PT_U8,4>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U8,4>>, ArrayRef<8xaby3.BShr<PT_U8,4>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,4>>, ArrayRef<4xaby3.BShr<PT_U8,4>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,4>>, ArrayRef<4xaby3.BShr<PT_U8,4>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U8,2>>, ArrayRef<8xaby3.BShr<PT_U8,2>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U8,2>>, ArrayRef<8xaby3.BShr<PT_U8,2>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,2>>, ArrayRef<4xaby3.BShr<PT_U8,2>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,2>>, ArrayRef<4xaby3.BShr<PT_U8,2>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U8,1>>, ArrayRef<8xaby3.BShr<PT_U8,1>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U8,1>>, ArrayRef<8xaby3.BShr<PT_U8,1>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,1>>, ArrayRef<4xaby3.BShr<PT_U8,1>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,1>>, ArrayRef<4xaby3.BShr<PT_U8,1>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 63)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 63)
[2023-02-25 08:33:10.167] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,1>>, ArrayRef<4xaby3.BShr<PT_U8,1>>)
[2023-02-25 08:33:10.167] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U8,1>>, ArrayRef<4xaby3.BShr<PT_U8,1>>)
[2023-02-25 08:33:10.167] [TR] [E]               mpc.msb_a2b(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.167] [TR] [E]             mpc.msb_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.167] [TR] [E]           hal._msb_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.167] [TR] [E]         hal._msb(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.167] [TR] [B]         hal._make_p(0)
[2023-02-25 08:33:10.167] [TR] [B]           mpc.make_p(0)
[2023-02-25 08:33:10.168] [TR] [E]           mpc.make_p(0)
[2023-02-25 08:33:10.168] [TR] [E]         hal._make_p(0)
[2023-02-25 08:33:10.168] [TR] [B]         hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [E]         hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [B]         hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]             mpc.add_sp(ArrayRef<4xaby3.BShr<PT_U8,1>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.b2a(ArrayRef<4xaby3.BShr<PT_U8,1>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.b2a(ArrayRef<4xaby3.BShr<PT_U8,1>>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]             mpc.add_sp(ArrayRef<4xaby3.BShr<PT_U8,1>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [E]         hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]         hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._make_p(1)
[2023-02-25 08:33:10.168] [TR] [B]             mpc.make_p(1)
[2023-02-25 08:33:10.168] [TR] [E]             mpc.make_p(1)
[2023-02-25 08:33:10.168] [TR] [E]           hal._make_p(1)
[2023-02-25 08:33:10.168] [TR] [B]           hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [E]           hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [B]           hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [E]         hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]         hal._mux(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._sub(Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               hal._make_p(1)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.make_p(1)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.make_p(1)
[2023-02-25 08:33:10.168] [TR] [E]               hal._make_p(1)
[2023-02-25 08:33:10.168] [TR] [B]               hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [E]               hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [B]               hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]                 hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]                   mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                   mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]               hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]                 hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]                   mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                   mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [E]               hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._add(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               hal._add_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.add_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                   mpc.add_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                   mpc.add_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.add_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]               hal._add_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._add(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._sub(Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._mul(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._mul_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._mul_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._mul(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._add(Value<2x2xSFXP,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._add_ss(Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.add_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.add_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.add_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.add_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._add_ss(Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._add(Value<2x2xSFXP,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]         hal._mux(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]         hal._prefix_or(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._make_p(0)
[2023-02-25 08:33:10.168] [TR] [B]             mpc.make_p(0)
[2023-02-25 08:33:10.168] [TR] [E]             mpc.make_p(0)
[2023-02-25 08:33:10.168] [TR] [E]           hal._make_p(0)
[2023-02-25 08:33:10.168] [TR] [B]           hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [E]           hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xSFXP,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.a2b(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                   mpc.add_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                   mpc.add_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.a2b(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bp(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bp(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xSFXP,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._rshift(Value<2x2xS*,s=2,1>, 1)
[2023-02-25 08:33:10.168] [TR] [B]             hal._rshift_s(Value<2x2xS*,s=2,1>, 1)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]             hal._rshift_s(Value<2x2xS*,s=2,1>, 1)
[2023-02-25 08:33:10.168] [TR] [E]           hal._rshift(Value<2x2xS*,s=2,1>, 1)
[2023-02-25 08:33:10.168] [TR] [B]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,63>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,63>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,63>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,63>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,63>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,63>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,63>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,63>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._rshift(Value<2x2xS*,s=2,1>, 2)
[2023-02-25 08:33:10.168] [TR] [B]             hal._rshift_s(Value<2x2xS*,s=2,1>, 2)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [E]             hal._rshift_s(Value<2x2xS*,s=2,1>, 2)
[2023-02-25 08:33:10.168] [TR] [E]           hal._rshift(Value<2x2xS*,s=2,1>, 2)
[2023-02-25 08:33:10.168] [TR] [B]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,62>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,62>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,62>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,62>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,62>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,62>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,62>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,62>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._rshift(Value<2x2xS*,s=2,1>, 4)
[2023-02-25 08:33:10.168] [TR] [B]             hal._rshift_s(Value<2x2xS*,s=2,1>, 4)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [E]             hal._rshift_s(Value<2x2xS*,s=2,1>, 4)
[2023-02-25 08:33:10.168] [TR] [E]           hal._rshift(Value<2x2xS*,s=2,1>, 4)
[2023-02-25 08:33:10.168] [TR] [B]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,60>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,60>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,60>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,60>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,60>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,60>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,60>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,60>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._rshift(Value<2x2xS*,s=2,1>, 8)
[2023-02-25 08:33:10.168] [TR] [B]             hal._rshift_s(Value<2x2xS*,s=2,1>, 8)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [E]             hal._rshift_s(Value<2x2xS*,s=2,1>, 8)
[2023-02-25 08:33:10.168] [TR] [E]           hal._rshift(Value<2x2xS*,s=2,1>, 8)
[2023-02-25 08:33:10.168] [TR] [B]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,56>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,56>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,56>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,56>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,56>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,56>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,56>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,56>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._rshift(Value<2x2xS*,s=2,1>, 16)
[2023-02-25 08:33:10.168] [TR] [B]             hal._rshift_s(Value<2x2xS*,s=2,1>, 16)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [E]             hal._rshift_s(Value<2x2xS*,s=2,1>, 16)
[2023-02-25 08:33:10.168] [TR] [E]           hal._rshift(Value<2x2xS*,s=2,1>, 16)
[2023-02-25 08:33:10.168] [TR] [B]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,48>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,48>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,48>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U64,48>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,48>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,48>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,48>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,48>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._rshift(Value<2x2xS*,s=2,1>, 32)
[2023-02-25 08:33:10.168] [TR] [B]             hal._rshift_s(Value<2x2xS*,s=2,1>, 32)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [E]             hal._rshift_s(Value<2x2xS*,s=2,1>, 32)
[2023-02-25 08:33:10.168] [TR] [E]           hal._rshift(Value<2x2xS*,s=2,1>, 32)
[2023-02-25 08:33:10.168] [TR] [B]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U32,32>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U32,32>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U32,32>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.and_ss(ArrayRef<4xaby3.BShr<PT_U32,32>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._and_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._and(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U32,32>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U32,32>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U32,32>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U32,32>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]         hal._prefix_or(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]         hal._rshift(Value<2x2xS*,s=2,1>, 1)
[2023-02-25 08:33:10.168] [TR] [B]           hal._rshift_s(Value<2x2xS*,s=2,1>, 1)
[2023-02-25 08:33:10.168] [TR] [B]             mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.rshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]             mpc.rshift_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]           hal._rshift_s(Value<2x2xS*,s=2,1>, 1)
[2023-02-25 08:33:10.168] [TR] [E]         hal._rshift(Value<2x2xS*,s=2,1>, 1)
[2023-02-25 08:33:10.168] [TR] [B]         hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,63>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,63>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,63>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]             mpc.xor_ss(ArrayRef<4xaby3.BShr<PT_U64,63>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._xor_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]         hal._xor(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]         hal._bitrev(Value<2x2xS*,s=2,1>, 0, 36)
[2023-02-25 08:33:10.168] [TR] [B]           hal._bitrev_s(Value<2x2xS*,s=2,1>, 0, 36)
[2023-02-25 08:33:10.168] [TR] [B]             mpc.bitrev_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 0, 36)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.bitrev_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 0, 36)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.bitrev_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 0, 36)
[2023-02-25 08:33:10.168] [TR] [E]             mpc.bitrev_s(ArrayRef<4xaby3.BShr<PT_U64,64>>, 0, 36)
[2023-02-25 08:33:10.168] [TR] [E]           hal._bitrev_s(Value<2x2xS*,s=2,1>, 0, 36)
[2023-02-25 08:33:10.168] [TR] [E]         hal._bitrev(Value<2x2xS*,s=2,1>, 0, 36)
[2023-02-25 08:33:10.168] [TR] [B]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.mul_ss(ArrayRef<4xaby3.BShr<PT_U64,36>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.b2a(ArrayRef<4xaby3.BShr<PT_U64,36>>)
[2023-02-25 08:33:10.168] [TR] [B]                   mpc.add_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                   mpc.add_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.b2a(ArrayRef<4xaby3.BShr<PT_U64,36>>)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.mul_ss(ArrayRef<4xaby3.BShr<PT_U64,36>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.168] [TR] [E]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [E]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.168] [TR] [B]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.168] [TR] [B]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.168] [TR] [B]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.168] [TR] [E]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.168] [TR] [E]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.168] [TR] [E]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.168] [TR] [E]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.168] [TR] [E]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]         hal.constant(PtBufferView<0x7fd4e8ff6440,xPT_I32,>, {2,2})
[2023-02-25 08:33:10.168] [TR] [B]           hal.make_pub2k(PtBufferView<0x7fd4e8ff6440,xPT_I32,>)
[2023-02-25 08:33:10.168] [TR] [E]           hal.make_pub2k(PtBufferView<0x7fd4e8ff6440,xPT_I32,>)
[2023-02-25 08:33:10.168] [TR] [B]           hal.broadcast_to(Value<xPI32,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [E]           hal.broadcast_to(Value<xPI32,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [E]         hal.constant(PtBufferView<0x7fd4e8ff6440,xPT_I32,>, {2,2})
[2023-02-25 08:33:10.168] [TR] [B]         hal.constant(PtBufferView<0x7fd4e8ff6440,xPT_F32,>, {2,2})
[2023-02-25 08:33:10.168] [TR] [B]           hal.make_pub2k(PtBufferView<0x7fd4e8ff6440,xPT_F32,>)
[2023-02-25 08:33:10.168] [TR] [E]           hal.make_pub2k(PtBufferView<0x7fd4e8ff6440,xPT_F32,>)
[2023-02-25 08:33:10.168] [TR] [B]           hal.broadcast_to(Value<xPFXP,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [E]           hal.broadcast_to(Value<xPFXP,s=>, {2,2})
[2023-02-25 08:33:10.168] [TR] [E]         hal.constant(PtBufferView<0x7fd4e8ff6440,xPT_F32,>, {2,2})
[2023-02-25 08:33:10.168] [TR] [B]         hal._mul(Value<2x2xPI32,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.168] [TR] [B]           hal._mul_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPI32,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]             mpc.mul_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.mul_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.mul_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             mpc.mul_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._mul_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPI32,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]         hal._mul(Value<2x2xPI32,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_sub(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal.f_negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._make_p(1)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.make_p(1)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.make_p(1)
[2023-02-25 08:33:10.169] [TR] [E]               hal._make_p(1)
[2023-02-25 08:33:10.169] [TR] [B]               hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [E]               hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [B]               hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]                 hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]                 hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal.f_negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal.f_add(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._add(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._add_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._add_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._add(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal.f_add(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_sub(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.constant(PtBufferView<0x7fd4e8ff6440,xPT_F32,>, {2,2})
[2023-02-25 08:33:10.169] [TR] [B]           hal.make_pub2k(PtBufferView<0x7fd4e8ff6440,xPT_F32,>)
[2023-02-25 08:33:10.169] [TR] [E]           hal.make_pub2k(PtBufferView<0x7fd4e8ff6440,xPT_F32,>)
[2023-02-25 08:33:10.169] [TR] [B]           hal.broadcast_to(Value<xPFXP,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [E]           hal.broadcast_to(Value<xPFXP,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [E]         hal.constant(PtBufferView<0x7fd4e8ff6440,xPT_F32,>, {2,2})
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [B]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [E]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_sub(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal.f_negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._make_p(1)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.make_p(1)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.make_p(1)
[2023-02-25 08:33:10.169] [TR] [E]               hal._make_p(1)
[2023-02-25 08:33:10.169] [TR] [B]               hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [E]               hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [B]               hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]                 hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]                 hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal.f_negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal.f_add(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._add(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._add_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._add_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._add(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal.f_add(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_sub(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_add(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._add(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._add_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._add_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._add(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_add(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [B]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [E]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_square(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [B]               hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]               hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [E]             hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [E]           hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_square(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_add(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._add(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._add_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._add_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._add(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_add(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [B]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [E]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._mul_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.mul_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.mul_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.mul_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.mul_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._mul_sp(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [B]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [E]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xPFXP,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.mul_ss(ArrayRef<4xaby3.BShr<PT_U64,36>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.b2a(ArrayRef<4xaby3.BShr<PT_U64,36>>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.add_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.and_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 2)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 4)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 8)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 16)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 32)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.and_bb(ArrayRef<8xaby3.BShr<PT_U64,64>>, ArrayRef<8xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.lshift_b(ArrayRef<4xaby3.BShr<PT_U64,64>>, 1)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.xor_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.add_bb(ArrayRef<4xaby3.BShr<PT_U64,64>>, ArrayRef<4xaby3.BShr<PT_U64,64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.b2a(ArrayRef<4xaby3.BShr<PT_U64,36>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.mul_ss(ArrayRef<4xaby3.BShr<PT_U64,36>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._mul_ss(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [B]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.trunc_a(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.trunc_s(ArrayRef<4xaby3.AShr<FM64>>, 18)
[2023-02-25 08:33:10.169] [TR] [E]             hal._trunc_s(Value<2x2xS*,s=2,1>, 18)
[2023-02-25 08:33:10.169] [TR] [E]           hal._trunc(Value<2x2xS*,s=2,1>, 0)
[2023-02-25 08:33:10.169] [TR] [E]         hal.f_mul(Value<2x2xSFXP,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]         hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._make_p(1)
[2023-02-25 08:33:10.169] [TR] [B]             mpc.make_p(1)
[2023-02-25 08:33:10.169] [TR] [E]             mpc.make_p(1)
[2023-02-25 08:33:10.169] [TR] [E]           hal._make_p(1)
[2023-02-25 08:33:10.169] [TR] [B]           hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [E]           hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [B]           hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]         hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]         hal._mux(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._sub(Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._make_p(1)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.make_p(1)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.make_p(1)
[2023-02-25 08:33:10.169] [TR] [E]               hal._make_p(1)
[2023-02-25 08:33:10.169] [TR] [B]               hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [E]               hal.broadcast_to(Value<xP*,s=>, {2,2})
[2023-02-25 08:33:10.169] [TR] [B]               hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]                 hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.not_a(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.not_s(ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 hal._not_s(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._not(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]                 hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                     mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                     mpc.add_ap(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.add_sp(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xPub2k<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 hal._add_sp(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._add(Value<2x2xS*,s=2,1>, Value<2x2xP*,s=0,0>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._negate(Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._add(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               hal._add_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.add_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                   mpc.add_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                   mpc.add_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.add_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               hal._add_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._add(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._sub(Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._mul(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._mul_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.mul_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.mul_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._mul_ss(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._mul(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]           hal._add(Value<2x2xSFXP,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]             hal._add_ss(Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [B]               mpc.add_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [B]                 mpc.add_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]                 mpc.add_aa(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]               mpc.add_ss(ArrayRef<4xaby3.AShr<FM64>>, ArrayRef<4xaby3.AShr<FM64>>)
[2023-02-25 08:33:10.169] [TR] [E]             hal._add_ss(Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]           hal._add(Value<2x2xSFXP,s=2,1>, Value<2x2xS*,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]         hal._mux(Value<2x2xS*,s=2,1>, Value<2x2xS*,s=2,1>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]       hal.div_goldschmidt(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]     hal.f_div(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E]   hal.div(Value<2x2xPFXP,s=0,0>, Value<2x2xSFXP,s=2,1>)
[2023-02-25 08:33:10.169] [TR] [E] hlo.pphlo.divide()

Surprise, it’s really a lot of ops!

Yes, that’s why MPC is still relatively slow and why SPU wants to optimize it :P

The reciprocal is still a relative simple operator, you can try more complicated op like convolution.

Misc#

Simulation could be used to inspect other parts of SPU, i.e. the fixed point arithmetic accuracy.

As the above example indicates, non-linear functions like reciprocal and exp are approximated with some numeric methods, so the result is not as accurate as floating point arithmetic.

For example.

[ ]:

%pip install matplotlib

[10]:

from matplotlib import pyplot as plt

simulator = pps.Simulator.simple(3, protocol, spu.FieldType.FM128)
spu_exp = pps.sim_jax(simulator, jnp.exp)

x = np.arange(0.,23.)
spu_y = spu_exp(x)
jax_y = jnp.exp(x)
plt.title("Matplotlib demo")
plt.plot(x,spu_y)
plt.plot(x,jax_y)
plt.show()
../../_images/getting_started_tutorials_spu_inside_24_0.png

As we can see, the SPU version of exp (blue line) diverges with the standard version when input is larger.

Finally, SPU, as a secure computation, behaves very differently from CPU, both in accuracy and cost model, when you are not sure about how it works, simulate on it!