Run results for: Linear Blend Skinning 2

Run details:
User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36
Browser: Chrome 121
Operating system: Linux
Device Platform: Desktop
Date tested: 10 months ago
Test name	Executions per second
Warmup	0.2 Ops/sec
Original	21.1 Ops/sec
UpdatedEmscripten	3.9 Ops/sec
LoicRewrite	100.4 Ops/sec
SubarrayOnTrans	228.0 Ops/sec
SubarrayOnPos	109.3 Ops/sec
SubarrayOnTransAndPos	271.8 Ops/sec
SubarrayOnTransAndPosWithFRound	23.3 Ops/sec
SubarrayOnTransAndPosWithoutPlus	270.6 Ops/sec
PosInOutOfTheLoopF32Array	101.2 Ops/sec
PosInOutOfTheLoopF32ArrayFromSubarray	107.0 Ops/sec
PosInOutOfTheLoopVars	99.5 Ops/sec
CacheTransWithSubarray	259.0 Ops/sec
CacheTransWithSlice	257.3 Ops/sec
CacheTransWithF32ArraySetFromSubarray	257.2 Ops/sec
CacheTransWithVarsFromSubarray	255.7 Ops/sec
CacheTransWithArrayFromSubarray	62.1 Ops/sec
SubarrayOnPosAndCacheTransWithSubarray	324.2 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData	316.9 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans	302.9 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans	306.3 Ops/sec
Script Preparation code:
debugger;
var position_count = 15000;
var joint_count = 30;
var max_number_of_consecutive_joints = 15;
var vertex_dim = 3;

var MEM_SIZE = 100*1024*1024;
var MEM_STRIDE = 2*1024*1024;

var MEM = new ArrayBuffer(MEM_SIZE);
var HEAP32 = new Int32Array(MEM);
var HEAPU32 = new Uint32Array(MEM);
var HEAPF32 = new Float32Array(MEM);
var HEAPF64 = new Float64Array(MEM);
var MEM_HEAD = 0;

function MEM_ALLOC(len) {
    let cur = MEM_HEAD;
    len += MEM_STRIDE;
    MEM_HEAD += len + (16 - (len % 16));
    return cur;
}

function splitmix32(a) {
    return function() {
      a |= 0; a = a + 0x9e3779b9 | 0;
      var t = a ^ a >>> 16; t = Math.imul(t, 0x21f0aaad);
          t = t ^ t >>> 15; t = Math.imul(t, 0x735a2d97);
      return ((t = t ^ t >>> 15) >>> 0) / 4294967296;
    }
}

Math_random = splitmix32(0);
Math_imul = Math.imul;
Math_fround = Math.fround;

if (typeof window !== 'undefined' && window.navigator && window.navigator.wakeLock)
    window.navigator.wakeLock.request('screen');

var positions = MEM_ALLOC(position_count * 3 * 4);

for (let i = 0; i < position_count; ++i) {
    const p = (positions >> 2) + i * 3;
    HEAPF32[p] = Math_random() * 100;
    HEAPF32[p + 1] = Math_random() * 100;
    HEAPF32[p + 2] = Math_random() * 100;
}

var repeat_last_joint = -1;
var last_joint;
function get_joint() {
    if (repeat_last_joint < 0) {
        repeat_last_joint = (Math_random() * max_number_of_consecutive_joints) |0;
        last_joint = Math_random() * (joint_count - 1) | 0;
    }
    repeat_last_joint -= 1;
    return last_joint;
}

var joints = MEM_ALLOC(position_count * 4);

for (let i = 0; i < position_count; ++i) {
    const p = (joints >> 2) + i;
    HEAPU32[p] = get_joint();
}

var transformations = MEM_ALLOC(joint_count * 16 * 4);

for (let i = 0; i < joint_count; ++i) {
    const p = (transformations >> 2) + i * 16;
    for (let j = 0; j < 16; ++j)
        HEAPF32[p + j] = Math_random() * 100;
}

var res = MEM_ALLOC(position_count * 3 * 4);

var positions_and_joints = MEM_ALLOC(position_count * 4 * 4);

for (let i = 0; i < position_count; ++i) {
    const p = (positions_and_joints >> 2) + i * 4;
    HEAPU32[p] = get_joint();
    HEAPF32[p + 1] = Math_random() * 100;
    HEAPF32[p + 2] = Math_random() * 100;
    HEAPF32[p + 3] = Math_random() * 100;
}

var small_transformations = MEM_ALLOC(joint_count * 12 * 4);

for (let i = 0; i < joint_count; ++i) {
    const p = (small_transformations >> 2) + i * 12;
    for (let j = 0; j < 12; ++j)
        HEAPF32[p + j] = Math_random() * 100;
}

var positions_f64 = MEM_ALLOC(position_count * 3 * 8);

for (let i = 0; i < position_count; ++i) {
    const p = (positions_f64 >> 3) + i * 3;
    HEAPF64[p] = Math_random() * 100;
    HEAPF64[p + 1] = Math_random() * 100;
    HEAPF64[p + 2] = Math_random() * 100;
}

var transformations_f64 = MEM_ALLOC(joint_count * 16 * 8);

for (let i = 0; i < joint_count; ++i) {
    const p = (transformations_f64 >> 3) + i * 16;
    for (let j = 0; j < 16; ++j)
        HEAPF64[p + j] = Math_random() * 100;
}

