import {
__raweq1,
__raweq2,
__raweq3,
__raweq4,
__raweq5,
__raweq6,
__raweq7,
__raweq8,
__raweq9,
__raweq10,
__raweq11,
__raweq12,
__raweq13,
__raweq14,
__raweq15,
__raweq16,
__raweq17,
__raweq18,
__raweq19,
__raweq20,
__raweq21,
__raweq22,
__raweq23,
__raweq24,
__raweq25,
__raweq26,
__raweq27,
__raweq28,
__raweq29,
__raweq30,
__raweq31,
__raweq32,
__raweq33,
__raweq34,
__raweq35,
__raweq36,
__raweq37,
__raweq38,
__raweq39,
__raweq40,
__raweq41,
__raweq42,
__raweq43,
__raweq44,
__raweq45,
__raweq46,
__raweq47,
__raweq48,
__raweq49,
__raweq50,
__raweq51,
__raweq52,
__raweq53,
__raweq54,
__raweq55,
__raweq56,
__raweq57,
__raweq58,
__raweq59,
__raweq60,
__raweq61,
__raweq62,
__raweq63,
__raweq64,
__raweq65,
__raweq66,
__raweq67,
__raweq68,
__raweq69,
__raweq70,
__raweq71,
__raweq72,
__raweq73,
__raweq74,
__raweq75,
__raweq76,
__raweq77,
__raweq78,
__raweq79,
__raweq80,
__raweq81,
__raweq82,
__raweq83,
__raweq84,
__raweq85,
__raweq86,
__raweq87,
__raweq88,
__raweq89,
__raweq90,
__raweq91,
__raweq92,
__raweq93,
__raweq94,
__raweq95,
__raweq96,
__raweq97,
__raweq98,
__raweq99,
__raweq100,
__raweq101,
__raweq102,
__raweq103,
__raweq104,
__raweq105,
__raweq106,
__raweq107,
__raweq108,
__raweq109,
__raweq110,
__raweq111,
__raweq112,
__raweq113,
__raweq114,
__raweq115,
__raweq116,
__raweq117,
__raweq118,
__raweq119,
__raweq120,
__raweq121,
__raweq122,
__raweq123,
__raweq124,
__raweq125,
__raweq126,
__raweq127,
__raweq128
} from "./util/raweq";

@global @inline
export function __eq0(left: ByteView, right: string): bool {
  return left.length == 0;
}

@global @inline
export function __eq1(left: ByteView, right: string): bool {
  if (left.length != 1) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq1(ptr1, ptr2);
}

@global @inline
export function __eq2(left: ByteView, right: string): bool {
  if (left.length != 2) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq2(ptr1, ptr2);
}

@global @inline
export function __eq3(left: ByteView, right: string): bool {
  if (left.length != 3) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq3(ptr1, ptr2);
}

@global @inline
export function __eq4(left: ByteView, right: string): bool {
  if (left.length != 4) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq4(ptr1, ptr2);
}

@global @inline
export function __eq5(left: ByteView, right: string): bool {
  if (left.length != 5) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq5(ptr1, ptr2);
}

@global @inline
export function __eq6(left: ByteView, right: string): bool {
  if (left.length != 6) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq6(ptr1, ptr2);
}

@global @inline
export function __eq7(left: ByteView, right: string): bool {
  if (left.length != 7) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq7(ptr1, ptr2);
}

@global @inline
export function __eq8(left: ByteView, right: string): bool {
  if (left.length != 8) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq8(ptr1, ptr2);
}

@global @inline
export function __eq9(left: ByteView, right: string): bool {
  if (left.length != 9) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq9(ptr1, ptr2);
}

@global @inline
export function __eq10(left: ByteView, right: string): bool {
  if (left.length != 10) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq10(ptr1, ptr2);
}

@global @inline
export function __eq11(left: ByteView, right: string): bool {
  if (left.length != 11) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq11(ptr1, ptr2);
}

@global @inline
export function __eq12(left: ByteView, right: string): bool {
  if (left.length != 12) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq12(ptr1, ptr2);
}

