@solibo/solibo-sdk 1.0.35 → 1.0.37

package/cryptography-kotlin-cryptography-serialization-asn1.mjs

@@ -0,0 +1,1413 @@
+import {
+  Unit_instance28fytmsmm6r23 as Unit_instance,
+  Enum3alwj03lh1n41 as Enum,
+  protoOf180f3jzyo7rfj as protoOf,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  VOID3gxj6tk5isa35 as VOID,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  last1x5hqf11b8kkw as last,
+  countTrailingZeroBitszhs0313cn11e as countTrailingZeroBits,
+  toString1pkumu07cwy4m as toString,
+  IllegalStateException_init_$Create$2429fvs1h56dm as IllegalStateException_init_$Create$,
+  objectCreate1ve4bgxiu4x98 as objectCreate,
+  copyOfRange3alro60z4hhf8 as copyOfRange,
+  takeHighestOneBit9p7rdtda63bc as takeHighestOneBit,
+  copyOfwy6h3t5vzqpl as copyOf,
+  toByte4i43936u611k as toByte,
+  arrayCopytctsywo3h7gj as arrayCopy,
+  equals2au1ep9vhcato as equals,
+  isByteArray4nnzfn1x4o3w as isByteArray,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  StringBuilder_init_$Create$322n630qt3r8c as StringBuilder_init_$Create$,
+  _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx,
+  split2bvyvnrlcifjv as split,
+  toInt2q8uldh7sc951 as toInt,
+  _UByte___init__impl__g9hnc418b8pq346rvu4 as _UByte___init__impl__g9hnc4,
+  toStringicfo093rs8qc as toString_0,
+  UBytep4j7r1t64gz1 as UByte,
+} from './kotlin-kotlin-stdlib.mjs';
+import {
+  PluginGeneratedSerialDescriptorqdzeg5asqhfg as PluginGeneratedSerialDescriptor,
+  ByteArraySerializer_getInstancebtnovhz524d2 as ByteArraySerializer_getInstance,
+  UnknownFieldException_init_$Create$2dwzk7svpmqo1 as UnknownFieldException_init_$Create$,
+  IntSerializer_getInstance3pev8isxtkhc2 as IntSerializer_getInstance,
+  typeParametersSerializers2likxjr48tr7y as typeParametersSerializers,
+  GeneratedSerializer1f7t7hssdd2ws as GeneratedSerializer,
+  throwMissingFieldException2cmke0v3ynf14 as throwMissingFieldException,
+  EmptySerializersModule991ju6pz9b79 as EmptySerializersModule,
+  BinaryFormat3f3aelhmz0ro1 as BinaryFormat,
+  InlineClassDescriptor2odlvyasjrmr0 as InlineClassDescriptor,
+  StringSerializer_getInstance2hpyx1v3alnih as StringSerializer_getInstance,
+  AbstractDecoder35guh02ubh2hm as AbstractDecoder,
+  ByteArraySerializersn06x87bo7h0 as ByteArraySerializer,
+  PolymorphicKindla9gurooefwb as PolymorphicKind,
+  CLASS_getInstance3v12utpo53nyi as CLASS_getInstance,
+  SerializationException_init_$Create$2gf2fbfh3gfxm as SerializationException_init_$Create$,
+  AbstractEncoder2gxtu3xmy3f8j as AbstractEncoder,
+} from './kotlinx-serialization-kotlinx-serialization-core.mjs';
+import {
+  Companion_getInstance2wwh92wx91oht as Companion_getInstance,
+  toBigInt2ed03w99r27qk as toBigInt,
+  toBigInt29u3xna2n8w21 as toBigInt_0,
+  toBigInt3kphjqnio21gn as toBigInt_1,
+  toBigInt11bczolyoumqk as toBigInt_2,
+  BigInt23zwv5kv3od56 as BigInt,
+  decodeToBigInt1petkle13vaiv as decodeToBigInt,
+  encodeToByteArrayripney4e4aue as encodeToByteArray,
+} from './cryptography-kotlin-cryptography-bigint.mjs';
+//region block: imports
+var imul = Math.imul;
+var clz32 = Math.clz32;
+//endregion
+//region block: pre-declaration
+initMetadataForClass(TagType, 'TagType', VOID, Enum);
+initMetadataForClass(ContextSpecificTag, 'ContextSpecificTag');
+initMetadataForCompanion(Companion);
+initMetadataForObject($serializer, '$serializer', VOID, VOID, [GeneratedSerializer]);
+initMetadataForClass(BitArray, 'BitArray', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance});
+initMetadataForClass(Der, 'Der', VOID, VOID, [BinaryFormat]);
+initMetadataForObject(Default, 'Default', VOID, Der);
+initMetadataForCompanion(Companion_0);
+initMetadataForObject($serializer_0, '$serializer', VOID, VOID, [GeneratedSerializer]);
+initMetadataForClass(ObjectIdentifier, 'ObjectIdentifier', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance_0});
+initMetadataForClass(ByteArrayInput, 'ByteArrayInput');
+initMetadataForClass(ByteArrayOutput, 'ByteArrayOutput', ByteArrayOutput);
+initMetadataForClass(DerDecoder, 'DerDecoder', VOID, AbstractDecoder);
+initMetadataForClass(DerEncoder, 'DerEncoder', VOID, AbstractEncoder);
+initMetadataForClass(DerInput, 'DerInput');
+initMetadataForClass(DerOutput, 'DerOutput');
+//endregion
+var TagType_IMPLICIT_instance;
+var TagType_EXPLICIT_instance;
+var TagType_entriesInitialized;
+function TagType_initEntries() {
+  if (TagType_entriesInitialized)
+    return Unit_instance;
+  TagType_entriesInitialized = true;
+  TagType_IMPLICIT_instance = new TagType('IMPLICIT', 0);
+  TagType_EXPLICIT_instance = new TagType('EXPLICIT', 1);
+}
+function TagType(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function TagType_EXPLICIT_getInstance() {
+  TagType_initEntries();
+  return TagType_EXPLICIT_instance;
+}
+function ContextSpecificTag(classIndex, type) {
+  this.ko7_1 = classIndex;
+  this.lo7_1 = type;
+}
+protoOf(ContextSpecificTag).equals = function (other) {
+  if (!(other instanceof ContextSpecificTag))
+    return false;
+  var tmp0_other_with_cast = other instanceof ContextSpecificTag ? other : THROW_CCE();
+  if (!(this.ko7_1 === tmp0_other_with_cast.ko7_1))
+    return false;
+  if (!this.lo7_1.equals(tmp0_other_with_cast.lo7_1))
+    return false;
+  return true;
+};
+protoOf(ContextSpecificTag).hashCode = function () {
+  var result = imul(getStringHashCode('classIndex'), 127) ^ this.ko7_1;
+  result = result + (imul(getStringHashCode('type'), 127) ^ this.lo7_1.hashCode()) | 0;
+  return result;
+};
+protoOf(ContextSpecificTag).toString = function () {
+  return '@dev.whyoleg.cryptography.serialization.asn1.ContextSpecificTag(' + 'classIndex=' + this.ko7_1 + ', ' + 'type=' + this.lo7_1.toString() + ')';
+};
+function Companion() {
+}
+protoOf(Companion).g63 = function () {
+  return $serializer_getInstance();
+};
+var Companion_instance;
+function Companion_getInstance_0() {
+  return Companion_instance;
+}
+function $serializer() {
+  $serializer_instance = this;
+  var tmp0_serialDesc = new PluginGeneratedSerialDescriptor('dev.whyoleg.cryptography.serialization.asn1.BitArray', this, 2);
+  tmp0_serialDesc.r13('unusedBits', false);
+  tmp0_serialDesc.r13('byteArray', false);
+  this.mo7_1 = tmp0_serialDesc;
+}
+protoOf($serializer).no7 = function (encoder, value) {
+  var tmp0_desc = this.mo7_1;
+  var tmp1_output = encoder.ew(tmp0_desc);
+  tmp1_output.ox(tmp0_desc, 0, value.oo7_1);
+  tmp1_output.vx(tmp0_desc, 1, ByteArraySerializer_getInstance(), value.po7_1);
+  tmp1_output.fw(tmp0_desc);
+};
+protoOf($serializer).ct = function (encoder, value) {
+  return this.no7(encoder, value instanceof BitArray ? value : THROW_CCE());
+};
+protoOf($serializer).dt = function (decoder) {
+  var tmp0_desc = this.mo7_1;
+  var tmp1_flag = true;
+  var tmp2_index = 0;
+  var tmp3_bitMask0 = 0;
+  var tmp4_local0 = 0;
+  var tmp5_local1 = null;
+  var tmp6_input = decoder.ew(tmp0_desc);
+  if (tmp6_input.uw()) {
+    tmp4_local0 = tmp6_input.jw(tmp0_desc, 0);
+    tmp3_bitMask0 = tmp3_bitMask0 | 1;
+    tmp5_local1 = tmp6_input.qw(tmp0_desc, 1, ByteArraySerializer_getInstance(), tmp5_local1);
+    tmp3_bitMask0 = tmp3_bitMask0 | 2;
+  } else
+    while (tmp1_flag) {
+      tmp2_index = tmp6_input.vw(tmp0_desc);
+      switch (tmp2_index) {
+        case -1:
+          tmp1_flag = false;
+          break;
+        case 0:
+          tmp4_local0 = tmp6_input.jw(tmp0_desc, 0);
+          tmp3_bitMask0 = tmp3_bitMask0 | 1;
+          break;
+        case 1:
+          tmp5_local1 = tmp6_input.qw(tmp0_desc, 1, ByteArraySerializer_getInstance(), tmp5_local1);
+          tmp3_bitMask0 = tmp3_bitMask0 | 2;
+          break;
+        default:
+          throw UnknownFieldException_init_$Create$(tmp2_index);
+      }
+    }
+  tmp6_input.fw(tmp0_desc);
+  return BitArray_init_$Create$(tmp3_bitMask0, tmp4_local0, tmp5_local1, null);
+};
+protoOf($serializer).ps = function () {
+  return this.mo7_1;
+};
+protoOf($serializer).k14 = function () {
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  return [IntSerializer_getInstance(), ByteArraySerializer_getInstance()];
+};
+var $serializer_instance;
+function $serializer_getInstance() {
+  if ($serializer_instance == null)
+    new $serializer();
+  return $serializer_instance;
+}
+function BitArray_init_$Init$(seen0, unusedBits, byteArray, serializationConstructorMarker, $this) {
+  if (!(3 === (3 & seen0))) {
+    throwMissingFieldException(seen0, 3, $serializer_getInstance().mo7_1);
+  }
+  $this.oo7_1 = unusedBits;
+  $this.po7_1 = byteArray;
+  // Inline function 'kotlin.collections.isEmpty' call
+  if ($this.po7_1.length === 0) {
+    // Inline function 'kotlin.check' call
+    if (!($this.oo7_1 === 0)) {
+      var message = "empty array couldn't have unused bits";
+      throw IllegalStateException_init_$Create$(toString(message));
+    }
+  } else {
+    // Inline function 'kotlin.countTrailingZeroBits' call
+    var this_0 = last($this.po7_1);
+    var tmp$ret$3 = countTrailingZeroBits(this_0 | 256);
+    // Inline function 'kotlin.check' call
+    if (!($this.oo7_1 <= tmp$ret$3)) {
+      var message_0 = 'At least ' + $this.oo7_1 + ' last bits should be unused';
+      throw IllegalStateException_init_$Create$(toString(message_0));
+    }
+  }
+  return $this;
+}
+function BitArray_init_$Create$(seen0, unusedBits, byteArray, serializationConstructorMarker) {
+  return BitArray_init_$Init$(seen0, unusedBits, byteArray, serializationConstructorMarker, objectCreate(protoOf(BitArray)));
+}
+function BitArray(unusedBits, byteArray) {
+  this.oo7_1 = unusedBits;
+  this.po7_1 = byteArray;
+  // Inline function 'kotlin.collections.isEmpty' call
+  if (this.po7_1.length === 0) {
+    // Inline function 'kotlin.check' call
+    if (!(this.oo7_1 === 0)) {
+      var message = "empty array couldn't have unused bits";
+      throw IllegalStateException_init_$Create$(toString(message));
+    }
+  } else {
+    // Inline function 'kotlin.countTrailingZeroBits' call
+    var this_0 = last(this.po7_1);
+    var tmp$ret$3 = countTrailingZeroBits(this_0 | 256);
+    // Inline function 'kotlin.check' call
+    if (!(this.oo7_1 <= tmp$ret$3)) {
+      var message_0 = 'At least ' + this.oo7_1 + ' last bits should be unused';
+      throw IllegalStateException_init_$Create$(toString(message_0));
+    }
+  }
+}
+function Default() {
+  Default_instance = this;
+  Der.call(this, EmptySerializersModule());
+}
+var Default_instance;
+function Default_getInstance() {
+  if (Default_instance == null)
+    new Default();
+  return Default_instance;
+}
+function Der(serializersModule) {
+  Default_getInstance();
+  this.qo7_1 = serializersModule;
+}
+protoOf(Der).at = function () {
+  return this.qo7_1;
+};
+protoOf(Der).yt = function (serializer, value) {
+  var output = new ByteArrayOutput();
+  (new DerEncoder(this, output)).bt(serializer, value);
+  return output.xo7();
+};
+protoOf(Der).zt = function (deserializer, bytes) {
+  var input = new ByteArrayInput(bytes);
+  return (new DerDecoder(this, input)).et(deserializer);
+};
+function _ObjectIdentifier___init__impl__7hutfr(value) {
+  return value;
+}
+function _ObjectIdentifier___get_value__impl__wqzjw3($this) {
+  return $this;
+}
+function Companion_0() {
+}
+protoOf(Companion_0).g63 = function () {
+  return $serializer_getInstance_0();
+};
+var Companion_instance_0;
+function Companion_getInstance_1() {
+  return Companion_instance_0;
+}
+function $serializer_0() {
+  $serializer_instance_0 = this;
+  var tmp0_serialDesc = new InlineClassDescriptor('dev.whyoleg.cryptography.serialization.asn1.ObjectIdentifier', this);
+  tmp0_serialDesc.r13('value', false);
+  this.co8_1 = tmp0_serialDesc;
+}
+protoOf($serializer_0).do8 = function (encoder, value) {
+  var tmp0_inlineEncoder = encoder.kx(this.co8_1);
+  if (tmp0_inlineEncoder == null)
+    null;
+  else {
+    tmp0_inlineEncoder.ix(_ObjectIdentifier___get_value__impl__wqzjw3(value));
+  }
+};
+protoOf($serializer_0).ct = function (encoder, value) {
+  return this.do8(encoder, value instanceof ObjectIdentifier ? value.eo8_1 : THROW_CCE());
+};
+protoOf($serializer_0).fo8 = function (decoder) {
+  return _ObjectIdentifier___init__impl__7hutfr(decoder.cw(this.co8_1).aw());
+};
+protoOf($serializer_0).dt = function (decoder) {
+  return new ObjectIdentifier(this.fo8(decoder));
+};
+protoOf($serializer_0).ps = function () {
+  return this.co8_1;
+};
+protoOf($serializer_0).k14 = function () {
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  return [StringSerializer_getInstance()];
+};
+var $serializer_instance_0;
+function $serializer_getInstance_0() {
+  if ($serializer_instance_0 == null)
+    new $serializer_0();
+  return $serializer_instance_0;
+}
+function ObjectIdentifier__toString_impl_dtwsrd($this) {
+  return 'ObjectIdentifier(value=' + $this + ')';
+}
+function ObjectIdentifier__hashCode_impl_7x941i($this) {
+  return getStringHashCode($this);
+}
+function ObjectIdentifier__equals_impl_u5dbkq($this, other) {
+  if (!(other instanceof ObjectIdentifier))
+    return false;
+  if (!($this === (other instanceof ObjectIdentifier ? other.eo8_1 : THROW_CCE())))
+    return false;
+  return true;
+}
+function ObjectIdentifier(value) {
+  this.eo8_1 = value;
+}
+protoOf(ObjectIdentifier).toString = function () {
+  return ObjectIdentifier__toString_impl_dtwsrd(this.eo8_1);
+};
+protoOf(ObjectIdentifier).hashCode = function () {
+  return ObjectIdentifier__hashCode_impl_7x941i(this.eo8_1);
+};
+protoOf(ObjectIdentifier).equals = function (other) {
+  return ObjectIdentifier__equals_impl_u5dbkq(this.eo8_1, other);
+};
+function get_emptyArray() {
+  _init_properties_ByteArrayInput_kt__imea6f();
+  return emptyArray;
+}
+var emptyArray;
+function _get_available__saq0tk($this) {
+  return $this.ho8_1 - $this.io8_1 | 0;
+}
+function ensureAvailableBytes($this, count) {
+  // Inline function 'kotlin.check' call
+  if (!(_get_available__saq0tk($this) >= count)) {
+    var message = 'Unexpected EOF, available ' + _get_available__saq0tk($this) + ' bytes, requested: ' + count;
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+}
+function ByteArrayInput(array, startIndex, endIndex) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  endIndex = endIndex === VOID ? array.length : endIndex;
+  this.go8_1 = array;
+  this.ho8_1 = endIndex;
+  this.io8_1 = startIndex;
+}
+protoOf(ByteArrayInput).jo8 = function () {
+  return _get_available__saq0tk(this) === 0;
+};
+protoOf(ByteArrayInput).toString = function () {
+  return 'ByteArrayInput(size=' + this.go8_1.length + ', endIndex=' + this.ho8_1 + ', position=' + this.io8_1 + ', available=' + _get_available__saq0tk(this) + ')';
+};
+protoOf(ByteArrayInput).ko8 = function () {
+  ensureAvailableBytes(this, 1);
+  return this.go8_1[this.io8_1];
+};
+protoOf(ByteArrayInput).x66 = function () {
+  ensureAvailableBytes(this, 1);
+  var _unary__edvuaz = this.io8_1;
+  this.io8_1 = _unary__edvuaz + 1 | 0;
+  return this.go8_1[_unary__edvuaz];
+};
+protoOf(ByteArrayInput).lo8 = function (length) {
+  ensureAvailableBytes(this, length);
+  if (length === 0)
+    return get_emptyArray();
+  // Inline function 'kotlin.also' call
+  var this_0 = copyOfRange(this.go8_1, this.io8_1, this.io8_1 + length | 0);
+  this.io8_1 = this.io8_1 + length | 0;
+  return this_0;
+};
+protoOf(ByteArrayInput).mo8 = function (length) {
+  ensureAvailableBytes(this, length);
+  if (length === 0)
+    return new ByteArrayInput(get_emptyArray());
+  // Inline function 'kotlin.also' call
+  var this_0 = new ByteArrayInput(this.go8_1, this.io8_1, this.io8_1 + length | 0);
+  this.io8_1 = this.io8_1 + length | 0;
+  return this_0;
+};
+var properties_initialized_ByteArrayInput_kt_acgl39;
+function _init_properties_ByteArrayInput_kt__imea6f() {
+  if (!properties_initialized_ByteArrayInput_kt_acgl39) {
+    properties_initialized_ByteArrayInput_kt_acgl39 = true;
+    emptyArray = new Int8Array(0);
+  }
+}
+function ensureCapacity($this, elementsToAppend) {
+  if (($this.wo7_1 + elementsToAppend | 0) <= $this.vo7_1.length)
+    return Unit_instance;
+  $this.vo7_1 = copyOf($this.vo7_1, takeHighestOneBit($this.wo7_1 + elementsToAppend | 0) << 1);
+}
+function ByteArrayOutput() {
+  this.vo7_1 = new Int8Array(32);
+  this.wo7_1 = 0;
+}
+protoOf(ByteArrayOutput).g1 = function () {
+  return this.wo7_1;
+};
+protoOf(ByteArrayOutput).xo7 = function () {
+  return copyOf(this.vo7_1, this.wo7_1);
+};
+protoOf(ByteArrayOutput).no8 = function (byte) {
+  ensureCapacity(this, 1);
+  var tmp = this.vo7_1;
+  var _unary__edvuaz = this.wo7_1;
+  this.wo7_1 = _unary__edvuaz + 1 | 0;
+  tmp[_unary__edvuaz] = byte;
+};
+protoOf(ByteArrayOutput).oo8 = function (byte) {
+  this.no8(toByte(byte));
+};
+protoOf(ByteArrayOutput).po8 = function (bytes) {
+  // Inline function 'kotlin.collections.isEmpty' call
+  if (bytes.length === 0)
+    return Unit_instance;
+  ensureCapacity(this, bytes.length);
+  var tmp2 = this.vo7_1;
+  // Inline function 'kotlin.collections.copyInto' call
+  var destinationOffset = this.wo7_1;
+  var endIndex = bytes.length;
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = bytes;
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  arrayCopy(tmp, tmp2, destinationOffset, 0, endIndex);
+  this.wo7_1 = this.wo7_1 + bytes.length | 0;
+};
+protoOf(ByteArrayOutput).qo8 = function (output) {
+  if (output.g1() === 0)
+    return Unit_instance;
+  ensureCapacity(this, output.wo7_1);
+  var tmp0 = output.vo7_1;
+  var tmp2 = this.vo7_1;
+  var tmp4 = this.wo7_1;
+  // Inline function 'kotlin.collections.copyInto' call
+  var endIndex = output.wo7_1;
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = tmp0;
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  arrayCopy(tmp, tmp2, tmp4, 0, endIndex);
+  this.wo7_1 = this.wo7_1 + output.wo7_1 | 0;
+};
+function getAndResetTagOverride($this) {
+  var tag = $this.bo8_1;
+  $this.bo8_1 = null;
+  return tag;
+}
+function DerDecoder(der, byteArrayInput) {
+  AbstractDecoder.call(this);
+  this.yo7_1 = der;
+  this.zo7_1 = new DerInput(byteArrayInput);
+  this.ao8_1 = 0;
+  this.bo8_1 = null;
+}
+protoOf(DerDecoder).at = function () {
+  return this.yo7_1.at();
+};
+protoOf(DerDecoder).vw = function (descriptor) {
+  if (this.zo7_1.jo8())
+    return -1;
+  var tag = this.zo7_1.so8();
+  $l$loop: while (true) {
+    var index = this.ao8_1;
+    this.bo8_1 = getElementContextSpecificTag(descriptor, index);
+    if (descriptor.uu(index)) {
+      var tmp0 = this.bo8_1;
+      var tmp$ret$1;
+      $l$block: {
+        // Inline function 'kotlin.checkNotNull' call
+        if (tmp0 == null) {
+          var message = 'Optional element ' + toString(descriptor) + '[' + index + '] must have context specific tag';
+          throw IllegalStateException_init_$Create$(toString(message));
+        } else {
+          tmp$ret$1 = tmp0;
+          break $l$block;
+        }
+      }
+      var requiredTag = tmp$ret$1;
+      if (!(tag === get_tag(requiredTag))) {
+        this.ao8_1 = this.ao8_1 + 1 | 0;
+        continue $l$loop;
+      }
+    }
+    var _unary__edvuaz = this.ao8_1;
+    this.ao8_1 = _unary__edvuaz + 1 | 0;
+    return _unary__edvuaz;
+  }
+};
+protoOf(DerDecoder).qv = function () {
+  return this.zo7_1.to8();
+};
+protoOf(DerDecoder).rv = function () {
+  return this.zo7_1.uo8();
+};
+protoOf(DerDecoder).tv = function () {
+  return this.zo7_1.vo8(getAndResetTagOverride(this)).co6();
+};
+protoOf(DerDecoder).uv = function () {
+  return this.zo7_1.vo8(getAndResetTagOverride(this)).do6();
+};
+protoOf(DerDecoder).vv = function () {
+  return this.zo7_1.vo8(getAndResetTagOverride(this)).eo6();
+};
+protoOf(DerDecoder).wv = function () {
+  return this.zo7_1.vo8(getAndResetTagOverride(this)).fo6();
+};
+protoOf(DerDecoder).et = function (deserializer) {
+  var tmp0_subject = deserializer.ps();
+  var tmp;
+  if (equals(tmp0_subject, ByteArraySerializer().ps())) {
+    var tmp_0 = this.zo7_1.yo8(getAndResetTagOverride(this));
+    tmp = !(tmp_0 == null) ? tmp_0 : THROW_CCE();
+  } else if (equals(tmp0_subject, Companion_instance.g63().ps())) {
+    var tmp_1 = this.zo7_1.xo8(getAndResetTagOverride(this));
+    tmp = !(tmp_1 == null) ? tmp_1 : THROW_CCE();
+  } else if (equals(tmp0_subject, Companion_instance_0.g63().ps())) {
+    var tmp_2 = this.zo7_1.wo8(getAndResetTagOverride(this));
+    tmp = !(new ObjectIdentifier(tmp_2) == null) ? new ObjectIdentifier(tmp_2) : THROW_CCE();
+  } else if (equals(tmp0_subject, Companion_getInstance().g63().ps())) {
+    var tmp_3 = this.zo7_1.vo8(getAndResetTagOverride(this));
+    tmp = !(tmp_3 == null) ? tmp_3 : THROW_CCE();
+  } else {
+    tmp = deserializer.dt(this);
+  }
+  return tmp;
+};
+protoOf(DerDecoder).ew = function (descriptor) {
+  var tmp0_subject = descriptor.nu();
+  var tmp;
+  var tmp_0;
+  if (equals(tmp0_subject, CLASS_getInstance())) {
+    tmp_0 = true;
+  } else {
+    tmp_0 = tmp0_subject instanceof PolymorphicKind;
+  }
+  if (tmp_0) {
+    tmp = new DerDecoder(this.yo7_1, this.zo7_1.zo8(getAndResetTagOverride(this)));
+  } else {
+    throw SerializationException_init_$Create$('This serial kind is not supported as structure: ' + toString(descriptor));
+  }
+  return tmp;
+};
+protoOf(DerDecoder).cw = function (descriptor) {
+  return this;
+};
+protoOf(DerDecoder).pw = function (descriptor, index) {
+  return this;
+};
+protoOf(DerDecoder).bw = function (enumDescriptor) {
+  var message = 'Enum decoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerDecoder).aw = function () {
+  var message = 'String decoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerDecoder).zv = function () {
+  var message = 'Char decoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerDecoder).sv = function () {
+  var message = 'Boolean decoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerDecoder).yv = function () {
+  var message = 'Double decoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerDecoder).xv = function () {
+  var message = 'Float decoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerDecoder).pv = function () {
+  var message = 'should not be called';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+function getAndResetTagOverride_0($this) {
+  var tag = $this.uo7_1;
+  $this.uo7_1 = null;
+  return tag;
+}
+function DerEncoder(der, byteArrayOutput, parentOutput) {
+  parentOutput = parentOutput === VOID ? null : parentOutput;
+  AbstractEncoder.call(this);
+  this.ro7_1 = der;
+  this.so7_1 = parentOutput;
+  this.to7_1 = new DerOutput(byteArrayOutput);
+  this.uo7_1 = null;
+}
+protoOf(DerEncoder).at = function () {
+  return this.ro7_1.at();
+};
+protoOf(DerEncoder).ay = function (descriptor, index) {
+  return false;
+};
+protoOf(DerEncoder).xw = function (descriptor, index) {
+  this.uo7_1 = getElementContextSpecificTag(descriptor, index);
+  return true;
+};
+protoOf(DerEncoder).yx = function () {
+};
+protoOf(DerEncoder).zw = function () {
+  return this.to7_1.bo9();
+};
+protoOf(DerEncoder).bx = function (value) {
+  return this.to7_1.co9(getAndResetTagOverride_0(this), toBigInt(value));
+};
+protoOf(DerEncoder).cx = function (value) {
+  return this.to7_1.co9(getAndResetTagOverride_0(this), toBigInt_0(value));
+};
+protoOf(DerEncoder).dx = function (value) {
+  return this.to7_1.co9(getAndResetTagOverride_0(this), toBigInt_1(value));
+};
+protoOf(DerEncoder).ex = function (value) {
+  return this.to7_1.co9(getAndResetTagOverride_0(this), toBigInt_2(value));
+};
+protoOf(DerEncoder).bt = function (serializer, value) {
+  var tmp0_subject = serializer.ps();
+  var tmp;
+  if (equals(tmp0_subject, ByteArraySerializer().ps())) {
+    var tmp_0 = getAndResetTagOverride_0(this);
+    this.to7_1.fo9(tmp_0, (!(value == null) ? isByteArray(value) : false) ? value : THROW_CCE());
+    tmp = Unit_instance;
+  } else if (equals(tmp0_subject, Companion_instance.g63().ps())) {
+    var tmp_1 = getAndResetTagOverride_0(this);
+    this.to7_1.eo9(tmp_1, value instanceof BitArray ? value : THROW_CCE());
+    tmp = Unit_instance;
+  } else if (equals(tmp0_subject, Companion_instance_0.g63().ps())) {
+    var tmp_2 = getAndResetTagOverride_0(this);
+    this.to7_1.do9(tmp_2, value instanceof ObjectIdentifier ? value.eo8_1 : THROW_CCE());
+    tmp = Unit_instance;
+  } else if (equals(tmp0_subject, Companion_getInstance().g63().ps())) {
+    var tmp_3 = getAndResetTagOverride_0(this);
+    this.to7_1.co9(tmp_3, value instanceof BigInt ? value : THROW_CCE());
+    tmp = Unit_instance;
+  } else {
+    serializer.ct(this, value);
+    tmp = Unit_instance;
+  }
+  return tmp;
+};
+protoOf(DerEncoder).ew = function (descriptor) {
+  var tmp0_subject = descriptor.nu();
+  var tmp;
+  var tmp_0;
+  if (equals(tmp0_subject, CLASS_getInstance())) {
+    tmp_0 = true;
+  } else {
+    tmp_0 = tmp0_subject instanceof PolymorphicKind;
+  }
+  if (tmp_0) {
+    tmp = new DerEncoder(this.ro7_1, new ByteArrayOutput(), this.to7_1);
+  } else {
+    throw SerializationException_init_$Create$('This serial kind is not supported as structure: ' + toString(descriptor));
+  }
+  return tmp;
+};
+protoOf(DerEncoder).fw = function (descriptor) {
+  var tmp0 = this.so7_1;
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.checkNotNull' call
+    if (tmp0 == null) {
+      var message = 'Should be called after beginStructure';
+      throw IllegalStateException_init_$Create$(toString(message));
+    } else {
+      tmp$ret$1 = tmp0;
+      break $l$block;
+    }
+  }
+  tmp$ret$1.go9(getAndResetTagOverride_0(this), this.to7_1);
+};
+protoOf(DerEncoder).kx = function (descriptor) {
+  return this;
+};
+protoOf(DerEncoder).ho9 = function (enumDescriptor, index) {
+  var message = 'Enum encoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerEncoder).jx = function (enumDescriptor, index) {
+  return this.ho9(enumDescriptor, index);
+};
+protoOf(DerEncoder).ix = function (value) {
+  var message = 'String encoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerEncoder).hx = function (value) {
+  var message = 'Char encoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerEncoder).ax = function (value) {
+  var message = 'Boolean encoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerEncoder).fx = function (value) {
+  var message = 'Float encoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerEncoder).gx = function (value) {
+  var message = 'Double encoding is not supported';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(DerEncoder).yw = function (value) {
+  var message = 'should not be called';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+function DerInput(input) {
+  this.ro8_1 = input;
+}
+protoOf(DerInput).jo8 = function () {
+  return this.ro8_1.jo8();
+};
+protoOf(DerInput).so8 = function () {
+  return this.ro8_1.ko8();
+};
+protoOf(DerInput).to8 = function () {
+  return !(this.so8() === 5);
+};
+protoOf(DerInput).uo8 = function () {
+  readRequestedTag(this.ro8_1, 5);
+  var length = readLength(this.ro8_1);
+  // Inline function 'kotlin.check' call
+  if (!(length === 0)) {
+    var message = 'NULL tag length should be zero, but was: ' + length;
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  return null;
+};
+protoOf(DerInput).vo8 = function (tagOverride) {
+  var tmp0 = this.ro8_1;
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.readTagWithOverride' call
+    if (tagOverride == null) {
+      readRequestedTag(tmp0, 2);
+      var length = readLength(tmp0);
+      var bytes = tmp0.lo8(length);
+      tmp$ret$1 = decodeToBigInt(bytes);
+      break $l$block;
+    }
+    readRequestedTag(tmp0, get_tag(tagOverride));
+    var tmp;
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        var length_0 = readLength(tmp0);
+        var bytes_0 = tmp0.lo8(length_0);
+        tmp = decodeToBigInt(bytes_0);
+        break;
+      case 1:
+        var length_1 = readLength(tmp0);
+        var explicitInput = tmp0.mo8(length_1);
+        readRequestedTag(explicitInput, 2);
+        var length_2 = readLength(explicitInput);
+        var bytes_1 = explicitInput.lo8(length_2);
+        tmp = decodeToBigInt(bytes_1);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+    tmp$ret$1 = tmp;
+  }
+  return tmp$ret$1;
+};
+protoOf(DerInput).xo8 = function (tagOverride) {
+  var tmp0 = this.ro8_1;
+  var tmp$ret$7;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.readTagWithOverride' call
+    if (tagOverride == null) {
+      readRequestedTag(tmp0, 3);
+      var length = readLength(tmp0);
+      var unusedBits = tmp0.x66();
+      var bytes = tmp0.lo8(length - 1 | 0);
+      // Inline function 'kotlin.collections.isEmpty' call
+      if (bytes.length === 0) {
+        // Inline function 'kotlin.check' call
+        if (!(unusedBits === 0)) {
+          var message = 'wrong number of unused bits, expected 0, received: ' + unusedBits;
+          throw IllegalStateException_init_$Create$(toString(message));
+        }
+      } else {
+        // Inline function 'kotlin.countTrailingZeroBits' call
+        var this_0 = last(bytes);
+        var trailingZeros = countTrailingZeroBits(this_0 | 256);
+        // Inline function 'kotlin.check' call
+        if (!(unusedBits <= trailingZeros)) {
+          var message_0 = 'Not all unused bits are zeros, expected at least ' + unusedBits + ' trailing zeros, received ' + trailingZeros;
+          throw IllegalStateException_init_$Create$(toString(message_0));
+        }
+      }
+      tmp$ret$7 = new BitArray(unusedBits, bytes);
+      break $l$block;
+    }
+    readRequestedTag(tmp0, get_tag(tagOverride));
+    var tmp;
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        var length_0 = readLength(tmp0);
+        var unusedBits_0 = tmp0.x66();
+        var bytes_0 = tmp0.lo8(length_0 - 1 | 0);
+        // Inline function 'kotlin.collections.isEmpty' call
+
+        if (bytes_0.length === 0) {
+          // Inline function 'kotlin.check' call
+          if (!(unusedBits_0 === 0)) {
+            var message_1 = 'wrong number of unused bits, expected 0, received: ' + unusedBits_0;
+            throw IllegalStateException_init_$Create$(toString(message_1));
+          }
+        } else {
+          // Inline function 'kotlin.countTrailingZeroBits' call
+          var this_1 = last(bytes_0);
+          var trailingZeros_0 = countTrailingZeroBits(this_1 | 256);
+          // Inline function 'kotlin.check' call
+          if (!(unusedBits_0 <= trailingZeros_0)) {
+            var message_2 = 'Not all unused bits are zeros, expected at least ' + unusedBits_0 + ' trailing zeros, received ' + trailingZeros_0;
+            throw IllegalStateException_init_$Create$(toString(message_2));
+          }
+        }
+
+        tmp = new BitArray(unusedBits_0, bytes_0);
+        break;
+      case 1:
+        var length_1 = readLength(tmp0);
+        var explicitInput = tmp0.mo8(length_1);
+        readRequestedTag(explicitInput, 3);
+        var length_2 = readLength(explicitInput);
+        var unusedBits_1 = explicitInput.x66();
+        var bytes_1 = explicitInput.lo8(length_2 - 1 | 0);
+        // Inline function 'kotlin.collections.isEmpty' call
+
+        if (bytes_1.length === 0) {
+          // Inline function 'kotlin.check' call
+          if (!(unusedBits_1 === 0)) {
+            var message_3 = 'wrong number of unused bits, expected 0, received: ' + unusedBits_1;
+            throw IllegalStateException_init_$Create$(toString(message_3));
+          }
+        } else {
+          // Inline function 'kotlin.countTrailingZeroBits' call
+          var this_2 = last(bytes_1);
+          var trailingZeros_1 = countTrailingZeroBits(this_2 | 256);
+          // Inline function 'kotlin.check' call
+          if (!(unusedBits_1 <= trailingZeros_1)) {
+            var message_4 = 'Not all unused bits are zeros, expected at least ' + unusedBits_1 + ' trailing zeros, received ' + trailingZeros_1;
+            throw IllegalStateException_init_$Create$(toString(message_4));
+          }
+        }
+
+        tmp = new BitArray(unusedBits_1, bytes_1);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+    tmp$ret$7 = tmp;
+  }
+  return tmp$ret$7;
+};
+protoOf(DerInput).yo8 = function (tagOverride) {
+  var tmp0 = this.ro8_1;
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.readTagWithOverride' call
+    if (tagOverride == null) {
+      readRequestedTag(tmp0, 4);
+      var length = readLength(tmp0);
+      tmp$ret$1 = tmp0.lo8(length);
+      break $l$block;
+    }
+    readRequestedTag(tmp0, get_tag(tagOverride));
+    var tmp;
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        var length_0 = readLength(tmp0);
+        tmp = tmp0.lo8(length_0);
+        break;
+      case 1:
+        var length_1 = readLength(tmp0);
+        var explicitInput = tmp0.mo8(length_1);
+        readRequestedTag(explicitInput, 4);
+        var length_2 = readLength(explicitInput);
+        tmp = explicitInput.lo8(length_2);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+    tmp$ret$1 = tmp;
+  }
+  return tmp$ret$1;
+};
+protoOf(DerInput).wo8 = function (tagOverride) {
+  var tmp0 = this.ro8_1;
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.readTagWithOverride' call
+    if (tagOverride == null) {
+      readRequestedTag(tmp0, 6);
+      var length = readLength(tmp0);
+      var slice = tmp0.mo8(length);
+      tmp$ret$1 = _ObjectIdentifier___init__impl__7hutfr(readOidElements(slice));
+      break $l$block;
+    }
+    readRequestedTag(tmp0, get_tag(tagOverride));
+    var tmp;
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        var length_0 = readLength(tmp0);
+        var slice_0 = tmp0.mo8(length_0);
+        tmp = new ObjectIdentifier(_ObjectIdentifier___init__impl__7hutfr(readOidElements(slice_0)));
+        break;
+      case 1:
+        var length_1 = readLength(tmp0);
+        var explicitInput = tmp0.mo8(length_1);
+        readRequestedTag(explicitInput, 6);
+        var length_2 = readLength(explicitInput);
+        var slice_1 = explicitInput.mo8(length_2);
+        tmp = new ObjectIdentifier(_ObjectIdentifier___init__impl__7hutfr(readOidElements(slice_1)));
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+    tmp$ret$1 = tmp.eo8_1;
+  }
+  return tmp$ret$1;
+};
+protoOf(DerInput).zo8 = function (tagOverride) {
+  var tmp0 = this.ro8_1;
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.readTagWithOverride' call
+    if (tagOverride == null) {
+      readRequestedTag(tmp0, 48);
+      var length = readLength(tmp0);
+      tmp$ret$1 = tmp0.mo8(length);
+      break $l$block;
+    }
+    readRequestedTag(tmp0, get_tag(tagOverride));
+    var tmp;
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        var length_0 = readLength(tmp0);
+        tmp = tmp0.mo8(length_0);
+        break;
+      case 1:
+        var length_1 = readLength(tmp0);
+        var explicitInput = tmp0.mo8(length_1);
+        readRequestedTag(explicitInput, 48);
+        var length_2 = readLength(explicitInput);
+        tmp = explicitInput.mo8(length_2);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+    tmp$ret$1 = tmp;
+  }
+  return tmp$ret$1;
+};
+function readRequestedTag(_this__u8e3s4, tag) {
+  var currentTag = _this__u8e3s4.x66();
+  // Inline function 'kotlin.check' call
+  if (!(currentTag === tag)) {
+    var message = "Requested tag '" + DerTag_name(tag) + "', received: '" + DerTag_name(currentTag) + "'";
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+}
+function readLength(_this__u8e3s4) {
+  var first = _this__u8e3s4.x66();
+  if (first >= 0)
+    return first;
+  var numberOfLengthBytes = first & 127;
+  // Inline function 'kotlin.check' call
+  if (!(numberOfLengthBytes <= 4)) {
+    var message = 'Supported number of bytes for tag length are in range 1..4, but was: ' + numberOfLengthBytes + ' ';
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  var length = 0;
+  // Inline function 'kotlin.repeat' call
+  var inductionVariable = 0;
+  if (inductionVariable < numberOfLengthBytes)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      length = (length << 8) + (_this__u8e3s4.x66() & 255) | 0;
+    }
+     while (inductionVariable < numberOfLengthBytes);
+  // Inline function 'kotlin.check' call
+  if (!(length > 0)) {
+    var message_0 = 'length overflow: ' + length;
+    throw IllegalStateException_init_$Create$(toString(message_0));
+  }
+  return length;
+}
+function readOidElements(_this__u8e3s4) {
+  // Inline function 'kotlin.text.buildString' call
+  // Inline function 'kotlin.apply' call
+  var this_0 = StringBuilder_init_$Create$();
+  var first = readOidElement(_this__u8e3s4);
+  if (first < 40)
+    this_0.s(_Char___init__impl__6a9atx(48)).s(_Char___init__impl__6a9atx(46)).yc(first);
+  else if (first < 80)
+    this_0.s(_Char___init__impl__6a9atx(49)).s(_Char___init__impl__6a9atx(46)).yc(first - 40 | 0);
+  else
+    this_0.s(_Char___init__impl__6a9atx(50)).s(_Char___init__impl__6a9atx(46)).yc(first - 80 | 0);
+  while (!_this__u8e3s4.jo8()) {
+    this_0.s(_Char___init__impl__6a9atx(46)).yc(readOidElement(_this__u8e3s4));
+  }
+  return this_0.toString();
+}
+function readOidElement(_this__u8e3s4) {
+  var element = 0;
+  do {
+    var b = _this__u8e3s4.x66();
+    element = (element << 7) + (b & 127) | 0;
+  }
+   while ((b & 128) === 128);
+  // Inline function 'kotlin.check' call
+  if (!(element >= 0)) {
+    var message = 'element overflow: ' + element;
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  return element;
+}
+function DerOutput(output) {
+  this.ao9_1 = output;
+}
+protoOf(DerOutput).bo9 = function () {
+  this.ao9_1.no8(5);
+  writeLength(this.ao9_1, 0);
+};
+protoOf(DerOutput).co9 = function (tagOverride, value) {
+  var tmp0 = this.ao9_1;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeTagWithOverride' call
+    if (tagOverride == null) {
+      tmp0.no8(2);
+      writeBytes(tmp0, encodeToByteArray(value));
+      break $l$block;
+    }
+    tmp0.no8(get_tag(tagOverride));
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        writeBytes(tmp0, encodeToByteArray(value));
+        break;
+      case 1:
+        // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeBytes' call
+
+        // Inline function 'kotlin.apply' call
+
+        var this_0 = new ByteArrayOutput();
+        this_0.no8(2);
+        writeBytes(this_0, encodeToByteArray(value));
+        writeBytes_0(tmp0, this_0);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+  }
+};
+protoOf(DerOutput).eo9 = function (tagOverride, bits) {
+  var tmp0 = this.ao9_1;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeTagWithOverride' call
+    if (tagOverride == null) {
+      tmp0.no8(3);
+      writeLength(tmp0, bits.po7_1.length + 1 | 0);
+      tmp0.oo8(bits.oo7_1);
+      tmp0.po8(bits.po7_1);
+      break $l$block;
+    }
+    tmp0.no8(get_tag(tagOverride));
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        writeLength(tmp0, bits.po7_1.length + 1 | 0);
+        tmp0.oo8(bits.oo7_1);
+        tmp0.po8(bits.po7_1);
+        break;
+      case 1:
+        // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeBytes' call
+
+        // Inline function 'kotlin.apply' call
+
+        var this_0 = new ByteArrayOutput();
+        this_0.no8(3);
+        writeLength(this_0, bits.po7_1.length + 1 | 0);
+        this_0.oo8(bits.oo7_1);
+        this_0.po8(bits.po7_1);
+        writeBytes_0(tmp0, this_0);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+  }
+};
+protoOf(DerOutput).fo9 = function (tagOverride, bytes) {
+  var tmp0 = this.ao9_1;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeTagWithOverride' call
+    if (tagOverride == null) {
+      tmp0.no8(4);
+      writeBytes(tmp0, bytes);
+      break $l$block;
+    }
+    tmp0.no8(get_tag(tagOverride));
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        writeBytes(tmp0, bytes);
+        break;
+      case 1:
+        // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeBytes' call
+
+        // Inline function 'kotlin.apply' call
+
+        var this_0 = new ByteArrayOutput();
+        this_0.no8(4);
+        writeBytes(this_0, bytes);
+        writeBytes_0(tmp0, this_0);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+  }
+};
+protoOf(DerOutput).do9 = function (tagOverride, value) {
+  var tmp0 = this.ao9_1;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeTagWithOverride' call
+    if (tagOverride == null) {
+      tmp0.no8(6);
+      // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeBytes' call
+      // Inline function 'kotlin.apply' call
+      var this_0 = new ByteArrayOutput();
+      writeOidElements(this_0, split(_ObjectIdentifier___get_value__impl__wqzjw3(value), ['.']));
+      writeBytes_0(tmp0, this_0);
+      break $l$block;
+    }
+    tmp0.no8(get_tag(tagOverride));
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeBytes' call
+
+        // Inline function 'kotlin.apply' call
+
+        var this_1 = new ByteArrayOutput();
+        writeOidElements(this_1, split(_ObjectIdentifier___get_value__impl__wqzjw3(value), ['.']));
+        writeBytes_0(tmp0, this_1);
+        break;
+      case 1:
+        // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeBytes' call
+
+        // Inline function 'kotlin.apply' call
+
+        var this_2 = new ByteArrayOutput();
+        this_2.no8(6);
+        // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeBytes' call
+
+        // Inline function 'kotlin.apply' call
+
+        var this_3 = new ByteArrayOutput();
+        writeOidElements(this_3, split(_ObjectIdentifier___get_value__impl__wqzjw3(value), ['.']));
+        writeBytes_0(this_2, this_3);
+        writeBytes_0(tmp0, this_2);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+  }
+};
+protoOf(DerOutput).go9 = function (tagOverride, bytes) {
+  var tmp0 = this.ao9_1;
+  $l$block: {
+    // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeTagWithOverride' call
+    if (tagOverride == null) {
+      tmp0.no8(48);
+      writeBytes_0(tmp0, bytes.ao9_1);
+      break $l$block;
+    }
+    tmp0.no8(get_tag(tagOverride));
+    switch (tagOverride.lo7_1.a1_1) {
+      case 0:
+        writeBytes_0(tmp0, bytes.ao9_1);
+        break;
+      case 1:
+        // Inline function 'dev.whyoleg.cryptography.serialization.asn1.internal.writeBytes' call
+
+        // Inline function 'kotlin.apply' call
+
+        var this_0 = new ByteArrayOutput();
+        this_0.no8(48);
+        writeBytes_0(this_0, bytes.ao9_1);
+        writeBytes_0(tmp0, this_0);
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+  }
+};
+function writeLength(_this__u8e3s4, length) {
+  if (length < 128)
+    return _this__u8e3s4.oo8(length);
+  // Inline function 'kotlin.countLeadingZeroBits' call
+  var numberOfLengthBytes = 4 - (clz32(length) / 8 | 0) | 0;
+  _this__u8e3s4.oo8(numberOfLengthBytes | 128);
+  // Inline function 'kotlin.repeat' call
+  var inductionVariable = 0;
+  if (inductionVariable < numberOfLengthBytes)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      _this__u8e3s4.oo8(length >>> imul(8, (numberOfLengthBytes - 1 | 0) - index | 0) | 0);
+    }
+     while (inductionVariable < numberOfLengthBytes);
+}
+function writeBytes(_this__u8e3s4, bytes) {
+  writeLength(_this__u8e3s4, bytes.length);
+  _this__u8e3s4.po8(bytes);
+}
+function writeOidElements(_this__u8e3s4, elements) {
+  // Inline function 'kotlin.check' call
+  if (!(elements.g1() >= 2)) {
+    var message = 'at least 2 components expected but was ' + elements.g1();
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  writeOidElement(_this__u8e3s4, imul(writeOidElements$element(elements, 0), 40) + writeOidElements$element(elements, 1) | 0);
+  // Inline function 'kotlin.repeat' call
+  var times = elements.g1() - 2 | 0;
+  var inductionVariable = 0;
+  if (inductionVariable < times)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      writeOidElement(_this__u8e3s4, writeOidElements$element(elements, index + 2 | 0));
+    }
+     while (inductionVariable < times);
+}
+function writeBytes_0(_this__u8e3s4, bytes) {
+  writeLength(_this__u8e3s4, bytes.g1());
+  _this__u8e3s4.qo8(bytes);
+}
+function writeOidElement(_this__u8e3s4, element) {
+  if (element < 128)
+    return _this__u8e3s4.oo8(element);
+  // Inline function 'kotlin.countLeadingZeroBits' call
+  var l = (32 - clz32(element) | 0) / 7 | 0;
+  // Inline function 'kotlin.repeat' call
+  var inductionVariable = 0;
+  if (inductionVariable < l)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var value = element >>> imul(l - index | 0, 7) | 0;
+      if (!(value === 0)) {
+        _this__u8e3s4.oo8(value & 127 | 128);
+      }
+    }
+     while (inductionVariable < l);
+  _this__u8e3s4.oo8(element & 127);
+}
+function writeOidElements$element($elements, index) {
+  return toInt($elements.h1(index));
+}
+function getElementContextSpecificTag(_this__u8e3s4, index) {
+  var tmp0 = _this__u8e3s4.su(index);
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.collections.firstOrNull' call
+    var _iterator__ex2g4s = tmp0.t();
+    while (_iterator__ex2g4s.u()) {
+      var element = _iterator__ex2g4s.v();
+      if (element instanceof ContextSpecificTag) {
+        tmp$ret$1 = element;
+        break $l$block;
+      }
+    }
+    tmp$ret$1 = null;
+  }
+  var tmp = tmp$ret$1;
+  var tmp0_elvis_lhs = tmp instanceof ContextSpecificTag ? tmp : null;
+  var tmp_0;
+  if (tmp0_elvis_lhs == null) {
+    return null;
+  } else {
+    tmp_0 = tmp0_elvis_lhs;
+  }
+  var annotation = tmp_0;
+  // Inline function 'kotlin.check' call
+  if (!(annotation.ko7_1 < 31)) {
+    var message = 'Context specific tag class must be less than 31, but was ' + annotation.ko7_1;
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  return annotation;
+}
+function get_tag(_this__u8e3s4) {
+  var contextSpecificTag = _this__u8e3s4.ko7_1 | 128;
+  var tmp;
+  switch (_this__u8e3s4.lo7_1.a1_1) {
+    case 0:
+      tmp = toByte(contextSpecificTag);
+      break;
+    case 1:
+      tmp = toByte(contextSpecificTag | 32);
+      break;
+    default:
+      noWhenBranchMatchedException();
+      break;
+  }
+  return tmp;
+}
+function DerTag_name(tag) {
+  var tmp;
+  if (tag === 2) {
+    tmp = 'INTEGER';
+  } else if (tag === 3) {
+    tmp = 'BIT_STRING';
+  } else if (tag === 4) {
+    tmp = 'OCTET_STRING';
+  } else if (tag === 5) {
+    tmp = 'NULL';
+  } else if (tag === 6) {
+    tmp = 'OID';
+  } else if (tag === 48) {
+    tmp = 'SEQUENCE';
+  } else {
+    var intTag = tag;
+    var tmp_0;
+    if (hasFlag(intTag, 128)) {
+      var tmp_1;
+      if (hasFlag(intTag, 32)) {
+        // Inline function 'kotlin.toUByte' call
+        var this_0 = (intTag - 128 | 0) - 32 | 0;
+        var tmp$ret$0 = _UByte___init__impl__g9hnc4(toByte(this_0));
+        tmp_1 = 'CONTEXT_SPECIFIC:EXPLICIT[' + new UByte(tmp$ret$0) + ']';
+      } else {
+        // Inline function 'kotlin.toUByte' call
+        var this_1 = intTag - 128 | 0;
+        var tmp$ret$1 = _UByte___init__impl__g9hnc4(toByte(this_1));
+        tmp_1 = 'CONTEXT_SPECIFIC:IMPLICIT[' + new UByte(tmp$ret$1) + ']';
+      }
+      tmp_0 = tmp_1;
+    } else {
+      // Inline function 'kotlin.toUByte' call
+      var tmp$ret$2 = _UByte___init__impl__g9hnc4(tag);
+      tmp_0 = 'UNKNOWN[0x' + toString_0(tmp$ret$2, 16) + ']';
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+}
+function hasFlag(_this__u8e3s4, flag) {
+  return (_this__u8e3s4 & flag) === flag;
+}
+//region block: post-declaration
+protoOf($serializer).l14 = typeParametersSerializers;
+protoOf($serializer_0).l14 = typeParametersSerializers;
+//endregion
+//region block: init
+Companion_instance = new Companion();
+Companion_instance_0 = new Companion_0();
+//endregion
+//region block: exports
+export {
+  BitArray as BitArray3ibxegq42amh4,
+  ContextSpecificTag as ContextSpecificTag1nleqg541pedp,
+  ObjectIdentifier as ObjectIdentifierz6uf0uceu1gm,
+  TagType_EXPLICIT_getInstance as TagType_EXPLICIT_getInstance10pdluq5x1ycm,
+  _ObjectIdentifier___init__impl__7hutfr as _ObjectIdentifier___init__impl__7hutfrluhqiu0s240g,
+  ObjectIdentifier__hashCode_impl_7x941i as ObjectIdentifier__hashCode_impl_7x941i112d4hk00z9e,
+  ObjectIdentifier__toString_impl_dtwsrd as ObjectIdentifier__toString_impl_dtwsrdsm2716jzm6vp,
+  $serializer_getInstance as $serializer_getInstance182nmf4yp1h51,
+  Default_getInstance as Default_getInstance3bn6zrp4tkdoy,
+  $serializer_getInstance_0 as $serializer_getInstance16vvpdozj55ex,
+  Companion_instance_0 as Companion_instance3nsfjzff13l9z,
+};
+//endregion
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-serialization-asn1.mjs.map