var res_f64 = MEM_ALLOC(position_count * 3 * 8);

var vertexCount = position_count;

var positions_view = HEAPF32.subarray(positions >> 2, (positions >> 2) + position_count * 3);
var joints_view = HEAPU32.subarray(joints >> 2, (joints >> 2) + position_count);
var transformations_view = HEAPF32.subarray(transformations >> 2, (transformations >> 2) + joint_count * 16);
var res_view = HEAPF32.subarray(res >> 2, (res >> 2) + position_count * 3);
var positions_and_joints_uview = HEAPU32.subarray(positions_and_joints >> 2, (positions_and_joints >> 2) + position_count * 4);
var positions_and_joints_fview = HEAPF32.subarray(positions_and_joints >> 2, (positions_and_joints >> 2) + position_count * 4);
var small_transformations_view = HEAPF32.subarray(small_transformations >> 2, (small_transformations >> 2) + joint_count * 12);
var positions_f64_view = HEAPF64.subarray(positions_f64 >> 3, (positions_f64 >> 3) + position_count * 3);
var transformations_f64_view = HEAPF64.subarray(transformations_f64 >> 3, (transformations_f64 >> 3) + joint_count * 16);
debugger;

function Warmup() {
    let a = 0;
    for (let i = 0; i < 8000000; i++) {
        a += Math.exp(Math_random()) * Math.exp(Math_random()) * Math.exp(Math_random()) * Math.exp(Math_random());
    }
}

function void_20mat_mult_4_2c_204_2c_204_2c_204_2c_20float__28int_2c_20float_20_28__29_20_5b4_5d_2c_20float_20const_20_28__29_20_5b4_5d_2c_20float_20const_20_28__29_20_5b4_5d_5b4_5d_29($0, $1, $2, $3) {
 var $4 = 0, $5 = 0, $6 = 0;
 if (($0 | 0) >= 1) {
  while (1) {
   $4 = $6 << 4;
   $5 = $4 + $1 | 0;
   $4 = $2 + $4 | 0;
   HEAPF32[$5 >> 2] = Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$4 >> 2] * HEAPF32[$3 >> 2]) + Math_fround(0)) + Math_fround(HEAPF32[$4 + 4 >> 2] * HEAPF32[$3 + 16 >> 2])) + Math_fround(HEAPF32[$4 + 8 >> 2] * HEAPF32[$3 + 32 >> 2])) + Math_fround(HEAPF32[$4 + 12 >> 2] * HEAPF32[$3 + 48 >> 2]);
   HEAPF32[$5 + 4 >> 2] = Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$4 >> 2] * HEAPF32[$3 + 4 >> 2]) + Math_fround(0)) + Math_fround(HEAPF32[$4 + 4 >> 2] * HEAPF32[$3 + 20 >> 2])) + Math_fround(HEAPF32[$4 + 8 >> 2] * HEAPF32[$3 + 36 >> 2])) + Math_fround(HEAPF32[$4 + 12 >> 2] * HEAPF32[$3 + 52 >> 2]);
   HEAPF32[$5 + 8 >> 2] = Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$4 >> 2] * HEAPF32[$3 + 8 >> 2]) + Math_fround(0)) + Math_fround(HEAPF32[$4 + 4 >> 2] * HEAPF32[$3 + 24 >> 2])) + Math_fround(HEAPF32[$4 + 8 >> 2] * HEAPF32[$3 + 40 >> 2])) + Math_fround(HEAPF32[$4 + 12 >> 2] * HEAPF32[$3 + 56 >> 2]);
   HEAPF32[$5 + 12 >> 2] = Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$4 >> 2] * HEAPF32[$3 + 12 >> 2]) + Math_fround(0)) + Math_fround(HEAPF32[$4 + 4 >> 2] * HEAPF32[$3 + 28 >> 2])) + Math_fround(HEAPF32[$4 + 8 >> 2] * HEAPF32[$3 + 44 >> 2])) + Math_fround(HEAPF32[$4 + 12 >> 2] * HEAPF32[$3 + 60 >> 2]);
   $6 = $6 + 1 | 0;
   if (($6 | 0) != ($0 | 0)) {
    continue;
   }
   break;
  }
 }
}
   