@global @inline
export function __eq13(left: ByteView, right: string): bool {
  if (left.length != 13) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq13(ptr1, ptr2);
}

@global @inline
export function __eq14(left: ByteView, right: string): bool {
  if (left.length != 14) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq14(ptr1, ptr2);
}

@global @inline
export function __eq15(left: ByteView, right: string): bool {
  if (left.length != 15) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq15(ptr1, ptr2);
}

@global @inline
export function __eq16(left: ByteView, right: string): bool {
  if (left.length != 16) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq16(ptr1, ptr2);
}

@global @inline
export function __eq17(left: ByteView, right: string): bool {
  if (left.length != 17) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq17(ptr1, ptr2);
}

@global @inline
export function __eq18(left: ByteView, right: string): bool {
  if (left.length != 18) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq18(ptr1, ptr2);
}

@global @inline
export function __eq19(left: ByteView, right: string): bool {
  if (left.length != 19) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq19(ptr1, ptr2);
}

@global @inline
export function __eq20(left: ByteView, right: string): bool {
  if (left.length != 20) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq20(ptr1, ptr2);
}

@global @inline
export function __eq21(left: ByteView, right: string): bool {
  if (left.length != 21) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq21(ptr1, ptr2);
}

@global @inline
export function __eq22(left: ByteView, right: string): bool {
  if (left.length != 22) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq22(ptr1, ptr2);
}

@global @inline
export function __eq23(left: ByteView, right: string): bool {
  if (left.length != 23) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq23(ptr1, ptr2);
}

@global @inline
export function __eq24(left: ByteView, right: string): bool {
  if (left.length != 24) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq24(ptr1, ptr2);
}

@global @inline
export function __eq25(left: ByteView, right: string): bool {
  if (left.length != 25) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq25(ptr1, ptr2);
}

@global @inline
export function __eq26(left: ByteView, right: string): bool {
  if (left.length != 26) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq26(ptr1, ptr2);
}

@global @inline
export function __eq27(left: ByteView, right: string): bool {
  if (left.length != 27) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq27(ptr1, ptr2);
}

@global @inline
export function __eq28(left: ByteView, right: string): bool {
  if (left.length != 28) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq28(ptr1, ptr2);
}

@global @inline
export function __eq29(left: ByteView, right: string): bool {
  if (left.length != 29) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq29(ptr1, ptr2);
}

@global @inline
export function __eq30(left: ByteView, right: string): bool {
  if (left.length != 30) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq30(ptr1, ptr2);
}

@global @inline
export function __eq31(left: ByteView, right: string): bool {
  if (left.length != 31) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq31(ptr1, ptr2);
}

@global @inline
export function __eq32(left: ByteView, right: string): bool {
  if (left.length != 32) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq32(ptr1, ptr2);
}

@global @inline
export function __eq33(left: ByteView, right: string): bool {
  if (left.length != 33) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq33(ptr1, ptr2);
}

@global @inline
export function __eq34(left: ByteView, right: string): bool {
  if (left.length != 34) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq34(ptr1, ptr2);
}

@global @inline
export function __eq35(left: ByteView, right: string): bool {
  if (left.length != 35) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq35(ptr1, ptr2);
}

@global @inline
export function __eq36(left: ByteView, right: string): bool {
  if (left.length != 36) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq36(ptr1, ptr2);
}

@global @inline
export function __eq37(left: ByteView, right: string): bool {
  if (left.length != 37) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq37(ptr1, ptr2);
}

@global @inline
export function __eq38(left: ByteView, right: string): bool {
  if (left.length != 38) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq38(ptr1, ptr2);
}

@global @inline
export function __eq39(left: ByteView, right: string): bool {
  if (left.length != 39) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq39(ptr1, ptr2);
}

@global @inline
export function __eq40(left: ByteView, right: string): bool {
  if (left.length != 40) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq40(ptr1, ptr2);
}

@global @inline
export function __eq41(left: ByteView, right: string): bool {
  if (left.length != 41) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq41(ptr1, ptr2);
}

