Run results for: Linear Blend Skinning 2

Run details:
User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Mobile/15E148 Safari/604.1
Browser: Mobile Safari 17
Operating system: iOS 17.2.1
Device Platform: Mobile
Date tested: 2 years ago
Benchmark engine: Benchmark.js
SubarrayOnPosAndCacheTransWithSubarray
218/s
SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans
207/s
CacheTransWithSlice
190/s
CacheTransWithF32ArraySetFromSubarray
190/s
CacheTransWithVarsFromSubarray
186/s
CacheTransWithSubarray
183/s
SubarrayOnTransAndPosWithoutPlus
172/s
SubarrayOnTransAndPos
168/s
SubarrayOnTrans
152/s
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData
111/s
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans
102/s
PosInOutOfTheLoopVars
77/s
PosInOutOfTheLoopF32ArrayFromSubarray
77/s
SubarrayOnPos
76/s
LoicRewrite
73/s
PosInOutOfTheLoopF32Array
71/s
CacheTransWithArrayFromSubarray
69/s
SubarrayOnTransAndPosWithFRound
20/s
Original
17/s
UpdatedEmscripten
3/s
Warmup
0/s
View exact numbers
Test name	Executions per second
✓ SubarrayOnPosAndCacheTransWithSubarray	218 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans	207 Ops/sec
CacheTransWithSlice	190 Ops/sec
CacheTransWithF32ArraySetFromSubarray	190 Ops/sec
CacheTransWithVarsFromSubarray	186 Ops/sec
CacheTransWithSubarray	183 Ops/sec
SubarrayOnTransAndPosWithoutPlus	172 Ops/sec
SubarrayOnTransAndPos	168 Ops/sec
SubarrayOnTrans	152 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData	111 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans	102 Ops/sec
PosInOutOfTheLoopVars	77 Ops/sec
PosInOutOfTheLoopF32ArrayFromSubarray	77 Ops/sec
SubarrayOnPos	76 Ops/sec
LoicRewrite	73 Ops/sec
PosInOutOfTheLoopF32Array	71 Ops/sec
CacheTransWithArrayFromSubarray	69 Ops/sec
SubarrayOnTransAndPosWithFRound	20 Ops/sec
Original	17 Ops/sec
UpdatedEmscripten	3 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()