Run results for: Linear Blend Skinning 2

Run details:
User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36
Browser: Chrome 120
Operating system: Linux
Device Platform: Desktop
Date tested: 2 years ago
Test name	Executions per second
Warmup	0.1 Ops/sec
Original	11.1 Ops/sec
UpdatedEmscripten	1.9 Ops/sec
LoicRewrite	54.2 Ops/sec
SubarrayOnTrans	113.9 Ops/sec
SubarrayOnPos	57.3 Ops/sec
SubarrayOnTransAndPos	132.8 Ops/sec
SubarrayOnTransAndPosWithFRound	12.1 Ops/sec
SubarrayOnTransAndPosWithoutPlus	93.7 Ops/sec
PosInOutOfTheLoopF32Array	53.7 Ops/sec
PosInOutOfTheLoopF32ArrayFromSubarray	56.6 Ops/sec
PosInOutOfTheLoopVars	53.6 Ops/sec
CacheTransWithSubarray	136.4 Ops/sec
CacheTransWithSlice	135.3 Ops/sec
CacheTransWithF32ArraySetFromSubarray	135.7 Ops/sec
CacheTransWithVarsFromSubarray	137.1 Ops/sec
CacheTransWithArrayFromSubarray	33.8 Ops/sec
SubarrayOnPosAndCacheTransWithSubarray	162.2 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingData	162.5 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndSmallTrans	154.1 Ops/sec
SubarrayOnPosAndCacheTransWithSubarrayAndInterleavingDataAndSmallTrans	152.2 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()