@global @inline
export function __eq42(left: ByteView, right: string): bool {
  if (left.length != 42) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq42(ptr1, ptr2);
}

@global @inline
export function __eq43(left: ByteView, right: string): bool {
  if (left.length != 43) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq43(ptr1, ptr2);
}

@global @inline
export function __eq44(left: ByteView, right: string): bool {
  if (left.length != 44) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq44(ptr1, ptr2);
}

@global @inline
export function __eq45(left: ByteView, right: string): bool {
  if (left.length != 45) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq45(ptr1, ptr2);
}

@global @inline
export function __eq46(left: ByteView, right: string): bool {
  if (left.length != 46) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq46(ptr1, ptr2);
}

@global @inline
export function __eq47(left: ByteView, right: string): bool {
  if (left.length != 47) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq47(ptr1, ptr2);
}

@global @inline
export function __eq48(left: ByteView, right: string): bool {
  if (left.length != 48) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq48(ptr1, ptr2);
}

@global @inline
export function __eq49(left: ByteView, right: string): bool {
  if (left.length != 49) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq49(ptr1, ptr2);
}

@global @inline
export function __eq50(left: ByteView, right: string): bool {
  if (left.length != 50) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq50(ptr1, ptr2);
}

@global @inline
export function __eq51(left: ByteView, right: string): bool {
  if (left.length != 51) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq51(ptr1, ptr2);
}

@global @inline
export function __eq52(left: ByteView, right: string): bool {
  if (left.length != 52) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq52(ptr1, ptr2);
}

@global @inline
export function __eq53(left: ByteView, right: string): bool {
  if (left.length != 53) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq53(ptr1, ptr2);
}

@global @inline
export function __eq54(left: ByteView, right: string): bool {
  if (left.length != 54) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq54(ptr1, ptr2);
}

@global @inline
export function __eq55(left: ByteView, right: string): bool {
  if (left.length != 55) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq55(ptr1, ptr2);
}

@global @inline
export function __eq56(left: ByteView, right: string): bool {
  if (left.length != 56) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq56(ptr1, ptr2);
}

@global @inline
export function __eq57(left: ByteView, right: string): bool {
  if (left.length != 57) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq57(ptr1, ptr2);
}

@global @inline
export function __eq58(left: ByteView, right: string): bool {
  if (left.length != 58) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq58(ptr1, ptr2);
}

@global @inline
export function __eq59(left: ByteView, right: string): bool {
  if (left.length != 59) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq59(ptr1, ptr2);
}

@global @inline
export function __eq60(left: ByteView, right: string): bool {
  if (left.length != 60) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq60(ptr1, ptr2);
}

@global @inline
export function __eq61(left: ByteView, right: string): bool {
  if (left.length != 61) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq61(ptr1, ptr2);
}

@global @inline
export function __eq62(left: ByteView, right: string): bool {
  if (left.length != 62) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq62(ptr1, ptr2);
}

@global @inline
export function __eq63(left: ByteView, right: string): bool {
  if (left.length != 63) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq63(ptr1, ptr2);
}

@global @inline
export function __eq64(left: ByteView, right: string): bool {
  if (left.length != 64) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq64(ptr1, ptr2);
}

@global @inline
export function __eq65(left: ByteView, right: string): bool {
  if (left.length != 65) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq65(ptr1, ptr2);
}

@global @inline
export function __eq66(left: ByteView, right: string): bool {
  if (left.length != 66) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq66(ptr1, ptr2);
}

@global @inline
export function __eq67(left: ByteView, right: string): bool {
  if (left.length != 67) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq67(ptr1, ptr2);
}

@global @inline
export function __eq68(left: ByteView, right: string): bool {
  if (left.length != 68) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq68(ptr1, ptr2);
}

@global @inline
export function __eq69(left: ByteView, right: string): bool {
  if (left.length != 69) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq69(ptr1, ptr2);
}

@global @inline
export function __eq70(left: ByteView, right: string): bool {
  if (left.length != 70) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq70(ptr1, ptr2);
}