function do_affine_28float__2c_20unsigned_20long_2c_20int_2c_20float__2c_20unsigned_20int__2c_20float_20_28__29_20_5b4_5d_5b4_5d_29($0, $1, $2, $3, $4, $5) {
 var $6 = 0, $7 = 0, $8 = 0, $9 = 0;
 if (($1 | 0) > 0) {
  $9 = $2 + -2 | 0;
  while (1) {
   label$3 : {
    if ($9 >>> 0 > 2) {
     break label$3;
    }
    $2 = HEAP32[($7 << 2) + $4 >> 2];
    label$4 : {
     switch ($9 - 1 | 0) {
     default:
      $6 = $7 << 3;
      $8 = $6 + $0 | 0;
      $2 = ($2 << 6) + $5 | 0;
      $6 = $3 + $6 | 0;
      HEAPF32[$8 >> 2] = HEAPF32[$2 + 48 >> 2] + Math_fround(HEAPF32[$2 + 32 >> 2] + Math_fround(Math_fround(Math_fround(HEAPF32[$6 >> 2] * HEAPF32[$2 >> 2]) + Math_fround(0)) + Math_fround(HEAPF32[$6 + 4 >> 2] * HEAPF32[$2 + 16 >> 2])));
      HEAPF32[$8 + 4 >> 2] = HEAPF32[$2 + 52 >> 2] + Math_fround(HEAPF32[$2 + 36 >> 2] + Math_fround(Math_fround(Math_fround(HEAPF32[$6 >> 2] * HEAPF32[$2 + 4 >> 2]) + Math_fround(0)) + Math_fround(HEAPF32[$6 + 4 >> 2] * HEAPF32[$2 + 20 >> 2])));
      break label$3;
     case 0:
      $6 = Math_imul($7, 12);
      $8 = $6 + $0 | 0;
      $2 = ($2 << 6) + $5 | 0;
      $6 = $3 + $6 | 0;
      HEAPF32[$8 >> 2] = HEAPF32[$2 + 48 >> 2] + Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$6 >> 2] * HEAPF32[$2 >> 2]) + Math_fround(0)) + Math_fround(HEAPF32[$6 + 4 >> 2] * HEAPF32[$2 + 16 >> 2])) + Math_fround(HEAPF32[$6 + 8 >> 2] * HEAPF32[$2 + 32 >> 2]));
      HEAPF32[$8 + 4 >> 2] = HEAPF32[$2 + 52 >> 2] + Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$6 >> 2] * HEAPF32[$2 + 4 >> 2]) + Math_fround(0)) + Math_fround(HEAPF32[$6 + 4 >> 2] * HEAPF32[$2 + 20 >> 2])) + Math_fround(HEAPF32[$6 + 8 >> 2] * HEAPF32[$2 + 36 >> 2]));
      HEAPF32[$8 + 8 >> 2] = HEAPF32[$2 + 56 >> 2] + Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$6 >> 2] * HEAPF32[$2 + 8 >> 2]) + Math_fround(0)) + Math_fround(HEAPF32[$6 + 4 >> 2] * HEAPF32[$2 + 24 >> 2])) + Math_fround(HEAPF32[$6 + 8 >> 2] * HEAPF32[$2 + 40 >> 2]));
      break label$3;
     case 1:
      break label$4;
     }
    }
    $6 = $7 << 4;
    void_20mat_mult_4_2c_204_2c_204_2c_204_2c_20float__28int_2c_20float_20_28__29_20_5b4_5d_2c_20float_20const_20_28__29_20_5b4_5d_2c_20float_20const_20_28__29_20_5b4_5d_5b4_5d_29(1, $6 + $0 | 0, $3 + $6 | 0, ($2 << 6) + $5 | 0);
   }
   $7 = $7 + 1 | 0;
   if (($7 | 0) != ($1 | 0)) {
    continue;
   }
   break;
  }
 }
}

function Original() {
    do_affine_28float__2c_20unsigned_20long_2c_20int_2c_20float__2c_20unsigned_20int__2c_20float_20_28__29_20_5b4_5d_5b4_5d_29(res, vertexCount, vertex_dim, positions, joints, transformations);
}

function UpdatedEmscripten() {
 var $3 = 0, $9 = Math_fround(0), $10 = 0, $11 = 0, $14 = 0, $15 = 0, $17 = 0, $24 = 0, $25 = 0, $27 = 0, $28 = 0;
 var $5 = position_count, $7 = transformations, $4 = res, $2 = vertex_dim, $12 = positions, $16 = joints, $8 = 0;
 if (($5 | 0) > 0) {
  $17 = $2 - 2 | 0;
  while (1) {
   $14 = HEAP32[$16 + ($8 << 2) >> 2];
   label$594: {
    label$595: {
     switch ($17 | 0) {
     case 0:
      $2 = $8 << 3;
      $24 = $2 + $12 | 0;
      $25 = $2 + $4 | 0;
      $11 = 0;
      $2 = 1;
      while (1) {
       $9 = Math_fround(0);
       $10 = 1;
       $3 = 0;
       while (1) {
        $15 = $11 << 2;
        $27 = $7 + ($14 << 6) | 0;
        $9 = Math_fround(Math_fround(HEAPF32[$24 + ($3 << 2) >> 2] * HEAPF32[$15 + ($27 + ($3 << 4) | 0) >> 2]) + $9);
        $3 = 1;
        $28 = $10 & 1;
        $10 = 0;
        if ($28) {
         continue;
        }
        break;
       }
       $3 = $15 + $27 | 0;
       HEAPF32[$15 + $25 >> 2] = Math_fround($9 + HEAPF32[$3 + 32 >> 2]) + HEAPF32[$3 + 48 >> 2];
       $11 = 1;
       $3 = $2;
       $2 = 0;
       if ($3) {
        continue;
       }
       break;
      }
      ;
      break label$594;
     case 1:
      $2 = Math_imul($8, 12);
      $11 = $2 + $12 | 0;
      $15 = $2 + $4 | 0;
      $10 = 0;
      while (1) {
       $9 = Math_fround(0);
       $3 = 0;
       while (1) {
        $2 = $10 << 2;
        $24 = $7 + ($14 << 6) | 0;
        $9 = Math_fround(Math_fround(HEAPF32[$11 + ($3 << 2) >> 2] * HEAPF32[$2 + ($24 + ($3 << 4) | 0) >> 2]) + $9);
        $3 = $3 + 1 | 0;
        if (($3 | 0) != 3) {
         continue;
        }
        break;
       }
       HEAPF32[$2 + $15 >> 2] = $9 + HEAPF32[($2 + $24 | 0) + 48 >> 2];
       $10 = $10 + 1 | 0;
       if (($10 | 0) != 3) {
        continue;
       }
       break;
      }
      ;
      break label$594;
     case 2:
      break label$595;
     default:
      break label$594;
     }
    }
    $2 = $8 << 4;
    $11 = $2 + $12 | 0;
    $2 = $2 + $4 | 0;
    $10 = 0;
    while (1) {
     $9 = Math_fround(0);
     $3 = 0;
     while (1) {
      $15 = $10 << 2;
      $9 = Math_fround(Math_fround(HEAPF32[$11 + ($3 << 2) >> 2] * HEAPF32[$15 + (($7 + ($14 << 6) | 0) + ($3 << 4) | 0) >> 2]) + $9);
      $3 = $3 + 1 | 0;
      if (($3 | 0) != 4) {
       continue;
      }
      break;
     }
     HEAPF32[$2 + $15 >> 2] = $9;
     $10 = $10 + 1 | 0;
     if (($10 | 0) != 4) {
      continue;
     }
     break;
    }
   }
   $8 = $8 + 1 | 0;
   if (($5 | 0) != ($8 | 0)) {
    continue;
   }
   break;
  }
 }
 $10 = 15;
}

