Run results for: Linear Blend Skinning 2

Run details:
User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Mobile Safari/537.36
Browser: Chrome Mobile 121
Operating system: Android
Device Platform: Mobile
Date tested: 2 years ago
Benchmark engine: Benchmark.js
SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans
104/s
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans
104/s
SubarrayOnPosAndCacheTransWithSubarray
100/s
CacheTransWithSubarray
91/s
CacheTransWithF32ArraySetFromSubarray
91/s
SubarrayOnTransAndPos
91/s
SubarrayOnTransAndPosWithoutPlus
89/s
CacheTransWithVarsFromSubarray
88/s
CacheTransWithSlice
87/s
SubarrayOnTrans
77/s
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData
75/s
SubarrayOnPos
38/s
PosInOutOfTheLoopF32ArrayFromSubarray
37/s
PosInOutOfTheLoopVars
36/s
LoicRewrite
36/s
PosInOutOfTheLoopF32Array
35/s
CacheTransWithArrayFromSubarray
24/s
SubarrayOnTransAndPosWithFRound
9/s
Original
8/s
UpdatedEmscripten
1/s
Warmup
0/s
View exact numbers
Test name	Executions per second
✓ SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans	104 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans	104 Ops/sec
SubarrayOnPosAndCacheTransWithSubarray	100 Ops/sec
CacheTransWithSubarray	91 Ops/sec
CacheTransWithF32ArraySetFromSubarray	91 Ops/sec
SubarrayOnTransAndPos	91 Ops/sec
SubarrayOnTransAndPosWithoutPlus	89 Ops/sec
CacheTransWithVarsFromSubarray	88 Ops/sec
CacheTransWithSlice	87 Ops/sec
SubarrayOnTrans	77 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData	75 Ops/sec
SubarrayOnPos	38 Ops/sec
PosInOutOfTheLoopF32ArrayFromSubarray	37 Ops/sec
PosInOutOfTheLoopVars	36 Ops/sec
LoicRewrite	36 Ops/sec
PosInOutOfTheLoopF32Array	35 Ops/sec
CacheTransWithArrayFromSubarray	24 Ops/sec
SubarrayOnTransAndPosWithFRound	9 Ops/sec
Original	8 Ops/sec
UpdatedEmscripten	1 Ops/sec
Warmup	0 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()