@global @inline
export function __eq71(left: ByteView, right: string): bool {
  if (left.length != 71) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq71(ptr1, ptr2);
}

@global @inline
export function __eq72(left: ByteView, right: string): bool {
  if (left.length != 72) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq72(ptr1, ptr2);
}

@global @inline
export function __eq73(left: ByteView, right: string): bool {
  if (left.length != 73) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq73(ptr1, ptr2);
}

@global @inline
export function __eq74(left: ByteView, right: string): bool {
  if (left.length != 74) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq74(ptr1, ptr2);
}

@global @inline
export function __eq75(left: ByteView, right: string): bool {
  if (left.length != 75) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq75(ptr1, ptr2);
}

@global @inline
export function __eq76(left: ByteView, right: string): bool {
  if (left.length != 76) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq76(ptr1, ptr2);
}

@global @inline
export function __eq77(left: ByteView, right: string): bool {
  if (left.length != 77) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq77(ptr1, ptr2);
}

@global @inline
export function __eq78(left: ByteView, right: string): bool {
  if (left.length != 78) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq78(ptr1, ptr2);
}

@global @inline
export function __eq79(left: ByteView, right: string): bool {
  if (left.length != 79) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq79(ptr1, ptr2);
}

@global @inline
export function __eq80(left: ByteView, right: string): bool {
  if (left.length != 80) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq80(ptr1, ptr2);
}

@global @inline
export function __eq81(left: ByteView, right: string): bool {
  if (left.length != 81) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq81(ptr1, ptr2);
}

@global @inline
export function __eq82(left: ByteView, right: string): bool {
  if (left.length != 82) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq82(ptr1, ptr2);
}

@global @inline
export function __eq83(left: ByteView, right: string): bool {
  if (left.length != 83) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq83(ptr1, ptr2);
}

@global @inline
export function __eq84(left: ByteView, right: string): bool {
  if (left.length != 84) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq84(ptr1, ptr2);
}

@global @inline
export function __eq85(left: ByteView, right: string): bool {
  if (left.length != 85) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq85(ptr1, ptr2);
}

@global @inline
export function __eq86(left: ByteView, right: string): bool {
  if (left.length != 86) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq86(ptr1, ptr2);
}

@global @inline
export function __eq87(left: ByteView, right: string): bool {
  if (left.length != 87) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq87(ptr1, ptr2);
}

@global @inline
export function __eq88(left: ByteView, right: string): bool {
  if (left.length != 88) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq88(ptr1, ptr2);
}

@global @inline
export function __eq89(left: ByteView, right: string): bool {
  if (left.length != 89) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq89(ptr1, ptr2);
}

@global @inline
export function __eq90(left: ByteView, right: string): bool {
  if (left.length != 90) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq90(ptr1, ptr2);
}

@global @inline
export function __eq91(left: ByteView, right: string): bool {
  if (left.length != 91) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq91(ptr1, ptr2);
}

@global @inline
export function __eq92(left: ByteView, right: string): bool {
  if (left.length != 92) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq92(ptr1, ptr2);
}

@global @inline
export function __eq93(left: ByteView, right: string): bool {
  if (left.length != 93) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq93(ptr1, ptr2);
}

@global @inline
export function __eq94(left: ByteView, right: string): bool {
  if (left.length != 94) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq94(ptr1, ptr2);
}

@global @inline
export function __eq95(left: ByteView, right: string): bool {
  if (left.length != 95) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq95(ptr1, ptr2);
}

@global @inline
export function __eq96(left: ByteView, right: string): bool {
  if (left.length != 96) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq96(ptr1, ptr2);
}

@global @inline
export function __eq97(left: ByteView, right: string): bool {
  if (left.length != 97) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq97(ptr1, ptr2);
}

@global @inline
export function __eq98(left: ByteView, right: string): bool {
  if (left.length != 98) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq98(ptr1, ptr2);
}

@global @inline
export function __eq99(left: ByteView, right: string): bool {
  if (left.length != 99) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq99(ptr1, ptr2);
}

@global @inline
export function __eq100(left: ByteView, right: string): bool {
  if (left.length != 100) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq100(ptr1, ptr2);
}

