@oiti/rn-liveness3d 2.0.0 → 2.1.0

package/ios/Pods/OICommons/Frameworks/OICommons.xcframework/ios-arm64_x86_64-simulator/OICommons.framework/Modules/OICommons.swiftmodule/arm64-apple-ios-simulator.swiftinterface

@@ -1,1865 +0,0 @@
-// swift-interface-format-version: 1.0
-// swift-compiler-version: Apple Swift version 5.7.1 (swiftlang-5.7.1.135.3 clang-1400.0.29.51)
-// swift-module-flags: -target arm64-apple-ios11.0-simulator -enable-objc-interop -enable-library-evolution -swift-version 5 -enforce-exclusivity=checked -Onone -module-name OICommons
-// swift-module-flags-ignorable: -enable-bare-slash-regex
-import AVFoundation
-import CallKit
-import CoreGraphics
-import CoreTelephony
-import CoreText
-import Darwin
-import Foundation
-@_exported import OICommons
-import Swift
-import SystemConfiguration
-import UIKit.UIControl
-import UIKit.UIDevice
-import UIKit.UIImagePickerController
-import UIKit
-import UIKit.UIViewController
-import _Concurrency
-import _StringProcessing
-extension Swift.UInt32 {
-  @_specialize(exported: false, kind: full, where T == Swift.ArraySlice<Swift.UInt8>)
-  @inlinable internal init<T>(bytes: T, fromIndex index: T.Index) where T : Swift.Collection, T.Element == Swift.UInt8, T.Index == Swift.Int {
-    if bytes.isEmpty {
-      self = 0
-      return
-    }
-
-    let count = bytes.count
-
-    let val0 = count > 0 ? UInt32(bytes[index.advanced(by: 0)]) << 24 : 0
-    let val1 = count > 1 ? UInt32(bytes[index.advanced(by: 1)]) << 16 : 0
-    let val2 = count > 2 ? UInt32(bytes[index.advanced(by: 2)]) << 8 : 0
-    let val3 = count > 3 ? UInt32(bytes[index.advanced(by: 3)]) : 0
-
-    self = val0 | val1 | val2 | val3
-  }
-}
-extension Swift.Collection where Self.Element == Swift.UInt8, Self.Index == Swift.Int {
-  @inlinable internal func toUInt32Array() -> Swift.Array<Swift.UInt32> {
-    guard !isEmpty else {
-      return []
-    }
-
-    let c = strideCount(from: startIndex, to: endIndex, by: 4)
-    return Array<UInt32>(unsafeUninitializedCapacity: c) { buf, count in
-      var counter = 0
-      for idx in stride(from: startIndex, to: endIndex, by: 4) {
-        let val = UInt32(bytes: self, fromIndex: idx).bigEndian
-        buf[counter] = val
-        counter += 1
-      }
-      count = counter
-      assert(counter == c)
-    }
-  }
-  @inlinable internal func toUInt64Array() -> Swift.Array<Swift.UInt64> {
-    guard !isEmpty else {
-      return []
-    }
-
-    let c = strideCount(from: startIndex, to: endIndex, by: 8)
-    return Array<UInt64>(unsafeUninitializedCapacity: c) { buf, count in
-      var counter = 0
-      for idx in stride(from: startIndex, to: endIndex, by: 8) {
-        let val = UInt64(bytes: self, fromIndex: idx).bigEndian
-        buf[counter] = val
-        counter += 1
-      }
-      count = counter
-      assert(counter == c)
-    }
-  }
-}
-@usableFromInline
-internal func strideCount(from: Swift.Int, to: Swift.Int, by: Swift.Int) -> Swift.Int
-@_hasMissingDesignatedInitializers public class FontUtil {
-  public static func registerFonts()
-  @objc deinit
-}
-@objc @_Concurrency.MainActor(unsafe) open class ViewControllerInViewCode : UIKit.UIViewController {
-  @_Concurrency.MainActor(unsafe) @objc dynamic public init()
-  @available(*, unavailable)
-  @_Concurrency.MainActor(unsafe) @objc required dynamic public init?(coder: Foundation.NSCoder)
-  @objc deinit
-}
-final public class AES {
-  public enum Error : Swift.Error {
-    case invalidKeySize
-    case dataPaddingRequired
-    case invalidData
-    public static func == (a: OICommons.AES.Error, b: OICommons.AES.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public enum Variant : Swift.Int {
-    case aes128, aes192, aes256
-    public init?(rawValue: Swift.Int)
-    public typealias RawValue = Swift.Int
-    public var rawValue: Swift.Int {
-      get
-    }
-  }
-  @usableFromInline
-  final internal let variantNr: Swift.Int
-  @usableFromInline
-  final internal let variantNb: Swift.Int
-  @usableFromInline
-  final internal let variantNk: Swift.Int
-  public static let blockSize: Swift.Int
-  final public let keySize: Swift.Int
-  final public let variant: OICommons.AES.Variant
-  @usableFromInline
-  final internal let blockMode: OICommons.BlockMode
-  @usableFromInline
-  final internal let padding: OICommons.Padding
-  @usableFromInline
-  final internal var expandedKey: Swift.Array<Swift.Array<Swift.UInt32>> {
-    get
-    set
-  }
-  @usableFromInline
-  final internal var expandedKeyInv: Swift.Array<Swift.Array<Swift.UInt32>> {
-    get
-    set
-  }
-  @usableFromInline
-  internal static let T0: [Swift.UInt32]
-  @usableFromInline
-  internal static let T0_INV: [Swift.UInt32]
-  @usableFromInline
-  internal static let T1: [Swift.UInt32]
-  @usableFromInline
-  internal static let T1_INV: [Swift.UInt32]
-  @usableFromInline
-  internal static let T2: [Swift.UInt32]
-  @usableFromInline
-  internal static let T2_INV: [Swift.UInt32]
-  @usableFromInline
-  internal static let T3: [Swift.UInt32]
-  @usableFromInline
-  internal static let T3_INV: [Swift.UInt32]
-  @usableFromInline
-  internal static let U1: [Swift.UInt32]
-  @usableFromInline
-  internal static let U2: [Swift.UInt32]
-  @usableFromInline
-  internal static let U3: [Swift.UInt32]
-  @usableFromInline
-  internal static let U4: [Swift.UInt32]
-  public init(key: Swift.Array<Swift.UInt8>, blockMode: OICommons.BlockMode, padding: OICommons.Padding = .pkcs7) throws
-  @inlinable final internal func encrypt(block: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>? {
-    if self.blockMode.options.contains(.paddingRequired) && block.count != AES.blockSize {
-      return Array(block)
-    }
-
-    let rounds = self.variantNr
-    let rk = self.expandedKey
-
-    let b00 = UInt32(block[block.startIndex.advanced(by: 0)])
-    let b01 = UInt32(block[block.startIndex.advanced(by: 1)]) << 8
-    let b02 = UInt32(block[block.startIndex.advanced(by: 2)]) << 16
-    let b03 = UInt32(block[block.startIndex.advanced(by: 3)]) << 24
-    var b0 = b00 | b01 | b02 | b03
-
-    let b10 = UInt32(block[block.startIndex.advanced(by: 4)])
-    let b11 = UInt32(block[block.startIndex.advanced(by: 5)]) << 8
-    let b12 = UInt32(block[block.startIndex.advanced(by: 6)]) << 16
-    let b13 = UInt32(block[block.startIndex.advanced(by: 7)]) << 24
-    var b1 = b10 | b11 | b12 | b13
-
-    let b20 = UInt32(block[block.startIndex.advanced(by: 8)])
-    let b21 = UInt32(block[block.startIndex.advanced(by: 9)]) << 8
-    let b22 = UInt32(block[block.startIndex.advanced(by: 10)]) << 16
-    let b23 = UInt32(block[block.startIndex.advanced(by: 11)]) << 24
-    var b2 = b20 | b21 | b22 | b23
-
-    let b30 = UInt32(block[block.startIndex.advanced(by: 12)])
-    let b31 = UInt32(block[block.startIndex.advanced(by: 13)]) << 8
-    let b32 = UInt32(block[block.startIndex.advanced(by: 14)]) << 16
-    let b33 = UInt32(block[block.startIndex.advanced(by: 15)]) << 24
-    var b3 = b30 | b31 | b32 | b33
-
-    let tLength = 4
-    let t = UnsafeMutablePointer<UInt32>.allocate(capacity: tLength)
-    t.initialize(repeating: 0, count: tLength)
-    defer {
-      t.deinitialize(count: tLength)
-      t.deallocate()
-    }
-
-    for r in 0..<rounds - 1 {
-      t[0] = b0 ^ rk[r][0]
-      t[1] = b1 ^ rk[r][1]
-      t[2] = b2 ^ rk[r][2]
-      t[3] = b3 ^ rk[r][3]
-
-      let lb00 = AES.T0[Int(t[0] & 0xff)]
-      let lb01 = AES.T1[Int((t[1] >> 8) & 0xff)]
-      let lb02 = AES.T2[Int((t[2] >> 16) & 0xff)]
-      let lb03 = AES.T3[Int(t[3] >> 24)]
-      b0 = lb00 ^ lb01 ^ lb02 ^ lb03
-
-      let lb10 = AES.T0[Int(t[1] & 0xff)]
-      let lb11 = AES.T1[Int((t[2] >> 8) & 0xff)]
-      let lb12 = AES.T2[Int((t[3] >> 16) & 0xff)]
-      let lb13 = AES.T3[Int(t[0] >> 24)]
-      b1 = lb10 ^ lb11 ^ lb12 ^ lb13
-
-      let lb20 = AES.T0[Int(t[2] & 0xff)]
-      let lb21 = AES.T1[Int((t[3] >> 8) & 0xff)]
-      let lb22 = AES.T2[Int((t[0] >> 16) & 0xff)]
-      let lb23 = AES.T3[Int(t[1] >> 24)]
-      b2 = lb20 ^ lb21 ^ lb22 ^ lb23
-
-      let lb30 = AES.T0[Int(t[3] & 0xff)]
-      let lb31 = AES.T1[Int((t[0] >> 8) & 0xff)]
-      let lb32 = AES.T2[Int((t[1] >> 16) & 0xff)]
-      let lb33 = AES.T3[Int(t[2] >> 24)]
-      b3 = lb30 ^ lb31 ^ lb32 ^ lb33
-    }
-
-    // last round
-    let r = rounds - 1
-
-    t[0] = b0 ^ rk[r][0]
-    t[1] = b1 ^ rk[r][1]
-    t[2] = b2 ^ rk[r][2]
-    t[3] = b3 ^ rk[r][3]
-
-    // rounds
-    b0 = F1(t[0], t[1], t[2], t[3]) ^ rk[rounds][0]
-    b1 = F1(t[1], t[2], t[3], t[0]) ^ rk[rounds][1]
-    b2 = F1(t[2], t[3], t[0], t[1]) ^ rk[rounds][2]
-    b3 = F1(t[3], t[0], t[1], t[2]) ^ rk[rounds][3]
-
-    let encrypted: Array<UInt8> = [
-      UInt8(b0 & 0xff), UInt8((b0 >> 8) & 0xff), UInt8((b0 >> 16) & 0xff), UInt8((b0 >> 24) & 0xff),
-      UInt8(b1 & 0xff), UInt8((b1 >> 8) & 0xff), UInt8((b1 >> 16) & 0xff), UInt8((b1 >> 24) & 0xff),
-      UInt8(b2 & 0xff), UInt8((b2 >> 8) & 0xff), UInt8((b2 >> 16) & 0xff), UInt8((b2 >> 24) & 0xff),
-      UInt8(b3 & 0xff), UInt8((b3 >> 8) & 0xff), UInt8((b3 >> 16) & 0xff), UInt8((b3 >> 24) & 0xff)
-    ]
-    return encrypted
-  }
-  @usableFromInline
-  final internal func decrypt(block: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>?
-  @objc deinit
-}
-extension OICommons.AES {
-  @usableFromInline
-  @inline(__always) final internal func F1(_ x0: Swift.UInt32, _ x1: Swift.UInt32, _ x2: Swift.UInt32, _ x3: Swift.UInt32) -> Swift.UInt32
-}
-extension OICommons.AES : OICommons.Cipher {
-  @inlinable final public func encrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8> {
-    let blockSize = self.blockMode.customBlockSize ?? AES.blockSize
-    let chunks = bytes.batched(by: blockSize)
-
-    var oneTimeCryptor = try makeEncryptor()
-    var out = Array<UInt8>(reserveCapacity: bytes.count)
-    for chunk in chunks {
-      out += try oneTimeCryptor.update(withBytes: chunk, isLast: false)
-    }
-    // Padding may be added at the very end
-    out += try oneTimeCryptor.finish()
-
-    if self.blockMode.options.contains(.paddingRequired) && (out.count % AES.blockSize != 0) {
-      throw Error.dataPaddingRequired
-    }
-
-    return out
-  }
-  @inlinable final public func decrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8> {
-    if self.blockMode.options.contains(.paddingRequired) && (bytes.count % AES.blockSize != 0) {
-      throw Error.dataPaddingRequired
-    }
-
-    var oneTimeCryptor = try makeDecryptor()
-    let chunks = bytes.batched(by: AES.blockSize)
-    if chunks.isEmpty {
-      throw Error.invalidData
-    }
-
-    var out = Array<UInt8>(reserveCapacity: bytes.count)
-
-    var lastIdx = chunks.startIndex
-    chunks.indices.formIndex(&lastIdx, offsetBy: chunks.count - 1)
-
-    // To properly remove padding, `isLast` has to be known when called with the last chunk of ciphertext
-    // Last chunk of ciphertext may contains padded data so next call to update(..) won't be able to remove it
-    for idx in chunks.indices {
-      out += try oneTimeCryptor.update(withBytes: chunks[idx], isLast: idx == lastIdx)
-    }
-    return out
-  }
-}
-@_inheritsConvenienceInitializers final public class CBCMAC : OICommons.CMAC {
-  override final public func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  override public init(key: Swift.Array<Swift.UInt8>) throws
-  @objc deinit
-}
-extension Swift.UInt64 {
-  @_specialize(exported: false, kind: full, where T == Swift.ArraySlice<Swift.UInt8>)
-  @inlinable internal init<T>(bytes: T, fromIndex index: T.Index) where T : Swift.Collection, T.Element == Swift.UInt8, T.Index == Swift.Int {
-    if bytes.isEmpty {
-      self = 0
-      return
-    }
-
-    let count = bytes.count
-
-    let val0 = count > 0 ? UInt64(bytes[index.advanced(by: 0)]) << 56 : 0
-    let val1 = count > 1 ? UInt64(bytes[index.advanced(by: 1)]) << 48 : 0
-    let val2 = count > 2 ? UInt64(bytes[index.advanced(by: 2)]) << 40 : 0
-    let val3 = count > 3 ? UInt64(bytes[index.advanced(by: 3)]) << 32 : 0
-    let val4 = count > 4 ? UInt64(bytes[index.advanced(by: 4)]) << 24 : 0
-    let val5 = count > 5 ? UInt64(bytes[index.advanced(by: 5)]) << 16 : 0
-    let val6 = count > 6 ? UInt64(bytes[index.advanced(by: 6)]) << 8 : 0
-    let val7 = count > 7 ? UInt64(bytes[index.advanced(by: 7)]) : 0
-
-    self = val0 | val1 | val2 | val3 | val4 | val5 | val6 | val7
-  }
-}
-final public class OCB : OICommons.BlockMode {
-  public enum Mode {
-    case combined
-    case detached
-    public static func == (a: OICommons.OCB.Mode, b: OICommons.OCB.Mode) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  final public let options: OICommons.BlockModeOption
-  public enum Error : Swift.Error {
-    case invalidNonce
-    case fail
-    public static func == (a: OICommons.OCB.Error, b: OICommons.OCB.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  final public let customBlockSize: Swift.Int?
-  final public var authenticationTag: Swift.Array<Swift.UInt8>?
-  public init(nonce N: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil, tagLength: Swift.Int = 16, mode: OICommons.OCB.Mode = .detached)
-  @inlinable convenience public init(nonce N: Swift.Array<Swift.UInt8>, authenticationTag: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil, mode: OICommons.OCB.Mode = .detached) {
-    self.init(nonce: N, additionalAuthenticatedData: additionalAuthenticatedData, tagLength: authenticationTag.count, mode: mode)
-    self.authenticationTag = authenticationTag
-  }
-  final public func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-  @objc deinit
-}
-@usableFromInline
-final internal class BlockEncryptor : OICommons.Cryptor, OICommons.Updatable {
-  @usableFromInline
-  internal init(blockSize: Swift.Int, padding: OICommons.Padding, _ worker: OICommons.CipherModeWorker) throws
-  final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool) throws -> Swift.Array<Swift.UInt8>
-  @usableFromInline
-  final internal func seek(to: Swift.Int) throws
-  @objc @usableFromInline
-  deinit
-}
-public enum EnvironmentManager {
-  public static func facecaptchaBaseUrl(from environment: OICommons.Environment) -> Swift.String
-  public static func certifaceBaseUrl(from environment: OICommons.Environment) -> Swift.String
-}
-extension OICommons.HMAC {
-  convenience public init(key: Swift.String, variant: OICommons.HMAC.Variant = .md5) throws
-}
-@_hasMissingDesignatedInitializers final public class FCWrapper {
-  final public var ok: Swift.Bool
-  public init(json: Swift.String)
-  final public func map<T>(optional: Swift.Bool = false, withClosure closure: ((OICommons.FCWrapper) -> (T?))? = nil) -> T?
-  final public func mapArrayOfObjects<T>(optional: Swift.Bool = false, withClosure closure: (OICommons.FCWrapper) -> (T.Iterator.Element)) -> T? where T : Swift.Collection
-  final public subscript(name: Swift.String) -> OICommons.FCWrapper {
-    get
-  }
-  @objc deinit
-}
-public enum Environment : Swift.String, Swift.CaseIterable {
-  case HML
-  case PRD
-  public init?(rawValue: Swift.String)
-  public typealias AllCases = [OICommons.Environment]
-  public typealias RawValue = Swift.String
-  public static var allCases: [OICommons.Environment] {
-    get
-  }
-  public var rawValue: Swift.String {
-    get
-  }
-}
-final public class MD5 {
-  public init()
-  final public func calculate(for bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-  @objc deinit
-}
-extension OICommons.MD5 : OICommons.Updatable {
-  final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8>
-}
-extension Swift.FixedWidthInteger {
-  @inlinable internal func bytes(totalBytes: Swift.Int = MemoryLayout<Self>.size) -> Swift.Array<Swift.UInt8> {
-    arrayOfBytes(value: self.littleEndian, length: totalBytes)
-    // TODO: adjust bytes order
-    // var value = self.littleEndian
-    // return withUnsafeBytes(of: &value, Array.init).reversed()
-  }
-}
-extension OICommons.PKCS5 {
-  public struct PBKDF1 {
-    public enum Error : Swift.Error {
-      case invalidInput
-      case derivedKeyTooLong
-      public static func == (a: OICommons.PKCS5.PBKDF1.Error, b: OICommons.PKCS5.PBKDF1.Error) -> Swift.Bool
-      public func hash(into hasher: inout Swift.Hasher)
-      public var hashValue: Swift.Int {
-        get
-      }
-    }
-    public enum Variant {
-      case md5, sha1
-      @usableFromInline
-      internal var size: Swift.Int {
-        get
-      }
-      @usableFromInline
-      internal func calculateHash(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-      public static func == (a: OICommons.PKCS5.PBKDF1.Variant, b: OICommons.PKCS5.PBKDF1.Variant) -> Swift.Bool
-      public func hash(into hasher: inout Swift.Hasher)
-      public var hashValue: Swift.Int {
-        get
-      }
-    }
-    @usableFromInline
-    internal let iterations: Swift.Int
-    @usableFromInline
-    internal let variant: OICommons.PKCS5.PBKDF1.Variant
-    @usableFromInline
-    internal let keyLength: Swift.Int
-    @usableFromInline
-    internal let t1: Swift.Array<Swift.UInt8>
-    public init(password: Swift.Array<Swift.UInt8>, salt: Swift.Array<Swift.UInt8>, variant: OICommons.PKCS5.PBKDF1.Variant = .sha1, iterations: Swift.Int = 4096, keyLength: Swift.Int? = nil) throws
-    @inlinable public func calculate() -> Swift.Array<Swift.UInt8> {
-      var t = self.t1
-      for _ in 2...self.iterations {
-        t = self.variant.calculateHash(t)
-      }
-      return Array(t[0..<self.keyLength])
-    }
-  }
-}
-public struct ECB : OICommons.BlockMode {
-  public let options: OICommons.BlockModeOption
-  public let customBlockSize: Swift.Int?
-  public init()
-  public func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-}
-public struct CTR {
-  public enum Error : Swift.Error {
-    case invalidInitializationVector
-    public static func == (a: OICommons.CTR.Error, b: OICommons.CTR.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public let options: OICommons.BlockModeOption
-  public let customBlockSize: Swift.Int?
-  public init(iv: Swift.Array<Swift.UInt8>, counter: Swift.Int = 0)
-  public func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-}
-@usableFromInline
-final internal class StreamEncryptor : OICommons.Cryptor, OICommons.Updatable {
-  @usableFromInline
-  final internal let blockSize: Swift.Int
-  @usableFromInline
-  final internal var worker: OICommons.CipherModeWorker
-  @usableFromInline
-  final internal let padding: OICommons.Padding
-  @usableFromInline
-  final internal var lastBlockRemainder: Swift.Int
-  @usableFromInline
-  internal init(blockSize: Swift.Int, padding: OICommons.Padding, _ worker: OICommons.CipherModeWorker) throws
-  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool) throws -> Swift.Array<Swift.UInt8> {
-    var accumulated = Array(bytes)
-    if isLast {
-      // CTR doesn't need padding. Really. Add padding to the last block if really want. but... don't.
-      accumulated = self.padding.add(to: accumulated, blockSize: self.blockSize - self.lastBlockRemainder)
-    }
-
-    var encrypted = Array<UInt8>(reserveCapacity: bytes.count)
-    for chunk in accumulated.batched(by: self.blockSize) {
-      encrypted += self.worker.encrypt(block: chunk)
-    }
-
-    // omit unecessary calculation if not needed
-    if self.padding != .noPadding {
-      self.lastBlockRemainder = encrypted.count.quotientAndRemainder(dividingBy: self.blockSize).remainder
-    }
-
-    if var finalizingWorker = worker as? FinalizingEncryptModeWorker, isLast == true {
-      encrypted = Array(try finalizingWorker.finalize(encrypt: encrypted.slice))
-    }
-
-    return encrypted
-  }
-  @usableFromInline
-  final internal func seek(to: Swift.Int) throws
-  @objc @usableFromInline
-  deinit
-}
-public protocol AEAD {
-  static var kLen: Swift.Int { get }
-  static var ivRange: Swift.Range<Swift.Int> { get }
-}
-@_specialize(exported: false, kind: full, where T == Swift.Int)
-@_specialize(exported: false, kind: full, where T == Swift.UInt)
-@_specialize(exported: false, kind: full, where T == Swift.UInt8)
-@_specialize(exported: false, kind: full, where T == Swift.UInt16)
-@_specialize(exported: false, kind: full, where T == Swift.UInt32)
-@_specialize(exported: false, kind: full, where T == Swift.UInt64)
-@inlinable internal func arrayOfBytes<T>(value: T, length totalBytes: Swift.Int = MemoryLayout<T>.size) -> Swift.Array<Swift.UInt8> where T : Swift.FixedWidthInteger {
-  let valuePointer = UnsafeMutablePointer<T>.allocate(capacity: 1)
-  valuePointer.pointee = value
-
-  let bytesPointer = UnsafeMutablePointer<UInt8>(OpaquePointer(valuePointer))
-  var bytes = Array<UInt8>(repeating: 0, count: totalBytes)
-  for j in 0..<min(MemoryLayout<T>.size, totalBytes) {
-    bytes[totalBytes - 1 - j] = (bytesPointer + j).pointee
-  }
-
-  valuePointer.deinitialize(count: 1)
-  valuePointer.deallocate()
-
-  return bytes
-}
-public protocol _UInt8Type {
-}
-extension Swift.UInt8 : OICommons._UInt8Type {
-}
-extension Swift.UInt8 {
-  public func bits() -> [OICommons.Bit]
-  public func bits() -> Swift.String
-}
-@objc @_inheritsConvenienceInitializers @_Concurrency.MainActor(unsafe) open class FCBaseView : UIKit.UIView {
-  @_Concurrency.MainActor(unsafe) @objc required dynamic public init?(coder aDecoder: Foundation.NSCoder)
-  @_Concurrency.MainActor(unsafe) @objc override dynamic public init(frame: CoreFoundation.CGRect)
-  @_Concurrency.MainActor(unsafe) open func setupView()
-  @objc deinit
-}
-final public class SHA1 {
-  @usableFromInline
-  internal static let digestLength: Swift.Int
-  @usableFromInline
-  internal static let blockSize: Swift.Int
-  @usableFromInline
-  internal static let hashInitialValue: Swift.ContiguousArray<Swift.UInt32>
-  @usableFromInline
-  final internal var accumulated: [Swift.UInt8]
-  @usableFromInline
-  final internal var processedBytesTotalCount: Swift.Int
-  @usableFromInline
-  final internal var accumulatedHash: Swift.ContiguousArray<Swift.UInt32>
-  public init()
-  @inlinable final public func calculate(for bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8> {
-    do {
-      return try update(withBytes: bytes.slice, isLast: true)
-    } catch {
-      return []
-    }
-  }
-  @usableFromInline
-  final internal func process(block chunk: Swift.ArraySlice<Swift.UInt8>, currentHash hh: inout Swift.ContiguousArray<Swift.UInt32>)
-  @objc deinit
-}
-extension OICommons.SHA1 : OICommons.Updatable {
-  @discardableResult
-  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
-    self.accumulated += bytes
-
-    if isLast {
-      let lengthInBits = (processedBytesTotalCount + self.accumulated.count) * 8
-      let lengthBytes = lengthInBits.bytes(totalBytes: 64 / 8) // A 64-bit representation of b
-
-      // Step 1. Append padding
-      bitPadding(to: &self.accumulated, blockSize: SHA1.blockSize, allowance: 64 / 8)
-
-      // Step 2. Append Length a 64-bit representation of lengthInBits
-      self.accumulated += lengthBytes
-    }
-
-    var processedBytes = 0
-    for chunk in self.accumulated.batched(by: SHA1.blockSize) {
-      if isLast || (self.accumulated.count - processedBytes) >= SHA1.blockSize {
-        self.process(block: chunk, currentHash: &self.accumulatedHash)
-        processedBytes += chunk.count
-      }
-    }
-    self.accumulated.removeFirst(processedBytes)
-    self.processedBytesTotalCount += processedBytes
-
-    // output current hash
-    var result = Array<UInt8>(repeating: 0, count: SHA1.digestLength)
-    var pos = 0
-    for idx in 0..<self.accumulatedHash.count {
-      let h = self.accumulatedHash[idx]
-      result[pos + 0] = UInt8((h >> 24) & 0xff)
-      result[pos + 1] = UInt8((h >> 16) & 0xff)
-      result[pos + 2] = UInt8((h >> 8) & 0xff)
-      result[pos + 3] = UInt8(h & 0xff)
-      pos += 4
-    }
-
-    // reset hash value for instance
-    if isLast {
-      self.accumulatedHash = SHA1.hashInitialValue
-    }
-
-    return result
-  }
-}
-final public class Checksum {
-  @usableFromInline
-  internal static let table32: [Swift.UInt32]
-  @usableFromInline
-  internal static let table32c: [Swift.UInt32]
-  @usableFromInline
-  internal static let table16: [Swift.UInt16]
-  @usableFromInline
-  internal init()
-  @inlinable final internal func crc32(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32 {
-    var crc: UInt32 = seed != nil ? seed! : 0xFFFF_FFFF
-    for chunk in message.batched(by: 256) {
-      for b in chunk {
-        let idx = Int((crc ^ UInt32(reflect ? b : reversed(b))) & 0xFF)
-        crc = (crc >> 8) ^ Checksum.table32[idx]
-      }
-    }
-    return (reflect ? crc : reversed(crc)) ^ 0xFFFF_FFFF
-  }
-  @inlinable final internal func crc32c(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32 {
-    var crc: UInt32 = seed != nil ? seed! : 0xFFFF_FFFF
-    for chunk in message.batched(by: 256) {
-      for b in chunk {
-        let idx = Int((crc ^ UInt32(reflect ? b : reversed(b))) & 0xFF)
-        crc = (crc >> 8) ^ Checksum.table32c[idx]
-      }
-    }
-    return (reflect ? crc : reversed(crc)) ^ 0xFFFF_FFFF
-  }
-  @inlinable final internal func crc16(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt16? = nil) -> Swift.UInt16 {
-    var crc: UInt16 = seed != nil ? seed! : 0x0000
-    for chunk in message.batched(by: 256) {
-      for b in chunk {
-        crc = (crc >> 8) ^ Checksum.table16[Int((crc ^ UInt16(b)) & 0xFF)]
-      }
-    }
-    return crc
-  }
-  @objc deinit
-}
-extension OICommons.Checksum {
-  @inlinable public static func crc32(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32 {
-    Checksum().crc32(message, seed: seed, reflect: reflect)
-  }
-  @inlinable public static func crc32c(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32 {
-    Checksum().crc32c(message, seed: seed, reflect: reflect)
-  }
-  @inlinable public static func crc16(_ message: Swift.Array<Swift.UInt8>, seed: Swift.UInt16? = nil) -> Swift.UInt16 {
-    Checksum().crc16(message, seed: seed)
-  }
-}
-final public class Scrypt {
-  public init(password: Swift.Array<Swift.UInt8>, salt: Swift.Array<Swift.UInt8>, dkLen: Swift.Int, N: Swift.Int, r: Swift.Int, p: Swift.Int) throws
-  final public func calculate() throws -> [Swift.UInt8]
-  @objc deinit
-}
-extension OICommons.PKCS5 {
-  public struct PBKDF2 {
-    public enum Error : Swift.Error {
-      case invalidInput
-      case derivedKeyTooLong
-      public static func == (a: OICommons.PKCS5.PBKDF2.Error, b: OICommons.PKCS5.PBKDF2.Error) -> Swift.Bool
-      public func hash(into hasher: inout Swift.Hasher)
-      public var hashValue: Swift.Int {
-        get
-      }
-    }
-    public init(password: Swift.Array<Swift.UInt8>, salt: Swift.Array<Swift.UInt8>, iterations: Swift.Int = 4096, keyLength: Swift.Int? = nil, variant: OICommons.HMAC.Variant = .sha256) throws
-    public func calculate() throws -> Swift.Array<Swift.UInt8>
-  }
-}
-final public class SHA3 {
-  final public let blockSize: Swift.Int
-  final public let digestLength: Swift.Int
-  final public let markByte: Swift.UInt8
-  @usableFromInline
-  final internal var accumulated: [Swift.UInt8]
-  @usableFromInline
-  final internal var accumulatedHash: Swift.Array<Swift.UInt64>
-  public enum Variant {
-    case sha224, sha256, sha384, sha512, keccak224, keccak256, keccak384, keccak512
-    public var outputLength: Swift.Int {
-      get
-    }
-    public static func == (a: OICommons.SHA3.Variant, b: OICommons.SHA3.Variant) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public init(variant: OICommons.SHA3.Variant)
-  @inlinable final public func calculate(for bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8> {
-    do {
-      return try update(withBytes: bytes.slice, isLast: true)
-    } catch {
-      return []
-    }
-  }
-  @usableFromInline
-  final internal func process(block chunk: Swift.ArraySlice<Swift.UInt64>, currentHash hh: inout Swift.Array<Swift.UInt64>)
-  @objc deinit
-}
-extension OICommons.SHA3 : OICommons.Updatable {
-  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
-    self.accumulated += bytes
-
-    if isLast {
-      // Add padding
-      let markByteIndex = self.accumulated.count
-
-      // We need to always pad the input. Even if the input is a multiple of blockSize.
-      let r = self.blockSize * 8
-      let q = (r / 8) - (accumulated.count % (r / 8))
-      self.accumulated += Array<UInt8>(repeating: 0, count: q)
-
-      self.accumulated[markByteIndex] |= self.markByte
-      self.accumulated[self.accumulated.count - 1] |= 0x80
-    }
-
-    var processedBytes = 0
-    for chunk in self.accumulated.batched(by: self.blockSize) {
-      if isLast || (self.accumulated.count - processedBytes) >= self.blockSize {
-        self.process(block: chunk.toUInt64Array().slice, currentHash: &self.accumulatedHash)
-        processedBytes += chunk.count
-      }
-    }
-    self.accumulated.removeFirst(processedBytes)
-
-    // TODO: verify performance, reduce vs for..in
-    let result = self.accumulatedHash.reduce(into: Array<UInt8>()) { (result, value) in
-      result += value.bigEndian.bytes()
-    }
-
-    // reset hash value for instance
-    if isLast {
-      self.accumulatedHash = Array<UInt64>(repeating: 0, count: self.digestLength)
-    }
-
-    return Array(result[0..<self.digestLength])
-  }
-}
-extension Swift.Array {
-  @inlinable internal init(reserveCapacity: Swift.Int) {
-    self = Array<Element>()
-    self.reserveCapacity(reserveCapacity)
-  }
-  @inlinable internal var slice: Swift.ArraySlice<Element> {
-    get {
-    self[self.startIndex ..< self.endIndex]
-  }
-  }
-}
-extension Swift.Array where Element == Swift.UInt8 {
-  public init(hex: Swift.String)
-  public func toHexString() -> Swift.String
-}
-extension Swift.Array where Element == Swift.UInt8 {
-  @available(*, deprecated)
-  public func chunks(size chunksize: Swift.Int) -> Swift.Array<Swift.Array<Element>>
-  public func md5() -> [Element]
-  public func sha1() -> [Element]
-  public func sha224() -> [Element]
-  public func sha256() -> [Element]
-  public func sha384() -> [Element]
-  public func sha512() -> [Element]
-  public func sha2(_ variant: OICommons.SHA2.Variant) -> [Element]
-  public func sha3(_ variant: OICommons.SHA3.Variant) -> [Element]
-  public func crc32(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32
-  public func crc32c(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.UInt32
-  public func crc16(seed: Swift.UInt16? = nil) -> Swift.UInt16
-  public func encrypt(cipher: OICommons.Cipher) throws -> [Element]
-  public func decrypt(cipher: OICommons.Cipher) throws -> [Element]
-  public func authenticate<A>(with authenticator: A) throws -> [Element] where A : OICommons.Authenticator
-}
-extension UIKit.UIView {
-  @_Concurrency.MainActor(unsafe) public func createImageFromView() -> UIKit.UIImage
-}
-public protocol Cryptor {
-  mutating func seek(to: Swift.Int) throws
-}
-final public class SHA2 {
-  @usableFromInline
-  final internal let variant: OICommons.SHA2.Variant
-  @usableFromInline
-  final internal let size: Swift.Int
-  @usableFromInline
-  final internal let blockSize: Swift.Int
-  @usableFromInline
-  final internal let digestLength: Swift.Int
-  @usableFromInline
-  final internal var accumulated: [Swift.UInt8]
-  @usableFromInline
-  final internal var processedBytesTotalCount: Swift.Int
-  @usableFromInline
-  final internal var accumulatedHash32: [Swift.UInt32]
-  @usableFromInline
-  final internal var accumulatedHash64: [Swift.UInt64]
-  public enum Variant : Swift.RawRepresentable {
-    case sha224, sha256, sha384, sha512
-    public var digestLength: Swift.Int {
-      get
-    }
-    public var blockSize: Swift.Int {
-      get
-    }
-    public typealias RawValue = Swift.Int
-    public var rawValue: OICommons.SHA2.Variant.RawValue {
-      get
-    }
-    public init?(rawValue: OICommons.SHA2.Variant.RawValue)
-    @usableFromInline
-    internal var h: Swift.Array<Swift.UInt64> {
-      get
-    }
-    @usableFromInline
-    internal var finalLength: Swift.Int {
-      get
-    }
-  }
-  public init(variant: OICommons.SHA2.Variant)
-  @inlinable final public func calculate(for bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8> {
-    do {
-      return try update(withBytes: bytes.slice, isLast: true)
-    } catch {
-      return []
-    }
-  }
-  @usableFromInline
-  final internal func process64(block chunk: Swift.ArraySlice<Swift.UInt8>, currentHash hh: inout Swift.Array<Swift.UInt64>)
-  @usableFromInline
-  final internal func process32(block chunk: Swift.ArraySlice<Swift.UInt8>, currentHash hh: inout Swift.Array<Swift.UInt32>)
-  @objc deinit
-}
-extension OICommons.SHA2 : OICommons.Updatable {
-  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
-    self.accumulated += bytes
-
-    if isLast {
-      let lengthInBits = (processedBytesTotalCount + self.accumulated.count) * 8
-      let lengthBytes = lengthInBits.bytes(totalBytes: self.blockSize / 8) // A 64-bit/128-bit representation of b. blockSize fit by accident.
-
-      // Step 1. Append padding
-      bitPadding(to: &self.accumulated, blockSize: self.blockSize, allowance: self.blockSize / 8)
-
-      // Step 2. Append Length a 64-bit representation of lengthInBits
-      self.accumulated += lengthBytes
-    }
-
-    var processedBytes = 0
-    for chunk in self.accumulated.batched(by: self.blockSize) {
-      if isLast || (self.accumulated.count - processedBytes) >= self.blockSize {
-        switch self.variant {
-          case .sha224, .sha256:
-            self.process32(block: chunk, currentHash: &self.accumulatedHash32)
-          case .sha384, .sha512:
-            self.process64(block: chunk, currentHash: &self.accumulatedHash64)
-          @unknown default:
-            preconditionFailure()
-          }
-        processedBytes += chunk.count
-      }
-    }
-    self.accumulated.removeFirst(processedBytes)
-    self.processedBytesTotalCount += processedBytes
-
-    // output current hash
-    var result = Array<UInt8>(repeating: 0, count: variant.digestLength)
-    switch self.variant {
-      case .sha224, .sha256:
-        var pos = 0
-        for idx in 0..<self.accumulatedHash32.count where idx < self.variant.finalLength {
-          let h = accumulatedHash32[idx]
-          result[pos + 0] = UInt8((h >> 24) & 0xff)
-          result[pos + 1] = UInt8((h >> 16) & 0xff)
-          result[pos + 2] = UInt8((h >> 8) & 0xff)
-          result[pos + 3] = UInt8(h & 0xff)
-          pos += 4
-        }
-      case .sha384, .sha512:
-        var pos = 0
-        for idx in 0..<self.accumulatedHash64.count where idx < self.variant.finalLength {
-          let h = accumulatedHash64[idx]
-          result[pos + 0] = UInt8((h >> 56) & 0xff)
-          result[pos + 1] = UInt8((h >> 48) & 0xff)
-          result[pos + 2] = UInt8((h >> 40) & 0xff)
-          result[pos + 3] = UInt8((h >> 32) & 0xff)
-          result[pos + 4] = UInt8((h >> 24) & 0xff)
-          result[pos + 5] = UInt8((h >> 16) & 0xff)
-          result[pos + 6] = UInt8((h >> 8) & 0xff)
-          result[pos + 7] = UInt8(h & 0xff)
-          pos += 8
-        }
-      @unknown default:
-          preconditionFailure()
-    }
-
-    // reset hash value for instance
-    if isLast {
-      switch self.variant {
-        case .sha224, .sha256:
-          self.accumulatedHash32 = self.variant.h.lazy.map { UInt32($0) } // FIXME: UInt64 for process64
-        case .sha384, .sha512:
-          self.accumulatedHash64 = self.variant.h
-        @unknown default:
-          preconditionFailure()
-      }
-    }
-
-    return result
-  }
-}
-extension OICommons.AES {
-  convenience public init(key: Swift.String, iv: Swift.String, padding: OICommons.Padding = .pkcs7) throws
-}
-public protocol CipherModeWorker {
-  var cipherOperation: OICommons.CipherOperationOnBlock { get }
-  var additionalBufferSize: Swift.Int { get }
-  @inlinable mutating func encrypt(block plaintext: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-  @inlinable mutating func decrypt(block ciphertext: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-}
-public protocol BlockModeWorker : OICommons.CipherModeWorker {
-  var blockSize: Swift.Int { get }
-}
-public protocol CounterModeWorker : OICommons.CipherModeWorker {
-  associatedtype Counter
-  var counter: Self.Counter { get set }
-}
-public protocol SeekableModeWorker : OICommons.CipherModeWorker {
-  mutating func seek(to position: Swift.Int) throws
-}
-public protocol StreamModeWorker : OICommons.CipherModeWorker {
-}
-public protocol FinalizingEncryptModeWorker : OICommons.CipherModeWorker {
-  mutating func finalize(encrypt ciphertext: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.ArraySlice<Swift.UInt8>
-}
-public protocol FinalizingDecryptModeWorker : OICommons.CipherModeWorker {
-  @discardableResult
-  mutating func willDecryptLast(bytes ciphertext: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.ArraySlice<Swift.UInt8>
-  mutating func didDecryptLast(bytes plaintext: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.ArraySlice<Swift.UInt8>
-  mutating func finalize(decrypt plaintext: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.ArraySlice<Swift.UInt8>
-}
-@available(*, renamed: "Digest")
-public typealias Hash = OICommons.Digest
-public struct Digest {
-  public static func md5(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-  public static func sha1(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-  public static func sha224(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-  public static func sha256(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-  public static func sha384(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-  public static func sha512(_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Array<Swift.UInt8>
-  public static func sha2(_ bytes: Swift.Array<Swift.UInt8>, variant: OICommons.SHA2.Variant) -> Swift.Array<Swift.UInt8>
-  public static func sha3(_ bytes: Swift.Array<Swift.UInt8>, variant: OICommons.SHA3.Variant) -> Swift.Array<Swift.UInt8>
-}
-extension UIKit.UIImage {
-  public static func rotatedImage(from cgImage: CoreGraphics.CGImage, rotatedBy degrees: Swift.Double) -> UIKit.UIImage?
-}
-@usableFromInline
-internal struct BatchedCollectionIndex<Base> where Base : Swift.Collection {
-}
-extension OICommons.BatchedCollectionIndex : Swift.Comparable {
-  @usableFromInline
-  internal static func == <Base>(lhs: OICommons.BatchedCollectionIndex<Base>, rhs: OICommons.BatchedCollectionIndex<Base>) -> Swift.Bool where Base : Swift.Collection
-  @usableFromInline
-  internal static func < <Base>(lhs: OICommons.BatchedCollectionIndex<Base>, rhs: OICommons.BatchedCollectionIndex<Base>) -> Swift.Bool where Base : Swift.Collection
-}
-@usableFromInline
-internal struct BatchedCollection<Base> : Swift.Collection where Base : Swift.Collection {
-  @usableFromInline
-  internal init(base: Base, size: Swift.Int)
-  @usableFromInline
-  internal typealias Index = OICommons.BatchedCollectionIndex<Base>
-  @usableFromInline
-  internal var startIndex: OICommons.BatchedCollection<Base>.Index {
-    get
-  }
-  @usableFromInline
-  internal var endIndex: OICommons.BatchedCollection<Base>.Index {
-    get
-  }
-  @usableFromInline
-  internal func index(after idx: OICommons.BatchedCollection<Base>.Index) -> OICommons.BatchedCollection<Base>.Index
-  @usableFromInline
-  internal subscript(idx: OICommons.BatchedCollection<Base>.Index) -> Base.SubSequence {
-    get
-  }
-  @usableFromInline
-  internal typealias Element = Base.SubSequence
-  @usableFromInline
-  internal typealias Indices = Swift.DefaultIndices<OICommons.BatchedCollection<Base>>
-  @usableFromInline
-  internal typealias Iterator = Swift.IndexingIterator<OICommons.BatchedCollection<Base>>
-  @usableFromInline
-  internal typealias SubSequence = Swift.Slice<OICommons.BatchedCollection<Base>>
-}
-extension Swift.Collection {
-  @inlinable internal func batched(by size: Swift.Int) -> OICommons.BatchedCollection<Self> {
-    BatchedCollection(base: self, size: size)
-  }
-}
-public struct CFB : OICommons.BlockMode {
-  public enum Error : Swift.Error {
-    case invalidInitializationVector
-    public static func == (a: OICommons.CFB.Error, b: OICommons.CFB.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public enum SegmentSize : Swift.Int {
-    case cfb8
-    case cfb128
-    public init?(rawValue: Swift.Int)
-    public typealias RawValue = Swift.Int
-    public var rawValue: Swift.Int {
-      get
-    }
-  }
-  public let options: OICommons.BlockModeOption
-  public let customBlockSize: Swift.Int?
-  public init(iv: Swift.Array<Swift.UInt8>, segmentSize: OICommons.CFB.SegmentSize = .cfb128)
-  public func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-}
-@_hasMissingDesignatedInitializers public class FCCipher {
-  public static let key: [Swift.UInt8]
-  public static let iv: [Swift.UInt8]
-  public static let key_string: Swift.String
-  public static let key_iv_string: Swift.String
-  public static func padMsg(_ source: Swift.String) -> Swift.String
-  public static func padKey(_ source: Swift.String) -> Swift.String
-  @objc deinit
-}
-extension OICommons.FCCipher {
-  public static func aesEncrypt(_ str: Swift.String, _ appKey: Swift.String) -> Swift.String
-  public static func aesDecrypt(_ str: Swift.String, _ appKey: Swift.String) -> Swift.String
-}
-public struct BlockModeOption : Swift.OptionSet {
-  public let rawValue: Swift.Int
-  public init(rawValue: Swift.Int)
-  @usableFromInline
-  internal static let none: OICommons.BlockModeOption
-  @usableFromInline
-  internal static let initializationVectorRequired: OICommons.BlockModeOption
-  @usableFromInline
-  internal static let paddingRequired: OICommons.BlockModeOption
-  @usableFromInline
-  internal static let useEncryptToDecrypt: OICommons.BlockModeOption
-  public typealias ArrayLiteralElement = OICommons.BlockModeOption
-  public typealias Element = OICommons.BlockModeOption
-  public typealias RawValue = Swift.Int
-}
-final public class Poly1305 : OICommons.Authenticator {
-  public enum Error : Swift.Error {
-    case authenticateError
-    public static func == (a: OICommons.Poly1305.Error, b: OICommons.Poly1305.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public static let blockSize: Swift.Int
-  public init(key: Swift.Array<Swift.UInt8>)
-  final public func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  @objc deinit
-}
-extension Swift.String {
-  public func addingPercentEncodingForURLQueryValue() -> Swift.String?
-  public func base64Encoded() -> Swift.String?
-  public func base64Decoded() -> Swift.String?
-  public func encodeURIComponent() -> Swift.String?
-}
-extension Swift.Dictionary {
-  public func stringFromHttpParameters() -> Swift.String
-}
-extension Swift.String {
-  @inlinable public var bytes: Swift.Array<Swift.UInt8> {
-    get {
-    data(using: String.Encoding.utf8, allowLossyConversion: true)?.bytes ?? Array(utf8)
-  }
-  }
-  @inlinable public func md5() -> Swift.String {
-    self.bytes.md5().toHexString()
-  }
-  @inlinable public func sha1() -> Swift.String {
-    self.bytes.sha1().toHexString()
-  }
-  @inlinable public func sha224() -> Swift.String {
-    self.bytes.sha224().toHexString()
-  }
-  @inlinable public func sha256() -> Swift.String {
-    self.bytes.sha256().toHexString()
-  }
-  @inlinable public func sha384() -> Swift.String {
-    self.bytes.sha384().toHexString()
-  }
-  @inlinable public func sha512() -> Swift.String {
-    self.bytes.sha512().toHexString()
-  }
-  @inlinable public func sha3(_ variant: OICommons.SHA3.Variant) -> Swift.String {
-    self.bytes.sha3(variant).toHexString()
-  }
-  @inlinable public func crc32(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.String {
-    self.bytes.crc32(seed: seed, reflect: reflect).bytes().toHexString()
-  }
-  @inlinable public func crc32c(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Swift.String {
-    self.bytes.crc32c(seed: seed, reflect: reflect).bytes().toHexString()
-  }
-  @inlinable public func crc16(seed: Swift.UInt16? = nil) -> Swift.String {
-    self.bytes.crc16(seed: seed).bytes().toHexString()
-  }
-  @inlinable public func encrypt(cipher: OICommons.Cipher) throws -> Swift.String {
-    try self.bytes.encrypt(cipher: cipher).toHexString()
-  }
-  @inlinable public func encryptToBase64(cipher: OICommons.Cipher) throws -> Swift.String? {
-    try self.bytes.encrypt(cipher: cipher).toBase64()
-  }
-  @inlinable public func authenticate<A>(with authenticator: A) throws -> Swift.String where A : OICommons.Authenticator {
-    try self.bytes.authenticate(with: authenticator).toHexString()
-  }
-}
-public enum HardwareStatusManager {
-  public static func checkCameraPermission(completion: @escaping (_ granted: Swift.Bool) -> Swift.Void)
-  public static func isConnectedToNetwork() -> Swift.Bool
-  public static func isOnPhoneCall() -> Swift.Bool
-}
-final public class Blowfish {
-  public enum Error : Swift.Error {
-    case dataPaddingRequired
-    case invalidKeyOrInitializationVector
-    case invalidInitializationVector
-    case invalidBlockMode
-    public static func == (a: OICommons.Blowfish.Error, b: OICommons.Blowfish.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public static let blockSize: Swift.Int
-  final public let keySize: Swift.Int
-  public init(key: Swift.Array<Swift.UInt8>, blockMode: OICommons.BlockMode = CBC(iv: Array<UInt8>(repeating: 0, count: Blowfish.blockSize)), padding: OICommons.Padding) throws
-  @objc deinit
-}
-extension OICommons.Blowfish : OICommons.Cipher {
-  final public func encrypt<C>(_ bytes: C) throws -> Swift.Array<Swift.UInt8> where C : Swift.Collection, C.Element == Swift.UInt8, C.Index == Swift.Int
-  final public func decrypt<C>(_ bytes: C) throws -> Swift.Array<Swift.UInt8> where C : Swift.Collection, C.Element == Swift.UInt8, C.Index == Swift.Int
-}
-extension Swift.Array where Element == Swift.UInt8 {
-  public func toBase64() -> Swift.String?
-  public init(base64: Swift.String)
-}
-extension OICommons.Blowfish {
-  convenience public init(key: Swift.String, iv: Swift.String, padding: OICommons.Padding = .pkcs7) throws
-}
-extension UIKit.UIDevice {
-  @_Concurrency.MainActor(unsafe) public static func vibrate()
-}
-extension UIKit.UIImage {
-  public static func fromGif(resourceName: Swift.String, bundle externalBundle: Foundation.Bundle? = nil, durationPerFrame duration: CoreFoundation.CGFloat) -> UIKit.UIImage?
-}
-public class ClosureSleeve {
-  public init(attachTo: Swift.AnyObject, closure: @escaping () -> Swift.Void)
-  @objc public func invoke()
-  @objc deinit
-}
-extension UIKit.UIControl {
-  @_Concurrency.MainActor(unsafe) public func addAction(for controlEvents: UIKit.UIControl.Event = .primaryActionTriggered, action: @escaping () -> Swift.Void)
-}
-extension UIKit.UIViewController {
-  @_Concurrency.MainActor(unsafe) public func showAlert(title: Swift.String?, message: Swift.String)
-}
-public struct Constants {
-  public static var FaceCaptchaImageHeight: Swift.Int
-  public static var FaceCaptchaImageWidth: Swift.Int
-  public static var FaceCaptchaImageQuality: Swift.Double
-  public static var DocLandscapeImageHeight: Swift.Int
-  public static var DocLandscapeImageWidth: Swift.Int
-  public static var DocPortraitImageHeight: Swift.Int
-  public static var DocPortraitImageWidth: Swift.Int
-  public static var DocImageQuality: Swift.Double
-}
-public protocol Updatable {
-  mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool) throws -> Swift.Array<Swift.UInt8>
-  mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws
-}
-extension OICommons.Updatable {
-  @inlinable public mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
-    let processed = try update(withBytes: bytes, isLast: isLast)
-    if !processed.isEmpty {
-      output(processed)
-    }
-  }
-  @inlinable public mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
-    try self.update(withBytes: bytes, isLast: isLast)
-  }
-  @inlinable public mutating func update(withBytes bytes: Swift.Array<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
-    try self.update(withBytes: bytes.slice, isLast: isLast)
-  }
-  @inlinable public mutating func update(withBytes bytes: Swift.Array<Swift.UInt8>, isLast: Swift.Bool = false, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
-    try self.update(withBytes: bytes.slice, isLast: isLast, output: output)
-  }
-  @inlinable public mutating func finish(withBytes bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8> {
-    try self.update(withBytes: bytes, isLast: true)
-  }
-  @inlinable public mutating func finish(withBytes bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8> {
-    try self.finish(withBytes: bytes.slice)
-  }
-  @inlinable public mutating func finish() throws -> Swift.Array<Swift.UInt8> {
-    try self.update(withBytes: [], isLast: true)
-  }
-  @inlinable public mutating func finish(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
-    let processed = try update(withBytes: bytes, isLast: true)
-    if !processed.isEmpty {
-      output(processed)
-    }
-  }
-  @inlinable public mutating func finish(withBytes bytes: Swift.Array<Swift.UInt8>, output: (_ bytes: Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
-    try self.finish(withBytes: bytes.slice, output: output)
-  }
-  @inlinable public mutating func finish(output: (Swift.Array<Swift.UInt8>) -> Swift.Void) throws {
-    try self.finish(withBytes: [], output: output)
-  }
-}
-@_hasMissingDesignatedInitializers final public class AEADChaCha20Poly1305 : OICommons.AEAD {
-  public static let kLen: Swift.Int
-  public static var ivRange: Swift.Range<Swift.Int>
-  public static func encrypt(_ plainText: Swift.Array<Swift.UInt8>, key: Swift.Array<Swift.UInt8>, iv: Swift.Array<Swift.UInt8>, authenticationHeader: Swift.Array<Swift.UInt8>) throws -> (cipherText: Swift.Array<Swift.UInt8>, authenticationTag: Swift.Array<Swift.UInt8>)
-  public static func decrypt(_ cipherText: Swift.Array<Swift.UInt8>, key: Swift.Array<Swift.UInt8>, iv: Swift.Array<Swift.UInt8>, authenticationHeader: Swift.Array<Swift.UInt8>, authenticationTag: Swift.Array<Swift.UInt8>) throws -> (plainText: Swift.Array<Swift.UInt8>, success: Swift.Bool)
-  @objc deinit
-}
-public struct OFB : OICommons.BlockMode {
-  public enum Error : Swift.Error {
-    case invalidInitializationVector
-    public static func == (a: OICommons.OFB.Error, b: OICommons.OFB.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public let options: OICommons.BlockModeOption
-  public let customBlockSize: Swift.Int?
-  public init(iv: Swift.Array<Swift.UInt8>)
-  public func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-}
-final public class ChaCha20 {
-  public enum Error : Swift.Error {
-    case invalidKeyOrInitializationVector
-    case notSupported
-    public static func == (a: OICommons.ChaCha20.Error, b: OICommons.ChaCha20.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public static let blockSize: Swift.Int
-  final public let keySize: Swift.Int
-  public init(key: Swift.Array<Swift.UInt8>, iv nonce: Swift.Array<Swift.UInt8>) throws
-  @objc deinit
-}
-extension OICommons.ChaCha20 : OICommons.Cipher {
-  final public func encrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  final public func decrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-}
-extension OICommons.ChaCha20 {
-  public struct ChaChaEncryptor : OICommons.Cryptor, OICommons.Updatable {
-    public mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8>
-    public func seek(to: Swift.Int) throws
-  }
-}
-extension OICommons.ChaCha20 {
-  public struct ChaChaDecryptor : OICommons.Cryptor, OICommons.Updatable {
-    public mutating func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = true) throws -> Swift.Array<Swift.UInt8>
-    public func seek(to: Swift.Int) throws
-  }
-}
-extension OICommons.ChaCha20 : OICommons.Cryptors {
-  final public func makeEncryptor() -> OICommons.Cryptor & OICommons.Updatable
-  final public func makeDecryptor() -> OICommons.Cryptor & OICommons.Updatable
-}
-public class CMAC : OICommons.Authenticator {
-  public enum Error : Swift.Error {
-    case wrongKeyLength
-    public static func == (a: OICommons.CMAC.Error, b: OICommons.CMAC.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public init(key: Swift.Array<Swift.UInt8>) throws
-  public func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  public func authenticate(_ bytes: Swift.Array<Swift.UInt8>, cipher: OICommons.Cipher) throws -> Swift.Array<Swift.UInt8>
-  @objc deinit
-}
-@_hasMissingDesignatedInitializers public class Logger {
-  public static let isLogEnabled: Swift.Bool
-  public static func log(_ items: Any...)
-  @objc deinit
-}
-extension UIKit.UIImage {
-  public func resizeImage(targetSize: CoreFoundation.CGSize) -> UIKit.UIImage?
-  public func toBase64(withSizeInMb expectedSizeInMb: Swift.Float) -> Swift.String?
-}
-extension Swift.String {
-  public func decryptBase64ToString(cipher: OICommons.Cipher) throws -> Swift.String
-  public func decryptBase64(cipher: OICommons.Cipher) throws -> Swift.Array<Swift.UInt8>
-}
-final public class HMAC : OICommons.Authenticator {
-  public enum Error : Swift.Error {
-    case authenticateError
-    case invalidInput
-    public static func == (a: OICommons.HMAC.Error, b: OICommons.HMAC.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public enum Variant {
-    case sha1, sha256, sha384, sha512, md5
-    public static func == (a: OICommons.HMAC.Variant, b: OICommons.HMAC.Variant) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public init(key: Swift.Array<Swift.UInt8>, variant: OICommons.HMAC.Variant = .md5)
-  final public func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  @objc deinit
-}
-public enum CipherError : Swift.Error {
-  case encrypt
-  case decrypt
-  public static func == (a: OICommons.CipherError, b: OICommons.CipherError) -> Swift.Bool
-  public func hash(into hasher: inout Swift.Hasher)
-  public var hashValue: Swift.Int {
-    get
-  }
-}
-public protocol Cipher : AnyObject {
-  var keySize: Swift.Int { get }
-  func encrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  func encrypt(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  func decrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  func decrypt(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-}
-extension OICommons.Cipher {
-  public func encrypt(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  public func decrypt(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-}
-extension Swift.Optional where Wrapped == Swift.String {
-  public var orEmpty: Swift.String {
-    get
-  }
-}
-extension Foundation.Data {
-  public func checksum() -> Swift.UInt16
-  public func md5() -> Foundation.Data
-  public func sha1() -> Foundation.Data
-  public func sha224() -> Foundation.Data
-  public func sha256() -> Foundation.Data
-  public func sha384() -> Foundation.Data
-  public func sha512() -> Foundation.Data
-  public func sha3(_ variant: OICommons.SHA3.Variant) -> Foundation.Data
-  public func crc32(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Foundation.Data
-  public func crc32c(seed: Swift.UInt32? = nil, reflect: Swift.Bool = true) -> Foundation.Data
-  public func crc16(seed: Swift.UInt16? = nil) -> Foundation.Data
-  public func encrypt(cipher: OICommons.Cipher) throws -> Foundation.Data
-  public func decrypt(cipher: OICommons.Cipher) throws -> Foundation.Data
-  public func authenticate(with authenticator: OICommons.Authenticator) throws -> Foundation.Data
-}
-extension Foundation.Data {
-  public init(hex: Swift.String)
-  public var bytes: Swift.Array<Swift.UInt8> {
-    get
-  }
-  public func toHexString() -> Swift.String
-}
-public enum Bit : Swift.Int {
-  case zero
-  case one
-  public init?(rawValue: Swift.Int)
-  public typealias RawValue = Swift.Int
-  public var rawValue: Swift.Int {
-    get
-  }
-}
-extension OICommons.Bit {
-  @inlinable internal func inverted() -> OICommons.Bit {
-    self == .zero ? .one : .zero
-  }
-}
-final public class Rabbit {
-  public enum Error : Swift.Error {
-    case invalidKeyOrInitializationVector
-    public static func == (a: OICommons.Rabbit.Error, b: OICommons.Rabbit.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public static let ivSize: Swift.Int
-  public static let keySize: Swift.Int
-  public static let blockSize: Swift.Int
-  final public var keySize: Swift.Int {
-    get
-  }
-  convenience public init(key: Swift.Array<Swift.UInt8>) throws
-  public init(key: Swift.Array<Swift.UInt8>, iv: Swift.Array<Swift.UInt8>?) throws
-  @objc deinit
-}
-extension OICommons.Rabbit : OICommons.Cipher {
-  final public func encrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-  final public func decrypt(_ bytes: Swift.ArraySlice<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-}
-@inlinable internal func rotateLeft(_ value: Swift.UInt8, by: Swift.UInt8) -> Swift.UInt8 {
-  ((value << by) & 0xff) | (value >> (8 - by))
-}
-@inlinable internal func rotateLeft(_ value: Swift.UInt16, by: Swift.UInt16) -> Swift.UInt16 {
-  ((value << by) & 0xffff) | (value >> (16 - by))
-}
-@inlinable internal func rotateLeft(_ value: Swift.UInt32, by: Swift.UInt32) -> Swift.UInt32 {
-  ((value << by) & 0xffffffff) | (value >> (32 - by))
-}
-@inlinable internal func rotateLeft(_ value: Swift.UInt64, by: Swift.UInt64) -> Swift.UInt64 {
-  (value << by) | (value >> (64 - by))
-}
-@inlinable internal func rotateRight(_ value: Swift.UInt16, by: Swift.UInt16) -> Swift.UInt16 {
-  (value >> by) | (value << (16 - by))
-}
-@inlinable internal func rotateRight(_ value: Swift.UInt32, by: Swift.UInt32) -> Swift.UInt32 {
-  (value >> by) | (value << (32 - by))
-}
-@inlinable internal func rotateRight(_ value: Swift.UInt64, by: Swift.UInt64) -> Swift.UInt64 {
-  ((value >> by) | (value << (64 - by)))
-}
-@inlinable internal func reversed(_ uint8: Swift.UInt8) -> Swift.UInt8 {
-  var v = uint8
-  v = (v & 0xf0) >> 4 | (v & 0x0f) << 4
-  v = (v & 0xcc) >> 2 | (v & 0x33) << 2
-  v = (v & 0xaa) >> 1 | (v & 0x55) << 1
-  return v
-}
-@inlinable internal func reversed(_ uint32: Swift.UInt32) -> Swift.UInt32 {
-  var v = uint32
-  v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1)
-  v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2)
-  v = ((v >> 4) & 0x0f0f0f0f) | ((v & 0x0f0f0f0f) << 4)
-  v = ((v >> 8) & 0x00ff00ff) | ((v & 0x00ff00ff) << 8)
-  v = ((v >> 16) & 0xffff) | ((v & 0xffff) << 16)
-  return v
-}
-@inlinable internal func xor<T, V>(_ left: T, _ right: V) -> Swift.ArraySlice<Swift.UInt8> where T : Swift.RandomAccessCollection, V : Swift.RandomAccessCollection, T.Element == Swift.UInt8, T.Index == Swift.Int, V.Element == Swift.UInt8, V.Index == Swift.Int {
-  return xor(left, right).slice
-}
-@inlinable internal func xor<T, V>(_ left: T, _ right: V) -> Swift.Array<Swift.UInt8> where T : Swift.RandomAccessCollection, V : Swift.RandomAccessCollection, T.Element == Swift.UInt8, T.Index == Swift.Int, V.Element == Swift.UInt8, V.Index == Swift.Int {
-  let length = Swift.min(left.count, right.count)
-
-  let buf = UnsafeMutablePointer<UInt8>.allocate(capacity: length)
-  buf.initialize(repeating: 0, count: length)
-  defer {
-    buf.deinitialize(count: length)
-    buf.deallocate()
-  }
-
-  // xor
-  for i in 0..<length {
-    buf[i] = left[left.startIndex.advanced(by: i)] ^ right[right.startIndex.advanced(by: i)]
-  }
-
-  return Array(UnsafeBufferPointer(start: buf, count: length))
-}
-@inline(__always) @inlinable internal func bitPadding(to data: inout Swift.Array<Swift.UInt8>, blockSize: Swift.Int, allowance: Swift.Int = 0) {
-  let msgLength = data.count
-  // Step 1. Append Padding Bits
-  // append one bit (UInt8 with one bit) to message
-  data.append(0x80)
-
-  // Step 2. append "0" bit until message length in bits ≡ 448 (mod 512)
-  let max = blockSize - allowance // 448, 986
-  if msgLength % blockSize < max { // 448
-    data += Array<UInt8>(repeating: 0, count: max - 1 - (msgLength % blockSize))
-  } else {
-    data += Array<UInt8>(repeating: 0, count: blockSize + max - 1 - (msgLength % blockSize))
-  }
-}
-extension OICommons.Rabbit {
-  convenience public init(key: Swift.String) throws
-  convenience public init(key: Swift.String, iv: Swift.String) throws
-}
-public struct HKDF {
-  public enum Error : Swift.Error {
-    case invalidInput
-    case derivedKeyTooLong
-    public static func == (a: OICommons.HKDF.Error, b: OICommons.HKDF.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public init(password: Swift.Array<Swift.UInt8>, salt: Swift.Array<Swift.UInt8>? = nil, info: Swift.Array<Swift.UInt8>? = nil, keyLength: Swift.Int? = nil, variant: OICommons.HMAC.Variant = .sha256) throws
-  public func calculate() throws -> Swift.Array<Swift.UInt8>
-}
-@usableFromInline
-final internal class StreamDecryptor : OICommons.Cryptor, OICommons.Updatable {
-  @usableFromInline
-  final internal let blockSize: Swift.Int
-  @usableFromInline
-  final internal var worker: OICommons.CipherModeWorker
-  @usableFromInline
-  final internal let padding: OICommons.Padding
-  @usableFromInline
-  final internal var accumulated: [Swift.UInt8]
-  @usableFromInline
-  final internal var lastBlockRemainder: Swift.Int
-  @usableFromInline
-  internal init(blockSize: Swift.Int, padding: OICommons.Padding, _ worker: OICommons.CipherModeWorker) throws
-  @inlinable final public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool) throws -> Swift.Array<Swift.UInt8> {
-    self.accumulated += bytes
-
-    let toProcess = self.accumulated.prefix(max(self.accumulated.count - self.worker.additionalBufferSize, 0))
-
-    if var finalizingWorker = worker as? FinalizingDecryptModeWorker, isLast == true {
-      // will truncate suffix if needed
-      try finalizingWorker.willDecryptLast(bytes: self.accumulated.slice)
-    }
-
-    var processedBytesCount = 0
-    var plaintext = Array<UInt8>(reserveCapacity: bytes.count + self.worker.additionalBufferSize)
-    for chunk in toProcess.batched(by: self.blockSize) {
-      plaintext += self.worker.decrypt(block: chunk)
-      processedBytesCount += chunk.count
-    }
-
-    if var finalizingWorker = worker as? FinalizingDecryptModeWorker, isLast == true {
-      plaintext = Array(try finalizingWorker.didDecryptLast(bytes: plaintext.slice))
-    }
-
-    // omit unecessary calculation if not needed
-    if self.padding != .noPadding {
-      self.lastBlockRemainder = plaintext.count.quotientAndRemainder(dividingBy: self.blockSize).remainder
-    }
-
-    if isLast {
-      // CTR doesn't need padding. Really. Add padding to the last block if really want. but... don't.
-      plaintext = self.padding.remove(from: plaintext, blockSize: self.blockSize - self.lastBlockRemainder)
-    }
-
-    self.accumulated.removeFirst(processedBytesCount) // super-slow
-
-    if var finalizingWorker = worker as? FinalizingDecryptModeWorker, isLast == true {
-      plaintext = Array(try finalizingWorker.finalize(decrypt: plaintext.slice))
-    }
-
-    return plaintext
-  }
-  @inlinable final public func seek(to position: Swift.Int) throws {
-    guard var worker = self.worker as? SeekableModeWorker else {
-      fatalError("Not supported")
-    }
-
-    try worker.seek(to: position)
-    self.worker = worker
-  }
-  @objc @usableFromInline
-  deinit
-}
-@objc @_Concurrency.MainActor(unsafe) public class CustomShape : OICommons.ViewInViewCode {
-  public typealias ShapeBuilder = (_ shape: UIKit.UIView, _ rect: CoreFoundation.CGRect) -> Swift.Void
-  @_Concurrency.MainActor(unsafe) public var path: UIKit.UIBezierPath?
-  @_Concurrency.MainActor(unsafe) public init(shapeBuilder: @escaping OICommons.CustomShape.ShapeBuilder)
-  @_Concurrency.MainActor(unsafe) @objc override dynamic public func draw(_ rect: CoreFoundation.CGRect)
-  @objc deinit
-}
-public struct CBC : OICommons.BlockMode {
-  public enum Error : Swift.Error {
-    case invalidInitializationVector
-    public static func == (a: OICommons.CBC.Error, b: OICommons.CBC.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public let options: OICommons.BlockModeOption
-  public let customBlockSize: Swift.Int?
-  public init(iv: Swift.Array<Swift.UInt8>)
-  public func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-}
-public protocol Cryptors : AnyObject {
-  func makeEncryptor() throws -> OICommons.Cryptor & OICommons.Updatable
-  func makeDecryptor() throws -> OICommons.Cryptor & OICommons.Updatable
-  static func randomIV(_ blockSize: Swift.Int) -> Swift.Array<Swift.UInt8>
-}
-extension OICommons.Cryptors {
-  public static func randomIV(_ count: Swift.Int) -> Swift.Array<Swift.UInt8>
-}
-public protocol Authenticator {
-  func authenticate(_ bytes: Swift.Array<Swift.UInt8>) throws -> Swift.Array<Swift.UInt8>
-}
-extension OICommons.AES : OICommons.Cryptors {
-  @inlinable final public func makeEncryptor() throws -> OICommons.Cryptor & OICommons.Updatable {
-    let blockSize = blockMode.customBlockSize ?? AES.blockSize
-    let worker = try blockMode.worker(blockSize: blockSize, cipherOperation: encrypt, encryptionOperation: encrypt)
-    if worker is StreamModeWorker {
-      return try StreamEncryptor(blockSize: blockSize, padding: padding, worker)
-    }
-    return try BlockEncryptor(blockSize: blockSize, padding: padding, worker)
-  }
-  @inlinable final public func makeDecryptor() throws -> OICommons.Cryptor & OICommons.Updatable {
-    let blockSize = blockMode.customBlockSize ?? AES.blockSize
-    let cipherOperation: CipherOperationOnBlock = blockMode.options.contains(.useEncryptToDecrypt) == true ? encrypt : decrypt
-    let worker = try blockMode.worker(blockSize: blockSize, cipherOperation: cipherOperation, encryptionOperation: encrypt)
-    if worker is StreamModeWorker {
-      return try StreamDecryptor(blockSize: blockSize, padding: padding, worker)
-    }
-    return try BlockDecryptor(blockSize: blockSize, padding: padding, worker)
-  }
-}
-public struct CCM {
-  public enum Error : Swift.Error {
-    case invalidInitializationVector
-    case invalidParameter
-    case fail
-    public static func == (a: OICommons.CCM.Error, b: OICommons.CCM.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public let options: OICommons.BlockModeOption
-  public let customBlockSize: Swift.Int?
-  public var authenticationTag: Swift.Array<Swift.UInt8>?
-  public init(iv: Swift.Array<Swift.UInt8>, tagLength: Swift.Int, messageLength: Swift.Int, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil)
-  public init(iv: Swift.Array<Swift.UInt8>, tagLength: Swift.Int, messageLength: Swift.Int, authenticationTag: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil)
-  public func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-}
-public typealias CipherOperationOnBlock = (_ block: Swift.ArraySlice<Swift.UInt8>) -> Swift.Array<Swift.UInt8>?
-public protocol BlockMode {
-  var options: OICommons.BlockModeOption { get }
-  @inlinable func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-  var customBlockSize: Swift.Int? { get }
-}
-@objc @_inheritsConvenienceInitializers @_Concurrency.MainActor(unsafe) open class ViewInViewCode : UIKit.UIView {
-  @_Concurrency.MainActor(unsafe) @objc override dynamic public init(frame: CoreFoundation.CGRect)
-  @_Concurrency.MainActor(unsafe) @objc dynamic public init()
-  @available(*, unavailable)
-  @_Concurrency.MainActor(unsafe) @objc required dynamic public init?(coder: Foundation.NSCoder)
-  @objc deinit
-}
-public class BlockDecryptor : OICommons.Cryptor, OICommons.Updatable {
-  @usableFromInline
-  final internal let blockSize: Swift.Int
-  @usableFromInline
-  final internal let padding: OICommons.Padding
-  @usableFromInline
-  internal var worker: OICommons.CipherModeWorker
-  @usableFromInline
-  internal var accumulated: [Swift.UInt8]
-  @usableFromInline
-  internal init(blockSize: Swift.Int, padding: OICommons.Padding, _ worker: OICommons.CipherModeWorker) throws
-  @inlinable public func update(withBytes bytes: Swift.ArraySlice<Swift.UInt8>, isLast: Swift.Bool = false) throws -> Swift.Array<Swift.UInt8> {
-    self.accumulated += bytes
-
-    // If a worker (eg GCM) can combine ciphertext + tag
-    // we need to remove tag from the ciphertext.
-    if !isLast && self.accumulated.count < self.blockSize + self.worker.additionalBufferSize {
-      return []
-    }
-
-    let accumulatedWithoutSuffix: Array<UInt8>
-    if self.worker.additionalBufferSize > 0 {
-      // FIXME: how slow is that?
-      accumulatedWithoutSuffix = Array(self.accumulated.prefix(self.accumulated.count - self.worker.additionalBufferSize))
-    } else {
-      accumulatedWithoutSuffix = self.accumulated
-    }
-
-    var processedBytesCount = 0
-    var plaintext = Array<UInt8>(reserveCapacity: accumulatedWithoutSuffix.count)
-    // Processing in a block-size manner. It's good for block modes, but bad for stream modes.
-    for var chunk in accumulatedWithoutSuffix.batched(by: self.blockSize) {
-      if isLast || (accumulatedWithoutSuffix.count - processedBytesCount) >= blockSize {
-        let isLastChunk = processedBytesCount + chunk.count == accumulatedWithoutSuffix.count
-
-        if isLast, isLastChunk, var finalizingWorker = worker as? FinalizingDecryptModeWorker {
-          chunk = try finalizingWorker.willDecryptLast(bytes: chunk + accumulated.suffix(worker.additionalBufferSize)) // tag size
-        }
-
-        if !chunk.isEmpty {
-          plaintext += worker.decrypt(block: chunk)
-        }
-
-        if isLast, isLastChunk, var finalizingWorker = worker as? FinalizingDecryptModeWorker {
-          plaintext = Array(try finalizingWorker.didDecryptLast(bytes: plaintext.slice))
-        }
-
-        processedBytesCount += chunk.count
-      }
-    }
-    accumulated.removeFirst(processedBytesCount) // super-slow
-
-    if isLast {
-      if accumulatedWithoutSuffix.isEmpty, var finalizingWorker = worker as? FinalizingDecryptModeWorker {
-        try finalizingWorker.willDecryptLast(bytes: self.accumulated.suffix(self.worker.additionalBufferSize))
-        plaintext = Array(try finalizingWorker.didDecryptLast(bytes: plaintext.slice))
-      }
-      plaintext = self.padding.remove(from: plaintext, blockSize: self.blockSize)
-    }
-
-    return plaintext
-  }
-  public func seek(to position: Swift.Int) throws
-  @objc deinit
-}
-public enum PKCS7 {
-}
-final public class GCM : OICommons.BlockMode {
-  public enum Mode {
-    case combined
-    case detached
-    public static func == (a: OICommons.GCM.Mode, b: OICommons.GCM.Mode) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  final public let options: OICommons.BlockModeOption
-  public enum Error : Swift.Error {
-    case invalidInitializationVector
-    case fail
-    public static func == (a: OICommons.GCM.Error, b: OICommons.GCM.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  final public let customBlockSize: Swift.Int?
-  final public var authenticationTag: Swift.Array<Swift.UInt8>?
-  public init(iv: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil, tagLength: Swift.Int = 16, mode: OICommons.GCM.Mode = .detached)
-  convenience public init(iv: Swift.Array<Swift.UInt8>, authenticationTag: Swift.Array<Swift.UInt8>, additionalAuthenticatedData: Swift.Array<Swift.UInt8>? = nil, mode: OICommons.GCM.Mode = .detached)
-  final public func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-  @objc deinit
-}
-extension OICommons.ChaCha20 {
-  convenience public init(key: Swift.String, iv: Swift.String) throws
-}
-public struct PCBC : OICommons.BlockMode {
-  public enum Error : Swift.Error {
-    case invalidInitializationVector
-    public static func == (a: OICommons.PCBC.Error, b: OICommons.PCBC.Error) -> Swift.Bool
-    public func hash(into hasher: inout Swift.Hasher)
-    public var hashValue: Swift.Int {
-      get
-    }
-  }
-  public let options: OICommons.BlockModeOption
-  public let customBlockSize: Swift.Int?
-  public init(iv: Swift.Array<Swift.UInt8>)
-  public func worker(blockSize: Swift.Int, cipherOperation: @escaping OICommons.CipherOperationOnBlock, encryptionOperation: @escaping OICommons.CipherOperationOnBlock) throws -> OICommons.CipherModeWorker
-}
-public enum PKCS5 {
-}
-public protocol PaddingProtocol {
-  func add(to: Swift.Array<Swift.UInt8>, blockSize: Swift.Int) -> Swift.Array<Swift.UInt8>
-  func remove(from: Swift.Array<Swift.UInt8>, blockSize: Swift.Int?) -> Swift.Array<Swift.UInt8>
-}
-public enum Padding : OICommons.PaddingProtocol {
-  case noPadding, zeroPadding, pkcs7, pkcs5, iso78164
-  public func add(to: Swift.Array<Swift.UInt8>, blockSize: Swift.Int) -> Swift.Array<Swift.UInt8>
-  public func remove(from: Swift.Array<Swift.UInt8>, blockSize: Swift.Int?) -> Swift.Array<Swift.UInt8>
-  public static func == (a: OICommons.Padding, b: OICommons.Padding) -> Swift.Bool
-  public func hash(into hasher: inout Swift.Hasher)
-  public var hashValue: Swift.Int {
-    get
-  }
-}
-extension UIKit.UIImage {
-  public func cropToRect(rect: CoreFoundation.CGRect) -> UIKit.UIImage
-}
-extension OICommons.AES.Error : Swift.Equatable {}
-extension OICommons.AES.Error : Swift.Hashable {}
-extension OICommons.AES.Variant : Swift.Equatable {}
-extension OICommons.AES.Variant : Swift.Hashable {}
-extension OICommons.AES.Variant : Swift.RawRepresentable {}
-extension OICommons.OCB.Mode : Swift.Equatable {}
-extension OICommons.OCB.Mode : Swift.Hashable {}
-extension OICommons.OCB.Error : Swift.Equatable {}
-extension OICommons.OCB.Error : Swift.Hashable {}
-extension OICommons.Environment : Swift.Equatable {}
-extension OICommons.Environment : Swift.Hashable {}
-extension OICommons.Environment : Swift.RawRepresentable {}
-extension OICommons.PKCS5.PBKDF1.Error : Swift.Equatable {}
-extension OICommons.PKCS5.PBKDF1.Error : Swift.Hashable {}
-extension OICommons.PKCS5.PBKDF1.Variant : Swift.Equatable {}
-extension OICommons.PKCS5.PBKDF1.Variant : Swift.Hashable {}
-extension OICommons.CTR : OICommons.BlockMode {}
-extension OICommons.CTR.Error : Swift.Equatable {}
-extension OICommons.CTR.Error : Swift.Hashable {}
-extension OICommons.PKCS5.PBKDF2.Error : Swift.Equatable {}
-extension OICommons.PKCS5.PBKDF2.Error : Swift.Hashable {}
-extension OICommons.SHA3.Variant : Swift.Equatable {}
-extension OICommons.SHA3.Variant : Swift.Hashable {}
-extension OICommons.SHA2.Variant : Swift.Equatable {}
-extension OICommons.SHA2.Variant : Swift.Hashable {}
-extension OICommons.CFB.Error : Swift.Equatable {}
-extension OICommons.CFB.Error : Swift.Hashable {}
-extension OICommons.CFB.SegmentSize : Swift.Equatable {}
-extension OICommons.CFB.SegmentSize : Swift.Hashable {}
-extension OICommons.CFB.SegmentSize : Swift.RawRepresentable {}
-extension OICommons.Poly1305.Error : Swift.Equatable {}
-extension OICommons.Poly1305.Error : Swift.Hashable {}
-extension OICommons.Blowfish.Error : Swift.Equatable {}
-extension OICommons.Blowfish.Error : Swift.Hashable {}
-extension OICommons.OFB.Error : Swift.Equatable {}
-extension OICommons.OFB.Error : Swift.Hashable {}
-extension OICommons.ChaCha20.Error : Swift.Equatable {}
-extension OICommons.ChaCha20.Error : Swift.Hashable {}
-extension OICommons.CMAC.Error : Swift.Equatable {}
-extension OICommons.CMAC.Error : Swift.Hashable {}
-extension OICommons.HMAC.Error : Swift.Equatable {}
-extension OICommons.HMAC.Error : Swift.Hashable {}
-extension OICommons.HMAC.Variant : Swift.Equatable {}
-extension OICommons.HMAC.Variant : Swift.Hashable {}
-extension OICommons.CipherError : Swift.Equatable {}
-extension OICommons.CipherError : Swift.Hashable {}
-extension OICommons.Bit : Swift.Equatable {}
-extension OICommons.Bit : Swift.Hashable {}
-extension OICommons.Bit : Swift.RawRepresentable {}
-extension OICommons.Rabbit.Error : Swift.Equatable {}
-extension OICommons.Rabbit.Error : Swift.Hashable {}
-extension OICommons.HKDF.Error : Swift.Equatable {}
-extension OICommons.HKDF.Error : Swift.Hashable {}
-extension OICommons.CBC.Error : Swift.Equatable {}
-extension OICommons.CBC.Error : Swift.Hashable {}
-extension OICommons.CCM : OICommons.BlockMode {}
-extension OICommons.CCM.Error : Swift.Equatable {}
-extension OICommons.CCM.Error : Swift.Hashable {}
-extension OICommons.GCM.Mode : Swift.Equatable {}
-extension OICommons.GCM.Mode : Swift.Hashable {}
-extension OICommons.GCM.Error : Swift.Equatable {}
-extension OICommons.GCM.Error : Swift.Hashable {}
-extension OICommons.PCBC.Error : Swift.Equatable {}
-extension OICommons.PCBC.Error : Swift.Hashable {}
-extension OICommons.Padding : Swift.Equatable {}
-extension OICommons.Padding : Swift.Hashable {}