Zipper multiplication Introduction

Let's define a new arithmetical operation, which I call zipper multiplication.
To zipper multiply two nonnegative integers, you add leading zeros to make the lengths match, multiply the corresponding base-10 digits of the numbers, add leading zeros to the results to get 2-digit numbers, concatenate them, and finally drop leading zeros.

Here's an example with A = 1276 and B = 933024:

1. Add leading zeros
 A = 001276
 B = 933024

2. Multiply digit-wise
 A = 0  0  1  2  7  6
 B = 9  9  3  0  2  4
 -&gt;  0  0  3  0 14 24

3. Pad to 2 digits
 -&gt; 00 00 03 00 14 24

4. Concatenate
 -&gt; 000003001424

5. Drop leading zeros
 -&gt; 3001424


The operation is extended to all integers with the usual sign rules: positive times negative is negative, negative times negative is positive and so on.

The task

Your inputs are two integers, and your output is their zipper multiplication.
You should be able to handle arbitrarily large inputs.
Input and/or output can be in string format (and indeed must be, if your language doesn't support arbitrarily large integers).
Note that -0 is not a valid input or output.

Rules and scoring

You can write a full program or a function, and the lowest byte count wins.

Test cases

0 0 -&gt; 0
302 40 -&gt; 0
302 -40 -&gt; 0
-4352 448 -&gt; -122016
0 6623 -&gt; 0
0 -6623 -&gt; 0
20643 -56721 -&gt; -1000420803
63196 21220 -&gt; 1203021800
1276 933024 -&gt; 3001424
-1276 933024 -&gt; -3001424
-1276 -933024 -&gt; 3001424
5007204555 350073039 -&gt; 12001545
-612137119 -8088606033 -&gt; 816060042000327
3389903661 -6619166963 -&gt; -18180881090018543603
-23082746128560880381 1116941217 -&gt; -8050600723200060807
-668336881543038127783364011867 896431401738330915057436190556 -&gt; -485448120906320001351224000900090235004021121824000900403042
402878826066336701417493206805490000415 312487283677673237790517973105761463808 -&gt; 120004325656161618004242182118140007280900200921180018080025285400000000320040
Jelly, 11 10 bytes

ƓDUz0P€Uḅ³


Try it online!

I couldn't get this down to 10 bytes by myself, but @Pietu1998 pointed me to an atom I'd missed, this giving this 10-byte solution. Unusually for Jelly, this one takes input from standard input (in the form 1276,933024), not from the command line (this enables the use of the ³ command, which returns the command line argument, defaulting to 100).

Explanation:

ƓDUz0P€Uḅ³
Ɠ           read standard input
 D          convert to base 10
  U         reverse elements
   z0       transpose, padding the end with zeroes
     P€     take the product of each (€) inner list
       U    reverse elements back
        b³  convert from base 100


The use of base 100 is a simple way to implement the "pad to 2 digits, then convert to base 10" technique. The only other subtle thing here is the reversing; we want to pad with zeroes at the start of the number, but Jelly's z command pads at the end, so reversing the lists means that z will pad correctly.