@global @inline
export function __eq101(left: ByteView, right: string): bool {
  if (left.length != 101) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq101(ptr1, ptr2);
}

@global @inline
export function __eq102(left: ByteView, right: string): bool {
  if (left.length != 102) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq102(ptr1, ptr2);
}

@global @inline
export function __eq103(left: ByteView, right: string): bool {
  if (left.length != 103) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq103(ptr1, ptr2);
}

@global @inline
export function __eq104(left: ByteView, right: string): bool {
  if (left.length != 104) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq104(ptr1, ptr2);
}

@global @inline
export function __eq105(left: ByteView, right: string): bool {
  if (left.length != 105) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq105(ptr1, ptr2);
}

@global @inline
export function __eq106(left: ByteView, right: string): bool {
  if (left.length != 106) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq106(ptr1, ptr2);
}

@global @inline
export function __eq107(left: ByteView, right: string): bool {
  if (left.length != 107) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq107(ptr1, ptr2);
}

@global @inline
export function __eq108(left: ByteView, right: string): bool {
  if (left.length != 108) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq108(ptr1, ptr2);
}

@global @inline
export function __eq109(left: ByteView, right: string): bool {
  if (left.length != 109) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq109(ptr1, ptr2);
}

@global @inline
export function __eq110(left: ByteView, right: string): bool {
  if (left.length != 110) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq110(ptr1, ptr2);
}

@global @inline
export function __eq111(left: ByteView, right: string): bool {
  if (left.length != 111) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq111(ptr1, ptr2);
}

@global @inline
export function __eq112(left: ByteView, right: string): bool {
  if (left.length != 112) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq112(ptr1, ptr2);
}

@global @inline
export function __eq113(left: ByteView, right: string): bool {
  if (left.length != 113) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq113(ptr1, ptr2);
}

@global @inline
export function __eq114(left: ByteView, right: string): bool {
  if (left.length != 114) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq114(ptr1, ptr2);
}

@global @inline
export function __eq115(left: ByteView, right: string): bool {
  if (left.length != 115) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq115(ptr1, ptr2);
}

@global @inline
export function __eq116(left: ByteView, right: string): bool {
  if (left.length != 116) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq116(ptr1, ptr2);
}

@global @inline
export function __eq117(left: ByteView, right: string): bool {
  if (left.length != 117) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq117(ptr1, ptr2);
}

@global @inline
export function __eq118(left: ByteView, right: string): bool {
  if (left.length != 118) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq118(ptr1, ptr2);
}

@global @inline
export function __eq119(left: ByteView, right: string): bool {
  if (left.length != 119) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq119(ptr1, ptr2);
}

@global @inline
export function __eq120(left: ByteView, right: string): bool {
  if (left.length != 120) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq120(ptr1, ptr2);
}

@global @inline
export function __eq121(left: ByteView, right: string): bool {
  if (left.length != 121) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq121(ptr1, ptr2);
}

@global @inline
export function __eq122(left: ByteView, right: string): bool {
  if (left.length != 122) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq122(ptr1, ptr2);
}

@global @inline
export function __eq123(left: ByteView, right: string): bool {
  if (left.length != 123) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq123(ptr1, ptr2);
}

@global @inline
export function __eq124(left: ByteView, right: string): bool {
  if (left.length != 124) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq124(ptr1, ptr2);
}

@global @inline
export function __eq125(left: ByteView, right: string): bool {
  if (left.length != 125) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq125(ptr1, ptr2);
}

@global @inline
export function __eq126(left: ByteView, right: string): bool {
  if (left.length != 126) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq126(ptr1, ptr2);
}

@global @inline
export function __eq127(left: ByteView, right: string): bool {
  if (left.length != 127) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq127(ptr1, ptr2);
}

@global @inline
export function __eq128(left: ByteView, right: string): bool {
  if (left.length != 128) return false;
  let ptr1 = changetype<usize>(left.underlying) + left.offset;
  let ptr2 = changetype<usize>(right);
  return __raweq128(ptr1, ptr2);
}