// Metro module 511 (f512).
import { toByteArray, fromByteArray } from "./Module206";
import * as _Module512 from "./Module512";
import { read } from "./Module512";
let c493_3, from, allocUnsafe, fromArrayLike, byteLength, slowToString, bidirectionalIndexOf, arrayIndexOf, utf8Slice, c493_13, c493_14, utf8ToBytes, c493_16;
const Buffer2 = function(a0, a1, a2) {
  if (typeof a0 === "number") {
    if (typeof a1 === "string") {
      throw new TypeError("The \"string\" argument must be of type string. Received type number");
    }
    return allocUnsafe(a0);
  }
  return from(a0, a1, a2);
};
from = function from(a0, a1, a2) {
  let r68, r78;
  if (typeof a0 === "string") {
    const r262 = (typeof a1 === "string" ? a1 !== "" : typeof a1 === "string") ? a1 : "utf8";
    if (Buffer2.isEncoding(r262)) {
      const r277 = byteLength(a0, r262) | 0;
      if (r277 > c493_3) {
        throw new RangeError("The value \"" + r277 + "\" is invalid for option \"size\"");
      }
      const uint8Array3 = new Uint8Array(r277);
      Object.setPrototypeOf(uint8Array3, Buffer2.prototype);
      const r291 = uint8Array3.write(a0, r262);
      return r291 !== r277 ? uint8Array3.slice(0, r291) : uint8Array3;
    }
    throw new TypeError("Unknown encoding: " + r262);
  }
  if (ArrayBuffer.isView(a0)) {
    return fromArrayLike(a0);
  }
  if (a0 == null) {
    throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof a0);
  }
  const r26 = ArrayBuffer;
  const r3 = a0 instanceof r26 || a0 != null && a0.constructor != null && a0.constructor.name != null && a0.constructor.name === r26.name;
  L89: {
    if (!r3) {
      if (a0) {
        const buffer = a0.buffer;
        const r34 = ArrayBuffer;
        if (buffer instanceof r34 || buffer != null && buffer.constructor != null && buffer.constructor.name != null && buffer.constructor.name === r34.name) {
          break L89;
        }
      }
      L42: {
        if (typeof globalThis.SharedArrayBuffer !== "undefined") {
          const r43 = SharedArrayBuffer;
          if (!(a0 instanceof r43 || a0 != null && a0.constructor != null && a0.constructor.name != null && a0.constructor.name === r43.name)) {
            if (!a0) {
              break L42;
            }
            const buffer2 = a0.buffer;
            const r53 = SharedArrayBuffer;
            if (!(buffer2 instanceof r53 || buffer2 != null && buffer2.constructor != null && buffer2.constructor.name != null && buffer2.constructor.name === r53.name)) {
              break L42;
            }
          }
          if (!(a1 < 0) && !(a0.byteLength < a1)) {
            if (a0.byteLength < a1 + (a2 ? a2 : 0)) {
              throw new RangeError("\"length\" is outside of buffer bounds");
            }
            const r178 = a1 === void 0 && a2 === void 0 ? new Uint8Array(a0) : a2 === void 0 ? new Uint8Array(a0, a1) : new Uint8Array(a0, a1, a2);
            Object.setPrototypeOf(r178, Buffer2.prototype);
            return r178;
          }
          throw new RangeError("\"offset\" is outside of buffer bounds");
        }
      }
      if (typeof a0 === "number") {
        throw new TypeError("The \"value\" argument must not be of type number. Received type number");
      }
      const r62 = a0.valueOf && a0.valueOf();
      if (r62 != null && r62 !== a0) {
        return Buffer2.from(r62, a1, a2);
      }
      const isBuffer2 = Buffer2.isBuffer(a0);
      const length = a0.length;
      if (isBuffer2) {
        if (length >= c493_3) {
          throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + c493_3.toString(16) + " bytes");
        }
        const r98 = length | 0 | 0;
        if (r98 > c493_3) {
          throw new RangeError("The value \"" + r98 + "\" is invalid for option \"size\"");
        }
        const uint8Array2 = new Uint8Array(r98);
        Object.setPrototypeOf(uint8Array2, Buffer2.prototype);
        const length3 = uint8Array2.length;
        r68 = uint8Array2;
        if (length3 !== 0) {
          a0.copy(uint8Array2, 0, 0, r98);
          r68 = uint8Array2;
        }
      } else if (length !== void 0) {
        L57: {
          if (typeof a0.length === "number") {
            const length2 = a0.length;
            if (length2 == length2) {
              r78 = fromArrayLike(a0);
              break L57;
            }
          }
          if (0 > c493_3) {
            throw new RangeError("The value \"" + 0 + "\" is invalid for option \"size\"");
          }
          const uint8Array = new Uint8Array(0);
          Object.setPrototypeOf(uint8Array, Buffer2.prototype);
          r78 = uint8Array;
        }
        r68 = r78;
      } else {
        r68 = a0.type === "Buffer" ? Array.isArray(a0.data) ? fromArrayLike(a0.data) : void 0 : void 0;
      }
      if (r68) {
        return r68;
      }
      if (typeof globalThis.Symbol !== "undefined" && Symbol.toPrimitive != null && typeof a0[Symbol.toPrimitive] === "function") {
        return Buffer2.from(a0[Symbol.toPrimitive]("string"), a1, a2);
      }
      throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof a0);
    }
  }
  if (!(a1 < 0) && !(a0.byteLength < a1)) {
    if (a0.byteLength < a1 + (a2 ? a2 : 0)) {
      throw new RangeError("\"length\" is outside of buffer bounds");
    }
    const r220 = a1 === void 0 && a2 === void 0 ? new Uint8Array(a0) : a2 === void 0 ? new Uint8Array(a0, a1) : new Uint8Array(a0, a1, a2);
    Object.setPrototypeOf(r220, Buffer2.prototype);
    return r220;
  }
  throw new RangeError("\"offset\" is outside of buffer bounds");
};
allocUnsafe = function allocUnsafe(a0) {
  if (typeof a0 !== "number") {
    throw new TypeError("\"size\" argument must be of type number");
  }
  if (a0 < 0) {
    throw new RangeError("The value \"" + a0 + "\" is invalid for option \"size\"");
  }
  const r2 = a0 < 0;
  let r12 = 0;
  if (!r2) {
    if (a0 >= c493_3) {
      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + c493_3.toString(16) + " bytes");
    }
    r12 = a0 | 0 | 0;
  }
  if (r12 > c493_3) {
    throw new RangeError("The value \"" + r12 + "\" is invalid for option \"size\"");
  }
  const uint8Array = new Uint8Array(r12);
  Object.setPrototypeOf(uint8Array, Buffer2.prototype);
  return uint8Array;
};
fromArrayLike = function fromArrayLike(data) {
  const r5 = data.length < 0;
  let r4 = 0;
  if (!r5) {
    const length = data.length;
    if (length >= c493_3) {
      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + c493_3.toString(16) + " bytes");
    }
    r4 = length | 0 | 0;
  }
  if (r4 > c493_3) {
    throw new RangeError("The value \"" + r4 + "\" is invalid for option \"size\"");
  }
  const uint8Array = new Uint8Array(r4);
  Object.setPrototypeOf(uint8Array, Buffer2.prototype);
  let r39 = 0;
  while (r39 < r4) {
    uint8Array[r39] = 255 & data[r39];
    r39 = r39 + 1;
  }
  return uint8Array;
};
byteLength = function byteLength(a0, a1) {
  let r62;
  if (Buffer2.isBuffer(a0)) {
    return a0.length;
  }
  if (!ArrayBuffer.isView(a0)) {
    const r30 = ArrayBuffer;
    if (!(a0 instanceof r30 || a0 != null && a0.constructor != null && a0.constructor.name != null && a0.constructor.name === r30.name)) {
      if (typeof a0 !== "string") {
        throw new TypeError("The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. Received type " + typeof a0);
      }
      const length = a0.length;
      const r40 = arguments.length > 2 && arguments[2] === true;
      let r44 = false;
      let r45 = a1;
      if (!r40) {
        r44 = false;
        r45 = a1;
        if (length === 0) {
          return 0;
        }
      }
      while (true) {
        const r46 = r44;
        const r47 = r45;
        switch (r47) {
          case "ascii":
          case "latin1":
          case "binary":
            return length;
          case "utf8":
          case "utf-8":
            return utf8ToBytes(a0).length;
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return 2 * length;
          case "hex":
            return length >>> 1;
          case "base64":
            const r21 = a0.split("=")[0].trim();
            let r54 = "";
            const r55 = r21.replace(c493_14, "");
            if (!(r55.length < 2)) {
              const r58 = r55.length % 4;
              let r59 = r55;
              let r60 = r59;
              if (r58 !== 0) {
                do {
                  const r61 = r59 + "=";
                  r62 = r61.length % 4;
                  r59 = r61;
                  r60 = r59;
                } while (r62 !== 0);
              }
              r54 = r60;
            }
            return toByteArray(r54).length;
          default:
            if (r46) {
              return r40 ? -1 : utf8ToBytes(a0).length;
            }
            r45 = ("" + r47).toLowerCase();
            r44 = true;
        }
      }
    }
  }
  return a0.byteLength;
};
slowToString = function slowToString(a0, a1, a2) {
  let length;
  const r13 = a1 === void 0 || a1 < 0 ? 0 : a1;
  if (r13 > this.length) {
    return "";
  }
  const r29 = a2 === void 0 || a2 > this.length ? this.length : a2;
  if (r29 <= 0) {
    return "";
  }
  const r6 = r29 >>> 0;
  const r31 = r13 >>> 0;
  if (r6 <= r31) {
    return "";
  }
  let r32 = a0;
  let r33 = false;
  if (!a0) {
    r32 = "utf8";
    r33 = false;
  }
  while (true) {
    const r10 = r33;
    const r34 = r32;
    switch (r34) {
      case "hex":
        const length2 = this.length;
        let r90 = (r31 ? r31 < 0 : !r31) ? 0 : r31;
        const r92 = (r6 ? r6 < 0 : !r6) || r6 > length2 ? length2 : r6;
        const r93 = r90 < r92;
        let r94 = "";
        let r96 = "";
        if (r93) {
          do {
            r94 = r94 + c493_16[this[r90]];
            r90 = r90 + 1;
            r96 = r94;
          } while (r90 < r92);
        }
        return r96;
      case "utf8":
      case "utf-8":
        return utf8Slice(this, r31, r6);
      case "ascii":
        const r74 = Math.min(this.length, r6);
        const r75 = r31 < r74;
        let r76 = "";
        let r79 = r31;
        let r80 = "";
        if (r75) {
          do {
            r76 = r76 + String.fromCharCode(127 & this[r79]);
            r79 = r79 + 1;
            r80 = r76;
          } while (r79 < r74);
        }
        return r80;
      case "latin1":
      case "binary":
        const r60 = Math.min(this.length, r6);
        const r61 = r31 < r60;
        let r62 = "";
        let r64 = r31;
        let r65 = "";
        if (r61) {
          do {
            r62 = r62 + String.fromCharCode(this[r64]);
            r64 = r64 + 1;
            r65 = r62;
          } while (r64 < r60);
        }
        return r65;
      case "base64":
        return r31 === 0 && r6 === this.length ? fromByteArray(this) : fromByteArray(this.slice(r31, r6));
      case "ucs2":
      case "ucs-2":
      case "utf16le":
      case "utf-16le":
        const r21 = this.slice(r31, r6);
        const r9 = 0 < r21.length;
        let r19 = "";
        let r0 = 0;
        let r37 = "";
        if (r9) {
          do {
            r19 = r19 + String.fromCharCode(r21[r0] + 256 * r21[r0 + 1]);
            r0 = r0 + 2;
            length = r21.length;
            r37 = r19;
          } while (r0 < length);
        }
        return r37;
      default:
        if (r10) {
          throw new TypeError("Unknown encoding: " + r34);
        }
        r32 = ("" + r34).toLowerCase();
        r33 = true;
    }
  }
};
bidirectionalIndexOf = function bidirectionalIndexOf(a0, a1, a2, a3, a4) {
  let r51;
  if (a0.length === 0) {
    return -1;
  }
  let r9 = a2;
  let r20 = 0;
  if (typeof a2 !== "string") {
    const r4 = a2 > 2147483647;
    r9 = a3;
    r20 = 2147483647;
    if (!r4) {
      r9 = a3;
      r20 = a2;
      if (a2 < -2147483648) {
        r9 = a3;
        r20 = -2147483648;
      }
    }
  }
  let r23 = +r20;
  if (r23 !== r23) {
    r23 = a4 ? 0 : a0.length - 1;
  }
  let r8 = r23;
  if (r8 < 0) {
    r8 = a0.length + r23;
  }
  if (r8 >= a0.length) {
    if (a4) {
      return -1;
    }
    r8 = a0.length - 1;
  } else if (r8 < 0) {
    r8 = 0;
    if (!a4) {
      return -1;
    }
  }
  const r31 = typeof a1 === "string" ? Buffer2.from(a1, r9) : a1;
  if (Buffer2.isBuffer(r31)) {
    return r31.length !== 0 ? arrayIndexOf(a0, r31, r8, r9, a4) : -1;
  }
  if (typeof r31 === "number") {
    const r42 = r31 & 255;
    if (typeof Uint8Array.prototype.indexOf === "function") {
      const prototype = Uint8Array.prototype;
      r51 = a4 ? prototype.indexOf.call(a0, r42, r8) : prototype.lastIndexOf.call(a0, r42, r8);
    } else {
      r51 = arrayIndexOf(a0, [r42], r8, r9, a4);
    }
    return r51;
  }
  throw new TypeError("val must be string, number or Buffer");
};
arrayIndexOf = function arrayIndexOf(a0, a1, a2, a3, a4) {
  let r3, r6, r13, r14, r15, r43, r57, r59;
  L8: {
    const length2 = a0.length;
    const length = a1.length;
    r3 = 1;
    r15 = length;
    r14 = length2;
    r6 = 1;
    r13 = a2;
    if (a3 !== void 0) {
      const r24 = String(a3).toLowerCase();
      if (r24 !== "ucs2" && r24 !== "ucs-2" && r24 !== "utf16le") {
        r3 = 1;
        r15 = length;
        r14 = length2;
        r6 = 1;
        r13 = a2;
        if (r24 !== "utf-16le") {
          break L8;
        }
      }
      if (!(a0.length < 2) && !(a1.length < 2)) {
        r14 = length2 / 2;
        r15 = length / 2;
        r13 = a2 / 2;
        r3 = 2;
        r6 = 2;
        break L8;
      }
      return -1;
    }
  }
  if (a4) {
    const r44 = r13 < r14;
    let r46 = -1;
    if (r44) {
      do {
        let r47 = r46;
        const r48 = r13;
        const r51 = r3 === 1 ? a0[r48] : a0.readUInt16BE(r48 * r3);
        const r52 = r47 === -1;
        const r53 = r52 ? 0 : r48 - r47;
        if (r51 === (r3 === 1 ? a1[r53] : a1.readUInt16BE(r53 * r3))) {
          if (r52) {
            r47 = r48;
          }
          const r61 = r48 - r47 + 1;
          r59 = r47;
          r57 = r48;
          if (r61 === r15) {
            return r47 * r6;
          }
        } else {
          r57 = r47 !== -1 ? r48 - (r48 - r47) : r48;
          r59 = -1;
        }
        r13 = r57 + 1;
        r46 = r59;
      } while (r13 < r14);
    }
  } else {
    let r33 = r13 + r15 > r14 ? r14 - r15 : r13;
    while (r33 >= 0) {
      const r10 = 0 < r15;
      const r34 = r33;
      let r35 = 0;
      let r7 = true;
      if (r10) {
        do {
          const r36 = r34 + r35;
          const r0 = r35;
          const r38 = r3 === 1 ? a0[r36] : a0.readUInt16BE(r36 * r3);
          const r41 = r3 === 1 ? a1[r0] : a1.readUInt16BE(r0 * r3);
          r7 = false;
          if (r38 !== r41) {
            break;
          }
          const r42 = r0 + 1;
          r43 = r42 < r15;
          r35 = r42;
          r7 = true;
        } while (r43);
      }
      if (r7) {
        return r34;
      }
      r33 = r34 - 1;
    }
  }
  return -1;
};
utf8Slice = function utf8Slice(a0, a1, a2) {
  let r117;
  let r7 = a1;
  const r51 = Math.min(a0.length, a2);
  const r52 = [];
  const r35 = a1 < r51;
  let r39 = void 0;
  if (r35) {
    do {
      const r53 = a0[r7];
      const r54 = r53 > 239;
      const r38 = r39;
      const r4 = r7;
      const r3 = r54 ? 4 : r53 > 223 ? 3 : r53 > 191 ? 2 : 1;
      const r34 = r4 + r3 <= r51;
      let r58 = null;
      let r59 = r38;
      if (r34) {
        if (r3 === 1) {
          const r99 = r53 < 128;
          r58 = null;
          r59 = r38;
          if (r99) {
            r58 = r53;
            r59 = r38;
          }
        } else if (r3 === 2) {
          const r91 = a0[r4 + 1];
          const r92 = 192 & r91;
          let r93 = r92 === 128;
          let r94 = r38;
          if (r92 === 128) {
            const r98 = (31 & r53) << 6 | 63 & r91;
            r93 = r98 > 127;
            r94 = r98;
          }
          r58 = null;
          r59 = r94;
          if (r93) {
            r58 = r94;
            r59 = r58;
          }
        } else if (r3 === 3) {
          const r76 = a0[r4 + 1];
          const r78 = a0[r4 + 2];
          const r79 = 192 & r76;
          let r80 = r79 === 128 ? (192 & r78) === 128 : r79 === 128;
          let r82 = r38;
          if (r80) {
            const r89 = (15 & r53) << 12 | (63 & r76) << 6 | 63 & r78;
            r80 = r89 > 2047;
            r82 = r89;
          }
          if (r80) {
            r80 = r82 < 55296 || r82 > 57343;
          }
          r58 = null;
          r59 = r82;
          if (r80) {
            r58 = r82;
            r59 = r58;
          }
        } else {
          r58 = null;
          r59 = r38;
          if (r3 === 4) {
            const r49 = a0[r4 + 1];
            const r48 = a0[r4 + 2];
            const r47 = a0[r4 + 3];
            const r63 = 192 & r49;
            let r33 = (r63 === 128 ? (192 & r48) === 128 : r63 === 128) && (192 & r47) === 128;
            let r66 = r38;
            if (r33) {
              const r74 = (15 & r53) << 18 | (63 & r49) << 12 | (63 & r48) << 6 | 63 & r47;
              r33 = r74 > 65535;
              r66 = r74;
            }
            if (r33) {
              r33 = r66 < 1114112;
            }
            r58 = null;
            r59 = r66;
            if (r33) {
              r58 = r66;
              r59 = r58;
            }
          }
        }
      }
      let r100 = 1;
      let r101 = 65533;
      if (r58 !== null) {
        r100 = r3;
        r101 = r58;
        if (r101 > 65535) {
          const r102 = r58 - 65536;
          r52.push(r102 >>> 10 & 1023 | 55296);
          r101 = 56320 | 1023 & r102;
          r100 = r3;
        }
      }
      r52.push(r101);
      r7 = r4 + r100;
      r39 = r59;
    } while (r7 < r51);
  }
  const length = r52.length;
  if (length <= c493_13) {
    r117 = String.fromCharCode.apply(String, r52);
  } else {
    let r114 = 0;
    const r115 = 0 < length;
    let r116 = "";
    r117 = "";
    if (r115) {
      do {
        const fromCharCode = String.fromCharCode;
        const r120 = String;
        const r123 = r114 + c493_13;
        r116 = r116 + fromCharCode.apply(r120, r52.slice(r114, r123));
        r117 = r116;
        r114 = r123;
      } while (r114 < length);
    }
  }
  return r117;
};
utf8ToBytes = function utf8ToBytes(a0, a1) {
  let r14, r34, r45, r58, r59;
  let r36 = a1 ? a1 : Infinity;
  const length = a0.length;
  const r38 = [];
  const r33 = 0 < length;
  let r6 = 0;
  let r39 = null;
  if (r33) {
    do {
      L33: {
        L18: {
          const r43 = a0.charCodeAt(r6);
          r14 = r6;
          const r44 = r39;
          const r35 = r36;
          if (r43 > 55295 && r43 < 57344) {
            if (r44) {
              if (r43 < 56320) {
                const r100 = r35 - 3;
                r58 = r43;
                r59 = r100;
                if (!(-1 < r100)) {
                  break L33;
                }
                r38.push(239, 191, 189);
                r58 = r43;
                r59 = r100;
                break L33;
              }
              r45 = 65536 + (r44 - 55296 << 10 | r43 - 56320);
              r34 = r35;
              break L18;
            }
            if (r43 > 56319) {
              const r62 = r35 - 3;
              r58 = r44;
              r59 = r62;
              if (!(-1 < r59)) {
                break L33;
              }
              r38.push(239, 191, 189);
              r58 = r44;
              r59 = r62;
              break L33;
            }
            const r57 = r14 + 1;
            r58 = r43;
            r59 = r35;
            if (r57 !== length) {
              break L33;
            }
            const r60 = r35 - 3;
            r58 = r44;
            r59 = r60;
            if (!(-1 < r59)) {
              break L33;
            }
            r38.push(239, 191, 189);
            r58 = r44;
            r59 = r60;
            break L33;
          }
          let r53 = r44;
          let r54 = r35;
          if (r44) {
            const r0 = r35 - 3;
            r53 = r0 > -1;
            r54 = r0;
          }
          r45 = r43;
          r34 = r54;
          if (r53) {
            r38.push(239, 191, 189);
            r45 = r43;
            r34 = r54;
          }
        }
        if (r45 < 128) {
          const r97 = r34 - 1;
          if (r97 < 0) {
            break;
          }
          r38.push(r45);
          r58 = null;
          r59 = r97;
        } else if (r45 < 2048) {
          const r90 = r34 - 2;
          if (r90 < 0) {
            break;
          }
          r38.push(r45 >> 6 | 192, 63 & r45 | 128);
          r58 = null;
          r59 = r90;
        } else if (r45 < 65536) {
          const r80 = r34 - 3;
          if (r80 < 0) {
            break;
          }
          r38.push(r45 >> 12 | 224, r45 >> 6 & 63 | 128, 63 & r45 | 128);
          r58 = null;
          r59 = r80;
        } else {
          if (!(r45 < 1114112)) {
            throw new Error("Invalid code point");
          }
          const r72 = r34 - 4;
          if (r72 < 0) {
            break;
          }
          r38.push(r45 >> 18 | 240, r45 >> 12 & 63 | 128, r45 >> 6 & 63 | 128, 63 & r45 | 128);
          r58 = null;
          r59 = r72;
        }
      }
      r6 = r14 + 1;
      r39 = r58;
      r36 = r59;
    } while (r6 < length);
  }
  return r38;
};
const r15 = typeof globalThis.Symbol === "function" ? typeof Symbol.for === "function" ? Symbol.for("nodejs.util.inspect.custom") : null : null;
export { Buffer2 as Buffer };
export function SlowBuffer(a0) {
  return Buffer2.alloc(+(+a0 != a0 ? 0 : a0));
}
export const INSPECT_MAX_BYTES = 50;
c493_3 = 2147483647;
export const kMaxLength = 2147483647;
Buffer2.TYPED_ARRAY_SUPPORT = (function typedArraySupport() {
  let r20;
  try {
    const uint8Array = new Uint8Array(1);
    const r12 = {
      foo: function foo() {
        return 42;
      }
    };
    Object.setPrototypeOf(r12, Uint8Array.prototype);
    Object.setPrototypeOf(uint8Array, r12);
    r20 = uint8Array.foo();
  } catch ($e) {
    return false;
  }
  return r20 === 42;
})();
if (!(Buffer2.TYPED_ARRAY_SUPPORT || typeof globalThis.console === "undefined" || typeof console.error !== "function")) {
  console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
}
Object.defineProperty(Buffer2.prototype, "parent", {
  enumerable: true,
  get: function get() {
    if (Buffer2.isBuffer(this)) {
      return this.buffer;
    }
  }
});
Object.defineProperty(Buffer2.prototype, "offset", {
  enumerable: true,
  get: function get() {
    if (Buffer2.isBuffer(this)) {
      return this.byteOffset;
    }
  }
});
Buffer2.poolSize = 8192;
Buffer2.from = function(a0, a1, a2) {
  return from(a0, a1, a2);
};
Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
Object.setPrototypeOf(Buffer2, Uint8Array);
Buffer2.alloc = function(a0, a1, a2) {
  let r17, r45;
  if (typeof a0 !== "number") {
    throw new TypeError("\"size\" argument must be of type number");
  }
  if (a0 < 0) {
    throw new RangeError("The value \"" + a0 + "\" is invalid for option \"size\"");
  }
  if (a0 <= 0) {
    if (a0 > c493_3) {
      throw new RangeError("The value \"" + a0 + "\" is invalid for option \"size\"");
    }
    const uint8Array3 = new Uint8Array(a0);
    Object.setPrototypeOf(uint8Array3, Buffer2.prototype);
    r17 = uint8Array3;
  } else if (a1 !== void 0) {
    if (typeof a2 === "string") {
      if (a0 > c493_3) {
        throw new RangeError("The value \"" + a0 + "\" is invalid for option \"size\"");
      }
      const uint8Array2 = new Uint8Array(a0);
      Object.setPrototypeOf(uint8Array2, Buffer2.prototype);
      r45 = uint8Array2.fill(a1, a2);
    } else {
      if (a0 > c493_3) {
        throw new RangeError("The value \"" + a0 + "\" is invalid for option \"size\"");
      }
      const uint8Array = new Uint8Array(a0);
      Object.setPrototypeOf(uint8Array, Buffer2.prototype);
      r45 = uint8Array.fill(a1);
    }
    r17 = r45;
  } else {
    if (a0 > c493_3) {
      throw new RangeError("The value \"" + a0 + "\" is invalid for option \"size\"");
    }
    r17 = new Uint8Array(a0);
    Object.setPrototypeOf(r17, Buffer2.prototype);
  }
  return r17;
};
Buffer2.allocUnsafe = function(a0) {
  return allocUnsafe(a0);
};
Buffer2.allocUnsafeSlow = function(a0) {
  return allocUnsafe(a0);
};
Buffer2.isBuffer = function isBuffer(a0) {
  return a0 != null && a0._isBuffer === true && a0 !== Buffer2.prototype;
};
Buffer2.compare = function compare(a0, a1) {
  const r10 = Uint8Array;
  const r28 = a0 instanceof r10 || a0 != null && a0.constructor != null && a0.constructor.name != null && a0.constructor.name === r10.name ? Buffer2.from(a0, a0.offset, a0.byteLength) : a0;
  const r29 = Uint8Array;
  const r39 = a1 instanceof r29 || a1 != null && a1.constructor != null && a1.constructor.name != null && a1.constructor.name === r29.name ? Buffer2.from(a1, a1.offset, a1.byteLength) : a1;
  if (Buffer2.isBuffer(r28) && Buffer2.isBuffer(r39)) {
    if (r28 === r39) {
      return 0;
    }
    const length = r28.length;
    const length2 = r39.length;
    const r57 = Math.min(length, length2);
    const r58 = 0 < r57;
    let r0 = 0;
    let r59 = length2;
    let r60 = length;
    if (r58) {
      do {
        const r61 = r28[r0];
        const r62 = r39[r0];
        const r1 = r0;
        if (r61 !== r62) {
          r60 = r28[r1];
          r59 = r39[r1];
          break;
        }
        r0 = r1 + 1;
        r59 = length2;
        r60 = length;
      } while (r0 < r57);
    }
    return r60 < r59 ? -1 : r59 < r60 ? 1 : 0;
  }
  throw new TypeError("The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array");
};
Buffer2.isEncoding = function isEncoding(a0) {
  switch (String(a0).toLowerCase()) {
    case "hex":
    case "utf8":
    case "utf-8":
    case "ascii":
    case "latin1":
    case "binary":
    case "base64":
    case "ucs2":
    case "ucs-2":
    case "utf16le":
    case "utf-16le":
      return true;
    default:
      return false;
  }
};
Buffer2.concat = function concat(a0, a1) {
  let length;
  if (Array.isArray(a0)) {
    if (a0.length === 0) {
      return Buffer2.alloc(0);
    }
    let r11 = a1;
    if (a1 === void 0) {
      const r28 = 0 < a0.length;
      let r0 = 0;
      let r29 = 0;
      r11 = 0;
      if (r28) {
        do {
          r29 = r29 + a0[r0].length;
          r0 = r0 + 1;
          length = a0.length;
          r11 = r29;
        } while (r0 < length);
      }
    }
    const r35 = Buffer2.allocUnsafe(r11);
    const r5 = 0 < a0.length;
    let r39 = 0;
    let r40 = 0;
    if (r5) {
      do {
        const r17 = a0[r40];
        const r41 = Uint8Array;
        let r42 = r17 instanceof r41;
        const r14 = r39;
        const r2 = r40;
        if (!r42) {
          r42 = r17 != null && r17.constructor != null && r17.constructor.name != null && r17.constructor.name === r41.name;
        }
        const r48 = r42 ? Buffer2.from(r17) : r17;
        if (!Buffer2.isBuffer(r48)) {
          throw new TypeError("\"list\" argument must be an Array of Buffers");
        }
        r48.copy(r35, r14);
        r39 = r14 + r48.length;
        r40 = r2 + 1;
      } while (r40 < a0.length);
    }
    return r35;
  }
  throw new TypeError("\"list\" argument must be an Array of Buffers");
};
Buffer2.byteLength = byteLength;
Buffer2.prototype._isBuffer = true;
Buffer2.prototype.swap16 = function swap16() {
  const length = this.length;
  if (length % 2 !== 0) {
    throw new RangeError("Buffer size must be a multiple of 16-bits");
  }
  const r4 = 0 < length;
  let r12 = 0;
  if (r4) {
    do {
      const r1 = r12 + 1;
      const r7 = this[r12];
      this[r12] = this[r1];
      this[r1] = r7;
      r12 = r12 + 2;
    } while (r12 < length);
  }
  return this;
};
Buffer2.prototype.swap32 = function swap32() {
  const length = this.length;
  if (length % 4 !== 0) {
    throw new RangeError("Buffer size must be a multiple of 32-bits");
  }
  const r7 = 0 < length;
  let r15 = 0;
  if (r7) {
    do {
      const r1 = r15 + 3;
      const r10 = this[r15];
      this[r15] = this[r1];
      this[r1] = r10;
      const r2 = r15 + 1;
      const r16 = r15 + 2;
      const r17 = this[r2];
      this[r2] = this[r16];
      this[r16] = r17;
      r15 = r15 + 4;
    } while (r15 < length);
  }
  return this;
};
Buffer2.prototype.swap64 = function swap64() {
  const length = this.length;
  if (length % 8 !== 0) {
    throw new RangeError("Buffer size must be a multiple of 64-bits");
  }
  const r11 = 0 < length;
  let r19 = 0;
  if (r11) {
    do {
      const r1 = r19 + 7;
      const r14 = this[r19];
      this[r19] = this[r1];
      this[r1] = r14;
      const r2 = r19 + 1;
      const r20 = r19 + 6;
      const r21 = this[r2];
      this[r2] = this[r20];
      this[r20] = r21;
      const r23 = r19 + 2;
      const r24 = r19 + 5;
      const r25 = this[r23];
      this[r23] = this[r24];
      this[r24] = r25;
      const r27 = r19 + 3;
      const r28 = r19 + 4;
      const r29 = this[r27];
      this[r27] = this[r28];
      this[r28] = r29;
      r19 = r19 + 8;
    } while (r19 < length);
  }
  return this;
};
Buffer2.prototype.toString = function toString() {
  const length = this.length;
  return length !== 0 ? arguments.length === 0 ? utf8Slice(this, 0, length) : slowToString.apply(this, arguments) : "";
};
Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
Buffer2.prototype.equals = function equals(a0) {
  if (Buffer2.isBuffer(a0)) {
    return this === a0 || Buffer2.compare(this, a0) === 0;
  }
  throw new TypeError("Argument must be a Buffer");
};
Buffer2.prototype.inspect = function inspect() {
  const INSPECT_MAX_BYTES = exports.INSPECT_MAX_BYTES;
  const r13 = this.toString("hex", 0, INSPECT_MAX_BYTES).replace(/(.{2})/g, "$1 ").trim();
  return "<Buffer " + (this.length > INSPECT_MAX_BYTES ? r13 + " ... " : r13) + ">";
};
if (r15) {
  Buffer2.prototype[r15] = Buffer2.prototype.inspect;
}
Buffer2.prototype.compare = function compare(a0, a1, a2, a3, a4) {
  const r12 = Uint8Array;
  const r29 = a0 instanceof r12 || a0 != null && a0.constructor != null && a0.constructor.name != null && a0.constructor.name === r12.name ? Buffer2.from(a0, a0.offset, a0.byteLength) : a0;
  if (Buffer2.isBuffer(r29)) {
    const r39 = a1 === void 0 ? 0 : a1;
    const r41 = a2 === void 0 ? r29 ? r29.length : 0 : a2;
    const r43 = a3 === void 0 ? 0 : a3;
    const r45 = a4 === void 0 ? this.length : a4;
    if (!(r39 < 0) && !(r41 > r29.length) && !(r43 < 0) && !(r45 > this.length)) {
      if (r43 >= r45 && r39 >= r41) {
        return 0;
      }
      if (r43 >= r45) {
        return -1;
      }
      if (r39 >= r41) {
        return 1;
      }
      if (this === r29) {
        return 0;
      }
      const r6 = r45 >>> 0;
      const r2 = r43 >>> 0;
      const r3 = r6 - r2;
      const r0 = r41 >>> 0;
      const r1 = r39 >>> 0;
      const r4 = r0 - r1;
      const r50 = Math.min(r3, r4);
      const r52 = this.slice(r2, r6);
      const r54 = r29.slice(r1, r0);
      const r55 = 0 < r50;
      let r57 = 0;
      let r58 = r4;
      let r59 = r3;
      if (r55) {
        do {
          const r60 = r52[r57];
          const r61 = r54[r57];
          const r62 = r57;
          if (r60 !== r61) {
            r59 = r52[r62];
            r58 = r54[r62];
            break;
          }
          r57 = r62 + 1;
          r58 = r4;
          r59 = r3;
        } while (r57 < r50);
      }
      return r59 < r58 ? -1 : r58 < r59 ? 1 : 0;
    }
    throw new RangeError("out of range index");
  }
  throw new TypeError("The \"target\" argument must be one of type Buffer or Uint8Array. Received type " + typeof r29);
};
Buffer2.prototype.includes = function includes(a0, a1, a2) {
  return this.indexOf(a0, a1, a2) !== -1;
};
Buffer2.prototype.indexOf = function indexOf(a0, a1, a2) {
  return bidirectionalIndexOf(this, a0, a1, a2, true);
};
Buffer2.prototype.lastIndexOf = function lastIndexOf(a0, a1, a2) {
  return bidirectionalIndexOf(this, a0, a1, a2, false);
};
Buffer2.prototype.write = function write(a0, a1, a2, a3) {
  let r4, r37, r94, r203, length, length10, length12, length4, length6, length8;
  L10: {
    if (a1 === void 0) {
      length = this.length;
      r37 = "utf8";
      r4 = 0;
    } else {
      if (a2 === void 0 && typeof a1 === "string") {
        length = this.length;
        r4 = 0;
        r37 = a1;
        break L10;
      }
      if (!isFinite(a1)) {
        throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
      }
      const r7 = a1 >>> 0;
      const isFinite2 = isFinite(a2);
      r37 = a2;
      length = void 0;
      r4 = r7;
      if (isFinite2) {
        r37 = a3;
        length = a2 >>> 0;
        r4 = r7;
        if (a3 === void 0) {
          r37 = "utf8";
          length = length;
          r4 = r7;
        }
      }
    }
  }
  const r41 = this.length - r4;
  if (length === void 0 || length > r41) {
    length = r41;
  }
  L84: {
    if (a0.length > 0) {
      if (length < 0) {
        break L84;
      }
      if (r4 < 0) {
        break L84;
      }
    }
    if (!(r4 > this.length)) {
      if (!r37) {
        r37 = "utf8";
      }
      let r10 = false;
      while (true) {
        const r14 = r10;
        const r46 = r37;
        switch (r46) {
          case "hex":
            const r184 = Number(r4) || 0;
            const r186 = this.length - r184;
            let r187 = r186;
            if (length) {
              r187 = Number(length);
              if (r187 > r186) {
                r187 = r186;
              }
            }
            const length13 = a0.length;
            if (r187 > length13 / 2) {
              r187 = length13 / 2;
            }
            L80: {
              const r192 = 0 < r187;
              let r195 = 0;
              let r196 = 0;
              if (r192) {
                do {
                  const r201 = parseInt(a0.substr(2 * r195, 2), 16);
                  const r202 = r195;
                  r203 = r202;
                  if (r201 != r201) {
                    break L80;
                  }
                  this[r184 + r202] = r201;
                  r195 = r202 + 1;
                  r196 = r195;
                } while (r196 < r187);
              }
              r203 = r196;
            }
            return r203;
          case "utf8":
          case "utf-8":
            const r166 = utf8ToBytes(a0, this.length - r4);
            const r167 = 0 < length;
            let r168 = 0;
            if (r167) {
              const r171 = 0 + r4 >= this.length;
              r168 = 0;
              if (!r171) {
                const r173 = 0 >= r166.length;
                let r175 = 0;
                r168 = 0;
                if (!r173) {
                  do {
                    this[r175 + r4] = r166[r175];
                    const r178 = r175 + 1;
                    r168 = r178;
                    if (!(r178 < length)) {
                      break;
                    }
                    const length11 = this.length;
                    const r180 = r178 + r4;
                    r168 = r178;
                    if (r180 >= length11) {
                      break;
                    }
                    length12 = r166.length;
                    r175 = r178;
                    r168 = r175;
                  } while (!(r168 >= length12));
                }
              }
            }
            return r168;
          case "ascii":
            const r137 = [];
            const r139 = 0 < a0.length;
            let r142 = 0;
            if (r139) {
              do {
                r137.push(255 & a0.charCodeAt(r142));
                r142 = r142 + 1;
              } while (r142 < a0.length);
            }
            const r149 = 0 < length;
            let r150 = 0;
            if (r149) {
              const r153 = 0 + r4 >= this.length;
              r150 = 0;
              if (!r153) {
                const r155 = 0 >= r137.length;
                let r156 = 0;
                r150 = 0;
                if (!r155) {
                  do {
                    this[r156 + r4] = r137[r156];
                    const r159 = r156 + 1;
                    r150 = r159;
                    if (!(r159 < length)) {
                      break;
                    }
                    const length9 = this.length;
                    const r161 = r159 + r4;
                    r150 = r159;
                    if (r161 >= length9) {
                      break;
                    }
                    length10 = r137.length;
                    r156 = r159;
                    r150 = r156;
                  } while (!(r150 >= length10));
                }
              }
            }
            return r150;
          case "latin1":
          case "binary":
            const r111 = [];
            const r113 = 0 < a0.length;
            let r116 = 0;
            if (r113) {
              do {
                r111.push(255 & a0.charCodeAt(r116));
                r116 = r116 + 1;
              } while (r116 < a0.length);
            }
            const r123 = 0 < length;
            let r124 = 0;
            if (r123) {
              const r127 = 0 + r4 >= this.length;
              r124 = 0;
              if (!r127) {
                const r129 = 0 >= r111.length;
                let r130 = 0;
                r124 = 0;
                if (!r129) {
                  do {
                    this[r130 + r4] = r111[r130];
                    const r133 = r130 + 1;
                    r124 = r133;
                    if (!(r133 < length)) {
                      break;
                    }
                    const length7 = this.length;
                    const r135 = r133 + r4;
                    r124 = r133;
                    if (r135 >= length7) {
                      break;
                    }
                    length8 = r111.length;
                    r130 = r133;
                    r124 = r130;
                  } while (!(r124 >= length8));
                }
              }
            }
            return r124;
          case "base64":
            const r27 = a0.split("=")[0].trim();
            let r83 = "";
            const r84 = r27.replace(c493_14, "");
            if (!(r84.length < 2)) {
              const r90 = r84.length % 4;
              let r91 = r84;
              let r92 = r91;
              if (r90 !== 0) {
                do {
                  const r93 = r91 + "=";
                  r94 = r93.length % 4;
                  r91 = r93;
                  r92 = r91;
                } while (r94 !== 0);
              }
              r83 = r92;
            }
            const r95 = toByteArray(r83);
            const r96 = 0 < length;
            let r97 = 0;
            if (r96) {
              const r100 = 0 + r4 >= this.length;
              r97 = 0;
              if (!r100) {
                const r102 = 0 >= r95.length;
                let r104 = 0;
                r97 = 0;
                if (!r102) {
                  do {
                    this[r104 + r4] = r95[r104];
                    const r107 = r104 + 1;
                    r97 = r107;
                    if (!(r107 < length)) {
                      break;
                    }
                    const length5 = this.length;
                    const r109 = r107 + r4;
                    r97 = r107;
                    if (r109 >= length5) {
                      break;
                    }
                    length6 = r95.length;
                    r104 = r107;
                    r97 = r104;
                  } while (!(r97 >= length6));
                }
              }
            }
            return r97;
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            const r48 = this.length - r4;
            const r49 = [];
            if (0 < a0.length) {
              let r5 = r48 - 2;
              let r51 = 0;
              while (!(r5 < 0)) {
                const r53 = a0.charCodeAt(r51);
                const r6 = r53 >> 8;
                r49.push(r53 % 256);
                r49.push(r6);
                const r58 = r51 + 1;
                const length2 = a0.length;
                const r60 = r5;
                if (!(r58 < length2)) {
                  break;
                }
                r5 = r60 - 2;
                r51 = r58;
              }
            }
            const r12 = 0 < length;
            let r61 = 0;
            if (r12) {
              const r64 = 0 + r4 >= this.length;
              r61 = 0;
              if (!r64) {
                const r66 = 0 >= r49.length;
                let r68 = 0;
                r61 = 0;
                if (!r66) {
                  do {
                    this[r68 + r4] = r49[r68];
                    const r71 = r68 + 1;
                    r61 = r71;
                    if (!(r71 < length)) {
                      break;
                    }
                    const length3 = this.length;
                    const r73 = r71 + r4;
                    r61 = r71;
                    if (r73 >= length3) {
                      break;
                    }
                    length4 = r49.length;
                    r68 = r71;
                    r61 = r68;
                  } while (!(r61 >= length4));
                }
              }
            }
            return r61;
          default:
            if (r14) {
              throw new TypeError("Unknown encoding: " + r46);
            }
            r37 = ("" + r46).toLowerCase();
            r10 = true;
        }
      }
    }
  }
  throw new RangeError("Attempt to write outside buffer bounds");
};
Buffer2.prototype.toJSON = function toJSON() {
  return {
    type: "Buffer",
    data: Array.prototype.slice.call(this._arr || this, 0)
  };
};
c493_13 = 4096;
Buffer2.prototype.slice = function slice(a0, a1) {
  let r5, r11;
  const length = this.length;
  const r8 = ~~a0;
  if (r8 < 0) {
    r5 = r8 + length;
    if (r5 < 0) {
      r5 = 0;
    }
  } else {
    r5 = r8;
    if (r5 > length) {
      r5 = length;
    }
  }
  const r9 = a1 !== void 0 ? ~~a1 : length;
  if (r9 < 0) {
    r11 = r9 + length;
    if (r11 < 0) {
      r11 = 0;
    }
  } else {
    r11 = r9;
    if (r11 > length) {
      r11 = length;
    }
  }
  if (r11 < r5) {
    r11 = r5;
  }
  const r14 = this.subarray(r5, r11);
  Object.setPrototypeOf(r14, Buffer2.prototype);
  return r14;
};
Buffer2.prototype.readUIntLE = function readUIntLE(a0, a1, a2) {
  let r4, r7;
  L6: {
    r4 = a0 >>> 0;
    r7 = a1 >>> 0;
    if (!a2) {
      const length = this.length;
      if (r4 % 1 === 0 && !(r4 < 0)) {
        if (!(r4 + r7 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  let r29 = this[r4];
  let r30 = 256;
  let r31 = r29;
  let r32 = 1;
  if (1 < r7) {
    do {
      const r35 = r29 + this[r4 + r32] * r30;
      const r3 = r32 + 1;
      const r36 = r30;
      r31 = r35;
      if (!(r3 < r7)) {
        break;
      }
      r30 = r36 * 256;
      r32 = r3;
      r29 = r35;
      r31 = r29;
    } while (r30);
  }
  return r31;
};
Buffer2.prototype.readUIntBE = function readUIntBE(a0, a1, a2) {
  let r0, r5;
  L6: {
    r5 = a0 >>> 0;
    r0 = a1 >>> 0;
    if (!a2) {
      const length = this.length;
      if (r5 % 1 === 0 && !(r5 < 0)) {
        if (!(r5 + r0 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  let r2 = r0 - 1;
  let r30 = this[r5 + r2];
  let r32 = 256;
  let r33 = r30;
  if (0 < r2) {
    do {
      const r3 = r2 - 1;
      const r36 = r30 + this[r5 + r3] * r32;
      const r37 = r32;
      r33 = r36;
      if (!(0 < r3)) {
        break;
      }
      r32 = r37 * 256;
      r30 = r36;
      r2 = r3;
      r33 = r30;
    } while (r32);
  }
  return r33;
};
Buffer2.prototype.readUInt8 = function readUInt8(a0, a1) {
  let r1;
  L6: {
    r1 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r1 % 1 === 0 && !(r1 < 0)) {
        if (!(r1 + 1 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return this[r1];
};
Buffer2.prototype.readUInt16LE = function readUInt16LE(a0, a1) {
  let r1;
  L6: {
    r1 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r1 % 1 === 0 && !(r1 < 0)) {
        if (!(r1 + 2 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return this[r1] | this[r1 + 1] << 8;
};
Buffer2.prototype.readUInt16BE = function readUInt16BE(a0, a1) {
  let r2;
  L6: {
    r2 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r2 % 1 === 0 && !(r2 < 0)) {
        if (!(r2 + 2 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return this[r2] << 8 | this[r2 + 1];
};
Buffer2.prototype.readUInt32LE = function readUInt32LE(a0, a1) {
  let r2;
  L6: {
    r2 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r2 % 1 === 0 && !(r2 < 0)) {
        if (!(r2 + 4 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return (this[r2] | this[r2 + 1] << 8 | this[r2 + 2] << 16) + 16777216 * this[r2 + 3];
};
Buffer2.prototype.readUInt32BE = function readUInt32BE(a0, a1) {
  let r1;
  L6: {
    r1 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r1 % 1 === 0 && !(r1 < 0)) {
        if (!(r1 + 4 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return 16777216 * this[r1] + (this[r1 + 1] << 16 | this[r1 + 2] << 8 | this[r1 + 3]);
};
Buffer2.prototype.readIntLE = function readIntLE(a0, a1, a2) {
  let r5, r8;
  L6: {
    r5 = a0 >>> 0;
    r8 = a1 >>> 0;
    if (!a2) {
      const length = this.length;
      if (r5 % 1 === 0 && !(r5 < 0)) {
        if (!(r5 + r8 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  let r31 = this[r5];
  let r2 = 1;
  let r32 = 256;
  let r33 = r31;
  let r34 = 1;
  if (1 < r8) {
    do {
      const r37 = r31 + this[r5 + r2] * r32;
      const r4 = r2 + 1;
      const r38 = r32;
      r34 = r38;
      r33 = r37;
      if (!(r4 < r8)) {
        break;
      }
      r32 = r38 * 256;
      r2 = r4;
      r31 = r37;
      r33 = r31;
      r34 = r32;
    } while (r34);
  }
  const r40 = r34 * 128;
  let r41 = r33;
  if (r41 >= r40) {
    r41 = r33 - Math.pow(2, 8 * r8);
  }
  return r41;
};
Buffer2.prototype.readIntBE = function readIntBE(a0, a1, a2) {
  let r5, r8;
  L6: {
    r5 = a0 >>> 0;
    r8 = a1 >>> 0;
    if (!a2) {
      const length = this.length;
      if (r5 % 1 === 0 && !(r5 < 0)) {
        if (!(r5 + r8 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  let r2 = r8 - 1;
  let r33 = this[r5 + r2];
  let r34 = 256;
  let r35 = r33;
  let r4 = 1;
  if (0 < r2) {
    do {
      const r3 = r2 - 1;
      const r38 = r33 + this[r5 + r3] * r34;
      const r39 = r34;
      r35 = r38;
      r4 = r39;
      if (!(0 < r3)) {
        break;
      }
      r34 = r39 * 256;
      r33 = r38;
      r2 = r3;
      r35 = r33;
      r4 = r34;
    } while (r4);
  }
  const r41 = r4 * 128;
  let r42 = r35;
  if (r42 >= r41) {
    r42 = r35 - Math.pow(2, 8 * r8);
  }
  return r42;
};
Buffer2.prototype.readInt8 = function readInt8(a0, a1) {
  let r1;
  L6: {
    r1 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r1 % 1 === 0 && !(r1 < 0)) {
        if (!(r1 + 1 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  const r25 = 128 & this[r1];
  const r26 = this[r1];
  return r25 ? -1 * (255 - r26 + 1) : r26;
};
Buffer2.prototype.readInt16LE = function readInt16LE(a0, a1) {
  let r1;
  L6: {
    r1 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r1 % 1 === 0 && !(r1 < 0)) {
        if (!(r1 + 2 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  const r30 = this[r1] | this[r1 + 1] << 8;
  return 32768 & r30 ? 4294901760 | r30 : r30;
};
Buffer2.prototype.readInt16BE = function readInt16BE(a0, a1) {
  let r0;
  L6: {
    r0 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r0 % 1 === 0 && !(r0 < 0)) {
        if (!(r0 + 2 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  const r30 = this[r0 + 1] | this[r0] << 8;
  return 32768 & r30 ? 4294901760 | r30 : r30;
};
Buffer2.prototype.readInt32LE = function readInt32LE(a0, a1) {
  let r2;
  L6: {
    r2 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r2 % 1 === 0 && !(r2 < 0)) {
        if (!(r2 + 4 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return this[r2] | this[r2 + 1] << 8 | this[r2 + 2] << 16 | this[r2 + 3] << 24;
};
Buffer2.prototype.readInt32BE = function readInt32BE(a0, a1) {
  let r2;
  L6: {
    r2 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r2 % 1 === 0 && !(r2 < 0)) {
        if (!(r2 + 4 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return this[r2] << 24 | this[r2 + 1] << 16 | this[r2 + 2] << 8 | this[r2 + 3];
};
Buffer2.prototype.readFloatLE = function readFloatLE(a0, a1) {
  let r2;
  L6: {
    r2 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r2 % 1 === 0 && !(r2 < 0)) {
        if (!(r2 + 4 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return read(this, r2, true, 23, 4);
};
Buffer2.prototype.readFloatBE = function readFloatBE(a0, a1) {
  let r2;
  L6: {
    r2 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r2 % 1 === 0 && !(r2 < 0)) {
        if (!(r2 + 4 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return read(this, r2, false, 23, 4);
};
Buffer2.prototype.readDoubleLE = function readDoubleLE(a0, a1) {
  let r2;
  L6: {
    r2 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r2 % 1 === 0 && !(r2 < 0)) {
        if (!(r2 + 8 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return read(this, r2, true, 52, 8);
};
Buffer2.prototype.readDoubleBE = function readDoubleBE(a0, a1) {
  let r2;
  L6: {
    r2 = a0 >>> 0;
    if (!a1) {
      const length = this.length;
      if (r2 % 1 === 0 && !(r2 < 0)) {
        if (!(r2 + 8 > length)) {
          break L6;
        }
        throw new RangeError("Trying to access beyond buffer length");
      }
      throw new RangeError("offset is not uint");
    }
  }
  return read(this, r2, false, 52, 8);
};
Buffer2.prototype.writeUIntLE = function writeUIntLE(a0, a1, a2, a3) {
  let r5, r6, r9;
  L8: {
    r6 = +a0;
    r5 = a1 >>> 0;
    r9 = a2 >>> 0;
    if (!a3) {
      const r25 = Math.pow(2, 8 * r9) - 1;
      if (Buffer2.isBuffer(this)) {
        if (!(r25 < r6) && !(r6 < 0)) {
          if (!(r5 + r9 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r5] = 255 & r6;
  let r49 = 256;
  let r50 = 1;
  if (1 < r9) {
    do {
      this[r5 + r50] = r6 / r49 & 255;
      const r52 = r50 + 1;
      const r53 = r49;
      if (!(r52 < r9)) {
        break;
      }
      r49 = r53 * 256;
      r50 = r52;
    } while (r49);
  }
  return r5 + r9;
};
Buffer2.prototype.writeUIntBE = function writeUIntBE(a0, a1, a2, a3) {
  let r5, r7, r9;
  L8: {
    r7 = +a0;
    r5 = a1 >>> 0;
    r9 = a2 >>> 0;
    if (!a3) {
      const r26 = Math.pow(2, 8 * r9) - 1;
      if (Buffer2.isBuffer(this)) {
        if (!(r26 < r7) && !(r7 < 0)) {
          if (!(r5 + r9 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  const r48 = r9 - 1;
  this[r5 + r48] = 255 & r7;
  let r50 = r48 - 1;
  let r52 = 256;
  if (0 <= r50) {
    do {
      this[r5 + r50] = r7 / r52 & 255;
      const r54 = r50 - 1;
      const r55 = r52;
      if (!(0 <= r54)) {
        break;
      }
      r52 = r55 * 256;
      r50 = r54;
    } while (r52);
  }
  return r5 + r9;
};
Buffer2.prototype.writeUInt8 = function writeUInt8(a0, a1, a2) {
  let r1, r2;
  L8: {
    r2 = +a0;
    r1 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(255 < r2) && !(r2 < 0)) {
          if (!(r1 + 1 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r1] = 255 & r2;
  return r1 + 1;
};
Buffer2.prototype.writeUInt16LE = function writeUInt16LE(a0, a1, a2) {
  let r1, r2;
  L8: {
    r1 = +a0;
    r2 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(65535 < r1) && !(r1 < 0)) {
          if (!(r2 + 2 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r2] = 255 & r1;
  this[r2 + 1] = r1 >>> 8;
  return r2 + 2;
};
Buffer2.prototype.writeUInt16BE = function writeUInt16BE(a0, a1, a2) {
  let r1, r2;
  L8: {
    r1 = +a0;
    r2 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(65535 < r1) && !(r1 < 0)) {
          if (!(r2 + 2 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r2] = r1 >>> 8;
  this[r2 + 1] = 255 & r1;
  return r2 + 2;
};
Buffer2.prototype.writeUInt32LE = function writeUInt32LE(a0, a1, a2) {
  let r1, r2;
  L8: {
    r2 = +a0;
    r1 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(4294967295 < r2) && !(r2 < 0)) {
          if (!(r1 + 4 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r1 + 3] = r2 >>> 24;
  this[r1 + 2] = r2 >>> 16;
  this[r1 + 1] = r2 >>> 8;
  this[r1] = 255 & r2;
  return r1 + 4;
};
Buffer2.prototype.writeUInt32BE = function writeUInt32BE(a0, a1, a2) {
  let r1, r2;
  L8: {
    r1 = +a0;
    r2 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(4294967295 < r1) && !(r1 < 0)) {
          if (!(r2 + 4 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r2] = r1 >>> 24;
  this[r2 + 1] = r1 >>> 16;
  this[r2 + 2] = r1 >>> 8;
  this[r2 + 3] = 255 & r1;
  return r2 + 4;
};
Buffer2.prototype.writeIntLE = function writeIntLE(a0, a1, a2, a3) {
  let r9, r10;
  L8: {
    r10 = +a0;
    r9 = a1 >>> 0;
    if (!a3) {
      const r32 = Math.pow(2, 8 * a2 - 1);
      const r33 = r32 - 1;
      const r34 = -r32;
      if (Buffer2.isBuffer(this)) {
        if (!(r33 < r10) && !(r10 < r34)) {
          if (!(r9 + a2 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r9] = 255 & r10;
  const r14 = 1 < a2;
  const r15 = r10 < 0;
  let r56 = 0;
  let r57 = 256;
  let r58 = 1;
  if (r14) {
    do {
      let r0 = r56;
      const r7 = r57;
      const r2 = r58;
      if ((r10 < 0 ? r0 === 0 : r15) && this[r9 + r2 - 1] !== 0) {
        r0 = 1;
      }
      this[r9 + r2] = (r10 / r7 | 0) - r0 & 255;
      const r66 = r2 + 1;
      if (!(r66 < a2)) {
        break;
      }
      r57 = r7 * 256;
      r56 = r0;
      r58 = r66;
    } while (r57);
  }
  return r9 + a2;
};
Buffer2.prototype.writeIntBE = function writeIntBE(a0, a1, a2, a3) {
  let r9, r11;
  L8: {
    r11 = +a0;
    r9 = a1 >>> 0;
    if (!a3) {
      const r32 = Math.pow(2, 8 * a2 - 1);
      const r33 = r32 - 1;
      const r34 = -r32;
      if (Buffer2.isBuffer(this)) {
        if (!(r33 < r11) && !(r11 < r34)) {
          if (!(r9 + a2 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  const r55 = a2 - 1;
  this[r9 + r55] = 255 & r11;
  let r5 = r55 - 1;
  const r15 = r11 < 0;
  let r59 = 256;
  let r60 = 0;
  if (0 <= r5) {
    do {
      let r0 = r60;
      const r7 = r59;
      const r2 = r5;
      if ((r11 < 0 ? r0 === 0 : r15) && this[r9 + r2 + 1] !== 0) {
        r0 = 1;
      }
      this[r9 + r2] = (r11 / r7 | 0) - r0 & 255;
      const r67 = r2 - 1;
      if (!(0 <= r67)) {
        break;
      }
      r59 = r7 * 256;
      r60 = r0;
      r5 = r67;
    } while (r59);
  }
  return r9 + a2;
};
Buffer2.prototype.writeInt8 = function writeInt8(a0, a1, a2) {
  let r2, r3;
  L8: {
    r2 = +a0;
    r3 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(127 < r2) && !(r2 < -128)) {
          if (!(r3 + 1 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  let r38 = r2;
  if (r38 < 0) {
    r38 = 255 + r2 + 1;
  }
  this[r3] = 255 & r38;
  return r3 + 1;
};
Buffer2.prototype.writeInt16LE = function writeInt16LE(a0, a1, a2) {
  let r1, r2;
  L8: {
    r1 = +a0;
    r2 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(32767 < r1) && !(r1 < -32768)) {
          if (!(r2 + 2 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r2] = 255 & r1;
  this[r2 + 1] = r1 >>> 8;
  return r2 + 2;
};
Buffer2.prototype.writeInt16BE = function writeInt16BE(a0, a1, a2) {
  let r1, r2;
  L8: {
    r1 = +a0;
    r2 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(32767 < r1) && !(r1 < -32768)) {
          if (!(r2 + 2 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r2] = r1 >>> 8;
  this[r2 + 1] = 255 & r1;
  return r2 + 2;
};
Buffer2.prototype.writeInt32LE = function writeInt32LE(a0, a1, a2) {
  let r1, r2;
  L8: {
    r1 = +a0;
    r2 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(2147483647 < r1) && !(r1 < -2147483648)) {
          if (!(r2 + 4 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  this[r2] = 255 & r1;
  this[r2 + 1] = r1 >>> 8;
  this[r2 + 2] = r1 >>> 16;
  this[r2 + 3] = r1 >>> 24;
  return r2 + 4;
};
Buffer2.prototype.writeInt32BE = function writeInt32BE(a0, a1, a2) {
  let r2, r4;
  L8: {
    r4 = +a0;
    r2 = a1 >>> 0;
    if (!a2) {
      if (Buffer2.isBuffer(this)) {
        if (!(2147483647 < r4) && !(r4 < -2147483648)) {
          if (!(r2 + 4 > this.length)) {
            break L8;
          }
          throw new RangeError("Index out of range");
        }
        throw new RangeError("\"value\" argument is out of bounds");
      }
      throw new TypeError("\"buffer\" argument must be a Buffer instance");
    }
  }
  let r38 = r4;
  if (r38 < 0) {
    r38 = 4294967295 + r4 + 1;
  }
  this[r2] = r38 >>> 24;
  this[r2 + 1] = r38 >>> 16;
  this[r2 + 2] = r38 >>> 8;
  this[r2 + 3] = 255 & r38;
  return r2 + 4;
};
Buffer2.prototype.writeFloatLE = function writeFloatLE(a0, a1, a2) {
  const r3 = +a0;
  const r2 = a1 >>> 0;
  if (!a2) {
    if (r2 + 4 > this.length) {
      throw new RangeError("Index out of range");
    }
    if (r2 < 0) {
      throw new RangeError("Index out of range");
    }
  }
  _Module512.write(this, r3, r2, true, 23, 4);
  return r2 + 4;
};
Buffer2.prototype.writeFloatBE = function writeFloatBE(a0, a1, a2) {
  const r3 = +a0;
  const r2 = a1 >>> 0;
  if (!a2) {
    if (r2 + 4 > this.length) {
      throw new RangeError("Index out of range");
    }
    if (r2 < 0) {
      throw new RangeError("Index out of range");
    }
  }
  _Module512.write(this, r3, r2, false, 23, 4);
  return r2 + 4;
};
Buffer2.prototype.writeDoubleLE = function writeDoubleLE(a0, a1, a2) {
  const r3 = +a0;
  const r2 = a1 >>> 0;
  if (!a2) {
    if (r2 + 8 > this.length) {
      throw new RangeError("Index out of range");
    }
    if (r2 < 0) {
      throw new RangeError("Index out of range");
    }
  }
  _Module512.write(this, r3, r2, true, 52, 8);
  return r2 + 8;
};
Buffer2.prototype.writeDoubleBE = function writeDoubleBE(a0, a1, a2) {
  const r3 = +a0;
  const r2 = a1 >>> 0;
  if (!a2) {
    if (r2 + 8 > this.length) {
      throw new RangeError("Index out of range");
    }
    if (r2 < 0) {
      throw new RangeError("Index out of range");
    }
  }
  _Module512.write(this, r3, r2, false, 52, 8);
  return r2 + 8;
};
Buffer2.prototype.copy = function copy(a0, a1, a2, a3) {
  let r38;
  if (Buffer2.isBuffer(a0)) {
    const r11 = a2 ? a2 : 0;
    let r10 = (a3 ? a3 : a3 === 0) ? a3 : this.length;
    const r27 = (a1 >= a0.length ? a0.length : a1) || 0;
    if (r10 > 0 && r10 < r11) {
      r10 = r11;
    }
    if (r10 === r11) {
      return 0;
    }
    if (a0.length !== 0 && this.length !== 0) {
      if (r27 < 0) {
        throw new RangeError("targetStart out of bounds");
      }
      if (!(r11 < 0) && !(r11 >= this.length)) {
        if (r10 < 0) {
          throw new RangeError("sourceEnd out of bounds");
        }
        if (r10 > this.length) {
          r10 = this.length;
        }
        if (a0.length - r27 < r10 - r11) {
          r10 = a0.length - r27 + r11;
        }
        L39: {
          r38 = r10 - r11;
          const r39 = this === a0;
          if (r39 && typeof Uint8Array.prototype.copyWithin === "function") {
            this.copyWithin(r27, r11, r10);
          } else {
            if (r39 && r11 < r27 && r27 < r10) {
              let r0 = r38 - 1;
              if (!(0 <= r0)) {
                break L39;
              }
              while (true) {
                a0[r0 + r27] = this[r0 + r11];
                r0 = r0 - 1;
                if (!(0 <= r0)) {
                  break L39;
                }
              }
            }
            Uint8Array.prototype.set.call(a0, this.subarray(r11, r10), r27);
          }
        }
        return r38;
      }
      throw new RangeError("Index out of range");
    }
    return 0;
  }
  throw new TypeError("argument should be a Buffer");
};
Buffer2.prototype.fill = function fill(a0, a1, a2, a3) {
  let r8, r9, r11, r13, r14, length;
  let r16 = a3;
  if (typeof a0 === "string") {
    if (typeof a1 === "string") {
      length = this.length;
      r14 = 0;
      r16 = a1;
    } else {
      length = a2;
      r14 = a1;
      if (typeof a2 === "string") {
        length = this.length;
        r16 = a2;
        r14 = a1;
      }
    }
    if (r16 !== void 0 && typeof r16 !== "string") {
      throw new TypeError("encoding must be a string");
    }
    if (typeof r16 === "string" && !Buffer2.isEncoding(r16)) {
      throw new TypeError("Unknown encoding: " + r16);
    }
    const length2 = a0.length;
    r13 = r16;
    r8 = length;
    r11 = r14;
    r9 = a0;
    if (length2 === 1) {
      const r38 = a0.charCodeAt(0);
      const r40 = r16 === "utf8" && r38 < 128 || r16 === "latin1";
      r13 = r16;
      r8 = length;
      r11 = r14;
      r9 = a0;
      if (r40) {
        r13 = r16;
        r8 = length;
        r11 = r14;
        r9 = r38;
      }
    }
  } else if (typeof a0 === "number") {
    r9 = a0 & 255;
    r13 = a3;
    r8 = a2;
    r11 = a1;
  } else {
    r13 = a3;
    r8 = a2;
    r11 = a1;
    r9 = a0;
    if (typeof a0 === "boolean") {
      r9 = Number(a0);
      r13 = a3;
      r8 = a2;
      r11 = a1;
    }
  }
  if (!(r11 < 0) && !(this.length < r11) && !(this.length < r8)) {
    if (r8 <= r11) {
      return this;
    }
    let r1 = r11 >>> 0;
    const r46 = r8 === void 0 ? this.length : r8 >>> 0;
    if (!r9) {
      r9 = 0;
    }
    if (typeof r9 === "number") {
      while (r1 < r46) {
        this[r1] = r9;
        r1 = r1 + 1;
      }
    } else {
      const r50 = Buffer2.isBuffer(r9) ? r9 : Buffer2.from(r9, r13);
      const length3 = r50.length;
      if (length3 === 0) {
        throw new TypeError("The value \"" + r9 + "\" is invalid for argument \"value\"");
      }
      const r53 = r46 - r1;
      let r54 = 0;
      if (0 < r53) {
        do {
          this[r54 + r1] = r50[r54 % length3];
          r54 = r54 + 1;
        } while (r54 < r46 - r1);
      }
    }
    return this;
  }
  throw new RangeError("Out of range index");
};
c493_14 = /[^+/0-9A-Za-z-_]/g;
const array = new Array(256);
let r197 = 0;
loop12: while (true) {
  const r3 = 16 * r197;
  const r1 = r197;
  let r0 = 0;
  while (true) {
    array[r3 + r0] = "0123456789abcdef"[r1] + "0123456789abcdef"[r0];
    r0 = r0 + 1;
    if (!(r0 < 16)) {
      r197 = r1 + 1;
      if (r197 < 16) {
        continue loop12;
      }
      c493_16 = array;
      return void 0;
    }
  }
}