Run results for: Linear Blend Skinning 2

Run details:
User agent: Mozilla/5.0 (Android 13; Mobile; rv:122.0) Gecko/122.0 Firefox/122.0
Browser: Firefox Mobile 122
Operating system: Android
Device Platform: Mobile
Date tested: 2 years ago
Benchmark engine: Benchmark.js
F64PosAndF64TransAndF64Res
4K/s
LoicRewrite
4K/s
F64PosAndF64Trans
3K/s
PosInOutOfTheLoopVars
3K/s
I32Joint
3K/s
VarInsteadOfLetAndConst
3K/s
PosInOutOfTheLoopF32Array
2K/s
Original
2K/s
CacheTransWithSlice
1K/s
CacheTransWithSubarray
1K/s
UpdatedEmscripten
1K/s
CacheTransWithVarsFromSubarray
982/s
CacheTransWithF32ArraySetFromSubarray
873/s
SubarrayOnTrans
326/s
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData
280/s
SubarrayOnPosAndCacheTransWithSubarray
274/s
SubarrayOnPos
269/s
SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans
240/s
PosInOutOfTheLoopF32ArrayFromSubarray
201/s
SubarrayOnTransAndPosWithoutPlus
193/s
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans
190/s
SubarrayOnTransAndPosWithFRound
175/s
SubarrayOnTransAndPos
168/s
CacheTransWithArrayFromSubarray
124/s
Warmup
1/s
View exact numbers
Test name	Executions per second
✓ F64PosAndF64TransAndF64Res	3,679 Ops/sec
LoicRewrite	3,642 Ops/sec
F64PosAndF64Trans	3,330 Ops/sec
PosInOutOfTheLoopVars	3,296 Ops/sec
I32Joint	3,220 Ops/sec
VarInsteadOfLetAndConst	2,740 Ops/sec
PosInOutOfTheLoopF32Array	2,442 Ops/sec
Original	1,674 Ops/sec
CacheTransWithSlice	1,280 Ops/sec
CacheTransWithSubarray	1,161 Ops/sec
UpdatedEmscripten	1,111 Ops/sec
CacheTransWithVarsFromSubarray	982 Ops/sec
CacheTransWithF32ArraySetFromSubarray	873 Ops/sec
SubarrayOnTrans	326 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData	280 Ops/sec
SubarrayOnPosAndCacheTransWithSubarray	274 Ops/sec
SubarrayOnPos	269 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans	240 Ops/sec
PosInOutOfTheLoopF32ArrayFromSubarray	201 Ops/sec
SubarrayOnTransAndPosWithoutPlus	193 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans	190 Ops/sec
SubarrayOnTransAndPosWithFRound	175 Ops/sec
SubarrayOnTransAndPos	168 Ops/sec
CacheTransWithArrayFromSubarray	124 Ops/sec
Warmup	1 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()