function LoicRewrite() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F32 + (J << 4) | 0;
        const P1 = +HEAPF32[position_F32];
        const P2 = +HEAPF32[position_F32 + 1 | 0];
        const P3 = +HEAPF32[position_F32 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +HEAPF32[M        ] + P2 * +HEAPF32[M + 4 | 0] + P3 * +HEAPF32[M +  8 | 0] + +HEAPF32[M + 12 | 0];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +HEAPF32[M + 1 | 0] + P2 * +HEAPF32[M + 5 | 0] + P3 * +HEAPF32[M +  9 | 0] + +HEAPF32[M + 13 | 0];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +HEAPF32[M + 2 | 0] + P2 * +HEAPF32[M + 6 | 0] + P3 * +HEAPF32[M + 10 | 0] + +HEAPF32[M + 14 | 0];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function SubarrayOnTrans() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F32 + (J << 4) | 0;
        const MAT = HEAPF32.subarray(M, M + 16 | 0);
    
        const P1 = +HEAPF32[position_F32];
        const P2 = +HEAPF32[position_F32 + 1 | 0];
        const P3 = +HEAPF32[position_F32 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +MAT[0] + P2 * +MAT[4] + P3 * +MAT[ 8] + +MAT[12];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +MAT[1] + P2 * +MAT[5] + P3 * +MAT[ 9] + +MAT[13];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +MAT[2] + P2 * +MAT[6] + P3 * +MAT[10] + +MAT[14];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function SubarrayOnPos() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F32 + (J << 4) | 0;
        const POS = HEAPF32.subarray(position_F32, position_F32 + 3 | 0);
    
        HEAPF32[resPosition_F32        ] = +POS[0] * +HEAPF32[M        ] + +POS[1] * +HEAPF32[M + 4 | 0] + +POS[2] * +HEAPF32[M +  8 | 0] + +HEAPF32[M + 12 | 0];
        HEAPF32[resPosition_F32 + 1 | 0] = +POS[0] * +HEAPF32[M + 1 | 0] + +POS[1] * +HEAPF32[M + 5 | 0] + +POS[2] * +HEAPF32[M +  9 | 0] + +HEAPF32[M + 13 | 0];
        HEAPF32[resPosition_F32 + 2 | 0] = +POS[0] * +HEAPF32[M + 2 | 0] + +POS[1] * +HEAPF32[M + 6 | 0] + +POS[2] * +HEAPF32[M + 10 | 0] + +HEAPF32[M + 14 | 0];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function SubarrayOnTransAndPos() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F32 + (J << 4) | 0;
        const MAT = HEAPF32.subarray(M, M + 16 | 0);
        const POS = HEAPF32.subarray(position_F32, position_F32 + 3 | 0);
    
        HEAPF32[resPosition_F32        ] = +POS[0] * +MAT[0] + +POS[1] * +MAT[4] + +POS[2] * +MAT[ 8] + +MAT[12];
        HEAPF32[resPosition_F32 + 1 | 0] = +POS[0] * +MAT[1] + +POS[1] * +MAT[5] + +POS[2] * +MAT[ 9] + +MAT[13];
        HEAPF32[resPosition_F32 + 2 | 0] = +POS[0] * +MAT[2] + +POS[1] * +MAT[6] + +POS[2] * +MAT[10] + +MAT[14];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function SubarrayOnTransAndPosWithFRound() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F32 + (J << 4) | 0;
        const MAT = HEAPF32.subarray(M, M + 16 | 0);
        const POS = HEAPF32.subarray(position_F32, position_F32 + 3 | 0);
    
        HEAPF32[resPosition_F32        ] = Math.fround(Math.fround(Math.fround(Math.fround(Math.fround(POS[0]) * Math.fround(MAT[0])) + Math.fround(Math.fround(POS[1]) * Math.fround(MAT[4]))) + Math.fround(Math.fround(POS[2]) * Math.fround(MAT[ 8]))) + Math.fround(MAT[12]));
        HEAPF32[resPosition_F32 + 1 | 0] = Math.fround(Math.fround(Math.fround(Math.fround(Math.fround(POS[0]) * Math.fround(MAT[1])) + Math.fround(Math.fround(POS[1]) * Math.fround(MAT[5]))) + Math.fround(Math.fround(POS[2]) * Math.fround(MAT[ 9]))) + Math.fround(MAT[13]));
        HEAPF32[resPosition_F32 + 2 | 0] = Math.fround(Math.fround(Math.fround(Math.fround(Math.fround(POS[0]) * Math.fround(MAT[2])) + Math.fround(Math.fround(POS[1]) * Math.fround(MAT[6]))) + Math.fround(Math.fround(POS[2]) * Math.fround(MAT[10]))) + Math.fround(MAT[14]));
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function SubarrayOnTransAndPosWithoutPlus() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F32 + (J << 4) | 0;
        const MAT = HEAPF32.subarray(M, M + 16 | 0);
        const POS = HEAPF32.subarray(position_F32, position_F32 + 3 | 0);
    
        HEAPF32[resPosition_F32        ] = POS[0] * MAT[0] + POS[1] * MAT[4] + POS[2] * MAT[ 8] + MAT[12];
        HEAPF32[resPosition_F32 + 1 | 0] = POS[0] * MAT[1] + POS[1] * MAT[5] + POS[2] * MAT[ 9] + MAT[13];
        HEAPF32[resPosition_F32 + 2 | 0] = POS[0] * MAT[2] + POS[1] * MAT[6] + POS[2] * MAT[10] + MAT[14];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function PosInOutOfTheLoopF32Array() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    let POS = new Float32Array(3);

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F32 + (J << 4) | 0;

        POS[0] = +HEAPF32[position_F32];
        POS[1] = +HEAPF32[position_F32 + 1 | 0];
        POS[2] = +HEAPF32[position_F32 + 2 | 0];

        HEAPF32[resPosition_F32        ] = +POS[0] * +HEAPF32[M        ] + +POS[1] * +HEAPF32[M + 4 | 0] + +POS[2] * +HEAPF32[M +  8 | 0] + +HEAPF32[M + 12 | 0];
        HEAPF32[resPosition_F32 + 1 | 0] = +POS[0] * +HEAPF32[M + 1 | 0] + +POS[1] * +HEAPF32[M + 5 | 0] + +POS[2] * +HEAPF32[M +  9 | 0] + +HEAPF32[M + 13 | 0];
        HEAPF32[resPosition_F32 + 2 | 0] = +POS[0] * +HEAPF32[M + 2 | 0] + +POS[1] * +HEAPF32[M + 6 | 0] + +POS[2] * +HEAPF32[M + 10 | 0] + +HEAPF32[M + 14 | 0];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function PosInOutOfTheLoopF32ArrayFromSubarray() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    let POS = new Float32Array(3);

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F32 + (J << 4) | 0;
        POS.set(HEAPF32.subarray(position_F32, position_F32 + 3 | 0));
    
        HEAPF32[resPosition_F32        ] = +POS[0] * +HEAPF32[M        ] + +POS[1] * +HEAPF32[M + 4 | 0] + +POS[2] * +HEAPF32[M +  8 | 0] + +HEAPF32[M + 12 | 0];
        HEAPF32[resPosition_F32 + 1 | 0] = +POS[0] * +HEAPF32[M + 1 | 0] + +POS[1] * +HEAPF32[M + 5 | 0] + +POS[2] * +HEAPF32[M +  9 | 0] + +HEAPF32[M + 13 | 0];
        HEAPF32[resPosition_F32 + 2 | 0] = +POS[0] * +HEAPF32[M + 2 | 0] + +POS[1] * +HEAPF32[M + 6 | 0] + +POS[2] * +HEAPF32[M + 10 | 0] + +HEAPF32[M + 14 | 0];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function PosInOutOfTheLoopVars() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    let P1, P2, P3;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F32 + (J << 4) | 0;
        P1 = +HEAPF32[position_F32];
        P2 = +HEAPF32[position_F32 + 1 | 0];
        P3 = +HEAPF32[position_F32 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +HEAPF32[M        ] + P2 * +HEAPF32[M + 4 | 0] + P3 * +HEAPF32[M +  8 | 0] + +HEAPF32[M + 12 | 0];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +HEAPF32[M + 1 | 0] + P2 * +HEAPF32[M + 5 | 0] + P3 * +HEAPF32[M +  9 | 0] + +HEAPF32[M + 13 | 0];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +HEAPF32[M + 2 | 0] + P2 * +HEAPF32[M + 6 | 0] + P3 * +HEAPF32[M + 10 | 0] + +HEAPF32[M + 14 | 0];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function CacheTransWithSubarray() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    let J = -1|0, MAT;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const NJ = HEAPU32[joint_U32];
        if (NJ != J) {
            J = NJ;
            const M = transformations_F32 + (J << 4) | 0;
            MAT = HEAPF32.subarray(M, M + 16 | 0);    
        }
    
        const P1 = +HEAPF32[position_F32];
        const P2 = +HEAPF32[position_F32 + 1 | 0];
        const P3 = +HEAPF32[position_F32 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +MAT[0] + P2 * +MAT[4] + P3 * +MAT[ 8] + +MAT[12];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +MAT[1] + P2 * +MAT[5] + P3 * +MAT[ 9] + +MAT[13];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +MAT[2] + P2 * +MAT[6] + P3 * +MAT[10] + +MAT[14];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function CacheTransWithSlice() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    let J = -1|0, MAT;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const NJ = HEAPU32[joint_U32];
        if (NJ != J) {
            J = NJ;
            const M = transformations_F32 + (J << 4) | 0;
            MAT = HEAPF32.slice(M, M + 16 | 0);    
        }
    
        const P1 = +HEAPF32[position_F32];
        const P2 = +HEAPF32[position_F32 + 1 | 0];
        const P3 = +HEAPF32[position_F32 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +MAT[0] + P2 * +MAT[4] + P3 * +MAT[ 8] + +MAT[12];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +MAT[1] + P2 * +MAT[5] + P3 * +MAT[ 9] + +MAT[13];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +MAT[2] + P2 * +MAT[6] + P3 * +MAT[10] + +MAT[14];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function CacheTransWithF32ArraySetFromSubarray() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    let J = -1|0, MAT = new Float32Array(16);

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const NJ = HEAPU32[joint_U32];
        if (NJ != J) {
            J = NJ;
            const M = transformations_F32 + (J << 4) | 0;
            MAT.set(HEAPF32.subarray(M, M + 16 | 0));    
        }
    
        const P1 = +HEAPF32[position_F32];
        const P2 = +HEAPF32[position_F32 + 1 | 0];
        const P3 = +HEAPF32[position_F32 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +MAT[0] + P2 * +MAT[4] + P3 * +MAT[ 8] + +MAT[12];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +MAT[1] + P2 * +MAT[5] + P3 * +MAT[ 9] + +MAT[13];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +MAT[2] + P2 * +MAT[6] + P3 * +MAT[10] + +MAT[14];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function CacheTransWithVarsFromSubarray() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    let J = -1|0;
    // let M0 = Math.fround(0), M1 = Math.fround(0), M2 = Math.fround(0), M4 = Math.fround(0), M5 = Math.fround(0), M6 = Math.fround(0), M8 = Math.fround(0), M9 = Math.fround(0), M10 = Math.fround(0), M12 = Math.fround(0), M13 = Math.fround(0), M14 = Math.fround(0);
    let M0 , M1 , M2 , M4 , M5 , M6 , M8 , M9 , M10 , M12 , M13 , M14 ;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const NJ = HEAPU32[joint_U32];
        if (NJ != J) {
            J = NJ;
            const M = transformations_F32 + (J << 4) | 0;
            const MAT = HEAPF32.subarray(M, M + 16 | 0);
            M0 = MAT[0];
            M1 = MAT[1];
            M2 = MAT[2];
            M4 = MAT[4];
            M5 = MAT[5];
            M6= MAT[6];
            M8 = MAT[8];
            M9 = MAT[9];
            M10 = MAT[10];
            M12 = MAT[12];
            M13 = MAT[13];
            M14 = MAT[14];
        }

        const P1 = +HEAPF32[position_F32];
        const P2 = +HEAPF32[position_F32 + 1 | 0];
        const P3 = +HEAPF32[position_F32 + 2 | 0];

        HEAPF32[resPosition_F32        ] = P1 * M0 + P2 * M4 + P3 *  M8 + M12;
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * M1 + P2 * M5 + P3 *  M9 + M13;
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * M2 + P2 * M6 + P3 * M10 + M14;

        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function CacheTransWithArrayFromSubarray() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    let J = -1|0;
    // let M = [Math.fround(0), Math.fround(0), Math.fround(0), Math.fround(0), Math.fround(0), Math.fround(0), Math.fround(0), Math.fround(0), Math.fround(0), Math.fround(0), Math.fround(0), Math.fround(0)];
    let M = [];

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const NJ = HEAPU32[joint_U32];
        if (NJ != J) {
            J = NJ;
            const M = transformations_F32 + (J << 4) | 0;
            const MAT = HEAPF32.subarray(M, M + 16 | 0);
            M[0] = MAT[0];
            M[1] = MAT[1];
            M[2] = MAT[2];
            M[3] = MAT[4];
            M[4] = MAT[5];
            M[5] = MAT[6];
            M[6] = MAT[8];
            M[7] = MAT[9];
            M[8] = MAT[10];
            M[9] = MAT[12];
            M[10] = MAT[13];
            M[11] = MAT[14];
        }
    
        const P1 = +HEAPF32[position_F32];
        const P2 = +HEAPF32[position_F32 + 1 | 0];
        const P3 = +HEAPF32[position_F32 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +M[0] + P2 * +M[3] + P3 * +M[6] + +M[9];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +M[1] + P2 * +M[4] + P3 * +M[7] + +M[10];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +M[2] + P2 * +M[5] + P3 * +M[8] + +M[11];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function SubarrayOnPosAndCacheTransWithSubarray() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    let J = -1|0, MAT;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const NJ = HEAPU32[joint_U32];
        if (NJ != J) {
            J = NJ;
            const M = transformations_F32 + (J << 4) | 0;
            MAT = HEAPF32.subarray(M, M + 16 | 0);    
        }
    
        const POS = HEAPF32.subarray(position_F32, position_F32 + 3 | 0);
    
        HEAPF32[resPosition_F32        ] = +POS[0] * +MAT[0] + +POS[1] * +MAT[4] + +POS[2] * +MAT[ 8] + +MAT[12];
        HEAPF32[resPosition_F32 + 1 | 0] = +POS[0] * +MAT[1] + +POS[1] * +MAT[5] + +POS[2] * +MAT[ 9] + +MAT[13];
        HEAPF32[resPosition_F32 + 2 | 0] = +POS[0] * +MAT[2] + +POS[1] * +MAT[6] + +POS[2] * +MAT[10] + +MAT[14];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let positions_and_joints_32 = positions_and_joints >> 2;
    const transformations_F32 = transformations >> 2;

    let J = -1|0, MAT;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const NJ = HEAPU32[positions_and_joints_32];
        if (NJ != J) {
            J = NJ;
            const M = transformations_F32 + (J << 4) | 0;
            MAT = HEAPF32.subarray(M, M + 16 | 0);    
        }
    
        const POS = HEAPF32.subarray(positions_and_joints_32 + 1 | 0, positions_and_joints_32 + 3 | 0);
    
        HEAPF32[resPosition_F32        ] = +POS[0] * +MAT[0] + +POS[1] * +MAT[4] + +POS[2] * +MAT[ 8] + +MAT[12];
        HEAPF32[resPosition_F32 + 1 | 0] = +POS[0] * +MAT[1] + +POS[1] * +MAT[5] + +POS[2] * +MAT[ 9] + +MAT[13];
        HEAPF32[resPosition_F32 + 2 | 0] = +POS[0] * +MAT[2] + +POS[1] * +MAT[6] + +POS[2] * +MAT[10] + +MAT[14];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        positions_and_joints_32 = positions_and_joints_32 + 4 | 0;
    }
}

function SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_U32 = joints >> 2;
    const transformations_F32 = small_transformations >> 2;

    let J = -1|0, MAT;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const NJ = HEAPU32[joint_U32];
        if (NJ != J) {
            J = NJ;
            const M = transformations_F32 + Math_imul(J, 12) | 0;
            MAT = HEAPF32.subarray(M, M + 12 | 0);
        }
    
        const POS = HEAPF32.subarray(position_F32, position_F32 + 3 | 0);
    
        HEAPF32[resPosition_F32        ] = +POS[0] * +MAT[0] + +POS[1] * +MAT[3] + +POS[2] * +MAT[6] + +MAT[ 9];
        HEAPF32[resPosition_F32 + 1 | 0] = +POS[0] * +MAT[1] + +POS[1] * +MAT[4] + +POS[2] * +MAT[7] + +MAT[10];
        HEAPF32[resPosition_F32 + 2 | 0] = +POS[0] * +MAT[2] + +POS[1] * +MAT[5] + +POS[2] * +MAT[8] + +MAT[11];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let positions_and_joints_32 = positions_and_joints >> 2;
    const transformations_F32 = small_transformations >> 2;

    let J = -1|0, MAT;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const NJ = HEAPU32[positions_and_joints_32];
        if (NJ != J) {
            J = NJ;
            const M = transformations_F32 + Math_imul(J, 12) | 0;
            MAT = HEAPF32.subarray(M, M + 12 | 0);
        }
    
        const POS = HEAPF32.subarray(positions_and_joints_32 + 1 | 0, positions_and_joints_32 + 3 | 0);
    
        HEAPF32[resPosition_F32        ] = +POS[0] * +MAT[0] + +POS[1] * +MAT[3] + +POS[2] * +MAT[6] + +MAT[ 9];
        HEAPF32[resPosition_F32 + 1 | 0] = +POS[0] * +MAT[1] + +POS[1] * +MAT[4] + +POS[2] * +MAT[7] + +MAT[10];
        HEAPF32[resPosition_F32 + 2 | 0] = +POS[0] * +MAT[2] + +POS[1] * +MAT[5] + +POS[2] * +MAT[8] + +MAT[11];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        positions_and_joints_32 = positions_and_joints_32 + 4 | 0;
    }
}

function F64PosAndF64Trans() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F64 = positions_f64 >> 3;
    let joint_U32 = joints >> 2;
    const transformations_F64 = transformations_f64 >> 3;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F64 + (J << 4) | 0;
        const P1 = +HEAPF64[position_F64];
        const P2 = +HEAPF64[position_F64 + 1 | 0];
        const P3 = +HEAPF64[position_F64 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +HEAPF64[M        ] + P2 * +HEAPF64[M + 4 | 0] + P3 * +HEAPF64[M +  8 | 0] + +HEAPF64[M + 12 | 0];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +HEAPF64[M + 1 | 0] + P2 * +HEAPF64[M + 5 | 0] + P3 * +HEAPF64[M +  9 | 0] + +HEAPF64[M + 13 | 0];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +HEAPF64[M + 2 | 0] + P2 * +HEAPF64[M + 6 | 0] + P3 * +HEAPF64[M + 10 | 0] + +HEAPF64[M + 14 | 0];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F64 = position_F64 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function F64PosAndF64TransAndF64Res() {
    let resPosition_F64 = res_f64 >> 3;
    const endResPosition_F64 = (res_f64 >> 3) + Math_imul(vertexCount, 3) | 0;
    let position_F64 = positions_f64 >> 3;
    let joint_U32 = joints >> 2;
    const transformations_F64 = transformations_f64 >> 3;

    while (resPosition_F64 >>> 0 < endResPosition_F64 >>> 0) {
        const J = HEAPU32[joint_U32];
        const M = transformations_F64 + (J << 4) | 0;
        const P1 = +HEAPF64[position_F64];
        const P2 = +HEAPF64[position_F64 + 1 | 0];
        const P3 = +HEAPF64[position_F64 + 2 | 0];
    
        HEAPF32[resPosition_F64        ] = P1 * +HEAPF64[M        ] + P2 * +HEAPF64[M + 4 | 0] + P3 * +HEAPF64[M +  8 | 0] + +HEAPF64[M + 12 | 0];
        HEAPF32[resPosition_F64 + 1 | 0] = P1 * +HEAPF64[M + 1 | 0] + P2 * +HEAPF64[M + 5 | 0] + P3 * +HEAPF64[M +  9 | 0] + +HEAPF64[M + 13 | 0];
        HEAPF32[resPosition_F64 + 2 | 0] = P1 * +HEAPF64[M + 2 | 0] + P2 * +HEAPF64[M + 6 | 0] + P3 * +HEAPF64[M + 10 | 0] + +HEAPF64[M + 14 | 0];
    
        resPosition_F64 = resPosition_F64 + 3 | 0;
        position_F64 = position_F64 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}

function I32Joint() {
    let resPosition_F32 = res >> 2;
    const endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    let position_F32 = positions >> 2;
    let joint_I32 = joints >> 2;
    const transformations_F32 = transformations >> 2;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        const J = HEAP32[joint_I32];
        const M = transformations_F32 + Math_imul(J, 16) | 0;
        const P1 = +HEAPF32[position_F32];
        const P2 = +HEAPF32[position_F32 + 1 | 0];
        const P3 = +HEAPF32[position_F32 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +HEAPF32[M        ] + P2 * +HEAPF32[M + 4 | 0] + P3 * +HEAPF32[M +  8 | 0] + +HEAPF32[M + 12 | 0];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +HEAPF32[M + 1 | 0] + P2 * +HEAPF32[M + 5 | 0] + P3 * +HEAPF32[M +  9 | 0] + +HEAPF32[M + 13 | 0];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +HEAPF32[M + 2 | 0] + P2 * +HEAPF32[M + 6 | 0] + P3 * +HEAPF32[M + 10 | 0] + +HEAPF32[M + 14 | 0];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_I32 = joint_I32 + 1 | 0;
    }
}

function VarInsteadOfLetAndConst() {
    var resPosition_F32 = res >> 2;
    var endResPosition_F32 = (res >> 2) + Math_imul(vertexCount, 3) | 0;
    var position_F32 = positions >> 2;
    var joint_U32 = joints >> 2;
    var transformations_F32 = transformations >> 2;
    var J, M, P1, P2, P3;

    while (resPosition_F32 >>> 0 < endResPosition_F32 >>> 0) {
        J = HEAPU32[joint_U32];
        M = transformations_F32 + (J << 4) | 0;
        P1 = +HEAPF32[position_F32];
        P2 = +HEAPF32[position_F32 + 1 | 0];
        P3 = +HEAPF32[position_F32 + 2 | 0];
    
        HEAPF32[resPosition_F32        ] = P1 * +HEAPF32[M        ] + P2 * +HEAPF32[M + 4 | 0] + P3 * +HEAPF32[M +  8 | 0] + +HEAPF32[M + 12 | 0];
        HEAPF32[resPosition_F32 + 1 | 0] = P1 * +HEAPF32[M + 1 | 0] + P2 * +HEAPF32[M + 5 | 0] + P3 * +HEAPF32[M +  9 | 0] + +HEAPF32[M + 13 | 0];
        HEAPF32[resPosition_F32 + 2 | 0] = P1 * +HEAPF32[M + 2 | 0] + P2 * +HEAPF32[M + 6 | 0] + P3 * +HEAPF32[M + 10 | 0] + +HEAPF32[M + 14 | 0];
    
        resPosition_F32 = resPosition_F32 + 3 | 0;
        position_F32 = position_F32 + 3 | 0;
        joint_U32 = joint_U32 + 1 | 0;
    }
}
Tests:
Warmup
Warmup()
Original
Original()
UpdatedEmscripten
UpdatedEmscripten()
LoicRewrite
LoicRewrite()
SubarrayOnTrans
SubarrayOnTrans()
SubarrayOnPos
SubarrayOnPos()
SubarrayOnTransAndPos
SubarrayOnTransAndPos()
SubarrayOnTransAndPosWithFRound
SubarrayOnTransAndPosWithFRound()
SubarrayOnTransAndPosWithoutPlus
SubarrayOnTransAndPosWithoutPlus()
PosInOutOfTheLoopF32Array
PosInOutOfTheLoopF32Array()
PosInOutOfTheLoopF32ArrayFromSubarray
PosInOutOfTheLoopF32ArrayFromSubarray()
PosInOutOfTheLoopVars
PosInOutOfTheLoopVars()
CacheTransWithSubarray
CacheTransWithSubarray()
CacheTransWithSlice
CacheTransWithSlice()
CacheTransWithF32ArraySetFromSubarray
CacheTransWithF32ArraySetFromSubarray()
CacheTransWithVarsFromSubarray
CacheTransWithVarsFromSubarray()
CacheTransWithArrayFromSubarray
CacheTransWithArrayFromSubarray()
SubarrayOnPosAndCacheTransWithSubarray
SubarrayOnPosAndCacheTransWithSubarray()
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData()
SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans
SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans()
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans()
F64PosAndF64Trans
F64PosAndF64Trans()
F64PosAndF64TransAndF64Res
F64PosAndF64TransAndF64Res()
I32Joint
I32Joint()
VarInsteadOfLetAndConst
VarInsteadOfLetAndConst()